@dyrected/core 2.5.53 → 2.5.55

package/dist/chunk-CQDVPMEU.js

@@ -1,613 +0,0 @@
-// src/workflows.ts
-var WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
-var LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
-function publishingWorkflow() {
-  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: [
-      { role: "editor", capabilities: ["entry.edit", "entry.submit"] },
-      { role: "publisher", capabilities: ["entry.edit", "entry.submit", "entry.publish", "entry.unpublish"] },
-      { role: "admin", capabilities: ["entry.edit", "entry.submit", "entry.publish", "entry.unpublish"] }
-    ]
-  };
-}
-function publicMetadata(meta) {
-  const { availableTransitions: _availableTransitions, ...safe } = meta;
-  return safe;
-}
-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;
-}
-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));
-  });
-}
-function initializeWorkflowDocument(data, workflow) {
-  return {
-    ...data,
-    __workflow: { state: workflow.initialState, revision: 1 }
-  };
-}
-function materializeWorkflowDocument(doc, workflow, user) {
-  const meta = doc.__workflow;
-  if (!meta) return doc;
-  const { __published, __workflow, ...working } = doc;
-  if (!user) {
-    if (!__published || typeof __published !== "object") 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)}`;
-}
-function createLifecycleEvent(args) {
-  return {
-    id: eventId(),
-    name: args.name,
-    collection: args.collection,
-    documentId: args.documentId,
-    occurredAt: (/* @__PURE__ */ 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 });
-}
-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 ?? 1e3;
-  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: (/* @__PURE__ */ 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()
-      }
-    });
-  }
-}
-async function dispatchPendingLifecycleEvents(config, limit = 50) {
-  if (!config.db || !config.events?.handlers.length) return 0;
-  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) => !doc.nextAttemptAt || new Date(doc.nextAttemptAt).getTime() <= now);
-  for (const event of due) await dispatchLifecycleEvent(config, event);
-  return due.length;
-}
-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 event = createLifecycleEvent({
-    name: "revision.created",
-    collection: collection.slug,
-    documentId: id,
-    actorId: user?.sub,
-    payload: { revision: previous.revision + 1, previousRevision: previous.revision }
-  });
-  const doc = await db.transaction(async (tx) => {
-    const nextMeta = {
-      ...previous,
-      state: originalDoc.__published ? workflow.draftState ?? workflow.initialState : previous.state,
-      revision: previous.revision + 1
-    };
-    const updated = await tx.update({ collection: collection.slug, id, data: { ...data, __workflow: nextMeta } });
-    await persistEvent(tx, event);
-    return updated;
-  });
-  void dispatchLifecycleEvent(config, event);
-  return { doc, event };
-}
-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 };
-}
-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 !== void 0 && 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 now = (/* @__PURE__ */ new Date()).toISOString();
-    const { __published: _published, __workflow: _workflow, id: _id, ...working } = original;
-    const nextMeta = {
-      ...meta,
-      state: transition.to,
-      ...targetState.published ? { publishedRevision: meta.revision, publishedAt: now, publishedBy: user?.sub } : {},
-      ...transition.unpublish ? { publishedRevision: void 0, publishedAt: void 0, publishedBy: void 0 } : {}
-    };
-    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: meta.state, to: transition.to, revision: meta.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: meta.state, to: transition.to, revision: meta.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) {
-      console.error("[dyrected/workflow] afterTransition hook failed:", error);
-    }
-  }
-  return updated;
-}
-
-// src/utils/config.ts
-var AUDIT_COLLECTION_SLUG = "__audit";
-var SYSTEM_FIELDS = [
-  {
-    name: "createdAt",
-    type: "date",
-    label: "Created At",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "updatedAt",
-    type: "date",
-    label: "Updated At",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "createdBy",
-    type: "text",
-    label: "Created By",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "updatedBy",
-    type: "text",
-    label: "Updated By",
-    admin: { readOnly: true, hidden: true }
-  }
-];
-var AUDIT_COLLECTION = {
-  slug: AUDIT_COLLECTION_SLUG,
-  labels: { singular: "Audit Log", plural: "Audit Logs" },
-  fields: [
-    { name: "collection", type: "text", label: "Collection", required: true },
-    { name: "documentId", type: "text", label: "Document ID" },
-    { name: "operation", type: "select", label: "Operation", options: ["create", "update", "delete"], required: true },
-    { name: "user", type: "text", label: "User ID" },
-    { name: "timestamp", type: "date", label: "Timestamp", required: true },
-    { name: "changes", type: "json", label: "Changes" }
-  ],
-  admin: { hidden: true }
-};
-var WORKFLOW_HISTORY_COLLECTION_CONFIG = {
-  slug: WORKFLOW_HISTORY_COLLECTION,
-  labels: { singular: "Workflow transition", plural: "Workflow transitions" },
-  fields: [
-    { name: "collection", type: "text", required: true },
-    { name: "documentId", type: "text", required: true },
-    { name: "transition", type: "text", required: true },
-    { name: "from", type: "text", required: true },
-    { name: "to", type: "text", required: true },
-    { name: "revision", type: "number", required: true },
-    { name: "comment", type: "textarea" },
-    { name: "actorId", type: "text" },
-    { name: "createdAt", type: "date", required: true }
-  ],
-  access: { read: ({ user }) => !!user, create: () => false, update: () => false, delete: () => false },
-  admin: { hidden: true }
-};
-var LIFECYCLE_EVENTS_COLLECTION_CONFIG = {
-  slug: LIFECYCLE_EVENTS_COLLECTION,
-  labels: { singular: "Lifecycle event", plural: "Lifecycle events" },
-  fields: [
-    { name: "name", type: "text", required: true },
-    { name: "collection", type: "text", required: true },
-    { name: "documentId", type: "text", required: true },
-    { name: "occurredAt", type: "date", required: true },
-    { name: "actorId", type: "text" },
-    { name: "payload", type: "json", required: true },
-    { name: "attempts", type: "number", required: true },
-    { name: "status", type: "select", options: ["pending", "processing", "delivered", "failed"], required: true },
-    { name: "nextAttemptAt", type: "date" },
-    { name: "deliveredAt", type: "date" },
-    { name: "lastError", type: "textarea" }
-  ],
-  access: { read: ({ user }) => !!user?.roles?.includes("admin"), create: () => false, update: () => false, delete: () => false },
-  admin: { hidden: true }
-};
-function normalizeConfig(config) {
-  const collections = config?.collections || [];
-  const globals = config?.globals || [];
-  const needsAudit = collections.some((col) => col.audit);
-  const needsWorkflow = collections.some((col) => col.workflow);
-  const normalizedCollections = collections.map((col) => {
-    let fields = col.fields || [];
-    const existingFieldNames = new Set(fields.map((f) => f.name));
-    if (col.auth) {
-      if (!existingFieldNames.has("email")) {
-        fields = [
-          ...fields,
-          {
-            name: "email",
-            type: "email",
-            label: "Email",
-            required: true,
-            unique: true,
-            promoted: true,
-            access: {
-              update: "!id"
-            }
-          }
-        ];
-      }
-      if (!existingFieldNames.has("password")) {
-        fields = [
-          ...fields,
-          {
-            name: "password",
-            type: "text",
-            label: "Password",
-            required: true,
-            access: {
-              update: "!id || user.id == id"
-            }
-          }
-        ];
-      }
-      if (!existingFieldNames.has("roles")) {
-        fields = [
-          ...fields,
-          {
-            name: "roles",
-            type: "select",
-            label: "Roles",
-            defaultValue: [],
-            options: [
-              { value: "admin", label: "Admin" },
-              { value: "editor", label: "Editor" },
-              { value: "viewer", label: "Viewer" }
-            ],
-            access: {
-              update: "user.roles && 'admin' in user.roles"
-            }
-          }
-        ];
-      }
-      fields = fields.map((field) => {
-        if (field.name === "email") {
-          return {
-            ...field,
-            access: {
-              ...field.access || {},
-              update: "!id"
-            }
-          };
-        }
-        if (field.name === "password") {
-          return {
-            ...field,
-            admin: { ...field.admin || {} },
-            access: {
-              ...field.access || {},
-              update: "!id || user.id == id"
-            }
-          };
-        }
-        if (field.name === "roles") {
-          return {
-            ...field,
-            access: {
-              ...field.access || {},
-              // Must be an admin; cannot edit own roles (no self-elevation).
-              update: "user.roles && 'admin' in user.roles && user.id != id"
-            }
-          };
-        }
-        return field;
-      });
-    }
-    const updatedFieldNames = new Set(fields.map((f) => f.name));
-    const fieldsToInject = SYSTEM_FIELDS.filter((f) => !updatedFieldNames.has(f.name));
-    return {
-      ...col,
-      fields: [...fields, ...fieldsToInject]
-    };
-  });
-  const hasAuditCollection = normalizedCollections.some((col) => col.slug === AUDIT_COLLECTION_SLUG);
-  const systemCollections = [];
-  if (needsAudit && !hasAuditCollection) systemCollections.push(AUDIT_COLLECTION);
-  if (needsWorkflow && !normalizedCollections.some((col) => col.slug === WORKFLOW_HISTORY_COLLECTION)) {
-    systemCollections.push(WORKFLOW_HISTORY_COLLECTION_CONFIG);
-  }
-  if (needsWorkflow && !normalizedCollections.some((col) => col.slug === LIFECYCLE_EVENTS_COLLECTION)) {
-    systemCollections.push(LIFECYCLE_EVENTS_COLLECTION_CONFIG);
-  }
-  return {
-    ...config,
-    collections: [...normalizedCollections, ...systemCollections],
-    globals
-  };
-}
-
-// src/utils/hooks.ts
-async function runCollectionHooks(hooks, args, options = {}) {
-  if (!hooks || hooks.length === 0) {
-    return args.data ?? args.doc ?? void 0;
-  }
-  let currentPayload = args.data ?? args.doc ?? void 0;
-  for (const hook of hooks) {
-    try {
-      const result = await hook({
-        ...args,
-        data: args.data !== void 0 ? currentPayload : void 0,
-        doc: args.doc !== void 0 ? currentPayload : void 0
-      });
-      if (result !== void 0) {
-        currentPayload = result;
-      }
-    } catch (err) {
-      if (options.isolated) {
-        console.error("[dyrected/core] Side-effect hook failed (error isolated \u2014 DB write was successful):", err);
-      } else {
-        throw err;
-      }
-    }
-  }
-  return currentPayload;
-}
-async function executeFieldBeforeChange(fields, data, originalDoc, user, db) {
-  if (!data || typeof data !== "object") return data;
-  const result = { ...data };
-  for (const field of fields) {
-    if (!field.name) continue;
-    const value = result[field.name];
-    const origValue = originalDoc?.[field.name];
-    let updatedValue = value;
-    if (field.hooks?.beforeChange) {
-      for (const hook of field.hooks.beforeChange) {
-        updatedValue = await hook({
-          value: updatedValue,
-          originalDoc: originalDoc ?? void 0,
-          data: result,
-          user,
-          db
-        });
-      }
-      result[field.name] = updatedValue;
-    }
-    if (updatedValue !== void 0 && updatedValue !== null) {
-      if (field.type === "object" && field.fields) {
-        result[field.name] = await executeFieldBeforeChange(
-          field.fields,
-          updatedValue,
-          origValue,
-          user,
-          db
-        );
-      } else if (field.type === "array" && field.fields && Array.isArray(updatedValue)) {
-        const arrayResult = [];
-        for (let i = 0; i < updatedValue.length; i++) {
-          const item = updatedValue[i];
-          const origItem = Array.isArray(origValue) ? origValue[i] : null;
-          arrayResult.push(
-            await executeFieldBeforeChange(field.fields, item, origItem, user, db)
-          );
-        }
-        result[field.name] = arrayResult;
-      } else if (field.type === "blocks" && field.blocks && Array.isArray(updatedValue)) {
-        const blocksResult = [];
-        for (let i = 0; i < updatedValue.length; i++) {
-          const blockData = updatedValue[i];
-          const origBlock = Array.isArray(origValue) ? origValue[i] : null;
-          const blockConfig = field.blocks.find(
-            (b) => b.slug === blockData.blockType
-          );
-          if (blockConfig) {
-            blocksResult.push(
-              await executeFieldBeforeChange(
-                blockConfig.fields,
-                blockData,
-                origBlock,
-                user,
-                db
-              )
-            );
-          } else {
-            blocksResult.push(blockData);
-          }
-        }
-        result[field.name] = blocksResult;
-      }
-    }
-  }
-  return result;
-}
-async function executeFieldAfterRead(fields, doc, user, db) {
-  if (!doc || typeof doc !== "object") return doc;
-  const result = { ...doc };
-  for (const field of fields) {
-    if (!field.name) continue;
-    const value = result[field.name];
-    let updatedValue = value;
-    if (field.hooks?.afterRead) {
-      for (const hook of field.hooks.afterRead) {
-        updatedValue = await hook({
-          value: updatedValue,
-          doc: result,
-          user,
-          db
-        });
-      }
-      result[field.name] = updatedValue;
-    }
-    if (updatedValue !== void 0 && updatedValue !== null) {
-      if (field.type === "object" && field.fields) {
-        result[field.name] = await executeFieldAfterRead(
-          field.fields,
-          updatedValue,
-          user,
-          db
-        );
-      } else if (field.type === "array" && field.fields && Array.isArray(updatedValue)) {
-        const arrayResult = [];
-        for (const item of updatedValue) {
-          arrayResult.push(
-            await executeFieldAfterRead(
-              field.fields,
-              item,
-              user,
-              db
-            )
-          );
-        }
-        result[field.name] = arrayResult;
-      } else if (field.type === "blocks" && field.blocks && Array.isArray(updatedValue)) {
-        const blocksResult = [];
-        for (const blockData of updatedValue) {
-          const typedBlock = blockData;
-          const blockConfig = field.blocks.find(
-            (b) => b.slug === typedBlock.blockType
-          );
-          if (blockConfig) {
-            blocksResult.push(
-              await executeFieldAfterRead(
-                blockConfig.fields,
-                typedBlock,
-                user,
-                db
-              )
-            );
-          } else {
-            blocksResult.push(blockData);
-          }
-        }
-        result[field.name] = blocksResult;
-      }
-    }
-  }
-  return result;
-}
-
-export {
-  WORKFLOW_HISTORY_COLLECTION,
-  LIFECYCLE_EVENTS_COLLECTION,
-  publishingWorkflow,
-  workflowCapabilities,
-  availableWorkflowTransitions,
-  initializeWorkflowDocument,
-  materializeWorkflowDocument,
-  createLifecycleEvent,
-  dispatchLifecycleEvent,
-  dispatchPendingLifecycleEvents,
-  saveWorkflowDraft,
-  createWorkflowDocument,
-  transitionWorkflow,
-  normalizeConfig,
-  runCollectionHooks,
-  executeFieldBeforeChange,
-  executeFieldAfterRead
-};