@lssm/lib.jobs 0.0.0-canary-20251206160926

package/dist/entities/index.js

@@ -0,0 +1 @@
+import{i as e,n as t,r as n,t as r}from"../schema/dist/entity/defineEntity.js";import"../schema/dist/index.js";const i=t({name:`JobStatus`,values:[`PENDING`,`RUNNING`,`COMPLETED`,`FAILED`,`CANCELLED`,`DEAD_LETTER`],schema:`lssm_jobs`,description:`Status of a background job.`}),a=r({name:`Job`,description:`A background job for async processing.`,schema:`lssm_jobs`,map:`job`,fields:{id:n.id({description:`Unique job identifier`}),type:n.string({description:`Job type identifier`}),version:n.int({default:1,description:`Job type version`}),payload:n.json({description:`Job payload data`}),status:n.enum(`JobStatus`,{default:`PENDING`}),priority:n.int({default:0,description:`Higher = more urgent`}),attempts:n.int({default:0,description:`Number of execution attempts`}),maxRetries:n.int({default:3,description:`Maximum retry attempts`}),lastError:n.string({isOptional:!0,description:`Last error message`}),lastErrorStack:n.string({isOptional:!0,description:`Last error stack trace`}),scheduledAt:n.dateTime({isOptional:!0,description:`When job should be processed`}),startedAt:n.dateTime({isOptional:!0,description:`When processing started`}),completedAt:n.dateTime({isOptional:!0,description:`When processing completed`}),timeoutAt:n.dateTime({isOptional:!0,description:`Job timeout deadline`}),dedupeKey:n.string({isOptional:!0,description:`Key for deduplication`}),tenantId:n.string({isOptional:!0,description:`Tenant/org context`}),userId:n.string({isOptional:!0,description:`User who enqueued`}),traceId:n.string({isOptional:!0,description:`Distributed trace ID`}),metadata:n.json({isOptional:!0,description:`Additional metadata`}),result:n.json({isOptional:!0,description:`Job result data`}),createdAt:n.createdAt(),updatedAt:n.updatedAt(),scheduledJob:n.belongsTo(`ScheduledJob`,[`scheduledJobId`],[`id`]),scheduledJobId:n.string({isOptional:!0}),executions:n.hasMany(`JobExecution`)},indexes:[e.on([`status`,`scheduledAt`]),e.on([`type`,`status`]),e.on([`tenantId`,`status`]),e.unique([`dedupeKey`],{name:`job_dedupe_key_unique`})],enums:[i]}),o=r({name:`ScheduledJob`,description:`A scheduled/recurring job definition.`,schema:`lssm_jobs`,map:`scheduled_job`,fields:{id:n.id(),name:n.string({isUnique:!0,description:`Unique schedule name`}),description:n.string({isOptional:!0}),cronExpression:n.string({description:`Cron expression for scheduling`}),timezone:n.string({default:`"UTC"`,description:`Timezone for cron evaluation`}),jobType:n.string({description:`Job type to create`}),jobVersion:n.int({default:1}),payload:n.json({isOptional:!0,description:`Default payload for created jobs`}),maxRetries:n.int({default:3}),timeoutMs:n.int({isOptional:!0,description:`Job timeout in milliseconds`}),enabled:n.boolean({default:!0}),lastRunAt:n.dateTime({isOptional:!0}),nextRunAt:n.dateTime({isOptional:!0}),tenantId:n.string({isOptional:!0}),createdAt:n.createdAt(),updatedAt:n.updatedAt(),jobs:n.hasMany(`Job`)},indexes:[e.on([`enabled`,`nextRunAt`])]}),s=r({name:`JobExecution`,description:`A single execution attempt of a job.`,schema:`lssm_jobs`,map:`job_execution`,fields:{id:n.id(),jobId:n.foreignKey(),attemptNumber:n.int({description:`Which attempt this is`}),startedAt:n.dateTime(),completedAt:n.dateTime({isOptional:!0}),durationMs:n.int({isOptional:!0}),success:n.boolean({isOptional:!0}),error:n.string({isOptional:!0}),errorStack:n.string({isOptional:!0}),result:n.json({isOptional:!0}),workerId:n.string({isOptional:!0,description:`ID of worker that processed`}),job:n.belongsTo(`Job`,[`jobId`],[`id`],{onDelete:`Cascade`})},indexes:[e.on([`jobId`,`attemptNumber`])]}),c=[a,o,s],l={moduleId:`@lssm/lib.jobs`,entities:c,enums:[i]};export{a as JobEntity,s as JobExecutionEntity,i as JobStatusEnum,o as ScheduledJobEntity,c as jobEntities,l as jobsSchemaContribution};

package/dist/events.d.ts

@@ -0,0 +1,387 @@
+import * as _lssm_lib_schema114 from "@lssm/lib.schema";
+import * as _lssm_lib_contracts0 from "@lssm/lib.contracts";
+
+//#region src/events.d.ts
+/**
+ * Emitted when a job is enqueued.
+ */
+declare const JobEnqueuedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  priority: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  scheduledAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: true;
+  };
+  tenantId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: true;
+  };
+  enqueuedAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job starts processing.
+ */
+declare const JobStartedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  attempt: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  startedAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job completes successfully.
+ */
+declare const JobCompletedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  attempt: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  durationMs: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  completedAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job fails (single attempt).
+ */
+declare const JobFailedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  attempt: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  error: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  willRetry: {
+    type: _lssm_lib_schema114.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  failedAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job is being retried.
+ */
+declare const JobRetryingEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  attempt: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  nextAttemptAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+  backoffMs: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job is moved to dead letter queue.
+ */
+declare const JobDeadLetteredEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  attempts: {
+    type: _lssm_lib_schema114.FieldType<number, number>;
+    isOptional: false;
+  };
+  lastError: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  deadLetteredAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a job is cancelled.
+ */
+declare const JobCancelledEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  type: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  cancelledBy: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: true;
+  };
+  cancelledAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+}>>;
+/**
+ * Emitted when a scheduled job is triggered.
+ */
+declare const ScheduledJobTriggeredEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+  scheduleName: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  jobId: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  jobType: {
+    type: _lssm_lib_schema114.FieldType<string, string>;
+    isOptional: false;
+  };
+  triggeredAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: false;
+  };
+  nextRunAt: {
+    type: _lssm_lib_schema114.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>>;
+/**
+ * All job events.
+ */
+declare const JobEvents: {
+  JobEnqueuedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    priority: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    scheduledAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: true;
+    };
+    tenantId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: true;
+    };
+    enqueuedAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  JobStartedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    attempt: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    startedAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  JobCompletedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    attempt: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    durationMs: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    completedAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  JobFailedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    attempt: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    error: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    willRetry: {
+      type: _lssm_lib_schema114.FieldType<boolean, boolean>;
+      isOptional: false;
+    };
+    failedAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  JobRetryingEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    attempt: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    nextAttemptAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+    backoffMs: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+  }>>;
+  JobDeadLetteredEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    attempts: {
+      type: _lssm_lib_schema114.FieldType<number, number>;
+      isOptional: false;
+    };
+    lastError: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    deadLetteredAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  JobCancelledEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    type: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    cancelledBy: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: true;
+    };
+    cancelledAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+  }>>;
+  ScheduledJobTriggeredEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema114.SchemaModel<{
+    scheduleName: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    jobId: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    jobType: {
+      type: _lssm_lib_schema114.FieldType<string, string>;
+      isOptional: false;
+    };
+    triggeredAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: false;
+    };
+    nextRunAt: {
+      type: _lssm_lib_schema114.FieldType<Date, string>;
+      isOptional: true;
+    };
+  }>>;
+};
+//#endregion
+export { JobCancelledEvent, JobCompletedEvent, JobDeadLetteredEvent, JobEnqueuedEvent, JobEvents, JobFailedEvent, JobRetryingEvent, JobStartedEvent, ScheduledJobTriggeredEvent };

package/dist/events.js

@@ -0,0 +1 @@
+import{l as e}from"./schema/dist/ScalarTypeEnum.js";import{n as t}from"./schema/dist/SchemaModel.js";import"./schema/dist/index.js";import{e as n}from"./contracts/dist/events.js";import"./contracts/dist/index.js";const r=t({name:`JobEnqueuedEventPayload`,description:`Payload when a job is added to the queue`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},priority:{type:e.Int_unsecure(),isOptional:!1},scheduledAt:{type:e.DateTime(),isOptional:!0},tenantId:{type:e.String_unsecure(),isOptional:!0},enqueuedAt:{type:e.DateTime(),isOptional:!1}}}),i=t({name:`JobStartedEventPayload`,description:`Payload when a job starts processing`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},attempt:{type:e.Int_unsecure(),isOptional:!1},startedAt:{type:e.DateTime(),isOptional:!1}}}),a=t({name:`JobCompletedEventPayload`,description:`Payload when a job completes successfully`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},attempt:{type:e.Int_unsecure(),isOptional:!1},durationMs:{type:e.Int_unsecure(),isOptional:!1},completedAt:{type:e.DateTime(),isOptional:!1}}}),o=t({name:`JobFailedEventPayload`,description:`Payload when a job attempt fails`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},attempt:{type:e.Int_unsecure(),isOptional:!1},error:{type:e.String_unsecure(),isOptional:!1},willRetry:{type:e.Boolean(),isOptional:!1},failedAt:{type:e.DateTime(),isOptional:!1}}}),s=t({name:`JobRetryingEventPayload`,description:`Payload when a job is scheduled for retry`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},attempt:{type:e.Int_unsecure(),isOptional:!1},nextAttemptAt:{type:e.DateTime(),isOptional:!1},backoffMs:{type:e.Int_unsecure(),isOptional:!1}}}),c=t({name:`JobDeadLetteredEventPayload`,description:`Payload when a job is moved to dead letter queue`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},attempts:{type:e.Int_unsecure(),isOptional:!1},lastError:{type:e.String_unsecure(),isOptional:!1},deadLetteredAt:{type:e.DateTime(),isOptional:!1}}}),l=t({name:`JobCancelledEventPayload`,description:`Payload when a job is cancelled`,fields:{jobId:{type:e.String_unsecure(),isOptional:!1},type:{type:e.String_unsecure(),isOptional:!1},cancelledBy:{type:e.String_unsecure(),isOptional:!0},cancelledAt:{type:e.DateTime(),isOptional:!1}}}),u=t({name:`ScheduledJobTriggeredEventPayload`,description:`Payload when a scheduled job is triggered`,fields:{scheduleName:{type:e.String_unsecure(),isOptional:!1},jobId:{type:e.String_unsecure(),isOptional:!1},jobType:{type:e.String_unsecure(),isOptional:!1},triggeredAt:{type:e.DateTime(),isOptional:!1},nextRunAt:{type:e.DateTime(),isOptional:!0}}}),d=n({name:`job.enqueued`,version:1,description:`A job has been added to the queue.`,payload:r}),f=n({name:`job.started`,version:1,description:`A job has started processing.`,payload:i}),p=n({name:`job.completed`,version:1,description:`A job has completed successfully.`,payload:a}),m=n({name:`job.failed`,version:1,description:`A job attempt has failed.`,payload:o}),h=n({name:`job.retrying`,version:1,description:`A job is being scheduled for retry.`,payload:s}),g=n({name:`job.dead_lettered`,version:1,description:`A job has exhausted all retries and moved to dead letter queue.`,payload:c}),_=n({name:`job.cancelled`,version:1,description:`A job has been cancelled.`,payload:l}),v=n({name:`scheduler.job_triggered`,version:1,description:`A scheduled job has been triggered.`,payload:u}),y={JobEnqueuedEvent:d,JobStartedEvent:f,JobCompletedEvent:p,JobFailedEvent:m,JobRetryingEvent:h,JobDeadLetteredEvent:g,JobCancelledEvent:_,ScheduledJobTriggeredEvent:v};export{_ as JobCancelledEvent,p as JobCompletedEvent,g as JobDeadLetteredEvent,d as JobEnqueuedEvent,y as JobEvents,m as JobFailedEvent,h as JobRetryingEvent,f as JobStartedEvent,v as ScheduledJobTriggeredEvent};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { CancelJobContract, CreateScheduledJobContract, EnqueueJobContract, GetJobContract, GetQueueStatsContract, JobModel, ListScheduledJobsContract, QueueStatsModel, ScheduledJobModel, ToggleScheduledJobContract } from "./contracts/index.js";
+import { JobEntity, JobExecutionEntity, JobStatusEnum, ScheduledJobEntity, jobEntities, jobsSchemaContribution } from "./entities/index.js";
+import { JobCancelledEvent, JobCompletedEvent, JobDeadLetteredEvent, JobEnqueuedEvent, JobEvents, JobFailedEvent, JobRetryingEvent, JobStartedEvent, ScheduledJobTriggeredEvent } from "./events.js";
+import { DEFAULT_RETRY_POLICY, EnqueueOptions, Job, JobHandler, JobQueue, JobStatus, JobTypeDef, QueueStats, RetryPolicy, calculateBackoff, defineJobType } from "./queue/types.js";
+import { MemoryJobQueue, MemoryQueueOptions } from "./queue/memory-queue.js";
+import "./queue/index.js";
+import { ActiveSchedule, JobScheduler, ScheduledJobConfig, createScheduler, defineSchedule } from "./scheduler/index.js";
+export { ActiveSchedule, CancelJobContract, CreateScheduledJobContract, DEFAULT_RETRY_POLICY, EnqueueJobContract, EnqueueOptions, GetJobContract, GetQueueStatsContract, Job, JobCancelledEvent, JobCompletedEvent, JobDeadLetteredEvent, JobEnqueuedEvent, JobEntity, JobEvents, JobExecutionEntity, JobFailedEvent, JobHandler, JobModel, JobQueue, JobRetryingEvent, JobScheduler, JobStartedEvent, JobStatus, JobStatusEnum, JobTypeDef, ListScheduledJobsContract, MemoryJobQueue, MemoryQueueOptions, QueueStats, QueueStatsModel, RetryPolicy, ScheduledJobConfig, ScheduledJobEntity, ScheduledJobModel, ScheduledJobTriggeredEvent, ToggleScheduledJobContract, calculateBackoff, createScheduler, defineJobType, defineSchedule, jobEntities, jobsSchemaContribution };

package/dist/index.js

@@ -0,0 +1 @@
+import{JobCancelledEvent as e,JobCompletedEvent as t,JobDeadLetteredEvent as n,JobEnqueuedEvent as r,JobEvents as i,JobFailedEvent as a,JobRetryingEvent as o,JobStartedEvent as s,ScheduledJobTriggeredEvent as c}from"./events.js";import{JobEntity as l,JobExecutionEntity as u,JobStatusEnum as d,ScheduledJobEntity as f,jobEntities as p,jobsSchemaContribution as m}from"./entities/index.js";import{DEFAULT_RETRY_POLICY as h,calculateBackoff as g,defineJobType as _}from"./queue/types.js";import{MemoryJobQueue as v}from"./queue/memory-queue.js";import"./queue/index.js";import{JobScheduler as y,createScheduler as b,defineSchedule as x}from"./scheduler/index.js";import{CancelJobContract as S,CreateScheduledJobContract as C,EnqueueJobContract as w,GetJobContract as T,GetQueueStatsContract as E,JobModel as D,ListScheduledJobsContract as O,QueueStatsModel as k,ScheduledJobModel as A,ToggleScheduledJobContract as j}from"./contracts/index.js";export{S as CancelJobContract,C as CreateScheduledJobContract,h as DEFAULT_RETRY_POLICY,w as EnqueueJobContract,T as GetJobContract,E as GetQueueStatsContract,e as JobCancelledEvent,t as JobCompletedEvent,n as JobDeadLetteredEvent,r as JobEnqueuedEvent,l as JobEntity,i as JobEvents,u as JobExecutionEntity,a as JobFailedEvent,D as JobModel,o as JobRetryingEvent,y as JobScheduler,s as JobStartedEvent,d as JobStatusEnum,O as ListScheduledJobsContract,v as MemoryJobQueue,k as QueueStatsModel,f as ScheduledJobEntity,A as ScheduledJobModel,c as ScheduledJobTriggeredEvent,j as ToggleScheduledJobContract,g as calculateBackoff,b as createScheduler,_ as defineJobType,x as defineSchedule,p as jobEntities,m as jobsSchemaContribution};

package/dist/queue/index.d.ts

@@ -0,0 +1,3 @@
+import { DEFAULT_RETRY_POLICY, EnqueueOptions, Job, JobHandler, JobQueue, JobStatus, JobTypeDef, QueueStats, RetryPolicy, calculateBackoff, defineJobType } from "./types.js";
+import { MemoryJobQueue, MemoryQueueOptions } from "./memory-queue.js";
+export { DEFAULT_RETRY_POLICY, EnqueueOptions, Job, JobHandler, JobQueue, JobStatus, JobTypeDef, MemoryJobQueue, MemoryQueueOptions, QueueStats, RetryPolicy, calculateBackoff, defineJobType };

package/dist/queue/index.js

@@ -0,0 +1 @@
+import{DEFAULT_RETRY_POLICY as e,calculateBackoff as t,defineJobType as n}from"./types.js";import{MemoryJobQueue as r}from"./memory-queue.js";export{e as DEFAULT_RETRY_POLICY,r as MemoryJobQueue,t as calculateBackoff,n as defineJobType};

package/dist/queue/memory-queue.d.ts

@@ -0,0 +1,34 @@
+import { EnqueueOptions, Job, JobHandler, JobQueue, QueueStats, RetryPolicy } from "./types.js";
+
+//#region src/queue/memory-queue.d.ts
+interface MemoryQueueOptions {
+  /** Poll interval in milliseconds */
+  pollIntervalMs?: number;
+  /** Maximum concurrent jobs */
+  concurrency?: number;
+  /** Default retry policy */
+  retryPolicy?: RetryPolicy;
+}
+/**
+ * In-memory job queue for development and testing.
+ */
+declare class MemoryJobQueue implements JobQueue {
+  private readonly jobs;
+  private readonly handlers;
+  private timer?;
+  private activeCount;
+  private readonly pollIntervalMs;
+  private readonly concurrency;
+  private readonly retryPolicy;
+  constructor(options?: MemoryQueueOptions);
+  enqueue<TPayload>(jobType: string, payload: TPayload, options?: EnqueueOptions): Promise<Job<TPayload>>;
+  register<TPayload, TResult = void>(jobType: string, handler: JobHandler<TPayload, TResult>): void;
+  start(): void;
+  stop(): Promise<void>;
+  getJob(jobId: string): Promise<Job | null>;
+  cancelJob(jobId: string): Promise<boolean>;
+  getStats(): Promise<QueueStats>;
+  private processNext;
+}
+//#endregion
+export { MemoryJobQueue, MemoryQueueOptions };

package/dist/queue/memory-queue.js

@@ -0,0 +1 @@
+import{DEFAULT_RETRY_POLICY as e,calculateBackoff as t}from"./types.js";import{randomUUID as n}from"node:crypto";var r=class{jobs=new Map;handlers=new Map;timer;activeCount=0;pollIntervalMs;concurrency;retryPolicy;constructor(t={}){this.pollIntervalMs=t.pollIntervalMs??200,this.concurrency=t.concurrency??5,this.retryPolicy=t.retryPolicy??e}async enqueue(e,t,r={}){if(r.dedupeKey){let e=Array.from(this.jobs.values()).find(e=>e.dedupeKey===r.dedupeKey&&e.status===`pending`);if(e)return e}let i=new Date,a=r.delaySeconds?new Date(i.getTime()+r.delaySeconds*1e3):i,o={id:n(),type:e,version:1,payload:t,status:`pending`,priority:r.priority??0,attempts:0,maxRetries:r.maxRetries??this.retryPolicy.maxRetries,createdAt:i,updatedAt:i,scheduledAt:a,dedupeKey:r.dedupeKey,tenantId:r.tenantId,userId:r.userId,traceId:r.traceId,metadata:r.metadata};return r.timeoutMs&&(o.timeoutAt=new Date(i.getTime()+r.timeoutMs)),this.jobs.set(o.id,o),o}register(e,t){this.handlers.set(e,t)}start(){this.timer||=setInterval(()=>{this.processNext()},this.pollIntervalMs)}async stop(){for(this.timer&&=(clearInterval(this.timer),void 0);this.activeCount>0;)await new Promise(e=>setTimeout(e,50))}async getJob(e){return this.jobs.get(e)??null}async cancelJob(e){let t=this.jobs.get(e);return!t||t.status!==`pending`?!1:(t.status=`cancelled`,t.updatedAt=new Date,!0)}async getStats(){let e={pending:0,running:0,completed:0,failed:0,deadLetter:0};for(let t of this.jobs.values())switch(t.status){case`pending`:e.pending++;break;case`running`:e.running++;break;case`completed`:e.completed++;break;case`failed`:e.failed++;break;case`dead_letter`:e.deadLetter++;break}return e}async processNext(){if(this.activeCount>=this.concurrency)return;let e=new Date,n=Array.from(this.jobs.values()).filter(t=>t.status===`pending`&&(!t.scheduledAt||t.scheduledAt<=e)).sort((e,t)=>e.priority===t.priority?(e.scheduledAt?.getTime()??0)-(t.scheduledAt?.getTime()??0):t.priority-e.priority)[0];if(!n)return;let r=this.handlers.get(n.type);if(r){this.activeCount++,n.status=`running`,n.startedAt=new Date,n.updatedAt=new Date,n.attempts+=1;try{let e=await r(n);n.status=`completed`,n.completedAt=new Date,n.result=e}catch(e){if(n.lastError=e instanceof Error?e.message:`Unknown error`,n.attempts>=n.maxRetries)n.status=`dead_letter`;else{let e=t(n.attempts,this.retryPolicy);n.status=`pending`,n.scheduledAt=new Date(Date.now()+e)}}finally{n.updatedAt=new Date,this.activeCount--}}}};export{r as MemoryJobQueue};

package/dist/queue/types.d.ts

@@ -0,0 +1,131 @@
+import { z } from "zod";
+
+//#region src/queue/types.d.ts
+
+/**
+ * Job status values.
+ */
+type JobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'dead_letter';
+/**
+ * A job in the queue.
+ */
+interface Job<TPayload = unknown> {
+  id: string;
+  type: string;
+  version: number;
+  payload: TPayload;
+  status: JobStatus;
+  priority: number;
+  attempts: number;
+  maxRetries: number;
+  createdAt: Date;
+  updatedAt: Date;
+  scheduledAt?: Date;
+  startedAt?: Date;
+  completedAt?: Date;
+  timeoutAt?: Date;
+  lastError?: string;
+  dedupeKey?: string;
+  tenantId?: string;
+  userId?: string;
+  traceId?: string;
+  metadata?: Record<string, unknown>;
+  result?: unknown;
+}
+/**
+ * Options for enqueueing a job.
+ */
+interface EnqueueOptions {
+  /** Delay execution by this many seconds */
+  delaySeconds?: number;
+  /** Key for deduplication (only one job with this key can be pending) */
+  dedupeKey?: string;
+  /** Maximum retry attempts (overrides job type default) */
+  maxRetries?: number;
+  /** Job priority (higher = more urgent) */
+  priority?: number;
+  /** Timeout in milliseconds */
+  timeoutMs?: number;
+  /** Tenant context */
+  tenantId?: string;
+  /** User who enqueued */
+  userId?: string;
+  /** Trace ID for distributed tracing */
+  traceId?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Job handler function.
+ */
+type JobHandler<TPayload = unknown, TResult = void> = (job: Job<TPayload>) => Promise<TResult>;
+/**
+ * Job queue interface.
+ */
+interface JobQueue {
+  /** Enqueue a new job */
+  enqueue<TPayload>(jobType: string, payload: TPayload, options?: EnqueueOptions): Promise<Job<TPayload>>;
+  /** Register a handler for a job type */
+  register<TPayload, TResult = void>(jobType: string, handler: JobHandler<TPayload, TResult>): void;
+  /** Start processing jobs */
+  start(): void;
+  /** Stop processing jobs gracefully */
+  stop(): Promise<void>;
+  /** Get job by ID */
+  getJob?(jobId: string): Promise<Job | null>;
+  /** Cancel a pending job */
+  cancelJob?(jobId: string): Promise<boolean>;
+  /** Get queue stats */
+  getStats?(): Promise<QueueStats>;
+}
+/**
+ * Queue statistics.
+ */
+interface QueueStats {
+  pending: number;
+  running: number;
+  completed: number;
+  failed: number;
+  deadLetter: number;
+}
+/**
+ * Retry policy configuration.
+ */
+interface RetryPolicy {
+  /** Maximum number of retry attempts */
+  maxRetries: number;
+  /** Initial backoff in milliseconds */
+  initialBackoffMs: number;
+  /** Maximum backoff in milliseconds */
+  maxBackoffMs: number;
+  /** Backoff multiplier (exponential) */
+  multiplier: number;
+  /** Add jitter to backoff */
+  jitter: boolean;
+}
+/**
+ * Default retry policy.
+ */
+declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * Calculate backoff delay for a retry attempt.
+ */
+declare function calculateBackoff(attempt: number, policy?: RetryPolicy): number;
+/**
+ * Job type definition.
+ */
+interface JobTypeDef<TPayload = unknown> {
+  type: string;
+  version: number;
+  payload: z.ZodType<TPayload>;
+  options?: Partial<RetryPolicy & {
+    timeoutMs: number;
+  }>;
+  description?: string;
+}
+/**
+ * Define a typed job type.
+ */
+declare function defineJobType<TPayload>(def: JobTypeDef<TPayload>): JobTypeDef<TPayload>;
+//#endregion
+export { DEFAULT_RETRY_POLICY, EnqueueOptions, Job, JobHandler, JobQueue, JobStatus, JobTypeDef, QueueStats, RetryPolicy, calculateBackoff, defineJobType };

package/dist/queue/types.js

@@ -0,0 +1 @@
+import{z as e}from"zod";const t={maxRetries:3,initialBackoffMs:1e3,maxBackoffMs:6e4,multiplier:2,jitter:!0};function n(e,n=t){let r=Math.min(n.initialBackoffMs*n.multiplier**(e-1),n.maxBackoffMs);if(n.jitter){let e=.8+Math.random()*.4;return Math.floor(r*e)}return r}function r(e){return e}export{t as DEFAULT_RETRY_POLICY,n as calculateBackoff,r as defineJobType};