@dyrected/core 2.5.61 → 2.5.63

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -46,6 +56,7 @@ __export(index_exports, {
   defineMultiSelectField: () => defineMultiSelectField,
   defineNumberField: () => defineNumberField,
   defineObjectField: () => defineObjectField,
+  definePublishingWorkflow: () => definePublishingWorkflow,
   defineRadioField: () => defineRadioField,
   defineRelationshipField: () => defineRelationshipField,
   defineRichTextField: () => defineRichTextField,
@@ -70,6 +81,7 @@ __export(index_exports, {
   parseMongoWhere: () => parseMongoWhere,
   parseSort: () => parseSort,
   parseSqlWhere: () => parseSqlWhere,
+  publishedStateName: () => publishedStateName,
   publishingWorkflow: () => publishingWorkflow,
   resolveAdminAuthCollection: () => resolveAdminAuthCollection,
   runCollectionHooks: () => runCollectionHooks,
@@ -88,10 +100,47 @@ var LIFECYCLE_EVENT_NAMES = [
   "entry.unpublished"
 ];
 
+// src/auth/token.ts
+var import_jose = require("jose");
+var import_node_util = require("util");
+
+// src/auth/sessions.ts
+var AUTH_SESSIONS_COLLECTION = "__auth_sessions";
+
+// src/observability.ts
+var import_api = require("@opentelemetry/api");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_prometheus = require("@opentelemetry/exporter-prometheus");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_pino = __toESM(require("pino"), 1);
+var import_pino_pretty = __toESM(require("pino-pretty"), 1);
+var import_node_stream = require("stream");
+var runtimeByConfig = /* @__PURE__ */ new WeakMap();
+var fallbackLogger = (0, import_pino.default)({
+  name: "dyrected",
+  enabled: process.env.DISABLE_LOGGING !== "true",
+  timestamp: import_pino.stdTimeFunctions.isoTime
+});
+function getObservabilityRuntime(config) {
+  if (!config || typeof config !== "object") return void 0;
+  return runtimeByConfig.get(config);
+}
+function getConfigLogger(config, component) {
+  const base = config?.logger && !("options" in config.logger) ? config.logger : fallbackLogger;
+  return base.child({ component });
+}
+
 // src/workflows.ts
 var WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
 var LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
-function publishingWorkflow() {
+var EDITOR_CAPABILITIES = ["entry.edit", "entry.submit"];
+var PUBLISHER_CAPABILITIES = ["entry.edit", "entry.submit", "entry.publish", "entry.unpublish"];
+function definePublishingWorkflow(options = {}) {
+  const editors = options.editors ?? ["editor"];
+  const publishers = options.publishers ?? ["publisher", "admin"];
   return {
     initialState: "draft",
     draftState: "draft",
@@ -107,12 +156,14 @@ function publishingWorkflow() {
       { 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"] }
+      ...editors.map((role) => ({ role, capabilities: [...EDITOR_CAPABILITIES] })),
+      ...publishers.map((role) => ({ role, capabilities: [...PUBLISHER_CAPABILITIES] }))
     ]
   };
 }
+function publishingWorkflow() {
+  return definePublishingWorkflow();
+}
 function simplePublishingWorkflow() {
   return {
     initialState: "draft",
@@ -125,6 +176,9 @@ function simplePublishingWorkflow() {
       { 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) {
@@ -143,9 +197,13 @@ function canViewWorkflowDraft(workflow, user) {
   if (!user) return false;
   const capabilities = workflowCapabilities(workflow, user);
   if (capabilities.has("entry.edit")) return true;
-  return workflow.transitions.some(
+  if (workflow.transitions.some(
     (transition) => (transition.requiredCapabilities ?? []).some((capability) => capabilities.has(capability))
-  );
+  )) {
+    return true;
+  }
+  if (!workflow.roles || workflow.roles.length === 0) return true;
+  return false;
 }
 function availableWorkflowTransitions(workflow, state, user) {
   const capabilities = workflowCapabilities(workflow, user);
@@ -165,6 +223,7 @@ function publishedStateName(workflow) {
 }
 function materializeWorkflowDocument(doc, workflow, user) {
   const meta = doc.__workflow;
+  const publishedState = publishedStateName(workflow);
   if (!meta) {
     const { __published: _legacyPublished, __workflow: _legacyWorkflow, ...working2 } = doc;
     const state = publishedStateName(workflow);
@@ -179,7 +238,12 @@ function materializeWorkflowDocument(doc, workflow, user) {
   }
   const { __published, __workflow, ...working } = doc;
   if (!canViewWorkflowDraft(workflow, user)) {
-    if (!__published || typeof __published !== "object") return null;
+    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 {
@@ -259,20 +323,34 @@ async function saveWorkflowDraft(args) {
   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: previous.revision + 1, previousRevision: previous.revision }
+    payload: {
+      revision: baselineRevision + 1,
+      previousRevision: isLegacyPublishedDoc ? baselineRevision : previous?.revision ?? null
+    }
   });
   const doc = await db.transaction(async (tx) => {
     const nextMeta = {
-      ...previous,
-      state: originalDoc.__published ? workflow.draftState ?? workflow.initialState : previous.state,
-      revision: previous.revision + 1
+      ...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
     };
-    const updated = await tx.update({ collection: collection.slug, id, data: { ...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;
   });
@@ -371,7 +449,17 @@ async function transitionWorkflow(args) {
     try {
       await hook({ ...hookContext, doc: updated, event: events[0] });
     } catch (error) {
-      console.error("[dyrected/workflow] afterTransition hook failed:", 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;
@@ -412,6 +500,98 @@ function humanizeProviderName(id, type) {
   return cleaned.replace(/\b\w/g, (char) => char.toUpperCase());
 }
 
+// src/utils/block-references.ts
+function mergeUniqueBlocks(blocks) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const existing = seen.get(block.slug);
+    if (existing && existing !== block) {
+      throw new Error(
+        `Duplicate block slug "${block.slug}" found in the reusable block registry. Block slugs must be unique.`
+      );
+    }
+    if (!existing) seen.set(block.slug, block);
+  }
+  return Array.from(seen.values());
+}
+function buildRegistry(blocks) {
+  return new Map(blocks.map((block) => [block.slug, block]));
+}
+function resolveField(field, registry, blockCache) {
+  const next = { ...field };
+  if (next.fields) {
+    next.fields = next.fields.map(
+      (child) => resolveField(child, registry, blockCache)
+    );
+  }
+  if (next.type !== "blocks") return next;
+  const hasInlineBlocks = Array.isArray(next.blocks) && next.blocks.length > 0;
+  const hasReferences = Array.isArray(next.blockReferences) && next.blockReferences.length > 0;
+  if (hasInlineBlocks && hasReferences) {
+    throw new Error(
+      `Blocks field "${next.name ?? "(unnamed)"}" cannot define both "blocks" and "blockReferences". Use one or the other.`
+    );
+  }
+  if (hasReferences) {
+    next.blocks = next.blockReferences.map((slug) => {
+      const block = registry.get(slug);
+      if (!block) {
+        throw new Error(
+          `Unknown block reference "${slug}" on blocks field "${next.name ?? "(unnamed)"}". Add it to defineConfig({ blocks: [...] }).`
+        );
+      }
+      return resolveBlock(block, registry, blockCache);
+    });
+    return next;
+  }
+  if (hasInlineBlocks) {
+    next.blocks = next.blocks.map(
+      (block) => resolveBlock(block, registry, blockCache)
+    );
+  }
+  return next;
+}
+function resolveBlock(block, registry, blockCache) {
+  const cached = blockCache.get(block);
+  if (cached) return cached;
+  const resolved = {
+    ...block,
+    fields: []
+  };
+  blockCache.set(block, resolved);
+  resolved.fields = block.fields.map(
+    (field) => resolveField(field, registry, blockCache)
+  );
+  return resolved;
+}
+function resolveFields(fields, registry, blockCache) {
+  return fields.map((field) => resolveField(field, registry, blockCache));
+}
+function normalizeSchemaFragment(fragment) {
+  const reusableBlocks = mergeUniqueBlocks(fragment.blocks ?? []);
+  const registry = buildRegistry(reusableBlocks);
+  const blockCache = /* @__PURE__ */ new WeakMap();
+  const resolvedBlocks = reusableBlocks.map(
+    (block) => resolveBlock(block, registry, blockCache)
+  );
+  const resolvedCollections = (fragment.collections ?? []).map(
+    (collection) => ({
+      ...collection,
+      fields: resolveFields(collection.fields ?? [], registry, blockCache)
+    })
+  );
+  const resolvedGlobals = (fragment.globals ?? []).map((global) => ({
+    ...global,
+    fields: resolveFields(global.fields ?? [], registry, blockCache)
+  }));
+  return {
+    ...fragment,
+    ...fragment.blocks ? { blocks: resolvedBlocks } : {},
+    ...fragment.collections ? { collections: resolvedCollections } : {},
+    ...fragment.globals ? { globals: resolvedGlobals } : {}
+  };
+}
+
 // src/utils/config.ts
 var AUDIT_COLLECTION_SLUG = "__audit";
 var SYSTEM_FIELDS = [
@@ -446,12 +626,23 @@ var AUDIT_COLLECTION = {
   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: "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" }
   ],
-  access: { read: () => false, create: () => false, update: () => false, delete: () => false },
+  access: {
+    read: () => false,
+    create: () => false,
+    update: () => false,
+    delete: () => false
+  },
   admin: { hidden: true }
 };
 var WORKFLOW_HISTORY_COLLECTION_CONFIG = {
@@ -468,7 +659,12 @@ var WORKFLOW_HISTORY_COLLECTION_CONFIG = {
     { name: "actorId", type: "text" },
     { name: "createdAt", type: "date", required: true }
   ],
-  access: { read: ({ user }) => !!user, create: () => false, update: () => false, delete: () => false },
+  access: {
+    read: ({ user }) => !!user,
+    create: () => false,
+    update: () => false,
+    delete: () => false
+  },
   admin: { hidden: true }
 };
 var LIFECYCLE_EVENTS_COLLECTION_CONFIG = {
@@ -482,22 +678,56 @@ var LIFECYCLE_EVENTS_COLLECTION_CONFIG = {
     { 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: "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 },
+  access: {
+    read: ({ user }) => !!user?.roles?.includes("admin"),
+    create: () => false,
+    update: () => false,
+    delete: () => false
+  },
+  admin: { hidden: true }
+};
+var AUTH_SESSIONS_COLLECTION_CONFIG = {
+  slug: AUTH_SESSIONS_COLLECTION,
+  labels: { singular: "Auth session", plural: "Auth sessions" },
+  fields: [
+    { name: "userId", type: "text", required: true },
+    { name: "email", type: "email", required: true },
+    { name: "collection", type: "text", required: true },
+    { name: "authSource", type: "text" },
+    { name: "providerId", type: "text" },
+    { name: "lastIp", type: "text" },
+    { name: "lastSeenAt", type: "date" },
+    { name: "expiresAt", type: "date" },
+    { name: "revokedAt", type: "date" }
+  ],
+  access: {
+    read: () => false,
+    create: () => false,
+    update: () => false,
+    delete: () => false
+  },
   admin: { hidden: true }
 };
 function normalizeConfig(config) {
-  const collections = config?.collections || [];
-  const globals = config?.globals || [];
+  const schemaAwareConfig = normalizeSchemaFragment(config);
+  const collections = schemaAwareConfig?.collections || [];
+  const globals = schemaAwareConfig?.globals || [];
   const needsAudit = collections.some((col) => col.audit);
   const needsWorkflow = collections.some((col) => col.workflow || col.drafts);
+  const needsAuthSessions = collections.some((col) => !!col.auth);
   const adminAuthCollectionSlug = getAdminAuthCollection({
     collections,
-    adminAuth: config.adminAuth
+    adminAuth: schemaAwareConfig.adminAuth
   })?.slug;
   const normalizedCollections = collections.map((col) => {
     let fields = col.fields || [];
@@ -594,7 +824,7 @@ function normalizeConfig(config) {
         return field;
       });
     }
-    if (adminAuthCollectionSlug && col.slug === adminAuthCollectionSlug && config.adminAuth?.mode === "external") {
+    if (adminAuthCollectionSlug && col.slug === adminAuthCollectionSlug && schemaAwareConfig.adminAuth?.mode === "external") {
       const externalAdminFields = [
         {
           name: "authProvider",
@@ -628,7 +858,9 @@ function normalizeConfig(config) {
       }
     }
     const updatedFieldNames = new Set(fields.map((f) => f.name));
-    const fieldsToInject = SYSTEM_FIELDS.filter((f) => !updatedFieldNames.has(f.name));
+    const fieldsToInject = SYSTEM_FIELDS.filter(
+      (f) => !updatedFieldNames.has(f.name)
+    );
     const workflow = col.workflow || (col.drafts ? simplePublishingWorkflow() : void 0);
     return {
       ...col,
@@ -636,17 +868,27 @@ function normalizeConfig(config) {
       fields: [...fields, ...fieldsToInject]
     };
   });
-  const hasAuditCollection = normalizedCollections.some((col) => col.slug === AUDIT_COLLECTION_SLUG);
+  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)) {
+  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)) {
+  if (needsWorkflow && !normalizedCollections.some(
+    (col) => col.slug === LIFECYCLE_EVENTS_COLLECTION
+  )) {
     systemCollections.push(LIFECYCLE_EVENTS_COLLECTION_CONFIG);
   }
+  if (needsAuthSessions && !normalizedCollections.some((col) => col.slug === AUTH_SESSIONS_COLLECTION)) {
+    systemCollections.push(AUTH_SESSIONS_COLLECTION_CONFIG);
+  }
   return {
-    ...config,
+    ...schemaAwareConfig,
     collections: [...normalizedCollections, ...systemCollections],
     globals
   };
@@ -872,7 +1114,10 @@ async function runCollectionHooks(hooks, args, options = {}) {
       }
     } catch (err) {
       if (options.isolated) {
-        console.error("[dyrected/core] Side-effect hook failed (error isolated \u2014 DB write was successful):", err);
+        getConfigLogger(void 0, "hooks").error({
+          err,
+          msg: "Side-effect hook failed after a successful write"
+        });
       } else {
         throw err;
       }
@@ -917,7 +1162,13 @@ async function executeFieldBeforeChange(fields, data, originalDoc, user, db) {
           const item = updatedValue[i];
           const origItem = Array.isArray(origValue) ? origValue[i] : null;
           arrayResult.push(
-            await executeFieldBeforeChange(field.fields, item, origItem, user, db)
+            await executeFieldBeforeChange(
+              field.fields,
+              item,
+              origItem,
+              user,
+              db
+            )
           );
         }
         result[field.name] = arrayResult;
@@ -1058,7 +1309,15 @@ function generateOpenApi(config) {
         },
         WorkflowHistoryEntry: {
           type: "object",
-          required: ["collection", "documentId", "transition", "from", "to", "revision", "createdAt"],
+          required: [
+            "collection",
+            "documentId",
+            "transition",
+            "from",
+            "to",
+            "revision",
+            "createdAt"
+          ],
           properties: {
             id: { type: "string" },
             collection: { type: "string" },
@@ -1083,7 +1342,11 @@ function generateOpenApi(config) {
             user: { type: "string", nullable: true },
             timestamp: { type: "string", format: "date-time" },
             changes: {
-              oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }, { type: "null" }]
+              oneOf: [
+                { type: "string" },
+                { type: "object", additionalProperties: true },
+                { type: "null" }
+              ]
             }
           }
         },
@@ -1175,13 +1438,17 @@ function generateOpenApi(config) {
     get: {
       tags: ["Preferences"],
       summary: "Get an authenticated user preference",
-      parameters: [{ name: "key", in: "path", required: true, schema: { type: "string" } }],
+      parameters: [
+        { name: "key", in: "path", required: true, schema: { type: "string" } }
+      ],
       responses: { 200: { description: "Preference value" } }
     },
     put: {
       tags: ["Preferences"],
       summary: "Set an authenticated user preference",
-      parameters: [{ name: "key", in: "path", required: true, schema: { type: "string" } }],
+      parameters: [
+        { name: "key", in: "path", required: true, schema: { type: "string" } }
+      ],
       requestBody: {
         required: true,
         content: { "application/json": { schema: { type: "object" } } }
@@ -1217,10 +1484,23 @@ function generateOpenApi(config) {
       tags: ["Audit"],
       summary: "Get audit entries across all readable audited collections",
       parameters: [
-        { name: "limit", in: "query", schema: { type: "integer", default: 50, maximum: 100 } },
+        {
+          name: "limit",
+          in: "query",
+          schema: { type: "integer", default: 50, maximum: 100 }
+        },
         { name: "page", in: "query", schema: { type: "integer", default: 1 } },
-        { name: "where", in: "query", schema: { type: "string" }, description: "JSON filter" },
-        { name: "sort", in: "query", schema: { type: "string", default: "-timestamp" } }
+        {
+          name: "where",
+          in: "query",
+          schema: { type: "string" },
+          description: "JSON filter"
+        },
+        {
+          name: "sort",
+          in: "query",
+          schema: { type: "string", default: "-timestamp" }
+        }
       ],
       responses: {
         200: {
@@ -1425,10 +1705,27 @@ function generateOpenApi(config) {
           tags: [collectionTag],
           summary: `Get ${labels.singular} audit entries`,
           parameters: [
-            { name: "limit", in: "query", schema: { type: "integer", default: 50, maximum: 100 } },
-            { name: "page", in: "query", schema: { type: "integer", default: 1 } },
-            { name: "where", in: "query", schema: { type: "string" }, description: "JSON filter" },
-            { name: "sort", in: "query", schema: { type: "string", default: "-timestamp" } }
+            {
+              name: "limit",
+              in: "query",
+              schema: { type: "integer", default: 50, maximum: 100 }
+            },
+            {
+              name: "page",
+              in: "query",
+              schema: { type: "integer", default: 1 }
+            },
+            {
+              name: "where",
+              in: "query",
+              schema: { type: "string" },
+              description: "JSON filter"
+            },
+            {
+              name: "sort",
+              in: "query",
+              schema: { type: "string", default: "-timestamp" }
+            }
           ],
           responses: {
             200: {
@@ -1554,6 +1851,15 @@ function generateOpenApi(config) {
         post: {
           tags: [collectionTag],
           summary: `Log out of ${labels.plural}`,
+          parameters: [
+            {
+              name: "allSessions",
+              in: "query",
+              required: false,
+              schema: { type: "boolean" },
+              description: "Revoke every active session for this account instead of only the current one."
+            }
+          ],
           responses: { 200: { description: "Logged out" } }
         }
       };
@@ -1579,7 +1885,11 @@ function generateOpenApi(config) {
         post: {
           tags: [collectionTag],
           summary: "Refresh an authentication token",
-          responses: { 200: { description: "Refreshed token" } }
+          responses: {
+            200: {
+              description: "Refreshed token for the current active session"
+            }
+          }
         }
       };
       spec.paths[`${path}/forgot-password`] = {
@@ -1610,7 +1920,11 @@ function generateOpenApi(config) {
               schema: { type: "string" }
             }
           ],
-          responses: { 200: { description: "Password changed" } }
+          responses: {
+            200: {
+              description: "Password changed and active sessions revoked"
+            }
+          }
         }
       };
     }
@@ -1819,7 +2133,7 @@ function fieldsToProperties(fields) {
   return { properties: props, required };
 }
 function fieldToSchema(field) {
-  let schema = {};
+  let schema;
   switch (field.type) {
     case "text":
     case "textarea":
@@ -1828,7 +2142,10 @@ function fieldToSchema(field) {
       break;
     case "url":
       schema = {
-        oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }]
+        oneOf: [
+          { type: "string" },
+          { type: "object", additionalProperties: true }
+        ]
       };
       break;
     case "icon":
@@ -1998,6 +2315,7 @@ function defineTab(args) {
   defineMultiSelectField,
   defineNumberField,
   defineObjectField,
+  definePublishingWorkflow,
   defineRadioField,
   defineRelationshipField,
   defineRichTextField,
@@ -2022,6 +2340,7 @@ function defineTab(args) {
   parseMongoWhere,
   parseSort,
   parseSqlWhere,
+  publishedStateName,
   publishingWorkflow,
   resolveAdminAuthCollection,
   runCollectionHooks,