alepha 0.22.0 → 0.24.0

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

@@ -1,24 +1,25 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const jobRegistrationSchema = t.object({
-  name: t.text(),
-  description: t.optional(t.text()),
-  type: t.enum(["cron", "queue", "direct"], {
-    description:
+export const jobRegistrationSchema = z.object({
+  name: z.text(),
+  description: z.text().optional(),
+  type: z
+    .enum(["cron", "queue", "direct"])
+    .describe(
       "Effective runtime mode. 'cron' = scheduled. 'queue' = push-driven, dispatched via AlephaApiJobsQueue. 'direct' = push-driven, processed in-process (no queue infrastructure loaded), with the sweep as the safety net.",
-  }),
-  priority: t.enum(["critical", "high", "normal", "low"]),
-  cron: t.optional(t.text()),
-  timeout: t.optional(t.text()),
-  retry: t.optional(
-    t.object({
-      retries: t.integer(),
-    }),
-  ),
-  recent: t.object({
-    ok: t.integer(),
-    error: t.integer(),
-    lastRun: t.optional(t.datetime()),
+    ),
+  priority: z.enum(["critical", "high", "normal", "low"]),
+  cron: z.text().optional(),
+  timeout: z.text().optional(),
+  retry: z
+    .object({
+      retries: z.integer(),
+    })
+    .optional(),
+  recent: z.object({
+    ok: z.integer(),
+    error: z.integer(),
+    lastRun: z.datetime().optional(),
   }),
 });
 

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

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

package/src/api/jobs/services/JobService.ts

@@ -1,4 +1,4 @@
-import { $inject, Alepha, AlephaError, t } from "alepha";
+import { $inject, Alepha, AlephaError, z } from "alepha";
 import { $logger } from "alepha/logger";
 import { $repository, sql } from "alepha/orm";
 import { NotFoundError } from "alepha/server";
@@ -66,11 +66,11 @@ export class JobService {
         WHERE ${e.status} IN ('ok', 'error')
         GROUP BY ${e.jobName}, ${e.status}
       `,
-      t.object({
-        job_name: t.string(),
-        status: t.string(),
-        count: t.string(),
-        last_run: t.optional(t.nullable(t.union([t.string(), t.number()]))),
+      z.object({
+        job_name: z.string(),
+        status: z.string(),
+        count: z.string(),
+        last_run: z.union([z.string(), z.number()]).nullable().optional(),
       }),
     );
 

package/src/api/keys/__tests__/ApiKeyService.spec.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { $inject, Alepha, t } from "alepha";
+import { $inject, Alepha, z } from "alepha";
 import { AlephaOrmPostgres } from "alepha/orm/postgres";
 import { $issuer, $secure, AlephaSecurity } from "alepha/security";
 import { $action, AlephaServer } from "alepha/server";
@@ -212,7 +212,7 @@ describe("ApiKeyService", () => {
       protected = $action({
         use: [$secure()],
         schema: {
-          response: t.object({ userId: t.string() }),
+          response: z.object({ userId: z.string() }),
         },
         handler: (request) => {
           return { userId: request.user.id };

package/src/api/keys/controllers/AdminApiKeyController.ts

@@ -1,4 +1,4 @@
-import { $inject, t } from "alepha";
+import { $inject, z } from "alepha";
 import { $secure } from "alepha/security";
 import { $action, okSchema } from "alepha/server";
 import { adminApiKeyQuerySchema } from "../schemas/adminApiKeyQuerySchema.ts";
@@ -24,7 +24,7 @@ export class AdminApiKeyController {
     description: "Find API keys with pagination and filtering",
     schema: {
       query: adminApiKeyQuerySchema,
-      response: t.page(adminApiKeyResourceSchema),
+      response: z.page(adminApiKeyResourceSchema),
     },
     handler: ({ query }) => {
       const { userId, includeRevoked, ...pagination } = query;
@@ -45,8 +45,8 @@ export class AdminApiKeyController {
     use: [$secure({ permissions: ["admin:api-key:read"] })],
     description: "Get an API key by ID",
     schema: {
-      params: t.object({
-        id: t.uuid(),
+      params: z.object({
+        id: z.uuid(),
       }),
       response: adminApiKeyResourceSchema,
     },
@@ -63,8 +63,8 @@ export class AdminApiKeyController {
     use: [$secure({ permissions: ["admin:api-key:delete"] })],
     description: "Revoke an API key",
     schema: {
-      params: t.object({
-        id: t.uuid(),
+      params: z.object({
+        id: z.uuid(),
       }),
       response: okSchema,
     },
@@ -84,11 +84,11 @@ export class AdminApiKeyController {
     use: [$secure({ permissions: ["admin:api-key:delete"] })],
     description: "Revoke many API keys",
     schema: {
-      body: t.object({
-        ids: t.array(t.uuid(), { minItems: 1, maxItems: 1000 }),
+      body: z.object({
+        ids: z.array(z.uuid()).min(1).max(1000),
       }),
-      response: t.object({
-        revoked: t.array(t.uuid()),
+      response: z.object({
+        revoked: z.array(z.uuid()),
       }),
     },
     handler: async ({ body }) => {

package/src/api/keys/entities/apiKeyEntity.ts

@@ -1,37 +1,37 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { $entity, db } from "alepha/orm";
 
 export const apiKeyEntity = $entity({
   name: "api_keys",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
     organizationId: db.organization(),
 
     // Owner
-    userId: t.uuid(),
+    userId: z.uuid(),
 
     // Key metadata
-    name: t.text({ maxLength: 100 }),
-    description: t.optional(t.text({ maxLength: 500 })),
+    name: z.text({ maxLength: 100 }),
+    description: z.text({ maxLength: 500 }).optional(),
 
     // Token (hashed) - internal, not user input
-    tokenHash: t.string({ maxLength: 256 }),
-    tokenPrefix: t.string({ maxLength: 10 }),
-    tokenSuffix: t.string({ maxLength: 8 }),
+    tokenHash: z.string().max(256),
+    tokenPrefix: z.string().max(10),
+    tokenSuffix: z.string().max(8),
 
     // Roles (snapshot from user at creation)
-    roles: db.default(t.array(t.string()), []),
+    roles: db.default(z.array(z.string()), []),
 
     // Tracking
-    lastUsedAt: t.optional(t.datetime()),
-    lastUsedIp: t.optional(t.string({ maxLength: 45 })),
-    usageCount: db.default(t.integer(), 0),
+    lastUsedAt: z.datetime().optional(),
+    lastUsedIp: z.string().max(45).optional(),
+    usageCount: db.default(z.integer(), 0),
 
     // Lifecycle
-    expiresAt: t.optional(t.datetime()),
-    revokedAt: t.optional(t.datetime()),
+    expiresAt: z.datetime().optional(),
+    revokedAt: z.datetime().optional(),
   }),
   indexes: [
     { columns: ["userId", "name"], unique: true },

package/src/api/keys/schemas/adminApiKeyQuerySchema.ts

@@ -1,7 +1,7 @@
-import { t } from "alepha";
+import { z } from "alepha";
 import { pageQuerySchema } from "alepha/orm";
 
-export const adminApiKeyQuerySchema = t.extend(pageQuerySchema, {
-  userId: t.optional(t.uuid()),
-  includeRevoked: t.optional(t.boolean()),
+export const adminApiKeyQuerySchema = pageQuerySchema.extend({
+  userId: z.uuid().optional(),
+  includeRevoked: z.boolean().optional(),
 });

package/src/api/keys/schemas/adminApiKeyResourceSchema.ts

@@ -1,19 +1,19 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const adminApiKeyResourceSchema = t.object({
-  id: t.uuid(),
-  userId: t.uuid(),
-  name: t.string(),
-  description: t.optional(t.string()),
-  tokenPrefix: t.string(),
-  tokenSuffix: t.string(),
-  roles: t.array(t.string()),
-  createdAt: t.datetime(),
-  lastUsedAt: t.optional(t.datetime()),
-  lastUsedIp: t.optional(t.string()),
-  expiresAt: t.optional(t.datetime()),
-  revokedAt: t.optional(t.datetime()),
-  usageCount: t.integer(),
+export const adminApiKeyResourceSchema = z.object({
+  id: z.uuid(),
+  userId: z.uuid(),
+  name: z.string(),
+  description: z.string().optional(),
+  tokenPrefix: z.string(),
+  tokenSuffix: z.string(),
+  roles: z.array(z.string()),
+  createdAt: z.datetime(),
+  lastUsedAt: z.datetime().optional(),
+  lastUsedIp: z.string().optional(),
+  expiresAt: z.datetime().optional(),
+  revokedAt: z.datetime().optional(),
+  usageCount: z.integer(),
 });
 
 export type AdminApiKeyResource = Static<typeof adminApiKeyResourceSchema>;

package/src/api/keys/schemas/createApiKeyBodySchema.ts

@@ -1,7 +1,7 @@
-import { t } from "alepha";
+import { z } from "alepha";
 
-export const createApiKeyBodySchema = t.object({
-  name: t.text({ minLength: 1, maxLength: 100 }),
-  description: t.optional(t.text({ maxLength: 500 })),
-  expiresAt: t.optional(t.datetime()),
+export const createApiKeyBodySchema = z.object({
+  name: z.text({ minLength: 1, maxLength: 100 }),
+  description: z.text({ maxLength: 500 }).optional(),
+  expiresAt: z.datetime().optional(),
 });

package/src/api/keys/schemas/createApiKeyResponseSchema.ts

@@ -1,11 +1,11 @@
-import { t } from "alepha";
+import { z } from "alepha";
 
-export const createApiKeyResponseSchema = t.object({
-  id: t.uuid(),
-  name: t.string(),
-  token: t.string(),
-  tokenSuffix: t.string(),
-  roles: t.array(t.string()),
-  createdAt: t.datetime(),
-  expiresAt: t.optional(t.datetime()),
+export const createApiKeyResponseSchema = z.object({
+  id: z.uuid(),
+  name: z.string(),
+  token: z.string(),
+  tokenSuffix: z.string(),
+  roles: z.array(z.string()),
+  createdAt: z.datetime(),
+  expiresAt: z.datetime().optional(),
 });

package/src/api/keys/schemas/listApiKeyResponseSchema.ts

@@ -1,16 +1,16 @@
-import { t } from "alepha";
+import { z } from "alepha";
 
-export const listApiKeyItemSchema = t.object({
-  id: t.uuid(),
-  name: t.string(),
-  tokenPrefix: t.string(),
-  tokenSuffix: t.string(),
-  roles: t.array(t.string()),
-  createdAt: t.datetime(),
-  lastUsedAt: t.optional(t.datetime()),
-  lastUsedIp: t.optional(t.string()),
-  expiresAt: t.optional(t.datetime()),
-  usageCount: t.integer(),
+export const listApiKeyItemSchema = z.object({
+  id: z.uuid(),
+  name: z.string(),
+  tokenPrefix: z.string(),
+  tokenSuffix: z.string(),
+  roles: z.array(z.string()),
+  createdAt: z.datetime(),
+  lastUsedAt: z.datetime().optional(),
+  lastUsedIp: z.string().optional(),
+  expiresAt: z.datetime().optional(),
+  usageCount: z.integer(),
 });
 
-export const listApiKeyResponseSchema = t.array(listApiKeyItemSchema);
+export const listApiKeyResponseSchema = z.array(listApiKeyItemSchema);

package/src/api/keys/schemas/revokeApiKeyParamsSchema.ts

@@ -1,5 +1,5 @@
-import { t } from "alepha";
+import { z } from "alepha";
 
-export const revokeApiKeyParamsSchema = t.object({
-  id: t.uuid(),
+export const revokeApiKeyParamsSchema = z.object({
+  id: z.uuid(),
 });

package/src/api/keys/schemas/revokeApiKeyResponseSchema.ts

@@ -1,5 +1,5 @@
-import { t } from "alepha";
+import { z } from "alepha";
 
-export const revokeApiKeyResponseSchema = t.object({
-  ok: t.boolean(),
+export const revokeApiKeyResponseSchema = z.object({
+  ok: z.boolean(),
 });

package/src/api/notifications/__tests__/AlephaApiNotifications.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { AlephaApiJobs, JobProvider } from "alepha/api/jobs";
 import { AlephaEmail, MemoryEmailProvider } from "alepha/email";
 import { AlephaOrmPostgres } from "alepha/orm/postgres";
@@ -29,7 +29,7 @@ describe("AlephaApiNotifications — runs without AlephaApiJobsQueue", () => {
     class Templates {
       readonly welcome = $notification({
         name: "welcome-email",
-        schema: t.object({ name: t.text() }),
+        schema: z.object({ name: z.text() }),
         email: {
           subject: "Welcome",
           body: (vars) => `Hello ${vars.name}`,

package/src/api/notifications/controllers/AdminNotificationController.ts

@@ -1,7 +1,7 @@
-import { $inject, t } from "alepha";
+import { $inject, Alepha, z } from "alepha";
 import { jobExecutionEntity } from "alepha/api/jobs";
 import { $repository } from "alepha/orm";
-import { $secure } from "alepha/security";
+import { $secure, currentTenantAtom } from "alepha/security";
 import { $action, NotFoundError, okSchema } from "alepha/server";
 import { NotificationJobs } from "../jobs/NotificationJobs.ts";
 import { notificationDetailResourceSchema } from "../schemas/notificationDetailResourceSchema.ts";
@@ -11,6 +11,7 @@ import { notificationResourceSchema } from "../schemas/notificationResourceSchem
 export class AdminNotificationController {
   protected readonly url: string = "/notifications";
   protected readonly group: string = "admin:notifications";
+  protected readonly alepha = $inject(Alepha);
   protected readonly notificationJobs = $inject(NotificationJobs);
   protected readonly executions = $repository(jobExecutionEntity);
 
@@ -18,18 +19,38 @@ export class AdminNotificationController {
     return this.notificationJobs.sendNotification.name;
   }
 
+  /**
+   * The tenant this request is acting in, when multi-tenant. The notification
+   * outbox (`job_executions`) is shared across tenants in a pooled worker, so
+   * every read/delete here is scoped to this org to prevent cross-tenant access.
+   * Undefined in single-tenant apps → no extra filter (all rows are this app's).
+   */
+  protected get organizationId(): string | undefined {
+    return this.alepha.store.get(currentTenantAtom)?.id;
+  }
+
+  /** True when `exec` belongs to the acting tenant (or the app is single-tenant). */
+  protected sameTenant(exec: { organizationId?: string | null }): boolean {
+    const org = this.organizationId;
+    return !org || exec.organizationId === org;
+  }
+
   public readonly findNotifications = $action({
     path: this.url,
     group: this.group,
     use: [$secure({ permissions: ["admin:notification:read"] })],
     schema: {
       query: notificationQuerySchema,
-      response: t.page(notificationResourceSchema),
+      response: z.page(notificationResourceSchema),
     },
     handler: async ({ query }) => {
       query.sort ??= "-createdAt";
       const where = this.executions.createQueryWhere();
       where.jobName = { eq: this.jobName };
+      const org = this.organizationId;
+      if (org) {
+        where.organizationId = { eq: org };
+      }
       const page = await this.executions.paginate(
         query,
         { where },
@@ -47,14 +68,14 @@ export class AdminNotificationController {
     group: this.group,
     use: [$secure({ permissions: ["admin:notification:read"] })],
     schema: {
-      params: t.object({
-        id: t.uuid(),
+      params: z.object({
+        id: z.uuid(),
       }),
       response: notificationDetailResourceSchema,
     },
     handler: async ({ params }) => {
       const exec = await this.executions.findById(params.id);
-      if (!exec || exec.jobName !== this.jobName) {
+      if (!exec || exec.jobName !== this.jobName || !this.sameTenant(exec)) {
         throw new NotFoundError(`Notification not found: ${params.id}`);
       }
       return this.toDetailResource(exec) as any;
@@ -68,14 +89,14 @@ export class AdminNotificationController {
     use: [$secure({ permissions: ["admin:notification:delete"] })],
     description: "Delete a notification record",
     schema: {
-      params: t.object({
-        id: t.uuid(),
+      params: z.object({
+        id: z.uuid(),
       }),
       response: okSchema,
     },
     handler: async ({ params }) => {
       const exec = await this.executions.findById(params.id);
-      if (!exec || exec.jobName !== this.jobName) {
+      if (!exec || exec.jobName !== this.jobName || !this.sameTenant(exec)) {
         throw new NotFoundError(`Notification not found: ${params.id}`);
       }
       await this.executions.deleteById(params.id);
@@ -90,19 +111,22 @@ export class AdminNotificationController {
     use: [$secure({ permissions: ["admin:notification:delete"] })],
     description: "Delete many notification records in one call",
     schema: {
-      body: t.object({
-        ids: t.array(t.uuid(), { minItems: 1, maxItems: 1000 }),
+      body: z.object({
+        ids: z.array(z.uuid()).min(1).max(1000),
       }),
-      response: t.object({
-        deleted: t.array(t.uuid()),
+      response: z.object({
+        deleted: z.array(z.uuid()),
       }),
     },
     handler: async ({ body }) => {
       // Constrain to this job's executions so an admin can't delete arbitrary
-      // job rows through this endpoint.
+      // job rows through this endpoint — and, when multi-tenant, to this org so
+      // one club can't delete another club's notification records.
+      const org = this.organizationId;
       const deleted = await this.executions.deleteMany({
         id: { inArray: body.ids },
         jobName: { eq: this.jobName },
+        ...(org ? { organizationId: { eq: org } } : {}),
       });
       return { deleted: deleted.map(String) };
     },

package/src/api/notifications/jobs/NotificationJobs.ts

@@ -1,4 +1,4 @@
-import { $inject, t } from "alepha";
+import { $inject, z } from "alepha";
 import { $job, jobExecutionEntity } from "alepha/api/jobs";
 import { $parameter } from "alepha/api/parameters";
 import { DateTimeProvider } from "alepha/datetime";
@@ -36,12 +36,13 @@ export class NotificationJobs {
   public readonly settings = $parameter({
     name: "alepha.api.notifications",
     description: "Notification delivery & retention settings.",
-    schema: t.object({
-      retentionDays: t.integer({
-        description:
+    schema: z.object({
+      retentionDays: z
+        .integer()
+        .min(1)
+        .describe(
           "Days to keep notification execution rows before the purge sweep removes them.",
-        minimum: 1,
-      }),
+        ),
     }),
     default: {
       retentionDays: 7,

package/src/api/notifications/primitives/$notification.ts

@@ -7,6 +7,7 @@ import {
   type StaticEncode,
   type TObject,
 } from "alepha";
+import { currentTenantAtom } from "alepha/security";
 import { NotificationJobs } from "../jobs/NotificationJobs.ts";
 
 /**
@@ -21,7 +22,7 @@ import { NotificationJobs } from "../jobs/NotificationJobs.ts";
  *   welcomeEmail = $notification({
  *     name: "welcome-email",
  *     category: "onboarding",
- *     schema: t.object({ username: t.text(), activationLink: t.text() }),
+ *     schema: z.object({ username: z.text(), activationLink: z.text() }),
  *     email: {
  *       subject: "Welcome to our platform!",
  *       body: (vars) => `Hello ${vars.username}, click: ${vars.activationLink}`
@@ -68,10 +69,37 @@ export class NotificationPrimitive<T extends TObject> extends Primitive<
     return this.options.name ?? `${this.config.propertyKey}`;
   }
 
+  /**
+   * Recipient language for `translations` resolution. Explicit `lang` wins;
+   * otherwise the language is captured FROM THE CURRENT REQUEST at push time
+   * (the i18n `lang` cookie, then `Accept-Language`) — the send job may run
+   * out of request context, so this must be resolved here, not in the sender.
+   */
+  protected resolveLang(explicit?: string): string | undefined {
+    if (explicit) return explicit;
+    const request = this.alepha.store.get("alepha.http.request") as
+      | { headers?: Record<string, string | undefined> }
+      | undefined;
+    const cookie = request?.headers?.cookie;
+    const fromCookie = cookie?.match(/(?:^|;\s*)lang=([a-zA-Z-]+)/)?.[1];
+    if (fromCookie) return fromCookie;
+    const accept = request?.headers?.["accept-language"];
+    return accept?.split(",")[0]?.trim().split(";")[0] || undefined;
+  }
+
   public async push(options: NotificationPushOptions<T>) {
-    const pushOpts = this.options.critical
-      ? ({ priority: "critical" } as const)
-      : undefined;
+    const lang = this.resolveLang(options.lang);
+    // Tag the outbox row with the owning tenant so the notification admin list
+    // stays org-scoped (the outbox is shared by every tenant in a pooled
+    // worker). Explicit `organizationId` wins (cron sweeps run out of request
+    // context and pass the subject's org); otherwise fall back to the tenant
+    // resolved for the current request.
+    const organizationId =
+      options.organizationId ?? this.alepha.store.get(currentTenantAtom)?.id;
+    const pushOpts = {
+      ...(this.options.critical ? ({ priority: "critical" } as const) : {}),
+      organizationId,
+    };
 
     if (this.options.email) {
       await this.notificationJobs.sendNotification.push(
@@ -83,6 +111,7 @@ export class NotificationPrimitive<T extends TObject> extends Primitive<
           category: this.options.category,
           critical: this.options.critical,
           sensitive: this.options.sensitive,
+          lang,
         },
         pushOpts,
       );
@@ -98,6 +127,7 @@ export class NotificationPrimitive<T extends TObject> extends Primitive<
           category: this.options.category,
           critical: this.options.critical,
           sensitive: this.options.sensitive,
+          lang,
         },
         pushOpts,
       );
@@ -116,6 +146,15 @@ $notification[KIND] = NotificationPrimitive;
 export interface NotificationPushOptions<T extends TObject> {
   variables: StaticEncode<T>;
   contact: string;
+  /** Recipient language (e.g. "fr"); defaults to the current request's. */
+  lang?: string;
+  /**
+   * Owning tenant for this notification. Defaults to the tenant resolved for
+   * the current request. Pass it explicitly when sending from a context with no
+   * request tenant — e.g. a cron sweep that fans out across clubs (use the
+   * subject entity's `organizationId`) — so the row stays correctly org-scoped.
+   */
+  organizationId?: string;
 }
 
 export interface NotificationMessage<T extends TObject> {

package/src/api/notifications/schemas/notificationContactPreferencesSchema.ts

@@ -1,8 +1,8 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const notificationContactPreferencesSchema = t.object({
-  language: t.optional(t.text()),
-  exclude: t.array(t.text()),
+export const notificationContactPreferencesSchema = z.object({
+  language: z.text().optional(),
+  exclude: z.array(z.text()),
 });
 
 export type NotificationContactPreferences = Static<

package/src/api/notifications/schemas/notificationContactSchema.ts

@@ -1,11 +1,11 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const notificationContactSchema = t.object({
-  email: t.optional(t.email()),
-  phoneNumber: t.optional(t.e164()),
-  firstName: t.optional(t.shortText()),
-  lastName: t.optional(t.text({ size: "short" })),
-  language: t.optional(t.bcp47()),
+export const notificationContactSchema = z.object({
+  email: z.email().optional(),
+  phoneNumber: z.e164().optional(),
+  firstName: z.shortText().optional(),
+  lastName: z.text({ size: "short" }).optional(),
+  language: z.bcp47().optional(),
 });
 
 export type NotificationContact = Static<typeof notificationContactSchema>;