@objectstack/service-job 4.0.3 → 4.0.5

package/README.md

@@ -0,0 +1,371 @@
+# @objectstack/service-job
+
+Job Service for ObjectStack — implements `IJobService` with setInterval and cron scheduling.
+
+## Features
+
+- **Cron Scheduling**: Schedule jobs with cron expressions
+- **Interval Scheduling**: Run jobs at fixed intervals
+- **Job Queue**: Manage job execution queue
+- **Retry Logic**: Automatic retry on failure with exponential backoff
+- **Job History**: Track execution history and status
+- **Concurrency Control**: Limit concurrent job execution
+- **Timezone Support**: Schedule jobs in specific timezones
+- **Type-Safe**: Full TypeScript support
+
+## Installation
+
+```bash
+pnpm add @objectstack/service-job
+```
+
+## Basic Usage
+
+```typescript
+import { defineStack } from '@objectstack/spec';
+import { ServiceJob } from '@objectstack/service-job';
+
+const stack = defineStack({
+  services: [
+    ServiceJob.configure({
+      timezone: 'America/New_York',
+      maxConcurrent: 5,
+    }),
+  ],
+});
+```
+
+## Configuration
+
+```typescript
+interface JobServiceConfig {
+  /** Default timezone for cron jobs (default: 'UTC') */
+  timezone?: string;
+
+  /** Maximum concurrent job executions (default: 10) */
+  maxConcurrent?: number;
+
+  /** Enable job history tracking (default: true) */
+  enableHistory?: boolean;
+
+  /** Maximum history entries per job (default: 100) */
+  maxHistorySize?: number;
+}
+```
+
+## Service API
+
+```typescript
+// Get job service
+const jobs = kernel.getService<IJobService>('job');
+```
+
+### Cron Jobs
+
+```typescript
+// Schedule a job with cron expression
+const job = await jobs.schedule({
+  name: 'daily_report',
+  schedule: '0 9 * * *', // Every day at 9 AM
+  handler: async (context) => {
+    console.log('Generating daily report...');
+    // Your job logic here
+  },
+  timezone: 'America/New_York',
+});
+
+// Common cron patterns:
+// '*/5 * * * *'      - Every 5 minutes
+// '0 */2 * * *'      - Every 2 hours
+// '0 9 * * 1-5'      - Weekdays at 9 AM
+// '0 0 1 * *'        - First day of every month at midnight
+// '0 0 * * 0'        - Every Sunday at midnight
+```
+
+### Interval Jobs
+
+```typescript
+// Run every 30 seconds
+const job = await jobs.scheduleInterval({
+  name: 'health_check',
+  interval: 30000, // milliseconds
+  handler: async (context) => {
+    console.log('Running health check...');
+  },
+});
+
+// Run every 5 minutes
+const job = await jobs.scheduleInterval({
+  name: 'sync_data',
+  interval: 5 * 60 * 1000, // 5 minutes
+  handler: async (context) => {
+    // Sync data
+  },
+});
+```
+
+### One-Time Jobs
+
+```typescript
+// Schedule a one-time job
+const job = await jobs.scheduleOnce({
+  name: 'send_reminder',
+  runAt: new Date('2024-12-25T09:00:00Z'),
+  handler: async (context) => {
+    console.log('Sending holiday reminder...');
+  },
+});
+
+// Schedule to run after a delay
+const job = await jobs.scheduleOnce({
+  name: 'delayed_task',
+  delay: 3600000, // 1 hour from now
+  handler: async (context) => {
+    console.log('Executing delayed task...');
+  },
+});
+```
+
+### Job Management
+
+```typescript
+// List all jobs
+const allJobs = await jobs.listJobs();
+
+// Get job details
+const job = await jobs.getJob('daily_report');
+
+// Stop a job
+await jobs.stopJob('daily_report');
+
+// Resume a stopped job
+await jobs.resumeJob('daily_report');
+
+// Delete a job
+await jobs.deleteJob('daily_report');
+
+// Run a job immediately (ignoring schedule)
+await jobs.runNow('daily_report');
+```
+
+## Advanced Features
+
+### Job Context
+
+```typescript
+const job = await jobs.schedule({
+  name: 'process_orders',
+  schedule: '*/10 * * * *',
+  handler: async (context) => {
+    console.log('Job name:', context.jobName);
+    console.log('Execution ID:', context.executionId);
+    console.log('Scheduled time:', context.scheduledTime);
+    console.log('Execution count:', context.executionCount);
+
+    // Access services
+    const db = context.kernel.getService('database');
+    const orders = await db.find({ object: 'order', status: 'pending' });
+
+    // Process orders...
+  },
+});
+```
+
+### Retry Configuration
+
+```typescript
+const job = await jobs.schedule({
+  name: 'api_sync',
+  schedule: '0 * * * *', // Every hour
+  retry: {
+    maxAttempts: 3,
+    backoff: 'exponential', // 'linear' or 'exponential'
+    initialDelay: 1000, // 1 second
+    maxDelay: 60000, // 1 minute
+  },
+  handler: async (context) => {
+    // May fail and retry
+    await syncWithExternalAPI();
+  },
+});
+```
+
+### Concurrency Control
+
+```typescript
+const job = await jobs.schedule({
+  name: 'heavy_processing',
+  schedule: '*/5 * * * *',
+  concurrency: 1, // Only one instance can run at a time
+  handler: async (context) => {
+    // Long-running process
+  },
+});
+```
+
+### Job History
+
+```typescript
+// Get execution history for a job
+const history = await jobs.getJobHistory('daily_report', {
+  limit: 50,
+  status: 'success', // 'success', 'failed', 'running'
+});
+
+// Example history entry:
+// {
+//   executionId: 'exec:abc123',
+//   jobName: 'daily_report',
+//   status: 'success',
+//   startedAt: '2024-01-15T09:00:00Z',
+//   completedAt: '2024-01-15T09:05:23Z',
+//   duration: 323000, // milliseconds
+//   error: null,
+//   result: { records: 1250 }
+// }
+
+// Clear history for a job
+await jobs.clearHistory('daily_report');
+```
+
+### Job Data & Results
+
+```typescript
+const job = await jobs.schedule({
+  name: 'data_export',
+  schedule: '0 0 * * *',
+  handler: async (context) => {
+    const records = await exportData();
+
+    // Return result data
+    return {
+      recordCount: records.length,
+      fileSize: calculateSize(records),
+      exportedAt: new Date(),
+    };
+  },
+});
+
+// Get last execution result
+const lastRun = await jobs.getLastExecution('data_export');
+console.log('Last export:', lastRun.result);
+```
+
+## Common Patterns
+
+### Database Cleanup Job
+
+```typescript
+jobs.schedule({
+  name: 'cleanup_old_records',
+  schedule: '0 2 * * *', // 2 AM daily
+  handler: async (context) => {
+    const db = context.kernel.getService('database');
+
+    // Delete records older than 90 days
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 90);
+
+    await db.delete({
+      object: 'audit_log',
+      filters: [{ field: 'created_at', operator: 'lt', value: cutoff }],
+    });
+  },
+});
+```
+
+### Report Generation Job
+
+```typescript
+jobs.schedule({
+  name: 'weekly_sales_report',
+  schedule: '0 8 * * 1', // Mondays at 8 AM
+  handler: async (context) => {
+    const analytics = context.kernel.getService('analytics');
+
+    const data = await analytics.query({
+      object: 'order',
+      aggregations: [{ function: 'sum', field: 'amount' }],
+      groupBy: ['sales_rep'],
+      filters: [{ field: 'created_at', operator: 'last_week' }],
+    });
+
+    // Generate and email report
+    await sendReport(data);
+  },
+});
+```
+
+### Cache Warming Job
+
+```typescript
+jobs.scheduleInterval({
+  name: 'warm_cache',
+  interval: 15 * 60 * 1000, // Every 15 minutes
+  handler: async (context) => {
+    const cache = context.kernel.getService('cache');
+
+    // Pre-load frequently accessed data
+    const popularProducts = await getPopularProducts();
+    await cache.set('popular_products', popularProducts, { ttl: 900 });
+  },
+});
+```
+
+## REST API Endpoints
+
+```
+GET    /api/v1/jobs                    # List all jobs
+GET    /api/v1/jobs/:name              # Get job details
+POST   /api/v1/jobs/:name/run          # Run job immediately
+POST   /api/v1/jobs/:name/stop         # Stop job
+POST   /api/v1/jobs/:name/resume       # Resume job
+DELETE /api/v1/jobs/:name              # Delete job
+GET    /api/v1/jobs/:name/history      # Get execution history
+```
+
+## Best Practices
+
+1. **Idempotent Handlers**: Job handlers should be idempotent (safe to run multiple times)
+2. **Error Handling**: Always handle errors gracefully and log failures
+3. **Timeout Limits**: Set reasonable timeout limits for long-running jobs
+4. **Resource Limits**: Limit concurrent executions to avoid overloading the system
+5. **Monitoring**: Monitor job execution times and failure rates
+6. **Timezone Awareness**: Always specify timezone for cron jobs to avoid ambiguity
+7. **Cleanup**: Periodically delete old job history to save storage
+
+## Performance Considerations
+
+- **Concurrency**: Limit concurrent jobs based on system resources
+- **Job Duration**: Keep job execution time reasonable (< 5 minutes ideal)
+- **History Size**: Limit history entries to prevent memory bloat
+- **Batch Processing**: Process records in batches for large datasets
+
+## Contract Implementation
+
+Implements `IJobService` from `@objectstack/spec/contracts`:
+
+```typescript
+interface IJobService {
+  schedule(options: ScheduleOptions): Promise<Job>;
+  scheduleInterval(options: IntervalOptions): Promise<Job>;
+  scheduleOnce(options: OnceOptions): Promise<Job>;
+  getJob(name: string): Promise<Job>;
+  listJobs(filter?: JobFilter): Promise<Job[]>;
+  stopJob(name: string): Promise<void>;
+  resumeJob(name: string): Promise<void>;
+  deleteJob(name: string): Promise<void>;
+  runNow(name: string): Promise<JobExecution>;
+  getJobHistory(name: string, options?: HistoryOptions): Promise<JobExecution[]>;
+}
+```
+
+## License
+
+Apache-2.0
+
+## See Also
+
+- [Cron Expression Generator](https://crontab.guru/)
+- [@objectstack/spec/contracts](../../spec/src/contracts/)
+- [Job Scheduling Guide](/content/docs/guides/jobs/)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/service-job",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "license": "Apache-2.0",
   "description": "Job Service for ObjectStack — implements IJobService with setInterval and cron scheduling",
   "type": "module",
@@ -14,13 +14,38 @@
     }
   },
   "dependencies": {
-    "@objectstack/core": "4.0.3",
-    "@objectstack/spec": "4.0.3"
+    "@objectstack/core": "4.0.5",
+    "@objectstack/spec": "4.0.5"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "@types/node": "^25.6.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "keywords": [
+    "objectstack",
+    "service",
+    "job",
+    "cron",
+    "scheduler"
+  ],
+  "author": "ObjectStack",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/objectstack-ai/framework.git",
+    "directory": "packages/services/service-job"
+  },
+  "homepage": "https://objectstack.ai/docs",
+  "bugs": "https://github.com/objectstack-ai/framework/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
   },
   "scripts": {
     "build": "tsup --config ../../../tsup.config.ts",

package/.turbo/turbo-build.log

@@ -1,22 +0,0 @@
-
-> @objectstack/service-job@4.0.3 build /home/runner/work/framework/framework/packages/services/service-job
-> tsup --config ../../../tsup.config.ts
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/framework/framework/tsup.config.ts
-CLI Target: es2020
-CLI Cleaning output folder
-ESM Build start
-CJS Build start
-ESM dist/index.js     3.99 KB
-ESM dist/index.js.map 10.88 KB
-ESM ⚡️ Build success in 69ms
-CJS dist/index.cjs     5.09 KB
-CJS dist/index.cjs.map 11.42 KB
-CJS ⚡️ Build success in 71ms
-DTS Build start
-DTS ⚡️ Build success in 10242ms
-DTS dist/index.d.ts  3.60 KB
-DTS dist/index.d.cts 3.60 KB

package/CHANGELOG.md

@@ -1,169 +0,0 @@
-# @objectstack/service-job
-
-## 4.0.3
-
-### Patch Changes
-
-- @objectstack/spec@4.0.3
-- @objectstack/core@4.0.3
-
-## 4.0.2
-
-### Patch Changes
-
-- Updated dependencies [5f659e9]
-  - @objectstack/spec@4.0.2
-  - @objectstack/core@4.0.2
-
-## 4.0.0
-
-### Patch Changes
-
-- Updated dependencies [f08ffc3]
-- Updated dependencies [e0b0a78]
-  - @objectstack/spec@4.0.0
-  - @objectstack/core@4.0.0
-
-## 3.3.1
-
-### Patch Changes
-
-- @objectstack/spec@3.3.1
-- @objectstack/core@3.3.1
-
-## 3.3.0
-
-### Patch Changes
-
-- @objectstack/spec@3.3.0
-- @objectstack/core@3.3.0
-
-## 3.2.9
-
-### Patch Changes
-
-- @objectstack/spec@3.2.9
-- @objectstack/core@3.2.9
-
-## 3.2.8
-
-### Patch Changes
-
-- @objectstack/spec@3.2.8
-- @objectstack/core@3.2.8
-
-## 3.2.7
-
-### Patch Changes
-
-- @objectstack/spec@3.2.7
-- @objectstack/core@3.2.7
-
-## 3.2.6
-
-### Patch Changes
-
-- @objectstack/spec@3.2.6
-- @objectstack/core@3.2.6
-
-## 3.2.5
-
-### Patch Changes
-
-- @objectstack/spec@3.2.5
-- @objectstack/core@3.2.5
-
-## 3.2.4
-
-### Patch Changes
-
-- @objectstack/spec@3.2.4
-- @objectstack/core@3.2.4
-
-## 3.2.3
-
-### Patch Changes
-
-- @objectstack/spec@3.2.3
-- @objectstack/core@3.2.3
-
-## 3.2.2
-
-### Patch Changes
-
-- Updated dependencies [46defbb]
-  - @objectstack/spec@3.2.2
-  - @objectstack/core@3.2.2
-
-## 3.2.1
-
-### Patch Changes
-
-- Updated dependencies [850b546]
-  - @objectstack/spec@3.2.1
-  - @objectstack/core@3.2.1
-
-## 3.2.0
-
-### Patch Changes
-
-- Updated dependencies [5901c29]
-  - @objectstack/spec@3.2.0
-  - @objectstack/core@3.2.0
-
-## 3.1.1
-
-### Patch Changes
-
-- Updated dependencies [953d667]
-  - @objectstack/spec@3.1.1
-  - @objectstack/core@3.1.1
-
-## 3.1.0
-
-### Patch Changes
-
-- Updated dependencies [0088830]
-  - @objectstack/spec@3.1.0
-  - @objectstack/core@3.1.0
-
-## 3.0.11
-
-### Patch Changes
-
-- Updated dependencies [92d9d99]
-  - @objectstack/spec@3.0.11
-  - @objectstack/core@3.0.11
-
-## 3.0.10
-
-### Patch Changes
-
-- Updated dependencies [d1e5d31]
-  - @objectstack/spec@3.0.10
-  - @objectstack/core@3.0.10
-
-## 3.0.9
-
-### Patch Changes
-
-- Updated dependencies [15e0df6]
-  - @objectstack/spec@3.0.9
-  - @objectstack/core@3.0.9
-
-## 3.0.8
-
-### Patch Changes
-
-- Updated dependencies [5a968a2]
-  - @objectstack/spec@3.0.8
-  - @objectstack/core@3.0.8
-
-## 3.0.7
-
-### Patch Changes
-
-- Updated dependencies [0119bd7]
-- Updated dependencies [5426bdf]
-  - @objectstack/spec@3.0.7
-  - @objectstack/core@3.0.7

package/src/cron-job-adapter.ts

@@ -1,51 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { IJobService, JobSchedule, JobHandler, JobExecution } from '@objectstack/spec/contracts';
-
-/**
- * Configuration for the cron-based job adapter.
- */
-export interface CronJobAdapterOptions {
-  /** Timezone for cron expressions (default: 'UTC') */
-  timezone?: string;
-}
-
-/**
- * Cron-based job adapter skeleton implementing IJobService.
- *
- * This is a placeholder for future cron integration (e.g., `node-cron` or `croner`).
- * Concrete implementation will parse cron expressions and schedule jobs accordingly.
- *
- * @example
- * ```ts
- * const scheduler = new CronJobAdapter({ timezone: 'America/New_York' });
- * await scheduler.schedule('nightly-cleanup', { type: 'cron', expression: '0 0 * * *' }, handler);
- * ```
- */
-export class CronJobAdapter implements IJobService {
-  private readonly timezone: string;
-
-  constructor(options: CronJobAdapterOptions = {}) {
-    this.timezone = options.timezone ?? 'UTC';
-  }
-
-  async schedule(_name: string, _schedule: JobSchedule, _handler: JobHandler): Promise<void> {
-    throw new Error(`CronJobAdapter not yet implemented (timezone: ${this.timezone})`);
-  }
-
-  async cancel(_name: string): Promise<void> {
-    throw new Error('CronJobAdapter not yet implemented');
-  }
-
-  async trigger(_name: string, _data?: unknown): Promise<void> {
-    throw new Error('CronJobAdapter not yet implemented');
-  }
-
-  async getExecutions(_name: string, _limit?: number): Promise<JobExecution[]> {
-    throw new Error('CronJobAdapter not yet implemented');
-  }
-
-  async listJobs(): Promise<string[]> {
-    throw new Error('CronJobAdapter not yet implemented');
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export { JobServicePlugin } from './job-service-plugin.js';
-export type { JobServicePluginOptions } from './job-service-plugin.js';
-export { IntervalJobAdapter } from './interval-job-adapter.js';
-export type { IntervalJobAdapterOptions } from './interval-job-adapter.js';
-export { CronJobAdapter } from './cron-job-adapter.js';
-export type { CronJobAdapterOptions } from './cron-job-adapter.js';

package/src/interval-job-adapter.test.ts

@@ -1,120 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { describe, it, expect, afterEach } from 'vitest';
-import { IntervalJobAdapter } from './interval-job-adapter';
-import type { IJobService } from '@objectstack/spec/contracts';
-
-describe('IntervalJobAdapter', () => {
-  let adapter: IntervalJobAdapter;
-
-  afterEach(async () => {
-    await adapter?.destroy();
-  });
-
-  it('should implement IJobService contract', () => {
-    adapter = new IntervalJobAdapter();
-    const job: IJobService = adapter;
-    expect(typeof job.schedule).toBe('function');
-    expect(typeof job.cancel).toBe('function');
-    expect(typeof job.trigger).toBe('function');
-    expect(typeof job.getExecutions).toBe('function');
-    expect(typeof job.listJobs).toBe('function');
-  });
-
-  it('should schedule and list jobs', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('daily-report', { type: 'cron', expression: '0 0 * * *' }, async () => {});
-    expect(await adapter.listJobs()).toEqual(['daily-report']);
-  });
-
-  it('should cancel a job', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('temp-job', { type: 'cron', expression: '* * * * *' }, async () => {});
-    await adapter.cancel('temp-job');
-    expect(await adapter.listJobs()).toEqual([]);
-  });
-
-  it('should trigger a job handler with data', async () => {
-    adapter = new IntervalJobAdapter();
-    let triggered = false;
-    let receivedCtx: any;
-
-    await adapter.schedule('my-job', { type: 'cron', expression: '* * * * *' }, async (ctx) => {
-      triggered = true;
-      receivedCtx = ctx;
-    });
-
-    await adapter.trigger('my-job', { key: 'val' });
-    expect(triggered).toBe(true);
-    expect(receivedCtx.jobId).toBe('my-job');
-    expect(receivedCtx.data).toEqual({ key: 'val' });
-  });
-
-  it('should throw when triggering non-existent job', async () => {
-    adapter = new IntervalJobAdapter();
-    await expect(adapter.trigger('missing')).rejects.toThrow('Job "missing" not found');
-  });
-
-  it('should record execution history', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('tracked-job', { type: 'cron', expression: '* * * * *' }, async () => {});
-    await adapter.trigger('tracked-job');
-
-    const execs = await adapter.getExecutions('tracked-job');
-    expect(execs).toHaveLength(1);
-    expect(execs[0].status).toBe('success');
-    expect(execs[0].jobId).toBe('tracked-job');
-    expect(execs[0].startedAt).toBeTruthy();
-    expect(execs[0].completedAt).toBeTruthy();
-    expect(typeof execs[0].durationMs).toBe('number');
-  });
-
-  it('should record failed executions', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('fail-job', { type: 'cron', expression: '* * * * *' }, async () => {
-      throw new Error('Job failed');
-    });
-
-    await adapter.trigger('fail-job');
-
-    const execs = await adapter.getExecutions('fail-job');
-    expect(execs).toHaveLength(1);
-    expect(execs[0].status).toBe('failed');
-    expect(execs[0].error).toBe('Job failed');
-  });
-
-  it('should return empty executions for non-existent job', async () => {
-    adapter = new IntervalJobAdapter();
-    expect(await adapter.getExecutions('missing')).toEqual([]);
-  });
-
-  it('should limit execution history with limit param', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('multi-job', { type: 'cron', expression: '* * * * *' }, async () => {});
-    await adapter.trigger('multi-job');
-    await adapter.trigger('multi-job');
-    await adapter.trigger('multi-job');
-
-    const execs = await adapter.getExecutions('multi-job', 2);
-    expect(execs).toHaveLength(2);
-  });
-
-  it('should replace existing job with same name', async () => {
-    adapter = new IntervalJobAdapter();
-    let count = 0;
-    await adapter.schedule('dup', { type: 'cron', expression: '* * * * *' }, async () => { count = 1; });
-    await adapter.schedule('dup', { type: 'cron', expression: '* * * * *' }, async () => { count = 2; });
-
-    await adapter.trigger('dup');
-    expect(count).toBe(2);
-    expect(await adapter.listJobs()).toEqual(['dup']);
-  });
-
-  it('should clean up all timers on destroy', async () => {
-    adapter = new IntervalJobAdapter();
-    await adapter.schedule('j1', { type: 'interval', intervalMs: 100000 }, async () => {});
-    await adapter.schedule('j2', { type: 'interval', intervalMs: 100000 }, async () => {});
-    await adapter.destroy();
-    expect(await adapter.listJobs()).toEqual([]);
-  });
-});

package/src/interval-job-adapter.ts

@@ -1,130 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { IJobService, JobSchedule, JobHandler, JobExecution } from '@objectstack/spec/contracts';
-
-/**
- * Internal record for a scheduled job.
- */
-interface JobRecord {
-  name: string;
-  schedule: JobSchedule;
-  handler: JobHandler;
-  timerId?: ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>;
-  executions: JobExecution[];
-}
-
-/**
- * Configuration options for IntervalJobAdapter.
- */
-export interface IntervalJobAdapterOptions {
-  /** Maximum number of execution records to retain per job (default: 100) */
-  maxExecutions?: number;
-}
-
-/**
- * setInterval-based job adapter implementing IJobService.
- *
- * Supports `interval` and `once` schedule types using Node.js timers.
- * `cron` schedules are stored but not actively executed (requires a cron
- * library — see CronJobAdapter skeleton).
- *
- * Suitable for single-process environments, development, and testing.
- */
-export class IntervalJobAdapter implements IJobService {
-  private readonly jobs = new Map<string, JobRecord>();
-  private readonly maxExecutions: number;
-
-  constructor(options: IntervalJobAdapterOptions = {}) {
-    this.maxExecutions = options.maxExecutions ?? 100;
-  }
-
-  async schedule(name: string, schedule: JobSchedule, handler: JobHandler): Promise<void> {
-    // Cancel any existing job with the same name
-    await this.cancel(name);
-
-    const record: JobRecord = { name, schedule, handler, executions: [] };
-
-    if (schedule.type === 'interval' && schedule.intervalMs) {
-      record.timerId = setInterval(async () => {
-        await this.executeJob(record);
-      }, schedule.intervalMs);
-    } else if (schedule.type === 'once' && schedule.at) {
-      const delay = new Date(schedule.at).getTime() - Date.now();
-      if (delay > 0) {
-        record.timerId = setTimeout(async () => {
-          await this.executeJob(record);
-        }, delay);
-      }
-    }
-    // 'cron' type: stored but not actively scheduled (needs cron library)
-
-    this.jobs.set(name, record);
-  }
-
-  async cancel(name: string): Promise<void> {
-    const record = this.jobs.get(name);
-    if (record?.timerId) {
-      clearInterval(record.timerId as ReturnType<typeof setInterval>);
-      clearTimeout(record.timerId as ReturnType<typeof setTimeout>);
-    }
-    this.jobs.delete(name);
-  }
-
-  async trigger(name: string, data?: unknown): Promise<void> {
-    const record = this.jobs.get(name);
-    if (!record) {
-      throw new Error(`Job "${name}" not found`);
-    }
-    await this.executeJob(record, data);
-  }
-
-  async getExecutions(name: string, limit?: number): Promise<JobExecution[]> {
-    const record = this.jobs.get(name);
-    if (!record) return [];
-    const execs = record.executions;
-    return limit ? execs.slice(-limit) : execs;
-  }
-
-  async listJobs(): Promise<string[]> {
-    return [...this.jobs.keys()];
-  }
-
-  /**
-   * Stop all active timers. Call during plugin destroy phase.
-   */
-  async destroy(): Promise<void> {
-    for (const record of this.jobs.values()) {
-      if (record.timerId) {
-        clearInterval(record.timerId as ReturnType<typeof setInterval>);
-        clearTimeout(record.timerId as ReturnType<typeof setTimeout>);
-      }
-    }
-    this.jobs.clear();
-  }
-
-  private async executeJob(record: JobRecord, data?: unknown): Promise<void> {
-    const execution: JobExecution = {
-      jobId: record.name,
-      status: 'running',
-      startedAt: new Date().toISOString(),
-    };
-
-    const startMs = Date.now();
-    try {
-      await record.handler({ jobId: record.name, data });
-      execution.status = 'success';
-    } catch (err) {
-      execution.status = 'failed';
-      execution.error = err instanceof Error ? err.message : String(err);
-    } finally {
-      execution.completedAt = new Date().toISOString();
-      execution.durationMs = Date.now() - startMs;
-
-      record.executions.push(execution);
-      // Trim old executions
-      if (record.executions.length > this.maxExecutions) {
-        record.executions.splice(0, record.executions.length - this.maxExecutions);
-      }
-    }
-  }
-}

package/src/job-service-plugin.ts

@@ -1,65 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { Plugin, PluginContext } from '@objectstack/core';
-import { IntervalJobAdapter } from './interval-job-adapter.js';
-import type { IntervalJobAdapterOptions } from './interval-job-adapter.js';
-
-/**
- * Configuration options for the JobServicePlugin.
- */
-export interface JobServicePluginOptions {
-  /** Job adapter type (default: 'interval') */
-  adapter?: 'interval' | 'cron';
-  /** Options for the interval job adapter */
-  interval?: IntervalJobAdapterOptions;
-}
-
-/**
- * JobServicePlugin — Production IJobService implementation.
- *
- * Registers a job scheduler with the kernel during the init phase.
- * Supports setInterval-based and cron-based adapters.
- *
- * @example
- * ```ts
- * import { ObjectKernel } from '@objectstack/core';
- * import { JobServicePlugin } from '@objectstack/service-job';
- *
- * const kernel = new ObjectKernel();
- * kernel.use(new JobServicePlugin({ adapter: 'interval' }));
- * await kernel.bootstrap();
- *
- * const job = kernel.getService('job');
- * await job.schedule('cleanup', { type: 'interval', intervalMs: 60000 }, handler);
- * ```
- */
-export class JobServicePlugin implements Plugin {
-  name = 'com.objectstack.service.job';
-  version = '1.0.0';
-  type = 'standard';
-
-  private readonly options: JobServicePluginOptions;
-  private adapter?: IntervalJobAdapter;
-
-  constructor(options: JobServicePluginOptions = {}) {
-    this.options = { adapter: 'interval', ...options };
-  }
-
-  async init(ctx: PluginContext): Promise<void> {
-    const adapterType = this.options.adapter;
-    if (adapterType === 'cron') {
-      throw new Error(
-        'Cron job adapter is not yet implemented. ' +
-        'Use adapter: "interval" or provide a custom IJobService via ctx.registerService("job", impl).'
-      );
-    }
-
-    this.adapter = new IntervalJobAdapter(this.options.interval);
-    ctx.registerService('job', this.adapter);
-    ctx.logger.info('JobServicePlugin: registered interval job adapter');
-  }
-
-  async destroy(): Promise<void> {
-    await this.adapter?.destroy();
-  }
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "types": ["node"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}