Schedo.dev

https://docs.schedo.dev
Admin
Schedo.dev is a modern cloud-based job scheduling platform that provides a reliable, scalable, and...
Tokens:11,805
Snippets:90
Trust Score:3.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Schedo Go SDK

Source: https://docs.schedo.dev/documentation/sdks/go/quickstart

Instructions to install the Schedo Go SDK using Go modules, allowing you to easily manage dependencies in your Go project.

```Go
go get -u github.com/useschedo/golang-sdk
```

--------------------------------

### Install Schedo Node.js SDK

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Install the Schedo.dev Node.js SDK using your preferred package manager: npm, pnpm, or yarn.

```npm
npm install @useschedo/node
```

```pnpm
pnpm add @useschedo/node
```

```yarn
yarn add @useschedo/node
```

--------------------------------

### Connect to Schedo.dev and Define a Job

Source: https://docs.schedo.dev/sdks/node/quickstart

Illustrates how to connect to Schedo.dev using the Node.js SDK, initialize it with an API key from environment variables, define a job that runs every minute, and start the Schedo instance. This snippet demonstrates basic job definition and execution setup.

```javascript
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Install Schedo Node.js SDK

Source: https://docs.schedo.dev/sdks/node/quickstart

Instructions on how to install the Schedo Node.js SDK using pnpm package manager.

```bash
pnpm add @useschedo/node
```

--------------------------------

### Connect to Schedo.dev and Define a Job

Source: https://docs.schedo.dev/documentation/introduction

This example shows how to initialize the Schedo SDK using an API key from environment variables, define a job that runs every minute using `ExecutionInterval.EveryMinute`, and start the Schedo instance to begin processing jobs.

```javascript
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Define and Start Your First Schedo Job in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

This code initializes the Schedo SDK, defines a daily job with error handling and a timeout, and starts the job listener for cloud execution. It also includes a graceful shutdown mechanism.

```TypeScript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
  withBaseURL,
} from "@useschedo/node";

// Initialize the SDK with your API key
const schedo = new SchedoSDK(withApiKey("YOUR_API_KEY"));

// Define a job that runs every day at midnight
try {
  await schedo.defineJob(
    "error_handling_example",
    ExecutionInterval.Daily,
    async (ctx) => {
      // This job might fail
      if (Math.random() > 0.5) {
        throw new Error("Random failure");
      }
      return { success: true };
    },
    withTimeout(5) // Set a 5-second timeout
  );
} catch (error) {
  console.error("Failed to define job:", error);
}

// Start the job listener
schedo.start();

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('Shutting down...');
  schedo.stop();
  process.exit(0);
});
```

--------------------------------

### Install Schedo Node.js SDK

Source: https://docs.schedo.dev/documentation/introduction

This command installs the Schedo Node.js SDK package using pnpm, a fast package manager.

```bash
pnpm add @useschedo/node
```

--------------------------------

### Define a New Schedo Job in Go

Source: https://docs.schedo.dev/documentation/sdks/go/quickstart

Example of defining a new scheduled job using the Schedo Go SDK. This snippet demonstrates setting a cron schedule, defining the job execution function, and adding optional parameters like timeout and metadata. The `sdk.Start()` call initiates listening for job execution events.

```Go
package main

import (
    "context"
    "fmt"
    "time"
    schedo "github.com/useschedo/golang-sdk"
    "github.com/useschedo/golang-sdk/option"
)

func main() {
    client := schedo.NewClient(
        option.WithAPIKey("your_api_key"),
    )

    // Define a new job
   err := client.DefineJob(
		"example_job",
		"* * * * *", // Run every minute
		func(ctx *schedo.JobExecutionContext) (string, error) {
			fmt.Println("Executing job...")
			return "Job completed successfully", nil
		},
        schedo.WithTimeout(30*time.Second), // Optional: 30 second timeout
	    schedo.WithMetadata(map[string]any{"category": "reports"}), // Optional: adds metadata
	    schedo.WithBlocking(true), // Optional: makes job execution blocking
	)

	if err != nil {
		fmt.Printf("Failed to define job: %v\n", err)
		return
	}

	// Start listening for job execution events
	schedo.Start()
}
```

--------------------------------

### Install Schedo Node.js SDK

Source: https://docs.schedo.dev/core-concepts/scheduling

This command demonstrates how to install the Schedo Node.js SDK using pnpm, a fast, disk space efficient package manager.

```bash
pnpm add @useschedo/node
```

--------------------------------

### Install Schedo.dev Node.js SDK

Source: https://docs.schedo.dev/integrations/sherpa

This command installs the Schedo.dev Node.js SDK into your project using the pnpm package manager. It is the essential first step to integrate Schedo.dev's capabilities into your application.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Connect to Schedo.dev and Define a Recurring Job (Node.js)

Source: https://docs.schedo.dev/core-concepts/jobs

This Node.js example illustrates how to connect to Schedo.dev using an API key from environment variables, define a job that runs every minute using ExecutionInterval.EveryMinute (or a cron expression), and start the Schedo instance to begin task execution. It showcases the basic setup for integrating Schedo.dev into a Node.js application.

```JavaScript
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Connect to Schedo.dev and Define Job (Interval)

Source: https://docs.schedo.dev/core-concepts/monitoring

This example illustrates how to connect to Schedo.dev using an API key from environment variables and define a job named 'daily-cleanup'. It uses `ExecutionInterval.EveryMinute` for scheduling, demonstrating an alternative to cron expressions, and finally starts the Schedo instance to activate the job.

```TypeScript
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Install Schedo.dev Node.js SDK using pnpm

Source: https://docs.schedo.dev/core-concepts/jobs

This command shows how to install the Schedo.dev Node.js SDK into your project using pnpm, a fast and efficient package manager for JavaScript.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Define and Start a Daily Cleanup Job with Schedo SDK

Source: https://docs.schedo.dev/sdks/node/quickstart

Demonstrates how to initialize the Schedo SDK with an API key, define a recurring job named 'daily-cleanup' using a cron expression, and start the Schedo instance. This showcases the developer-first approach to scheduling tasks without manual DevOps configuration.

```javascript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Install Schedo Node.js SDK with pnpm

Source: https://docs.schedo.dev/core-concepts/monitoring

This command shows how to install the official Schedo Node.js SDK using pnpm. This is the essential first step for integrating Schedo.dev's job scheduling capabilities into any Node.js project.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Install Schedo Node.js SDK (pnpm)

Source: https://docs.schedo.dev/core-concepts/error-handling

This command shows how to install the official Schedo Node.js SDK using the pnpm package manager. The SDK provides the necessary tools to integrate Schedo.dev into your Node.js applications.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Install Schedo Node.js SDK with pnpm

Source: https://docs.schedo.dev/index

This command installs the Schedo Node.js SDK using pnpm, a fast package manager. It is the essential first step to integrate Schedo.dev into your Node.js project for job scheduling.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Authenticate Schedo Go Client

Source: https://docs.schedo.dev/documentation/sdks/go/quickstart

Initialize a new Schedo client with your API key. The API key can be explicitly provided using `option.WithAPIKey` or defaults to the `SCHEDO_API_KEY` environment variable if not specified.

```Go
import (
    "github.com/useschedo/golang-sdk"
    "github.com/useschedo/golang-sdk/option"
)

client := schedo.NewClient(
    option.WithAPIKey("your_api_key"), // defaults to os.LookupEnv("SCHEDO_API_KEY")
)
```

--------------------------------

### Install Schedo Node.js SDK

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Instructions to install the Schedo Node.js SDK using npm. This SDK is a crucial dependency for interacting with Schedo.dev services, particularly for webhook signature verification.

```bash
npm install @useschedo/node-sdk
```

--------------------------------

### Install Schedo.dev Node.js SDK with pnpm

Source: https://docs.schedo.dev/sdks/node

This command installs the Schedo.dev Node.js SDK using the pnpm package manager. It adds the @useschedo/node package to your project's dependencies, enabling you to use the SDK's functionalities.

```Shell
pnpm add @useschedo/node
```

--------------------------------

### Log Schedo.dev Job Execution Details for Monitoring

Source: https://docs.schedo.dev/documentation/core-concepts/monitoring

This best practice example demonstrates how to log key execution details like `jobCode` and `executionId` at the start of a Schedo.dev job. This provides valuable information for monitoring, debugging, and tracing individual job runs.

```JavaScript
async (ctx) => {
  console.log('Starting job:', {
    jobCode: ctx.jobCode,
    executionId: ctx.executionId
  });

  await processData();

  return 'Job completed';
}
```

--------------------------------

### Examples of Good Job Identifiers

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Provides examples of descriptive and unique identifiers recommended for Schedo jobs to facilitate tracking and configuration.

```JavaScript
// Good identifiers are descriptive and unique
'daily-cleanup'
'hourly-metrics'
'weekly-report'
```

--------------------------------

### Initialize Schedo SDK in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Connects your Node.js application to Schedo.dev’s cloud platform by initializing the SchedoSDK with an API key, typically sourced from environment variables.

```TypeScript
import { SchedoSDK, withApiKey } from "@useschedo/node";

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));
```

--------------------------------

### Define and Start Daily Cleanup Job using Schedo Node.js SDK

Source: https://docs.schedo.dev/index

Initializes SchedoSDK with an API key, defines a daily recurring job 'daily-cleanup' using a cron expression, and starts the Schedo instance. This demonstrates Schedo.dev's developer-first approach, abstracting DevOps complexities for scheduled tasks.

```Node.js
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Connect to Schedo.dev and Define a Job (Node.js)

Source: https://docs.schedo.dev/core-concepts/scheduling

This snippet shows how to initialize the Schedo Node.js SDK with an API key from environment variables, define a job that runs every minute, and start the Schedo instance to activate the job.

```javascript
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Define and Start a Daily Job with Schedo.dev Node.js SDK

Source: https://docs.schedo.dev/sdks/node

Initializes the Schedo.dev SDK with an API key. Defines a recurring job 'daily-cleanup' using a cron expression. The job's asynchronous logic is placed within the callback function, and the Schedo instance is then started.

```Node.js
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Handle Errors in Schedo Go SDK

Source: https://docs.schedo.dev/documentation/sdks/go/quickstart

Illustrates a best practice for error handling when interacting with the Schedo Go SDK. It shows how to check for and log errors appropriately after an operation, ensuring robust application behavior.

```Go
if err != nil {
       log.Printf("Failed to create job: %v", err)
       return
   }
```

--------------------------------

### Define and Start a Daily Cleanup Job (Node.js)

Source: https://docs.schedo.dev/core-concepts/error-handling

This snippet demonstrates how to initialize the SchedoSDK with an API key and define a recurring job named 'daily-cleanup'. The job logic is encapsulated within an asynchronous function, and the Schedo instance is started to begin scheduling.

```Node.js
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Connect to Schedo.dev and Define a Job (Node.js)

Source: https://docs.schedo.dev/core-concepts/error-handling

This example illustrates how to connect to Schedo.dev by initializing the SchedoSDK with your API key. It then defines a job that runs every minute, demonstrating the use of ExecutionInterval or a cron expression for scheduling.

```Node.js
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Define and Start a Daily Cleanup Job (Cron)

Source: https://docs.schedo.dev/core-concepts/monitoring

This snippet demonstrates initializing the Schedo SDK with an API key and defining a recurring job named 'daily-cleanup' using a cron expression ('0 0 * * *' for daily at midnight). It then starts the Schedo instance, showcasing the platform's developer-first approach to scheduling tasks without DevOps overhead.

```TypeScript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY")
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Set Schedo API Key Environment Variable

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Sets the `SCHEDO_API_KEY` environment variable, which is required for authenticating your application with the Schedo.dev API.

```Shell
export SCHEDO_API_KEY=your_api_key_here
```

--------------------------------

### Deploy Next.js Application

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Commands to build and start the Next.js application, preparing it for deployment to your preferred hosting platform. This step ensures the application, including the Schedo webhook endpoint, is ready to serve requests.

```bash
npm run build
npm run start
```

--------------------------------

### Run Schedo Job File in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Executes the job file using `tsx` for TypeScript or `node` for JavaScript, initiating the job listener and allowing Schedo.dev to manage its execution in the cloud.

```TypeScript
pnpm tsx jobs.ts
```

```Node.js
node jobs.js
```

--------------------------------

### Define and Start a Daily Cleanup Job with Schedo SDK (Node.js)

Source: https://docs.schedo.dev/core-concepts/scheduling

This snippet demonstrates how to define a scheduled job using the Schedo Node.js SDK. It initializes the SDK with an API key, defines a job named 'daily-cleanup' to run daily at midnight using a cron expression, and then starts the Schedo instance to begin job execution.

```javascript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Define and Start a Daily Cleanup Job with Schedo.dev Node.js SDK

Source: https://docs.schedo.dev/core-concepts/jobs

This Node.js snippet demonstrates how to initialize the SchedoSDK with an API key, define a recurring job named 'daily-cleanup' using a cron expression, and start the Schedo instance. It illustrates the developer-first approach to scheduling tasks without manual DevOps configuration.

```JavaScript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Define Type-Safe Schedo Job in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Illustrates defining a job with full TypeScript type safety, showing how the SDK provides strong typing for job definitions and return values.

```TypeScript
schedo.defineJob(
  'typed-job',
  '0 0 * * *',
  async (ctx) => {
    const result = await performCleanup();
    return {
      count: result.count,
      duration: result.duration
    };
  }
);
```

--------------------------------

### Dockerfile for Next.js Application on Container Platforms

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

A standard Dockerfile for building and deploying a Next.js application on containerized platforms, including dependencies installation, build process, and port exposure.

```Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]
```

--------------------------------

### Implement Error Handling for Schedo Jobs in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Demonstrates a try-catch block for operations within a job. Schedo.dev provides built-in error handling and automatically manages retries for failed operations.

```TypeScript
try {
  await operation();
} catch (error) {
  await log('Operation failed', { error });
  throw error;  // Schedo handles retries automatically
}
```

--------------------------------

### Access Job Execution Context in Go

Source: https://docs.schedo.dev/documentation/sdks/go/quickstart

Demonstrates how to access details about the job execution, such as the `ExecutionID`, from the `JobExecutionContext` within the job's handler function. This is a best practice for gaining more insight into job runs.

```Go
func(ctx *schedo.JobExecutionContext) (string, error) {
        fmt.Println("Execution ID: ", ctx.ExecutionID)
        return "Job completed successfully", nil
   }
```

--------------------------------

### Basic Job Definition and Lifecycle

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

An example of defining a simple Schedo job, illustrating its role in the job lifecycle (Scheduled, Running, Completed, Failed).

```JavaScript
schedo.defineJob(
  'example-job',
  '0 * * * *',
  async (ctx) => {
    await processData();
    return 'Job completed successfully';
  }
);
```

--------------------------------

### Connect to Schedo.dev and Define a Recurring Job in Node.js

Source: https://docs.schedo.dev/sdks/node

Connects to Schedo.dev using an API key from environment variables. Defines a job 'daily-cleanup' to run every minute using ExecutionInterval.EveryMinute. The Schedo instance is then started to activate the scheduled job.

```Node.js
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Migrate from Platform-Specific Cron to Schedo Webhooks

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Compares a traditional platform-specific cron job with its equivalent Schedo webhook implementation in Next.js. The 'After' example demonstrates adding crucial signature verification for enhanced security when using Schedo.

```javascript
// Before (Platform-specific cron)
export async function GET() {
  await runScheduledTask();
  return Response.json({ success: true });
}
```

```javascript
// After (Schedo webhook)
export async function POST(req: NextRequest) {
  // Add signature verification
  const isValid = verifier.verifyBytesSignature(/* ... */);
  if (!isValid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  await runScheduledTask();
  return NextResponse.json({ success: true });
}
```

--------------------------------

### Connect to Schedo.dev and Define Job with Node.js SDK (Interval)

Source: https://docs.schedo.dev/integrations/sherpa

This Node.js example illustrates how to connect to Schedo.dev using an API key from environment variables and define a recurring job. It uses 'ExecutionInterval.EveryMinute' for scheduling, providing an alternative to cron expressions for defining job frequency.

```Node.js
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Understand Cron Expression Format

Source: https://docs.schedo.dev/documentation/core-concepts/scheduling

This snippet illustrates the five fields of a standard cron expression, indicating the minute, hour, day of month, month, and day of week. It serves as a visual guide for constructing cron schedules.

```Plain Text
┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday to Saturday)
│ │ │ │ │
* * * * *
```

--------------------------------

### Define a Scheduled Job with Schedo in Node.js

Source: https://docs.schedo.dev/documentation/sdks/node/quickstart

Defines a job that Schedo.dev will execute according to the specified schedule. It includes a unique identifier, a cron expression for scheduling, and an asynchronous handler function for the job's logic.

```TypeScript
schedo.defineJob(
  'daily-cleanup',        // Unique job identifier
  '0 0 * * *',           // Run at midnight
  async (ctx) => {       // Job handler
    // Job logic
  });
```

--------------------------------

### Define and Start a Scheduled Job with Node.js SDK (Cron)

Source: https://docs.schedo.dev/integrations/sherpa

This Node.js snippet demonstrates how to initialize the Schedo.dev SDK with an API key and define a recurring job using a cron expression. The 'daily-cleanup' job is configured to run daily at midnight, and the 'schedo.start()' call initiates the job processing.

```Node.js
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Common Cron Scheduling Patterns

Source: https://docs.schedo.dev/documentation/core-concepts/scheduling

This snippet provides examples of frequently used cron expressions for various scheduling needs, including every minute, every 15 minutes, hourly, daily at midnight, weekly on Monday, and monthly on the 1st.

```JavaScript
// Every minute
'* * * * *'

// Every 15 minutes
'*/15 * * * *'

// Every hour
'0 * * * *'

// Every day at midnight
'0 0 * * *'

// Every Monday at 9:00 AM
'0 9 * * 1'

// Every month on the 1st at midnight
'0 0 1 * *'
```

--------------------------------

### Synchronize External Data via Schedo Webhooks

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

An example function for synchronizing data from an external API into a local database. It includes error handling to trigger retries in Schedo if the synchronization fails.

```TypeScript
async function syncExternalData(payload: any) {
  try {
    // Fetch from external API
    const externalData = await fetch('https://api.external.com/data', {
      headers: { 'Authorization': `Bearer ${process.env.EXTERNAL_API_KEY}` }
    }).then(res => res.json());

    // Update local database
    await db.externalData.upsert({
      where: { id: externalData.id },
      update: externalData,
      create: externalData
    });

    console.log(`Synced ${externalData.length} records`);
  } catch (error) {
    console.error('Sync failed:', error);
    throw error; // Will trigger retry in Schedo
  }
}
```

--------------------------------

### Send Daily Reports with Schedo Webhooks

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

An example function demonstrating how to generate and send daily reports via email using data fetched based on a scheduled payload. This illustrates a common use case for Schedo webhooks.

```TypeScript
async function sendDailyReport(payload: any) {
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);

  // Fetch data
  const analytics = await getAnalytics(yesterday);

  // Generate report
  const report = await generateReport(analytics);

  // Send via email
  await sendEmail({
    to: payload.customData.recipients,
    subject: `Daily Report - ${yesterday.toDateString()}`,
    html: report
  });
}
```

--------------------------------

### Stagger High-Load Jobs (Cron Best Practice)

Source: https://docs.schedo.dev/documentation/core-concepts/scheduling

This snippet demonstrates a best practice for staggering high-load jobs to avoid concurrent execution at the exact same time. By offsetting the start times by a few minutes, system load can be distributed more evenly.

```JavaScript
// Instead of all jobs at midnight
'0 0 * * *'     // Job A
'5 0 * * *'     // Job B
'10 0 * * *'    // Job C
```

--------------------------------

### Create Next.js API Route for Schedo Webhook

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Example Next.js API route, compatible with both App Router and Pages Router, designed to handle incoming Schedo webhooks. The code demonstrates how to verify the webhook's cryptographic signature using the @useschedo/node-sdk to ensure authenticity before executing the scheduled task logic.

```typescript
import { NextResponse } from "next/server";
import type { NextRequest } from "next/server";
import { SignatureVerifier } from "@useschedo/node-sdk";

const verifier = new SignatureVerifier(
  process.env.SCHEDO_SIGNATURE_KEY!
);

export async function POST(req: NextRequest) {
  try {
    const body = await req.json();

    // Verify webhook signature
    const signature = req.headers.get("x-schedo-signature");
    if (!signature) {
      return NextResponse.json(
        { error: "Missing signature" },
        { status: 401 }
      );
    }

    const isValid = verifier.verifyBytesSignature(
      Buffer.from(JSON.stringify(body)),
      signature
    );

    if (!isValid) {
      return NextResponse.json(
        { error: "Invalid signature" },
        { status: 401 }
      );
    }

    // Your scheduled task logic here
    await processScheduledTask(body);

    return NextResponse.json({
      success: true,
      timestamp: new Date().toISOString()
    });
  } catch (error) {
    console.error("Cron job error:", error);
    return NextResponse.json(
      { error: "Internal server error" },
      { status: 500 }
    );
  }
}

async function processScheduledTask(payload: any) {
  // Example: Send daily reports
  console.log("Processing scheduled task:", payload);

  // Your business logic here
  // - Send emails
  // - Process data
  // - Update database
  // - Call external APIs
}
```

--------------------------------

### Implementing Best Practices for Error Handling with Retries in Schedo.dev

Source: https://docs.schedo.dev/documentation/core-concepts/error-handling

Provides a best practice example for handling errors within a job. It suggests distinguishing between transient errors (which should be rethrown for Schedo.dev's retry mechanism) and permanent errors (which might require custom handling or logging before rethrowing).

```JavaScript
async (ctx) => {
  try {
    await operation();
  } catch (error) {
    if (isTransientError(error)) {
      throw error; // Let Schedo handle retries
    } else {
      // Handle non-retryable errors
      console.error('Permanent failure:', error);
      throw error;
    }
  }
}
```

--------------------------------

### Access Schedo.dev Job Execution Context

Source: https://docs.schedo.dev/documentation/core-concepts/monitoring

This example shows how to access the `ctx` (context) object within a Schedo.dev job. It allows retrieval of execution details like `jobCode` and `executionId`, and job-specific metadata using `ctx.getMetadata()` for enhanced monitoring.

```JavaScript
schedo.defineJob(
  'context-example',
  '0 * * * *',
  async (ctx) => {
    // Access execution context
    console.log('Job execution:', {
      jobCode: ctx.jobCode,
      executionId: ctx.executionId
    });

    // Access job metadata
    const metadata = ctx.getMetadata();
    console.log('Job metadata:', metadata);

    return 'Job completed';
  }
);
```

--------------------------------

### Example of Invalid Cron Expression Validation (Schedo.dev)

Source: https://docs.schedo.dev/documentation/core-concepts/scheduling

This snippet demonstrates how Schedo.dev validates cron expressions. An invalid hour (24) in the cron string will cause an error during job definition, preventing the job from ever running.

```JavaScript
schedo.defineJob(
  'invalid-job',
  '0 24 * * *',    // 24 is invalid hour
  async (ctx) => {
    // Never runs - throws error during definition
  }
);
```

--------------------------------

### Define a Job That Triggers Notifications

Source: https://docs.schedo.dev/documentation/core-concepts/notifications

This example demonstrates defining a job using `schedo.defineJob`. If this specific job fails, a notification will be sent. Schedo.dev's policy ensures that only the first failure of a job triggers a notification, preventing notification spam from repeated failures.

```JavaScript
// Example job that might trigger a notification
schedo.defineJob(
  'daily-report',
  '0 0 * * *',
  async (ctx) => {
    // If this fails, you'll get a notification
    // Subsequent failures won't trigger more notifications
    await generateReport();
  }
);
```

--------------------------------

### Connect to Schedo.dev and Define Recurring Job with Node.js SDK

Source: https://docs.schedo.dev/index

Connects to Schedo.dev using the Node.js SDK, initializing it with an API key from environment variables. It defines a job 'daily-cleanup' to run every minute using `ExecutionInterval`, showcasing integration and task scheduling.

```Node.js
import { SchedoSDK, withApiKey, ExecutionInterval } from '@useschedo/node';

const schedo = new SchedoSDK(withApiKey(process.env.SCHEDO_API_KEY));

schedo.defineJob('daily-cleanup',
      ExecutionInterval.EveryMinute, // or cron expression
      async (ctx) => {
        // Your job logic here
        return { processed: true };
      }
);

schedo.start();
```

--------------------------------

### Integrate Schedo.dev with Hono.js on Node.js

Source: https://docs.schedo.dev/documentation/cookbook/schedo-hono

This code snippet demonstrates how to set up a basic Hono.js application on Node.js and integrate it with Schedo.dev to define and run scheduled jobs. It shows how to initialize the SchedoSDK, define a job that makes an internal request to a Hono route, and handle the job's execution and potential errors.

```javascript
import { serve } from "@hono/node-server";
import { Hono } from "hono";

import {
  SchedoSDK,
  ExecutionInterval,
  JobExecutionContext,
  withApiKey,
  withMetadata,
  withTimeout,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

const app = new Hono();

// Here is our internal route for job execution
// We recommend using routes instead of random functions as your Hono context can
app.get("/job-executor", (c) => {
  return c.newResponse("Error happened inside job executor", 500);
});

sdk
  .defineJob(
    "example_hono_job",
    ExecutionInterval.EveryMinute,
    async (ctx: JobExecutionContext) => {
      console.log("Executing job...", ctx.jobCode, ctx.executionId);
      const result = await app.request("/job-executor", {
        body: JSON.stringify(ctx),
      });

      // throwing an error will make this job as failed in Schedo dashboard
      if (result.status >= 500) {
        throw new Error("Error happened: " + (await result.text()));
      }
      return result.text();
    },
    withMetadata({ key: "value" }),
    withTimeout(1000 * 60),
  )
  .then(() => sdk.start());

serve(
  {
    fetch: app.fetch,
    port: 3000,
  },
  async (info) => {
    console.log(`Server is running on http://localhost:${info.port}`);
  },
);
```

--------------------------------

### Define a Daily Cleanup Job with Schedo SDK

Source: https://docs.schedo.dev/documentation/introduction

This snippet demonstrates how to initialize the Schedo SDK with an API key and define a recurring job named 'daily-cleanup' using a cron expression. The job logic is executed asynchronously within the provided callback function.

```javascript
import {
  SchedoSDK,
  ExecutionInterval,
  withApiKey,
} from "@useschedo/node";

const sdk = new SchedoSDK(
  withApiKey("YOUR_API_KEY"),
);

schedo.defineJob(
  'daily-cleanup',
  '0 0 * * *',
  async (ctx) => {
    // Your job logic here
    return { processed: true };
  }
);

// start schedo instance
schedo.start();
```

--------------------------------

### Configuring Schedo Jobs with Options

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Demonstrates how to apply optional configurations to a Schedo job, such as setting an execution timeout, adding custom metadata, and enabling blocking behavior.

```JavaScript
schedo.defineJob(
  'configurable-job',
  '0 0 * * *',
  async (ctx) => {
    // Job implementation
  },
  withTimeout(seconds), // optinal execution timeout, default to 5 seconds
  withMetadata({ owner: "analytics-team", priority: "high" }), // optional metadata to be passed to the job
  withBlocking(true), // prevents another job instance from execution in case there is an existing one running
);
```

--------------------------------

### Configure Schedo Signature Key Environment Variable

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Instructions for setting the SCHEDO_SIGNATURE_KEY environment variable in a .env.local file. This key is essential for the API route to verify incoming webhook signatures and must be retrieved from the Schedo Dashboard.

```plaintext
SCHEDO_SIGNATURE_KEY=your_signature_key_here
```

--------------------------------

### Implement Basic Status Tracking with Error Handling in Schedo.dev Job

Source: https://docs.schedo.dev/documentation/core-concepts/monitoring

This snippet illustrates a best practice for basic status tracking within a job by wrapping an asynchronous operation in a `try-catch` block. It returns a success message on completion or re-throws the error to indicate failure, allowing the monitoring system to capture the outcome.

```JavaScript
async (ctx) => {
  try {
    await operation();
    return 'Operation completed successfully';
  } catch (error) {
    throw error;
  }
}
```

--------------------------------

### Implement Application-Level Logging for Next.js Webhooks

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

This code demonstrates how to add comprehensive logging to a Next.js POST handler, tracking webhook receipt, successful task completion, and errors. It includes request IDs, timestamps, and duration, providing valuable insights for monitoring and debugging.

```TypeScript
export async function POST(req: NextRequest) {
  const startTime = Date.now();
  const requestId = crypto.randomUUID();

  console.log(`[${requestId}] Webhook received`, {
    headers: Object.fromEntries(req.headers.entries()),
    timestamp: new Date().toISOString()
  });

  try {
    const result = await processScheduledTask(body);

    console.log(`[${requestId}] Task completed successfully`, {
      duration: Date.now() - startTime,
      result: result
    });

    return NextResponse.json({ success: true, requestId });
  } catch (error) {
    console.error(`[${requestId}] Task failed`, {
      error: error.message,
      duration: Date.now() - startTime
    });

    throw error;
  }
}
```

--------------------------------

### Store Sensitive Data in Environment Variables

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Illustrates how to define environment variables for sensitive data like API keys and database URLs in a production environment, adhering to security best practices.

```Shell
# Production environment
SCHEDO_SIGNATURE_KEY=your_production_key
DATABASE_URL=your_database_url
EMAIL_API_KEY=your_email_key
```

--------------------------------

### Ensuring Resource Cleanup in Schedo.dev Jobs

Source: https://docs.schedo.dev/documentation/core-concepts/error-handling

Demonstrates a best practice for resource management using a `finally` block. This ensures that allocated resources are properly released, regardless of whether the job execution succeeds or fails, preventing resource leaks and maintaining system stability.

```JavaScript
async (ctx) => {
  let resource;
  try {
    resource = await allocateResource();
    await useResource(resource);
  } catch (error) {
    throw error;
  } finally {
    if (resource) {
      await releaseResource(resource);
    }
  }
}
```

--------------------------------

### Define Schedo.dev Job for Basic Status Tracking

Source: https://docs.schedo.dev/documentation/core-concepts/monitoring

This snippet demonstrates how to define a Schedo.dev job using `schedo.defineJob`. The job's return value can be used for basic status tracking, indicating successful completion.

```JavaScript
schedo.defineJob(
  'example-job',
  '* * * * *',
  async (ctx) => {
    // Job implementation
    return 'Job completed successfully';
  }
);
```

--------------------------------

### Accessing Job Execution Context

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Demonstrates how to access execution-specific information and job metadata through the `ctx` (context) object within a job handler.

```JavaScript
async (ctx) => {
  // Execution metadata
  console.log(ctx.executionId);    // Unique execution ID
  console.log(ctx.jobCode);        // Job identifier

  // Job metadata
  const metadata = ctx.getMetadata();
  console.log(metadata);
}
```

--------------------------------

### Basic Error Handling in Schedo.dev Jobs

Source: https://docs.schedo.dev/documentation/core-concepts/error-handling

Demonstrates how to implement basic error handling within a Schedo.dev job definition. Errors caught internally should be rethrown to allow Schedo.dev's built-in retry mechanism to activate, ensuring the platform can manage retries based on its configuration.

```JavaScript
schedo.defineJob(
  'example-job',
  '* * * * *',
  async (ctx) => {
    try {
      await riskyOperation();
    } catch (error) {
      // Rethrow to trigger retry mechanism
      throw error;
    }
  }
);
```

--------------------------------

### Returning Values from a Job

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Shows how a job handler can return a string result, which will be stored as the execution output. Complex objects are serialized to JSON.

```JavaScript
async (ctx) => {
  const result = await processData();
  return `Processed ${result.count} items`;
}
```

--------------------------------

### Implement Rate Limiting for Next.js Webhooks using Upstash

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

This code demonstrates how to integrate rate limiting into a Next.js POST endpoint using @upstash/ratelimit and @upstash/redis. It limits requests based on IP address, returning a 429 status if the limit is exceeded, enhancing security against abuse.

```TypeScript
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const redis = new Redis({
  url: process.env.REDIS_URL,
  token: process.env.REDIS_TOKEN,
});

const ratelimit = new Ratelimit({
  redis: redis,
  limiter: Ratelimit.slidingWindow(10, "1 m"),
});

export async function POST(req: NextRequest) {
  const ip = req.ip ?? "127.0.0.1";
  const { success } = await ratelimit.limit(ip);

  if (!success) {
    return NextResponse.json({ error: "Rate limited" }, { status: 429 });
  }

  // Continue processing...
}
```

--------------------------------

### Define Daily Backup Job with Cron Expression (Schedo.dev)

Source: https://docs.schedo.dev/documentation/core-concepts/scheduling

This snippet demonstrates how to define a job in Schedo.dev that runs daily at midnight using a cron expression. It uses `schedo.defineJob` to register the job with a specified name, cron schedule, and an asynchronous execution context.

```JavaScript
schedo.defineJob(
  'daily-backup',
  '0 0 * * *',    // Run at midnight every day
  async (ctx) => {
    // Job implementation
  }
);
```

--------------------------------

### Configure Serverless Function Max Duration

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Shows a configuration snippet for serverless platforms to set the maximum execution duration for a specific API route, crucial for preventing timeouts in scheduled tasks.

```JSON
{
  "functions": {
    "pages/api/cron.js": {
      "maxDuration": 30
    }
  }
}
```

--------------------------------

### Schedo Job Definition API

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Details the core API for defining jobs in Schedo.dev, including the main `defineJob` function and the `ctx` object provided to job handlers, along with available configuration options.

```APIDOC
schedo.defineJob(
  identifier: string,
  schedule: string,
  handler: (ctx: JobContext) => Promise<string | object>,
  ...options: JobOption[]
)

JobContext:
  executionId: string
  jobCode: string
  getMetadata(): object

JobOption:
  withTimeout(seconds: number)
  withMetadata(metadata: object)
  withBlocking(blocking: boolean)
```

--------------------------------

### Defining a Schedo Job

Source: https://docs.schedo.dev/documentation/core-concepts/jobs

Illustrates the basic structure of a Schedo job definition, including its unique identifier, schedule (cron expression), and asynchronous handler function.

```JavaScript
schedo.defineJob(
  'unique-job-id',           // Identifier
  '*/15 * * * *',           // Schedule
  async (ctx) => {          // Handler
    // Job implementation
    return 'Job completed';
  }
);
```

--------------------------------

### Verify Webhook Signatures in Next.js

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

This snippet demonstrates how to properly verify webhook signatures in a Next.js POST handler to prevent unauthorized access. It contrasts a dangerous unverified approach with a secure, verified one, ensuring only legitimate requests are processed.

```TypeScript
// ❌ Don't skip signature verification
export async function POST(req: NextRequest) {
  // Process without verification - DANGEROUS!
  await processScheduledTask(await req.json());
}

// ✅ Always verify signatures
export async function POST(req: NextRequest) {
  const isValid = verifier.verifyBytesSignature(/* ... */);
  if (!isValid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
  // Safe to process
}
```

--------------------------------

### Configuring Retry Behavior for Schedo.dev Jobs

Source: https://docs.schedo.dev/documentation/core-concepts/error-handling

Illustrates how to configure retry attempts and delay for a Schedo.dev job. The `retries` option specifies the number of times a job will be re-executed upon failure, and `retryDelay` sets the interval between attempts in milliseconds, allowing for fine-grained control over retry logic.

```JavaScript
schedo.defineJob(
  'retry-example',
  '0 * * * *',
  async (ctx) => {
    // Job implementation
  },
  {
    // Retry configuration
    retries: 3,                    // Number of retry attempts
    retryDelay: 60000            // Delay between retries (ms)
  }
);
```

--------------------------------

### Create Next.js Endpoint for Schedo Webhook (GitHub Actions Migration)

Source: https://docs.schedo.dev/documentation/frameworks/nextjs

Presents the Next.js endpoint code required to handle scheduled tasks previously managed by GitHub Actions cron. This endpoint will be triggered by Schedo, executing the defined task logic.

```javascript
// Add this to your Next.js app instead
export async function POST(req: NextRequest) {
  // Your scheduled task logic here
  await runScheduledTask();
  return NextResponse.json({ success: true });
}
```
Tokens:
Raw