@dyrected/core 2.6.3 → 2.6.4

package/dist/utils/upload-validation.js

@@ -0,0 +1,46 @@
+/**
+ * Returns true if `mimeType` matches any of the allowed patterns.
+ * Patterns support an any-type wildcard, a `type/*` wildcard (e.g. `image/*`),
+ * or an exact `type/subtype` match. Matching is case-insensitive.
+ */
+export function isMimeAllowed(mimeType, allowed) {
+    const type = (mimeType || "").toLowerCase().trim();
+    return allowed.some((raw) => {
+        const pattern = (raw || "").toLowerCase().trim();
+        if (!pattern)
+            return false;
+        if (pattern === "*" || pattern === "*/*")
+            return true;
+        if (pattern.endsWith("/*"))
+            return type.startsWith(pattern.slice(0, -1)); // "image/*" -> "image/"
+        return type === pattern;
+    });
+}
+/**
+ * Validates an uploaded file against a collection's {@link UploadConfig}.
+ * Enforces `allowedMimeTypes` and `maxFileSize` when they are configured.
+ * Returns `null` when the upload is allowed (or when no config restricts it).
+ */
+export function validateUpload(file, config) {
+    if (!config)
+        return null;
+    const { allowedMimeTypes, maxFileSize } = config;
+    if (allowedMimeTypes && allowedMimeTypes.length > 0) {
+        if (!isMimeAllowed(file.type || "", allowedMimeTypes)) {
+            return {
+                status: 415,
+                message: `File type "${file.type || "unknown"}" is not allowed. Allowed types: ${allowedMimeTypes.join(", ")}.`,
+            };
+        }
+    }
+    if (typeof maxFileSize === "number" &&
+        typeof file.size === "number" &&
+        file.size > maxFileSize) {
+        return {
+            status: 413,
+            message: `File is too large (${file.size} bytes). Maximum allowed size is ${maxFileSize} bytes.`,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=upload-validation.js.map

package/dist/utils/upload-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-validation.js","sourceRoot":"","sources":["../../src/utils/upload-validation.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,QAAgB,EAAE,OAAiB;IAC/D,MAAM,IAAI,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IACnD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;QAC1B,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAC3B,IAAI,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QACtD,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,wBAAwB;QAClG,OAAO,IAAI,KAAK,OAAO,CAAC;IAC1B,CAAC,CAAC,CAAC;AACL,CAAC;AAQD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAqD,EACrD,MAAgC;IAEhC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEzB,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC;IAEjD,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,EAAE,gBAAgB,CAAC,EAAE,CAAC;YACtD,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,cAAc,IAAI,CAAC,IAAI,IAAI,SAAS,oCAAoC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;aAChH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,IACE,OAAO,WAAW,KAAK,QAAQ;QAC/B,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;QAC7B,IAAI,CAAC,IAAI,GAAG,WAAW,EACvB,CAAC;QACD,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,sBAAsB,IAAI,CAAC,IAAI,oCAAoC,WAAW,SAAS;SACjG,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/utils/where-sanitizer.d.ts

@@ -0,0 +1,10 @@
+import { WhereClause } from './parse-where.js';
+import type { Field } from '../types/index.js';
+/**
+ * Sanitizes a WhereClause by stripping out any fields that:
+ * 1. Do not exist in the schema.
+ * 2. Have admin.filterable === false.
+ * 3. Are of a type that is never filterable (e.g. password, richText).
+ */
+export declare function sanitizeWhereClause(where: WhereClause, fields: Field[]): WhereClause;
+//# sourceMappingURL=where-sanitizer.d.ts.map

package/dist/utils/where-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"where-sanitizer.d.ts","sourceRoot":"","sources":["../../src/utils/where-sanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAY/C;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,WAAW,CAwDpF"}

package/dist/utils/where-sanitizer.js

@@ -0,0 +1,67 @@
+const NEVER_FILTERABLE_TYPES = [
+    'password',
+    'richText',
+    'json',
+    'file',
+    'image',
+    'join',
+    'collapsible'
+];
+/**
+ * Sanitizes a WhereClause by stripping out any fields that:
+ * 1. Do not exist in the schema.
+ * 2. Have admin.filterable === false.
+ * 3. Are of a type that is never filterable (e.g. password, richText).
+ */
+export function sanitizeWhereClause(where, fields) {
+    // Build a fast lookup map for fields, including nested fields if needed.
+    // For simplicity, we just look at top-level fields for now, as the DSL is flat.
+    // If the DSL supports nested properties (e.g., block fields), we'd need a deep lookup.
+    const fieldMap = new Map();
+    function addFieldsToMap(fList, prefix = '') {
+        for (const f of fList) {
+            if ('name' in f && f.name) {
+                fieldMap.set(prefix + f.name, f);
+            }
+            // If we support filtering inside groups/rows, we would recurse here.
+            // But for now, let's just do top-level.
+            if (f.type === 'object' || f.type === 'row' || f.type === 'array') {
+                if ('fields' in f && Array.isArray(f.fields)) {
+                    addFieldsToMap(f.fields, f.type === 'object' || f.type === 'array' ? `${prefix}${f.name}.` : prefix);
+                }
+            }
+        }
+    }
+    addFieldsToMap(fields);
+    function walk(node) {
+        const result = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'AND' || key === 'OR') {
+                if (Array.isArray(value)) {
+                    const processed = value.map(v => walk(v)).filter(v => Object.keys(v).length > 0);
+                    if (processed.length > 0) {
+                        result[key] = processed;
+                    }
+                }
+                continue;
+            }
+            // It's a field condition
+            if (key === 'id') {
+                result[key] = value;
+                continue;
+            }
+            const fieldDef = fieldMap.get(key);
+            if (!fieldDef)
+                continue; // Field doesn't exist
+            if (fieldDef.admin?.filterable === false)
+                continue; // Explicitly opted out
+            if (NEVER_FILTERABLE_TYPES.includes(fieldDef.type))
+                continue; // Never filterable type
+            // Keep the field
+            result[key] = value;
+        }
+        return result;
+    }
+    return walk(where);
+}
+//# sourceMappingURL=where-sanitizer.js.map

package/dist/utils/where-sanitizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"where-sanitizer.js","sourceRoot":"","sources":["../../src/utils/where-sanitizer.ts"],"names":[],"mappings":"AAGA,MAAM,sBAAsB,GAAG;IAC7B,UAAU;IACV,UAAU;IACV,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,aAAa;CACd,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAkB,EAAE,MAAe;IACrE,yEAAyE;IACzE,gFAAgF;IAChF,uFAAuF;IACvF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiB,CAAC;IAE1C,SAAS,cAAc,CAAC,KAAc,EAAE,MAAM,GAAG,EAAE;QACjD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;gBAC1B,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,CAAU,CAAC,CAAC;YAC5C,CAAC;YACD,qEAAqE;YACrE,wCAAwC;YACxC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;gBAClE,IAAI,QAAQ,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC7C,cAAc,CAAC,CAAC,CAAC,MAAiB,EAAE,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,GAAI,CAAS,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC3H,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,cAAc,CAAC,MAAM,CAAC,CAAC;IAEvB,SAAS,IAAI,CAAC,IAAiB;QAC7B,MAAM,MAAM,GAAgB,EAAE,CAAC;QAE/B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;gBAClC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBACzB,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBACjF,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBACzB,MAAM,CAAC,GAAmB,CAAC,GAAG,SAAS,CAAC;oBAC1C,CAAC;gBACH,CAAC;gBACD,SAAS;YACX,CAAC;YAED,yBAAyB;YACzB,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;gBACjB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBACpB,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAEnC,IAAI,CAAC,QAAQ;gBAAE,SAAS,CAAC,sBAAsB;YAC/C,IAAI,QAAQ,CAAC,KAAK,EAAE,UAAU,KAAK,KAAK;gBAAE,SAAS,CAAC,uBAAuB;YAC3E,IAAI,sBAAsB,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,SAAS,CAAC,wBAAwB;YAEtF,iBAAiB;YACjB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACtB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC"}

package/dist/workflows.d.ts

@@ -0,0 +1,86 @@
+import type { AuthenticatedUser, BaseDocument, CollectionConfig, DyrectedConfig, HookRequestContext, LifecycleEvent, LifecycleEventName, WorkflowConfig, WorkflowTransition } from "./types/index.js";
+export declare const WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
+export declare const LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
+/**
+ * Role mapping for {@link definePublishingWorkflow}. Map your app's own role
+ * values onto the publishing workflow's two capability tiers.
+ */
+export interface PublishingWorkflowOptions {
+    /** Role values allowed to edit and submit for review. Defaults to `["editor"]`. */
+    editors?: string[];
+    /** Role values allowed to also publish and unpublish. Defaults to `["publisher", "admin"]`. */
+    publishers?: string[];
+}
+/**
+ * Build a `draft → in review → published` editorial workflow, mapping your own
+ * role values onto its capability tiers. Reach for this instead of
+ * {@link publishingWorkflow} when your roles aren't named
+ * `editor`/`publisher`/`admin`.
+ *
+ * @example
+ * workflow: definePublishingWorkflow({
+ *   editors: ["writer"],
+ *   publishers: ["managing-editor", "admin"],
+ * })
+ */
+export declare function definePublishingWorkflow(options?: PublishingWorkflowOptions): WorkflowConfig;
+/**
+ * The default `draft → in review → published` editorial workflow, using the
+ * conventional role names `editor`, `publisher`, and `admin`. Shorthand for
+ * `definePublishingWorkflow()` — use {@link definePublishingWorkflow} to map
+ * your own role names onto its capability tiers.
+ */
+export declare function publishingWorkflow(): WorkflowConfig;
+export declare function simplePublishingWorkflow(): WorkflowConfig;
+export declare function workflowCapabilities(workflow: WorkflowConfig, user?: AuthenticatedUser): Set<string>;
+export declare function canViewWorkflowDraft(workflow: WorkflowConfig, user?: AuthenticatedUser): boolean;
+export declare function availableWorkflowTransitions(workflow: WorkflowConfig, state: string, user?: AuthenticatedUser): WorkflowTransition[];
+export declare function initializeWorkflowDocument(data: Record<string, unknown>, workflow: WorkflowConfig): {
+    __workflow: {
+        state: string;
+        revision: number;
+    };
+};
+/** The state a legacy document is treated as: the published one, else the last. */
+export declare function publishedStateName(workflow: WorkflowConfig): string;
+export declare function materializeWorkflowDocument(doc: BaseDocument, workflow: WorkflowConfig, user?: AuthenticatedUser): BaseDocument | null;
+export declare function createLifecycleEvent(args: {
+    name: LifecycleEventName;
+    collection: string;
+    documentId: string;
+    actorId?: string;
+    payload: Record<string, unknown>;
+}): LifecycleEvent;
+export declare function dispatchLifecycleEvent(config: DyrectedConfig, event: LifecycleEvent): Promise<void>;
+export declare function dispatchPendingLifecycleEvents(config: DyrectedConfig, limit?: number): Promise<number>;
+export declare function saveWorkflowDraft(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    id: string;
+    originalDoc: BaseDocument;
+    data: Record<string, unknown>;
+    user?: AuthenticatedUser;
+}): Promise<{
+    doc: BaseDocument;
+    event: LifecycleEvent;
+}>;
+export declare function createWorkflowDocument(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    data: Record<string, unknown>;
+    user?: AuthenticatedUser;
+}): Promise<{
+    doc: BaseDocument;
+    event: LifecycleEvent;
+}>;
+export declare function transitionWorkflow(args: {
+    config: DyrectedConfig;
+    collection: CollectionConfig;
+    id: string;
+    transitionName: string;
+    expectedRevision?: number;
+    comment?: string;
+    user?: AuthenticatedUser;
+    req: HookRequestContext;
+}): Promise<BaseDocument>;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/workflows.d.ts.map

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

package/dist/workflows.js

@@ -0,0 +1,405 @@
+import { getConfigLogger, getObservabilityRuntime } from "./observability.js";
+export const WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
+export const LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
+/** Capabilities granted to the "editor" tier — edit and submit for review. */
+const EDITOR_CAPABILITIES = ["entry.edit", "entry.submit"];
+/** Capabilities granted to the "publisher" tier — edit, submit, publish, unpublish. */
+const PUBLISHER_CAPABILITIES = ["entry.edit", "entry.submit", "entry.publish", "entry.unpublish"];
+/**
+ * Build a `draft → in review → published` editorial workflow, mapping your own
+ * role values onto its capability tiers. Reach for this instead of
+ * {@link publishingWorkflow} when your roles aren't named
+ * `editor`/`publisher`/`admin`.
+ *
+ * @example
+ * workflow: definePublishingWorkflow({
+ *   editors: ["writer"],
+ *   publishers: ["managing-editor", "admin"],
+ * })
+ */
+export function definePublishingWorkflow(options = {}) {
+    const editors = options.editors ?? ["editor"];
+    const publishers = options.publishers ?? ["publisher", "admin"];
+    return {
+        initialState: "draft",
+        draftState: "draft",
+        states: [
+            { name: "draft", label: "Draft", color: "neutral" },
+            { name: "in_review", label: "In review", color: "warning" },
+            { name: "published", label: "Published", color: "success", published: true },
+        ],
+        transitions: [
+            { name: "submit", label: "Submit for review", from: "draft", to: "in_review", requiredCapabilities: ["entry.submit"] },
+            { name: "publish", label: "Publish", from: "in_review", to: "published", requiredCapabilities: ["entry.publish"] },
+            { name: "reject", label: "Request changes", from: "in_review", to: "draft", requiredCapabilities: ["entry.publish"], requireComment: true },
+            { name: "unpublish", label: "Unpublish", from: "published", to: "draft", requiredCapabilities: ["entry.unpublish"], unpublish: true },
+        ],
+        roles: [
+            ...editors.map((role) => ({ role, capabilities: [...EDITOR_CAPABILITIES] })),
+            ...publishers.map((role) => ({ role, capabilities: [...PUBLISHER_CAPABILITIES] })),
+        ],
+    };
+}
+/**
+ * The default `draft → in review → published` editorial workflow, using the
+ * conventional role names `editor`, `publisher`, and `admin`. Shorthand for
+ * `definePublishingWorkflow()` — use {@link definePublishingWorkflow} to map
+ * your own role names onto its capability tiers.
+ */
+export function publishingWorkflow() {
+    return definePublishingWorkflow();
+}
+export function simplePublishingWorkflow() {
+    return {
+        initialState: "draft",
+        draftState: "draft",
+        states: [
+            { name: "draft", label: "Draft", color: "neutral" },
+            { name: "published", label: "Published", color: "success", published: true },
+        ],
+        transitions: [
+            { name: "publish", label: "Publish", from: "draft", to: "published" },
+            { name: "unpublish", label: "Unpublish", from: "published", to: "draft", unpublish: true },
+        ],
+        // Intentionally no `roles`: this lightweight workflow (synthesized from
+        // `drafts: true`) does no capability-based gating. Draft visibility for a
+        // no-roles workflow is handled in `canViewWorkflowDraft`.
+    };
+}
+function publicMetadata(meta) {
+    const { availableTransitions: _availableTransitions, ...safe } = meta;
+    return safe;
+}
+export function workflowCapabilities(workflow, user) {
+    const capabilities = new Set(Array.isArray(user?.capabilities) ? user.capabilities : []);
+    const roles = Array.isArray(user?.roles) ? user.roles : [];
+    for (const mapping of workflow.roles ?? []) {
+        if (roles.includes(mapping.role))
+            mapping.capabilities.forEach((capability) => capabilities.add(capability));
+    }
+    return capabilities;
+}
+export function canViewWorkflowDraft(workflow, user) {
+    if (!user)
+        return false;
+    const capabilities = workflowCapabilities(workflow, user);
+    if (capabilities.has("entry.edit"))
+        return true;
+    if (workflow.transitions.some((transition) => (transition.requiredCapabilities ?? []).some((capability) => capabilities.has(capability)))) {
+        return true;
+    }
+    // A workflow with no role→capability mappings (e.g. the one synthesized from
+    // `drafts: true`) does no capability-based gating. Rather than hide drafts
+    // from everyone — which would empty the Admin list — let any authenticated
+    // user view them. Unauthenticated/public readers are already excluded above,
+    // so drafts still never leak to the public site.
+    if (!workflow.roles || workflow.roles.length === 0)
+        return true;
+    return false;
+}
+export function availableWorkflowTransitions(workflow, state, user) {
+    const capabilities = workflowCapabilities(workflow, user);
+    return workflow.transitions.filter((transition) => {
+        const from = Array.isArray(transition.from) ? transition.from : [transition.from];
+        return from.includes(state) && (transition.requiredCapabilities ?? []).every((item) => capabilities.has(item));
+    });
+}
+export function initializeWorkflowDocument(data, workflow) {
+    return {
+        ...data,
+        __workflow: { state: workflow.initialState, revision: 1 },
+    };
+}
+/** The state a legacy document is treated as: the published one, else the last. */
+export function publishedStateName(workflow) {
+    return (workflow.states.find((state) => state.published)?.name ??
+        workflow.states[workflow.states.length - 1]?.name ??
+        workflow.initialState);
+}
+export function materializeWorkflowDocument(doc, workflow, user) {
+    const meta = doc.__workflow;
+    const publishedState = publishedStateName(workflow);
+    // Legacy content: a document that predates the workflow (no `__workflow`).
+    // Treat it as already-published live content — its own fields are the
+    // published snapshot — so it stays visible to everyone and surfaces the
+    // workflow panel in the Admin. Without this, enabling `drafts`/workflow on an
+    // existing collection would leave old documents with no workflow metadata.
+    if (!meta) {
+        const { __published: _legacyPublished, __workflow: _legacyWorkflow, ...working } = doc;
+        const state = publishedStateName(workflow);
+        return {
+            ...working,
+            _workflow: {
+                state,
+                revision: 1,
+                availableTransitions: availableWorkflowTransitions(workflow, state, user).map((item) => item.name),
+            },
+        };
+    }
+    const { __published, __workflow, ...working } = doc;
+    if (!canViewWorkflowDraft(workflow, user)) {
+        if (!__published || typeof __published !== "object") {
+            if (meta.state === publishedState) {
+                return { ...working, _workflow: publicMetadata(meta) };
+            }
+            return null;
+        }
+        return { id: doc.id, ...__published, _workflow: publicMetadata(meta) };
+    }
+    return {
+        ...working,
+        _workflow: {
+            ...meta,
+            availableTransitions: availableWorkflowTransitions(workflow, meta.state, user).map((item) => item.name),
+        },
+    };
+}
+function eventId() {
+    return globalThis.crypto?.randomUUID?.() ?? `evt_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+export function createLifecycleEvent(args) {
+    return {
+        id: eventId(),
+        name: args.name,
+        collection: args.collection,
+        documentId: args.documentId,
+        occurredAt: new Date().toISOString(),
+        actorId: args.actorId,
+        payload: args.payload,
+        attempts: 0,
+        status: "pending",
+    };
+}
+async function persistEvent(db, event) {
+    await db.create({ collection: LIFECYCLE_EVENTS_COLLECTION, data: event });
+}
+export async function dispatchLifecycleEvent(config, event) {
+    const db = config.db;
+    if (!db || !config.events?.handlers.length)
+        return;
+    const maxAttempts = config.events.maxAttempts ?? 8;
+    const retryDelayMs = config.events.retryDelayMs ?? 1_000;
+    const attempts = event.attempts + 1;
+    try {
+        await db.update({ collection: LIFECYCLE_EVENTS_COLLECTION, id: event.id, data: { status: "processing", attempts } });
+        for (const handler of config.events.handlers)
+            await handler({ ...event, status: "processing", attempts });
+        await db.update({
+            collection: LIFECYCLE_EVENTS_COLLECTION,
+            id: event.id,
+            data: { status: "delivered", attempts, deliveredAt: new Date().toISOString(), lastError: null },
+        });
+    }
+    catch (error) {
+        const exhausted = attempts >= maxAttempts;
+        await db.update({
+            collection: LIFECYCLE_EVENTS_COLLECTION,
+            id: event.id,
+            data: {
+                status: "failed",
+                attempts,
+                lastError: error instanceof Error ? error.message : String(error),
+                nextAttemptAt: exhausted ? null : new Date(Date.now() + retryDelayMs * 2 ** (attempts - 1)).toISOString(),
+            },
+        });
+    }
+}
+// Drain the durable lifecycle-event outbox: deliver pending events and retry
+// failed ones that are due, with backoff. Returns how many were dispatched.
+//
+// DESIGN NOTE — core intentionally does NOT schedule this itself. Immediate
+// delivery is attempted inline after each change (see `void dispatchLifecycleEvent`
+// above); this function drains the outbox for retries and for anything the inline
+// attempt missed. The host owns the process, so the host schedules the drain:
+// Dyrected Cloud runs it via BullMQ/Redis every 30s; self-hosters call it from a
+// cron / worker / platform scheduler (Vercel Cron, Cloudflare Cron Triggers, …).
+//
+// FUTURE — consider: an opt-in `events.autoDispatch: { intervalMs }` could start a
+// `setInterval` in `createDyrectedApp` as a convenience for long-lived,
+// single-instance Node servers. Keep it opt-in and off by default — a built-in
+// timer is unreliable on serverless (the process is ephemeral) and would
+// double-dispatch across multiple instances without coordination.
+export async function dispatchPendingLifecycleEvents(config, limit = 50) {
+    if (!config.db || !config.events?.handlers.length)
+        return 0;
+    const maxAttempts = config.events.maxAttempts ?? 8;
+    const result = await config.db.find({
+        collection: LIFECYCLE_EVENTS_COLLECTION,
+        where: { status: { in: ["pending", "failed"] } },
+        sort: "occurredAt",
+        limit,
+    });
+    const now = Date.now();
+    const due = result.docs.filter((doc) => Number(doc.attempts ?? 0) < maxAttempts &&
+        (!doc.nextAttemptAt || new Date(doc.nextAttemptAt).getTime() <= now));
+    for (const event of due)
+        await dispatchLifecycleEvent(config, event);
+    return due.length;
+}
+export async function saveWorkflowDraft(args) {
+    const { config, collection, id, originalDoc, data, user } = args;
+    const db = config.db;
+    const workflow = collection.workflow;
+    if (!db.transaction)
+        throw new Error(`The configured database adapter does not support workflow transactions.`);
+    const previous = originalDoc.__workflow;
+    const isLegacyPublishedDoc = !previous;
+    const baselineRevision = previous?.revision ?? 1;
+    const event = createLifecycleEvent({
+        name: "revision.created",
+        collection: collection.slug,
+        documentId: id,
+        actorId: user?.sub,
+        payload: {
+            revision: baselineRevision + 1,
+            previousRevision: isLegacyPublishedDoc ? baselineRevision : previous?.revision ?? null,
+        },
+    });
+    const doc = await db.transaction(async (tx) => {
+        const nextMeta = {
+            ...(previous ?? {}),
+            state: isLegacyPublishedDoc
+                ? workflow.draftState ?? workflow.initialState
+                : originalDoc.__published
+                    ? workflow.draftState ?? workflow.initialState
+                    : previous.state,
+            revision: baselineRevision + 1,
+            ...(isLegacyPublishedDoc ? { publishedRevision: baselineRevision } : {}),
+        };
+        const updateData = {
+            ...data,
+            __workflow: nextMeta,
+        };
+        if (isLegacyPublishedDoc) {
+            const { __workflow: _legacyWorkflow, __published: _legacyPublished, ...publishedSnapshot } = originalDoc;
+            updateData.__published = publishedSnapshot;
+        }
+        const updated = await tx.update({ collection: collection.slug, id, data: updateData });
+        await persistEvent(tx, event);
+        return updated;
+    });
+    void dispatchLifecycleEvent(config, event);
+    return { doc, event };
+}
+export async function createWorkflowDocument(args) {
+    const { config, collection, data, user } = args;
+    const db = config.db;
+    if (!db.transaction)
+        throw new Error(`The configured database adapter does not support workflow transactions.`);
+    let event;
+    const doc = await db.transaction(async (tx) => {
+        const created = await tx.create({ collection: collection.slug, data });
+        event = createLifecycleEvent({
+            name: "revision.created",
+            collection: collection.slug,
+            documentId: created.id,
+            actorId: user?.sub,
+            payload: { revision: 1, previousRevision: null },
+        });
+        await persistEvent(tx, event);
+        return created;
+    });
+    void dispatchLifecycleEvent(config, event);
+    return { doc, event };
+}
+export async function transitionWorkflow(args) {
+    const { config, collection, id, transitionName, expectedRevision, comment, user, req } = args;
+    const db = config.db;
+    const workflow = collection.workflow;
+    if (!db.transaction)
+        throw new Error(`The configured database adapter does not support workflow transactions.`);
+    const original = await db.findOne({ collection: collection.slug, id });
+    if (!original)
+        throw Object.assign(new Error("Not Found"), { statusCode: 404 });
+    const meta = original.__workflow;
+    if (!meta)
+        throw Object.assign(new Error("Entry has no workflow metadata"), { statusCode: 409 });
+    if (expectedRevision !== undefined && expectedRevision !== meta.revision) {
+        throw Object.assign(new Error("This entry changed since it was loaded. Refresh before transitioning it."), { statusCode: 409 });
+    }
+    const transition = workflow.transitions.find((item) => item.name === transitionName);
+    const fromStates = transition ? (Array.isArray(transition.from) ? transition.from : [transition.from]) : [];
+    if (!transition || !fromStates.includes(meta.state)) {
+        throw Object.assign(new Error(`Transition "${transitionName}" is not valid from "${meta.state}".`), { statusCode: 409 });
+    }
+    if (!availableWorkflowTransitions(workflow, meta.state, user).some((item) => item.name === transition.name)) {
+        throw Object.assign(new Error(`You do not have permission to perform "${transition.label}".`), { statusCode: 403 });
+    }
+    if (transition.requireComment && !comment?.trim()) {
+        throw Object.assign(new Error(`A comment is required for "${transition.label}".`), { statusCode: 400 });
+    }
+    const hookContext = { transition, from: meta.state, to: transition.to, doc: original, user, comment, req, db };
+    for (const hook of workflow.hooks?.beforeTransition ?? [])
+        await hook(hookContext);
+    const events = [createLifecycleEvent({
+            name: "workflow.transitioned",
+            collection: collection.slug,
+            documentId: id,
+            actorId: user?.sub,
+            payload: { transition: transition.name, from: meta.state, to: transition.to, revision: meta.revision, comment },
+        })];
+    const targetState = workflow.states.find((state) => state.name === transition.to);
+    if (targetState.published) {
+        events.push(createLifecycleEvent({ name: "entry.published", collection: collection.slug, documentId: id, actorId: user?.sub, payload: { revision: meta.revision } }));
+    }
+    else if (transition.unpublish) {
+        events.push(createLifecycleEvent({ name: "entry.unpublished", collection: collection.slug, documentId: id, actorId: user?.sub, payload: { revision: meta.publishedRevision } }));
+    }
+    const updated = await db.transaction(async (tx) => {
+        const locked = await tx.findOne({ collection: collection.slug, id });
+        if (!locked)
+            throw Object.assign(new Error("Not Found"), { statusCode: 404 });
+        const lockedMeta = locked.__workflow;
+        if (lockedMeta.revision !== meta.revision ||
+            lockedMeta.state !== meta.state ||
+            (expectedRevision !== undefined && lockedMeta.revision !== expectedRevision)) {
+            throw Object.assign(new Error("This entry changed since it was loaded. Refresh before transitioning it."), { statusCode: 409 });
+        }
+        const now = new Date().toISOString();
+        const { __published: _published, __workflow: _workflow, id: _id, ...working } = locked;
+        const nextMeta = {
+            ...lockedMeta,
+            state: transition.to,
+            ...(targetState.published ? { publishedRevision: lockedMeta.revision, publishedAt: now, publishedBy: user?.sub } : {}),
+            ...(transition.unpublish ? { publishedRevision: undefined, publishedAt: undefined, publishedBy: undefined } : {}),
+        };
+        const data = { __workflow: nextMeta };
+        if (targetState.published)
+            data.__published = working;
+        if (transition.unpublish)
+            data.__published = null;
+        const next = await tx.update({ collection: collection.slug, id, data });
+        await tx.create({
+            collection: WORKFLOW_HISTORY_COLLECTION,
+            data: { collection: collection.slug, documentId: id, transition: transition.name, from: lockedMeta.state, to: transition.to, revision: lockedMeta.revision, comment: comment ?? null, actorId: user?.sub ?? null, createdAt: now },
+        });
+        for (const event of events)
+            await persistEvent(tx, event);
+        if (collection.audit) {
+            await tx.create({ collection: "__audit", data: { collection: collection.slug, documentId: id, operation: "workflow.transition", user: user?.sub ?? null, timestamp: now, changes: JSON.stringify({ transition: transition.name, from: lockedMeta.state, to: transition.to, revision: lockedMeta.revision }) } });
+        }
+        return next;
+    });
+    for (const event of events)
+        void dispatchLifecycleEvent(config, event);
+    for (const hook of workflow.hooks?.afterTransition ?? []) {
+        try {
+            await hook({ ...hookContext, doc: updated, event: events[0] });
+        }
+        catch (error) {
+            getObservabilityRuntime(config)?.recordWorkflowHookFailure({
+                collection: collection.slug,
+                transition: transition.name,
+            });
+            getConfigLogger(config, "workflow").error({
+                err: error,
+                msg: "afterTransition hook failed",
+                collection: collection.slug,
+                transition: transition.name,
+                documentId: id,
+            });
+        }
+    }
+    return updated;
+}
+//# sourceMappingURL=workflows.js.map