@digimuza/saas-core 0.0.2

package/dist/jobs/index.js

@@ -0,0 +1,114 @@
+/**
+ * Public jobs surface: `@digimuza/saas-core/jobs`. Server-only.
+ *
+ * Trigger.dev owns durable execution — retries, scheduling, cron, waits,
+ * concurrency, multi-step workflows and run observability. The core does not
+ * reimplement any of it and stores no run state: a `job_runs` table would be a
+ * second, always-slightly-wrong copy of what Trigger.dev already knows.
+ *
+ * What the core adds is exactly two things:
+ *
+ * 1. **Tenant attribution.** A job outlives the request that queued it, so the
+ *    workspace travels with it — in the payload envelope, in Trigger.dev tags,
+ *    and in run metadata.
+ * 2. **Application events.** `job.started` / `.progress` / `.completed` /
+ *    `.failed`, so the rest of the system (and eventually a browser) can react.
+ *
+ * Everything else is Trigger.dev's, and the SDK is re-exported below rather than
+ * wrapped, so advanced use is never blocked.
+ *
+ * ## Queueing work
+ *
+ * ```ts
+ * import { jobs } from "@digimuza/saas-core/jobs";
+ *
+ * const handle = await jobs.trigger("resize-image", { assetId }, {
+ *   workspaceId: context.workspaceId,
+ *   actorId: user.id,
+ *   idempotencyKey: requestId,
+ *   concurrencyKey: context.workspaceId, // one tenant cannot starve another
+ * });
+ * ```
+ *
+ * ## Writing the task
+ *
+ * ```ts
+ * import { task } from "@digimuza/saas-core/jobs";
+ * import type { JobPayload } from "@digimuza/saas-core/jobs";
+ * import { workspaces } from "@digimuza/saas-core/workspaces";
+ * import { jobs } from "@digimuza/saas-core/jobs";
+ *
+ * export const resizeImage = task({
+ *   id: "resize-image",
+ *   run: async (payload: JobPayload<{ assetId: string }>, { ctx }) => {
+ *     const reporter = jobs.reporter({ runId: ctx.run.id, taskId: ctx.task.id }, payload.tenant);
+ *     await reporter.started();
+ *
+ *     // Re-verify: the workspace may have been deleted, or the actor removed,
+ *     // between queueing and running. The payload is attribution, not authority.
+ *     const context = await workspaces.requireContext({
+ *       userId: payload.tenant.actorId!,
+ *       workspaceId: payload.tenant.workspaceId,
+ *     });
+ *
+ *     try {
+ *       await doWork(context, payload.data);
+ *       await reporter.completed();
+ *     } catch (error) {
+ *       await reporter.failed({ error, attempt: ctx.attempt.number });
+ *       throw error; // rethrow so Trigger.dev retries
+ *     }
+ *   },
+ * });
+ * ```
+ *
+ * ## Configuration
+ *
+ * Call {@link configureJobs} once at startup so the Infisical-injected `jobs`
+ * configuration reaches the SDK. Without it the SDK falls back to reading
+ * `TRIGGER_SECRET_KEY` from the environment itself, which works but bypasses the
+ * validation every other section gets.
+ */
+import { config } from "../config/index.js";
+import { events as coreEventsService } from "../events/index.js";
+import { createTriggerDevBackend } from "./backend.js";
+import { createJobsService } from "./service.js";
+export { createTriggerDevBackend } from "./backend.js";
+export { createJobsService, describeJobError, } from "./service.js";
+export { ACTOR_TAG_PREFIX, WORKSPACE_TAG_PREFIX, } from "./types.js";
+/**
+ * The Trigger.dev SDK, re-exported unchanged.
+ *
+ * Deliberate: the spec is explicit that advanced applications must be able to
+ * reach Trigger.dev's own capabilities. Wrapping `task`, `schedules` or `wait`
+ * would mean re-documenting and re-typing a mature API for no gain, and would
+ * lag behind it.
+ */
+export { batch, configure as configureTriggerClient, idempotencyKeys, logger, metadata, queue, queues, retry, runs, schedules, schemaTask, tags, task, tasks, timeout, usage, wait, } from "@trigger.dev/sdk";
+/**
+ * Point the Trigger.dev SDK at the configured credentials.
+ *
+ * Idempotent; call it from application startup and from the Trigger.dev config
+ * file. Reads the `jobs` configuration section, so it throws `ConfigError` if
+ * Trigger.dev is not configured.
+ */
+export async function configureJobs() {
+    const { configure } = await import("@trigger.dev/sdk");
+    const jobsConfig = config.jobs;
+    configure({
+        // `secretKey` is deprecated upstream in favour of `accessToken`.
+        accessToken: jobsConfig.secretKey,
+        baseURL: jobsConfig.apiUrl,
+    });
+}
+/**
+ * Default service, wired to Trigger.dev and the core event registry.
+ *
+ * The backend is built eagerly but imports the SDK lazily, so this module stays
+ * importable in a process that never queues anything.
+ */
+export const jobs = createJobsService({
+    backend: createTriggerDevBackend(),
+    events: coreEventsService,
+});
+//# sourceMappingURL=index.js.map

package/dist/jobs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/jobs/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,MAAM,IAAI,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAoB,MAAM,cAAc,CAAC;AAEnE,OAAO,EAAE,uBAAuB,EAAmB,MAAM,cAAc,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,gBAAgB,GAKjB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GAOrB,MAAM,YAAY,CAAC;AAEpB;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,EACL,SAAS,IAAI,sBAAsB,EACnC,eAAe,EACf,MAAM,EACN,QAAQ,EACR,KAAK,EACL,MAAM,EACN,KAAK,EACL,IAAI,EACJ,SAAS,EACT,UAAU,EACV,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,OAAO,EACP,KAAK,EACL,IAAI,GACL,MAAM,kBAAkB,CAAC;AAE1B;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa;IACjC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAC;IACvD,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;IAE/B,SAAS,CAAC;QACR,iEAAiE;QACjE,WAAW,EAAE,UAAU,CAAC,SAAS;QACjC,OAAO,EAAE,UAAU,CAAC,MAAM;KAC3B,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAgB,iBAAiB,CAAC;IACjD,OAAO,EAAE,uBAAuB,EAAE;IAClC,MAAM,EAAE,iBAAiB;CAC1B,CAAC,CAAC"}

package/dist/jobs/service.d.ts

@@ -0,0 +1,67 @@
+import type { CoreEventPublisher } from "../events/publisher.ts";
+import type { JobBackend } from "./backend.ts";
+import { type JobHandle, type JobTenant, type JobTriggerOptions, type TriggerJobOptions } from "./types.ts";
+export interface JobProgress {
+    readonly percent?: number;
+    readonly message?: string;
+    readonly step?: number;
+    readonly totalSteps?: number;
+}
+/**
+ * Emits `job.*` application events from inside a running task.
+ *
+ * Trigger.dev already tracks run state; these events exist so the *application*
+ * can react and a browser can watch progress. They are not a second source of
+ * truth, and losing one does not lose the run.
+ */
+export interface JobReporter {
+    started(): Promise<void>;
+    /**
+     * Report progress. Throttle it — each call writes a row, and a tight loop
+     * would turn the events table into a firehose.
+     */
+    progress(progress: JobProgress): Promise<void>;
+    completed(result?: {
+        durationMs?: number;
+    }): Promise<void>;
+    failed(input: {
+        error: unknown;
+        attempt?: number;
+    }): Promise<void>;
+}
+export interface JobsService {
+    /**
+     * Queue a task for a workspace.
+     *
+     * The payload is wrapped in a {@link JobPayload} envelope and the run is tagged
+     * with the workspace and actor, so runs are filterable per tenant in the
+     * Trigger.dev dashboard.
+     */
+    trigger<TData>(taskId: string, data: TData, options: TriggerJobOptions): Promise<JobHandle>;
+    /**
+     * Queue a task that belongs to no tenant — a nightly sweep, a catalogue sync.
+     *
+     * Separate from {@link trigger} rather than accepting a null workspace, so
+     * forgetting to attribute tenant work is a deliberate choice and not a typo.
+     */
+    triggerSystem<TData>(taskId: string, data: TData, options?: JobTriggerOptions): Promise<JobHandle>;
+    /** Build a reporter for the run currently executing. */
+    reporter(run: {
+        runId: string;
+        taskId: string;
+    }, tenant: JobTenant | null): JobReporter;
+}
+export interface JobsServiceDeps {
+    readonly backend: JobBackend;
+    /**
+     * Optional event publisher. Without it, {@link JobsService.reporter} returns a
+     * reporter that does nothing — so a task can call it unconditionally.
+     */
+    readonly events?: CoreEventPublisher;
+    readonly now?: () => Date;
+}
+/** Reduce an unknown throwable to a bounded string. */
+declare function describeError(error: unknown): string;
+export declare function createJobsService(deps: JobsServiceDeps): JobsService;
+export { describeError as describeJobError };
+//# sourceMappingURL=service.d.ts.map

package/dist/jobs/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/jobs/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,SAAS,EACd,KAAK,iBAAiB,EAEtB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,SAAS,CAAC,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,MAAM,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EACX,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,SAAS,CAAC,CAAC;IAEtB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,WAAW,CAAC;CACzF;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAcD,uDAAuD;AACvD,iBAAS,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAS7C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAyIpE;AAED,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/dist/jobs/service.js

@@ -0,0 +1,139 @@
+import { InvalidInputError } from "../errors.js";
+import { ACTOR_TAG_PREFIX, WORKSPACE_TAG_PREFIX, } from "./types.js";
+/** Trigger.dev caps tag length; keep messages short so they are not rejected. */
+const MAX_ERROR_LENGTH = 2000;
+function mergeTags(tenant, tags) {
+    const own = tenant === null
+        ? []
+        : [
+            `${WORKSPACE_TAG_PREFIX}${tenant.workspaceId}`,
+            ...(tenant.actorId !== null ? [`${ACTOR_TAG_PREFIX}${tenant.actorId}`] : []),
+        ];
+    // De-duplicated: Trigger.dev counts tags against a per-run limit.
+    return [...new Set([...own, ...(tags ?? [])])];
+}
+/** Reduce an unknown throwable to a bounded string. */
+function describeError(error) {
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : "Unknown error";
+    return message.length > MAX_ERROR_LENGTH ? `${message.slice(0, MAX_ERROR_LENGTH - 1)}…` : message;
+}
+export function createJobsService(deps) {
+    const now = deps.now ?? (() => new Date());
+    async function send(taskId, payload, tenant, options) {
+        if (taskId.trim().length === 0) {
+            throw new InvalidInputError("A task id is required.");
+        }
+        const { tags, metadata, ...rest } = options;
+        const handle = await deps.backend.trigger(taskId, payload, {
+            ...rest,
+            tags: mergeTags(tenant, tags),
+            metadata: {
+                ...(metadata ?? {}),
+                /**
+                 * Duplicated into metadata as well as the payload: metadata is visible in
+                 * the Trigger.dev dashboard and searchable there, which is what makes a
+                 * production incident traceable back to a tenant.
+                 */
+                ...(tenant !== null
+                    ? { workspaceId: tenant.workspaceId, actorId: tenant.actorId }
+                    : {}),
+            },
+        });
+        return { runId: handle.id, taskId };
+    }
+    return {
+        async trigger(taskId, data, options) {
+            const { workspaceId, actorId, ...triggerOptions } = options;
+            if (workspaceId.trim().length === 0) {
+                throw new InvalidInputError("A workspaceId is required to trigger a tenant job.");
+            }
+            const tenant = { workspaceId, actorId: actorId ?? null };
+            return send(taskId, { tenant, data }, tenant, triggerOptions);
+        },
+        async triggerSystem(taskId, data, options = {}) {
+            return send(taskId, { tenant: null, data }, null, options);
+        },
+        reporter(run, tenant) {
+            const publisher = deps.events;
+            // A no-op reporter, so a task never has to branch on whether events exist.
+            if (publisher === undefined) {
+                return {
+                    started: async () => undefined,
+                    progress: async () => undefined,
+                    completed: async () => undefined,
+                    failed: async () => undefined,
+                };
+            }
+            const workspaceId = tenant?.workspaceId ?? null;
+            const actorId = tenant?.actorId ?? null;
+            const startedAt = now();
+            async function emit(input) {
+                const { event, created } = await publisher.record(input);
+                if (created) {
+                    await publisher.dispatch(event);
+                }
+            }
+            return {
+                async started() {
+                    await emit({
+                        type: "job.started",
+                        workspaceId,
+                        actorId,
+                        /**
+                         * Keyed on the run so a Trigger.dev retry re-executing the task body
+                         * does not announce a second start for the same run.
+                         */
+                        idempotencyKey: run.runId,
+                        data: { runId: run.runId, taskId: run.taskId },
+                    });
+                },
+                async progress(progress) {
+                    await emit({
+                        type: "job.progress",
+                        workspaceId,
+                        actorId,
+                        // Progress is intentionally not deduplicated; each tick is news.
+                        data: { runId: run.runId, taskId: run.taskId, ...progress },
+                    });
+                },
+                async completed(result = {}) {
+                    await emit({
+                        type: "job.completed",
+                        workspaceId,
+                        actorId,
+                        idempotencyKey: run.runId,
+                        data: {
+                            runId: run.runId,
+                            taskId: run.taskId,
+                            durationMs: result.durationMs ?? now().getTime() - startedAt.getTime(),
+                        },
+                    });
+                },
+                async failed(input) {
+                    await emit({
+                        type: "job.failed",
+                        workspaceId,
+                        actorId,
+                        /**
+                         * Keyed per attempt, not per run: each failed attempt is a distinct
+                         * fact, and a run that fails twice should say so twice.
+                         */
+                        idempotencyKey: input.attempt !== undefined ? `${run.runId}:${input.attempt}` : run.runId,
+                        data: {
+                            runId: run.runId,
+                            taskId: run.taskId,
+                            error: describeError(input.error),
+                            ...(input.attempt !== undefined ? { attempt: input.attempt } : {}),
+                        },
+                    });
+                },
+            };
+        },
+    };
+}
+export { describeError as describeJobError };
+//# sourceMappingURL=service.js.map

package/dist/jobs/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/jobs/service.ts"],"names":[],"mappings":"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"}

package/dist/jobs/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Tenant attribution carried by every job the core triggers.
+ *
+ * A job outlives the request that queued it, so the workspace it belongs to has
+ * to travel with it. This is *attribution*, not authorisation: by the time the
+ * task runs, the workspace may have been deleted or the actor removed from it, so
+ * a task must re-verify with `workspaces.requireContext()` before touching tenant
+ * data.
+ */
+export interface JobTenant {
+    readonly workspaceId: string;
+    /** The user who queued it. Null for scheduled or system-initiated work. */
+    readonly actorId: string | null;
+}
+/**
+ * The envelope a core-triggered task receives.
+ *
+ * The application's own payload sits under `data`, untouched, so the two never
+ * collide — a task payload with its own `tenant` field keeps working.
+ *
+ * ```ts
+ * export const resizeImage = task({
+ *   id: "resize-image",
+ *   run: async (payload: JobPayload<{ assetId: string }>) => {
+ *     const context = await workspaces.requireContext({
+ *       userId: payload.tenant.actorId!,
+ *       workspaceId: payload.tenant.workspaceId,
+ *     });
+ *     // ...
+ *   },
+ * });
+ * ```
+ */
+export interface JobPayload<TData> {
+    readonly tenant: JobTenant;
+    readonly data: TData;
+}
+/** A payload for work that belongs to no single tenant. */
+export interface SystemJobPayload<TData> {
+    readonly tenant: null;
+    readonly data: TData;
+}
+/**
+ * Trigger.dev options the core passes straight through.
+ *
+ * Deliberately mirrored rather than re-invented: the core adds tenant tagging
+ * and nothing else, so anything Trigger.dev supports stays reachable. Use the
+ * re-exported SDK directly for options not listed here.
+ */
+export interface JobTriggerOptions {
+    /** Ensures the task runs once per key, even across retried requests. */
+    readonly idempotencyKey?: string | string[];
+    readonly idempotencyKeyTTL?: string;
+    readonly maxAttempts?: number;
+    readonly queue?: string;
+    /** Limits concurrency within a key — pass a workspace id to fence tenants. */
+    readonly concurrencyKey?: string;
+    readonly delay?: string | Date;
+    readonly ttl?: string | number;
+    readonly priority?: number;
+    /** Merged with the tenant tags the core adds. */
+    readonly tags?: string[];
+    readonly metadata?: Record<string, unknown>;
+}
+export interface TriggerJobOptions extends JobTriggerOptions {
+    readonly workspaceId: string;
+    readonly actorId?: string | null;
+}
+/** What a trigger returns: enough to correlate, not a run snapshot. */
+export interface JobHandle {
+    /** Trigger.dev run id. Use it to subscribe, cancel, or look the run up. */
+    readonly runId: string;
+    readonly taskId: string;
+}
+/** Tag prefixes the core attaches, so runs are filterable per tenant. */
+export declare const WORKSPACE_TAG_PREFIX = "workspace:";
+export declare const ACTOR_TAG_PREFIX = "actor:";
+//# sourceMappingURL=types.d.ts.map

package/dist/jobs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/jobs/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,UAAU,CAAC,KAAK;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACtB;AAED,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB,CAAC,KAAK;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,uEAAuE;AACvE,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,gBAAgB,WAAW,CAAC"}

package/dist/jobs/types.js

@@ -0,0 +1,4 @@
+/** Tag prefixes the core attaches, so runs are filterable per tenant. */
+export const WORKSPACE_TAG_PREFIX = "workspace:";
+export const ACTOR_TAG_PREFIX = "actor:";
+//# sourceMappingURL=types.js.map

package/dist/jobs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/jobs/types.ts"],"names":[],"mappings":"AAgFA,yEAAyE;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,YAAY,CAAC;AACjD,MAAM,CAAC,MAAM,gBAAgB,GAAG,QAAQ,CAAC"}

package/dist/logger/default.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from "./types.ts";
+export declare function getDefaultLogger(): Logger;
+/** Replace the core's logger. Call once, at startup. */
+export declare function setDefaultLogger(logger: Logger): void;
+/** Silence the core. For tests. */
+export declare function silenceDefaultLogger(): void;
+//# sourceMappingURL=default.d.ts.map

package/dist/logger/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/logger/default.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAiBzC,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,mCAAmC;AACnC,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

package/dist/logger/default.js

@@ -0,0 +1,28 @@
+import { createLogger } from "./service.js";
+import { createNoopSink } from "./sinks.js";
+/**
+ * The logger the core itself writes to.
+ *
+ * A mutable default rather than a configuration read, so that importing any core
+ * module never requires configuration — a migration script should not need
+ * `LOG_LEVEL` set to run. An application calls {@link setDefaultLogger} once at
+ * startup with something configured; until then the core logs at `info` to
+ * stdout as JSON.
+ *
+ * Deliberately in its own module with no imports beyond the logger itself: if this
+ * pulled in `config`, every module that logs would transitively depend on
+ * configuration.
+ */
+let current = createLogger();
+export function getDefaultLogger() {
+    return current;
+}
+/** Replace the core's logger. Call once, at startup. */
+export function setDefaultLogger(logger) {
+    current = logger;
+}
+/** Silence the core. For tests. */
+export function silenceDefaultLogger() {
+    current = createLogger({ sink: createNoopSink() });
+}
+//# sourceMappingURL=default.js.map

package/dist/logger/default.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.js","sourceRoot":"","sources":["../../src/logger/default.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;;;;;;;;;GAYG;AACH,IAAI,OAAO,GAAW,YAAY,EAAE,CAAC;AAErC,MAAM,UAAU,gBAAgB;IAC9B,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,GAAG,MAAM,CAAC;AACnB,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,oBAAoB;IAClC,OAAO,GAAG,YAAY,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;AACrD,CAAC"}

package/dist/logger/index.d.ts

@@ -0,0 +1,24 @@
+import { type CreateLoggerOptions } from "./service.ts";
+import type { Logger } from "./types.ts";
+export { createRedactor, DEFAULT_REDACT_KEYS, REDACTED, type RedactOptions, type Redactor, } from "./redact.ts";
+export { createJsonSink, createMemorySink, createMultiSink, createNoopSink, createPrettySink, type MemorySink, type StreamSinkOptions, } from "./sinks.ts";
+export { createLogger, type CreateLoggerOptions } from "./service.ts";
+export { getDefaultLogger, setDefaultLogger, silenceDefaultLogger, } from "./default.ts";
+export { LOG_LEVEL_RANK, type LogFields, type Logger, type LogLevel, type LogRecord, type LogSink, } from "./types.ts";
+/**
+ * A logger built from the `app` configuration section.
+ *
+ * JSON in production, human-readable outside it. Reads `LOG_LEVEL`, so it throws
+ * `ConfigError` if `app` is not configured — which is why the core does not call
+ * this itself.
+ */
+export declare function createConfiguredLogger(options?: Omit<CreateLoggerOptions, "level" | "sink">): Logger;
+/**
+ * The core's logger, as a stable reference.
+ *
+ * Each method resolves the current default at call time, so
+ * {@link setDefaultLogger} takes effect for code that captured this earlier.
+ * Explicit delegation rather than a Proxy — there is no magic to reason about.
+ */
+export declare const logger: Logger;
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logger/index.ts"],"names":[],"mappings":"AA0CA,OAAO,EAAgB,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGtE,OAAO,KAAK,EAAa,MAAM,EAAY,MAAM,YAAY,CAAC;AAE9D,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEtE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,cAAc,EACd,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,OAAO,GACb,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,MAAM,CAAM,GAAG,MAAM,CAcxG;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,MAUpB,CAAC"}

package/dist/logger/index.js

@@ -0,0 +1,90 @@
+/**
+ * Public logger surface: `@digimuza/saas-core/logger`. Server-only.
+ *
+ * Structured logging with bound context and redaction, over a one-method sink so
+ * any backend can be plugged in. No logging dependency: a level check, a merge and
+ * a JSON line do not justify one, and the sink seam means adding pino or a hosted
+ * collector later is an adapter rather than a migration.
+ *
+ * ## Setup
+ *
+ * ```ts
+ * import { createConfiguredLogger, setDefaultLogger } from "@digimuza/saas-core/logger";
+ *
+ * // Once at startup. Reads LOG_LEVEL and APP_ENV.
+ * setDefaultLogger(createConfiguredLogger());
+ * ```
+ *
+ * Until then the core logs at `info` to stdout as JSON — so importing a core
+ * module never requires configuration.
+ *
+ * ## Bound context is the point
+ *
+ * ```ts
+ * const log = logger.child({ requestId, workspaceId: context.workspaceId, userId: user.id });
+ *
+ * log.info("project created", { projectId });
+ * log.error("indexing failed", { projectId, error });
+ * ```
+ *
+ * Bind at the edge and every line beneath is attributable, without threading
+ * identifiers through call signatures.
+ *
+ * ## Redaction is on by default
+ *
+ * The core handles API keys, session cookies, invitation tokens and webhook
+ * secrets. A logger that faithfully serialises whatever it is handed is the
+ * easiest way to move all of them into an aggregator a wider audience can read.
+ *
+ * Sensitive **keys** are replaced whatever the value; credential-shaped **values**
+ * are replaced whatever the key. Both, because either alone has a hole.
+ */
+import { config } from "../config/index.js";
+import { createLogger } from "./service.js";
+import { createJsonSink, createPrettySink } from "./sinks.js";
+import { getDefaultLogger } from "./default.js";
+export { createRedactor, DEFAULT_REDACT_KEYS, REDACTED, } from "./redact.js";
+export { createJsonSink, createMemorySink, createMultiSink, createNoopSink, createPrettySink, } from "./sinks.js";
+export { createLogger } from "./service.js";
+export { getDefaultLogger, setDefaultLogger, silenceDefaultLogger, } from "./default.js";
+export { LOG_LEVEL_RANK, } from "./types.js";
+/**
+ * A logger built from the `app` configuration section.
+ *
+ * JSON in production, human-readable outside it. Reads `LOG_LEVEL`, so it throws
+ * `ConfigError` if `app` is not configured — which is why the core does not call
+ * this itself.
+ */
+export function createConfiguredLogger(options = {}) {
+    const app = config.app;
+    return createLogger({
+        ...options,
+        level: app.logLevel,
+        sink: app.isProduction ? createJsonSink() : createPrettySink(),
+        base: {
+            // Identifies the source when several services ship to one aggregator.
+            app: app.name,
+            env: app.environment,
+            ...options.base,
+        },
+    });
+}
+/**
+ * The core's logger, as a stable reference.
+ *
+ * Each method resolves the current default at call time, so
+ * {@link setDefaultLogger} takes effect for code that captured this earlier.
+ * Explicit delegation rather than a Proxy — there is no magic to reason about.
+ */
+export const logger = {
+    get level() {
+        return getDefaultLogger().level;
+    },
+    isEnabled: (level) => getDefaultLogger().isEnabled(level),
+    debug: (message, fields) => getDefaultLogger().debug(message, fields),
+    info: (message, fields) => getDefaultLogger().info(message, fields),
+    warn: (message, fields) => getDefaultLogger().warn(message, fields),
+    error: (message, fields) => getDefaultLogger().error(message, fields),
+    child: (fields) => getDefaultLogger().child(fields),
+};
+//# sourceMappingURL=index.js.map

package/dist/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/logger/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,YAAY,EAA4B,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGhD,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,QAAQ,GAGT,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,gBAAgB,GAGjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAA4B,MAAM,cAAc,CAAC;AAEtE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,cAAc,GAMf,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAO,GAAgD,EAAE;IAC9F,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;IAEvB,OAAO,YAAY,CAAC;QAClB,GAAG,OAAO;QACV,KAAK,EAAE,GAAG,CAAC,QAAQ;QACnB,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,gBAAgB,EAAE;QAC9D,IAAI,EAAE;YACJ,sEAAsE;YACtE,GAAG,EAAE,GAAG,CAAC,IAAI;YACb,GAAG,EAAE,GAAG,CAAC,WAAW;YACpB,GAAG,OAAO,CAAC,IAAI;SAChB;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAW;IAC5B,IAAI,KAAK;QACP,OAAO,gBAAgB,EAAE,CAAC,KAAK,CAAC;IAClC,CAAC;IACD,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;IACzD,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC;IACrE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC;IACnE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC;IACnE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC;IACrE,KAAK,EAAE,CAAC,MAAiB,EAAE,EAAE,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC;CAC/D,CAAC"}

package/dist/logger/redact.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Redaction.
+ *
+ * The core handles API keys, session cookies, invitation tokens and webhook
+ * signing secrets. A logger that faithfully serialises whatever it is handed is
+ * the easiest way to move all of them into a log aggregator that a wider audience
+ * can read — so redaction is on by default, and errs toward over-redacting.
+ *
+ * Two independent passes, because either alone has a hole:
+ *
+ * - **By key.** `{ apiKey: "..." }` is redacted whatever the value looks like.
+ * - **By value.** A credential under an innocent key — `{ input: "dgk_..." }` —
+ *   is caught by its shape.
+ */
+export declare const REDACTED = "[redacted]";
+/**
+ * Field names whose values are never logged.
+ *
+ * Matched as case-insensitive substrings of the key, so `workosCookiePassword`
+ * and `cookie_password` are both caught without enumerating spellings.
+ */
+export declare const DEFAULT_REDACT_KEYS: readonly string[];
+export interface RedactOptions {
+    /** Replaces {@link DEFAULT_REDACT_KEYS} entirely. */
+    readonly keys?: readonly string[];
+    /** Added to the defaults. The usual way to extend. */
+    readonly additionalKeys?: readonly string[];
+    /**
+     * Turn off value scanning.
+     *
+     * Only sensible when you are certain no credential can reach a field, and you
+     * have measured the scan as a problem. Key redaction stays on.
+     */
+    readonly disableValueScanning?: boolean;
+}
+export interface Redactor {
+    (value: unknown): unknown;
+}
+export declare function createRedactor(options?: RedactOptions): Redactor;
+//# sourceMappingURL=redact.d.ts.map

package/dist/logger/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../src/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,QAAQ,eAAe,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAmBhD,CAAC;AAwBF,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,sDAAsD;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACzC;AAOD,MAAM,WAAW,QAAQ;IACvB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CAC3B;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,aAAkB,GAAG,QAAQ,CA6FpE"}