alepha 0.20.1 → 0.20.2

package/src/api/jobs/providers/JobQueueProvider.ts

@@ -1,22 +1,19 @@
-import { $hook, $inject, t } from "alepha";
+import { $inject, t } from "alepha";
 import { $queue } from "alepha/queue";
 import { JobProvider } from "./JobProvider.ts";
 
-// -----------------------------------------------------------------------------------------------------------------
-
 /**
- * Optional queue-backed dispatch for the job system.
+ * Plumbs outbox-style dispatch through `AlephaQueue`.
  *
- * When registered, `JobProvider` will push work through this queue instead of
- * executing inline. This is the default for long-running (non-serverless) environments.
- * In serverless environments (Cloudflare Workers, Vercel), this provider is typically
- * omitted so jobs execute inline without requiring an external queue resource.
+ * Registered only when the app imports `AlephaApiJobsQueue`. Sets
+ * `JobProvider.queueDispatch` eagerly at instantiation so queue-mode jobs
+ * can dispatch regardless of start-hook ordering.
  */
 export class JobQueueProvider {
   protected readonly jobProvider = $inject(JobProvider);
 
   protected readonly queue = $queue({
-    name: "_alepha:jobs:dispatch",
+    name: "api:jobs:dispatch",
     schema: t.object({ jobName: t.text(), executionId: t.text() }),
     handler: async (msg) => {
       await this.jobProvider.processExecution(
@@ -26,17 +23,19 @@ export class JobQueueProvider {
     },
   });
 
-  protected readonly onStart = $hook({
-    on: "start",
-    handler: async () => {
-      this.jobProvider.queueDispatch = (jobName, executionId) =>
-        this.push(jobName, executionId);
-    },
-  });
+  constructor() {
+    // Install the dispatcher immediately — before any start hook runs,
+    // so JobProvider can validate presence and queue-mode push works
+    // from any lifecycle point.
+    this.wireDispatcher();
+  }
+
+  protected wireDispatcher(): void {
+    // `$inject` is resolved by the time constructor runs; assignment is safe.
+    this.jobProvider.queueDispatch = (jobName, executionId) =>
+      this.push(jobName, executionId);
+  }
 
-  /**
-   * Push a job execution onto the queue for async processing.
-   */
   public async push(jobName: string, executionId: string): Promise<void> {
     await this.queue.push({ jobName, executionId });
   }

package/src/api/jobs/schemas/jobConfigAtom.ts

@@ -2,23 +2,24 @@ import { $atom, type Static, t } from "alepha";
 
 export const jobConfig = $atom({
   name: "alepha.jobs",
-  description: "Configuration for the $job v2 primitive.",
+  description: "Configuration for the $job primitive.",
   schema: t.object({
-    recovery: t.object({
-      interval: t.integer({ description: "Sweep interval (ms)." }),
-      staleThreshold: t.integer({
-        description: "Pending age (ms) before re-dispatch.",
-      }),
-      runTimeout: t.integer({
-        description:
-          "Running age (ms) before assumed crash. Used as fallback when no per-job timeout is set.",
-      }),
+    sweepInterval: t.integer({
+      description: "Sweep cron interval in milliseconds.",
     }),
-    delayed: t.object({
-      interval: t.integer({ description: "Sweep interval (ms)." }),
+    staleThreshold: t.integer({
+      description: "Pending age (ms) before the sweep re-dispatches it.",
     }),
-    logRetentionDays: t.integer({
-      description: "Days to keep completed/dead executions.",
+    runTimeout: t.integer({
+      description:
+        "Running age (ms) before assumed crash (fallback when no per-job timeout).",
+    }),
+    keepLastSuccess: t.integer({
+      description:
+        "Max successful rows to keep per job. Set 0 to disable and delete on success.",
+    }),
+    keepLastError: t.integer({
+      description: "Max error rows to keep per job.",
     }),
     logMaxEntries: t.integer({
       description: "Max log entries captured per execution.",
@@ -28,15 +29,11 @@ export const jobConfig = $atom({
     }),
   }),
   default: {
-    recovery: {
-      interval: 300_000,
-      staleThreshold: 300_000,
-      runTimeout: 1_800_000,
-    },
-    delayed: {
-      interval: 300_000,
-    },
-    logRetentionDays: 30,
+    sweepInterval: 300_000,
+    staleThreshold: 300_000,
+    runTimeout: 1_800_000,
+    keepLastSuccess: 10,
+    keepLastError: 10,
     logMaxEntries: 100,
     drainTimeout: 30_000,
   },

package/src/api/jobs/schemas/jobExecutionQuerySchema.ts

@@ -1,34 +1,10 @@
 import { type Static, t } from "alepha";
-import { pageQuerySchema } from "alepha/orm";
 
-export const jobExecutionQuerySchema = t.extend(pageQuerySchema, {
-  job: t.optional(
-    t.text({
-      description: "Filter by job name",
-    }),
-  ),
+export const jobExecutionQuerySchema = t.object({
   status: t.optional(
-    t.enum([
-      "pending",
-      "scheduled",
-      "retrying",
-      "running",
-      "completed",
-      "dead",
-      "cancelled",
-    ]),
-  ),
-  priority: t.optional(t.enum(["critical", "high", "normal", "low"])),
-  from: t.optional(
-    t.datetime({
-      description: "From date (ISO)",
-    }),
-  ),
-  to: t.optional(
-    t.datetime({
-      description: "To date (ISO)",
-    }),
+    t.enum(["pending", "running", "scheduled", "ok", "error", "cancelled"]),
   ),
+  limit: t.optional(t.integer({ minimum: 1, maximum: 200, default: 20 })),
 });
 
 export type JobExecutionQuery = Static<typeof jobExecutionQuerySchema>;

package/src/api/jobs/schemas/jobExecutionResourceSchema.ts

@@ -1,19 +1,17 @@
 import { type Static, t } from "alepha";
 import { jobExecutionEntity } from "../entities/jobExecutionEntity.ts";
 
-export const jobExecutionCanSchema = t.object({
-  retry: t.boolean(),
-  cancel: t.boolean(),
-});
-
 export const jobExecutionResourceSchema = t.extend(
   jobExecutionEntity.schema,
   {
-    can: jobExecutionCanSchema,
+    can: t.object({
+      retry: t.boolean(),
+      cancel: t.boolean(),
+    }),
   },
   {
     title: "JobExecutionResource",
-    description: "A job execution resource.",
+    description: "A job execution row with derived actions.",
   },
 );
 

package/src/api/jobs/schemas/jobRegistrationSchema.ts

@@ -2,10 +2,9 @@ import { type Static, t } from "alepha";
 
 export const jobRegistrationSchema = t.object({
   name: t.text(),
-  type: t.enum(["cron", "push", "both"]),
+  description: t.optional(t.text()),
+  type: t.enum(["cron", "queue"]),
   priority: t.enum(["critical", "high", "normal", "low"]),
-  concurrency: t.integer(),
-  hasSchema: t.boolean(),
   cron: t.optional(t.text()),
   timeout: t.optional(t.text()),
   retry: t.optional(
@@ -14,7 +13,11 @@ export const jobRegistrationSchema = t.object({
       hasBackoff: t.boolean(),
     }),
   ),
-  paused: t.boolean(),
+  recent: t.object({
+    ok: t.integer(),
+    error: t.integer(),
+    lastRun: t.optional(t.datetime()),
+  }),
 });
 
 export type JobRegistration = Static<typeof jobRegistrationSchema>;

package/src/api/jobs/schemas/triggerJobSchema.ts

@@ -1,7 +1,6 @@
 import { type Static, t } from "alepha";
 
 export const triggerJobSchema = t.object({
-  name: t.text(),
   payload: t.optional(t.record(t.text(), t.any())),
 });