@bobbykim/manguito-cms-api 0.4.3 → 0.6.0

package/dist/index.mjs

@@ -1,13 +1,14 @@
 import {
   buildRelationsMap,
   createFieldKeyMap,
+  createFieldKeyMapFromProjection,
   deleteParagraphField,
   isColumnBacked,
   persistJunctionField,
   persistParagraphField,
   resolveRelationBareIds,
   resolveRelationField
-} from "./chunk-4Y4G564P.mjs";
+} from "./chunk-JVP33FI2.mjs";
 
 // src/paths.ts
 function normalizePrefix(prefix) {
@@ -18,15 +19,20 @@ function normalizePrefix(prefix) {
 }
 function createPublicPaths(prefix) {
   return {
-    collection: (basePath) => `${prefix}/${basePath}`,
-    item: (basePath) => `${prefix}/${basePath}/:slug`,
-    taxonomyCollection: (typeName) => `${prefix}/taxonomy/${typeName}`,
-    taxonomyItem: (typeName) => `${prefix}/taxonomy/${typeName}/:id`,
     mediaCollection: () => `${prefix}/media`,
     mediaItem: () => `${prefix}/media/:id`,
     openapi: () => `${prefix}/openapi.json`
   };
 }
+function createVersionedPaths(prefix, version) {
+  const root = version === null ? prefix : `${prefix}/${version}`;
+  return {
+    collection: (basePath) => `${root}/${basePath}`,
+    item: (basePath) => `${root}/${basePath}/:slug`,
+    taxonomyCollection: (typeName) => `${root}/taxonomy/${typeName}`,
+    taxonomyItem: (typeName) => `${root}/taxonomy/${typeName}/:id`
+  };
+}
 
 // src/app.ts
 import { Hono } from "hono";
@@ -96,7 +102,7 @@ function createSecurityHeadersMiddleware(options = {}) {
     c.res.headers.set("X-Content-Type-Options", "nosniff");
     c.res.headers.set("X-Frame-Options", "DENY");
     c.res.headers.set("Referrer-Policy", "no-referrer");
-    const isGraphiql = graphiqlPath !== void 0 && c.req.path === graphiqlPath;
+    const isGraphiql = graphiqlPath !== void 0 && (c.req.path === graphiqlPath || c.req.path.startsWith(`${graphiqlPath}/`));
     c.res.headers.set("Content-Security-Policy", isGraphiql ? graphiqlCsp : csp);
   };
 }
@@ -622,7 +628,7 @@ function nestedTargets(fields) {
   }
   return out;
 }
-function buildProjectors(registry, fieldKeyMaps) {
+function buildProjectors(registry, fieldKeyMaps, fallbacks) {
   const projectors = {};
   const sources = [
     registry.content_types,
@@ -633,7 +639,14 @@ function buildProjectors(registry, fieldKeyMaps) {
     for (const [typeName, type] of Object.entries(source)) {
       const map = fieldKeyMaps[typeName];
       if (!map) continue;
-      projectors[typeName] = { map, nested: nestedTargets(type.fields) };
+      const typeFallbacks = fallbacks?.[typeName];
+      projectors[typeName] = {
+        map,
+        nested: nestedTargets(type.fields),
+        // Spread rather than assign: with exactOptionalPropertyTypes, an optional
+        // property may be ABSENT but not present-and-undefined.
+        ...typeFallbacks !== void 0 && { fallbacks: typeFallbacks }
+      };
     }
   }
   return projectors;
@@ -642,6 +655,11 @@ function projectRow(row, typeName, projectors) {
   const p = projectors[typeName];
   if (!p) return row;
   const out = p.map.toLabels(row);
+  if (p.fallbacks !== void 0) {
+    for (const [label, value] of Object.entries(p.fallbacks)) {
+      if (out[label] === null || out[label] === void 0) out[label] = value;
+    }
+  }
   for (const { label, target } of p.nested) {
     const v = out[label];
     if (v === null || v === void 0) continue;
@@ -735,13 +753,24 @@ function registerPublicContentRoutes(app, registry, repos, projectors, paths, li
     const basePath = contentType.default_base_path;
     const repo = repos[typeName];
     if (!repo) continue;
-    const relationFieldNames = new Set(
-      contentType.fields.filter((f) => RELATION_FIELD_TYPES.has(f.field_type)).map((f) => f.name)
-    );
+    const fieldKeys = projectors[typeName].map;
+    const relationFieldNames = /* @__PURE__ */ new Set();
+    for (const f of contentType.fields) {
+      if (!RELATION_FIELD_TYPES.has(f.field_type)) continue;
+      if (isColumnBacked(f)) {
+        const label = fieldKeys.labelFor(f.db_column.column_name);
+        if (label !== void 0) relationFieldNames.add(label);
+      } else {
+        relationFieldNames.add(f.name);
+      }
+    }
     const filterableFieldNames = /* @__PURE__ */ new Set([
-      ...contentType.fields.filter((f) => f.field_type !== "programmatic").map((f) => f.name),
+      ...fieldKeys.labels,
       ...contentType.system_fields.map((f) => f.name)
     ]);
+    const sortableFieldNames = new Set(
+      [...SORTABLE_FIELDS].filter((f) => filterableFieldNames.has(f))
+    );
     if (contentType.only_one) {
       app.get(paths.collection(basePath), async (c) => {
         const result = await repo.findMany({ published_only: true, page: 1, per_page: 1 });
@@ -757,8 +786,6 @@ function registerPublicContentRoutes(app, registry, repos, projectors, paths, li
       });
     } else {
       registerListRoute(paths.collection(basePath), async (c) => {
-        const projector = projectors[typeName];
-        const fieldKeys = projector.map;
         const pagination = parsePagination(c.req.query("page"), c.req.query("per_page"));
         if (!pagination.ok) {
           return c.json(
@@ -773,13 +800,13 @@ function registerPublicContentRoutes(app, registry, repos, projectors, paths, li
           );
         }
         const sortBy = c.req.query("sort_by") ?? "created_at";
-        if (!SORTABLE_FIELDS.has(sortBy)) {
+        if (!sortableFieldNames.has(sortBy)) {
           return c.json(
             {
               ok: false,
               error: {
                 code: "INVALID_SORT_FIELD",
-                message: `'${sortBy}' is not sortable. Allowed: title, created_at, updated_at`
+                message: `'${sortBy}' is not sortable. Allowed: ${[...sortableFieldNames].join(", ")}`
               }
             },
             400
@@ -826,7 +853,7 @@ function registerPublicContentRoutes(app, registry, repos, projectors, paths, li
             );
           }
         }
-        const sortColumn = fieldKeys.columnFor(sortBy) ?? sortBy;
+        const sortColumn = fieldKeys.labels.includes(sortBy) ? fieldKeys.columnFor(sortBy) : sortBy;
         const result = await repo.findMany({
           published_only: true,
           page: pagination.page,
@@ -2706,7 +2733,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 import { sql as sql5 } from "drizzle-orm";
 var API_VERSION = (() => {
   try {
-    return "0.4.3";
+    return "0.6.0";
   } catch {
     return "0.0.0";
   }
@@ -3107,7 +3134,93 @@ function createMediaRepository(db) {
   };
 }
 
+// src/versions.ts
+var VERSION_SEGMENT = /^v\d+$/;
+function versionNumber(version) {
+  return Number.parseInt(version.slice(1), 10);
+}
+function classifyVersion(segment, model) {
+  if (!VERSION_SEGMENT.test(segment)) return "not-a-version";
+  if (model.live.includes(segment)) return "live";
+  return versionNumber(segment) < versionNumber(model.current) ? "retired" : "unknown";
+}
+function fallbacksFor(projection) {
+  const out = {};
+  for (const [typeName, type] of Object.entries(projection.types)) {
+    const perLabel = {};
+    for (const f of type.fields) {
+      if (f.fallback !== void 0) perLabel[f.exposed_as] = f.fallback;
+    }
+    if (Object.keys(perLabel).length > 0) out[typeName] = perLabel;
+  }
+  return out;
+}
+function buildVersionSurface(input) {
+  const { version, projectionVersion, prefix, registry, model, makeRepo } = input;
+  const paths = createVersionedPaths(prefix, version);
+  const projection = model.projections[projectionVersion];
+  const fieldKeyMaps = {};
+  const sources = [
+    registry.content_types,
+    registry.taxonomy_types,
+    registry.paragraph_types
+  ];
+  for (const source of sources) {
+    for (const [typeName, type] of Object.entries(source)) {
+      const projectionType = projection?.types[typeName];
+      fieldKeyMaps[typeName] = projectionType ? createFieldKeyMapFromProjection(projectionType, type.fields) : createFieldKeyMap(type.fields);
+    }
+  }
+  const fallbacks = projection ? fallbacksFor(projection) : void 0;
+  const projectors = buildProjectors(registry, fieldKeyMaps, fallbacks);
+  const sortableColumnsFor = (typeName) => {
+    const map = fieldKeyMaps[typeName];
+    const type = registry.content_types[typeName] ?? registry.taxonomy_types[typeName];
+    const systemFieldNames = new Set((type?.system_fields ?? []).map((f) => f.name));
+    const out = /* @__PURE__ */ new Set();
+    for (const label of SORTABLE_FIELDS) {
+      const column = map.columnFor(label);
+      if (column !== void 0) out.add(column);
+      else if (systemFieldNames.has(label)) out.add(label);
+    }
+    return out;
+  };
+  const repos = {};
+  for (const [typeName, ct] of Object.entries(registry.content_types)) {
+    repos[typeName] = makeRepo(typeName, ct.db.table_name, sortableColumnsFor(typeName));
+  }
+  for (const [typeName, tt] of Object.entries(registry.taxonomy_types)) {
+    repos[typeName] = makeRepo(typeName, tt.db.table_name, sortableColumnsFor(typeName));
+  }
+  return { paths, fieldKeyMaps, projectors, repos };
+}
+function deprecationHeaders(input) {
+  const { requested, model, successor } = input;
+  const link = `<${successor}>; rel="successor-version"`;
+  if (requested === null) {
+    if (model.live.length <= 1) return null;
+    return {
+      Deprecation: "true",
+      Link: link,
+      Warning: `299 - "Unversioned path resolves to the latest version (${model.current}) and will change when a new version is cut. Pin a version."`
+    };
+  }
+  if (requested === model.current) return null;
+  return { Deprecation: "true", Link: link };
+}
+
 // src/app.ts
+function versionRoutePaths(registry, paths) {
+  const out = [paths.collection("content"), paths.collection("taxonomy")];
+  for (const ct of Object.values(registry.content_types)) {
+    out.push(paths.collection(ct.default_base_path));
+    if (!ct.only_one) out.push(paths.item(ct.default_base_path));
+  }
+  for (const tt of Object.values(registry.taxonomy_types)) {
+    out.push(paths.taxonomyCollection(tt.name), paths.taxonomyItem(tt.name));
+  }
+  return out;
+}
 var MISSING_STORAGE_ERROR = `\u2717 api.storage is required but not configured.
   Add a storage adapter to your manguito.config.ts:
 
@@ -3123,6 +3236,7 @@ function createCmsApp(options) {
   }
   const prefix = normalizePrefix(options.prefix);
   const publicPaths = createPublicPaths(prefix);
+  const versionedPaths = createVersionedPaths(prefix, null);
   const { storage, registry, db, rateLimit, media, cors } = options;
   const cmsName = options.name ?? "Manguito CMS";
   const maxFileSize = media?.max_file_size;
@@ -3171,9 +3285,18 @@ function createCmsApp(options) {
     ])
   ]);
   const projectors = buildProjectors(registry, fieldKeyMaps);
-  const sortableColumnsFor = (typeName) => new Set(
-    [...SORTABLE_FIELDS].map((label) => fieldKeyMaps[typeName].columnFor(label) ?? label)
-  );
+  const sortableColumnsFor = (typeName) => {
+    const map = fieldKeyMaps[typeName];
+    const type = registry.content_types[typeName] ?? registry.taxonomy_types[typeName];
+    const systemFieldNames = new Set((type?.system_fields ?? []).map((f) => f.name));
+    const out = /* @__PURE__ */ new Set();
+    for (const label of SORTABLE_FIELDS) {
+      const column = map.columnFor(label);
+      if (column !== void 0) out.add(column);
+      else if (systemFieldNames.has(label)) out.add(label);
+    }
+    return out;
+  };
   const contentRepos = Object.fromEntries(
     Object.entries(registry.content_types).map(([typeName, ct]) => [
       typeName,
@@ -3192,41 +3315,14 @@ function createCmsApp(options) {
   );
   const repos = { ...contentRepos, ...taxonomyRepos };
   const mediaRepo = createMediaRepository(db);
-  const publicContentRepos = Object.fromEntries(
-    Object.entries(registry.content_types).map(([typeName, ct]) => [
-      typeName,
-      createDrizzleContentRepository(db, ct.db.table_name, {
-        relations: buildRelationsMap(ct.fields, registry),
-        publishedRelations: true,
-        sortableColumns: sortableColumnsFor(typeName)
-      })
-    ])
-  );
-  const publicTaxonomyRepos = Object.fromEntries(
-    Object.entries(registry.taxonomy_types).map(([typeName, tt]) => [
-      typeName,
-      createDrizzleContentRepository(db, tt.db.table_name, {
-        relations: buildRelationsMap(tt.fields, registry),
-        publishedRelations: true,
-        sortableColumns: sortableColumnsFor(typeName)
-      })
-    ])
-  );
-  const publicRepos = { ...publicContentRepos, ...publicTaxonomyRepos };
-  const graphqlRepos = Object.fromEntries([
-    ...Object.entries(registry.content_types).map(([typeName, ct]) => [
-      typeName,
-      createDrizzleContentRepository(db, ct.db.table_name, {
-        sortableColumns: sortableColumnsFor(typeName)
-      })
-    ]),
-    ...Object.entries(registry.taxonomy_types).map(([typeName, tt]) => [
-      typeName,
-      createDrizzleContentRepository(db, tt.db.table_name, {
-        sortableColumns: sortableColumnsFor(typeName)
-      })
-    ])
-  ]);
+  const makeRepo = (typeName, tableName, sortableColumns) => {
+    const type = registry.content_types[typeName] ?? registry.taxonomy_types[typeName];
+    return createDrizzleContentRepository(db, tableName, {
+      relations: buildRelationsMap(type.fields, registry),
+      publishedRelations: true,
+      sortableColumns
+    });
+  };
   registerAuthRoutes(app, db);
   app.use("/admin/api/*", authMiddleware);
   app.use("/admin/api/*", mustChangePasswordCheck);
@@ -3235,17 +3331,17 @@ function createCmsApp(options) {
     for (const ct of Object.values(registry.content_types)) {
       const base = ct.default_base_path;
       if (ct.only_one) {
-        paths[publicPaths.collection(base)] = { get: { summary: `Get ${ct.label}`, tags: [ct.label] } };
+        paths[versionedPaths.collection(base)] = { get: { summary: `Get ${ct.label}`, tags: [ct.label] } };
       } else {
-        paths[publicPaths.collection(base)] = { get: { summary: `List published ${ct.label}`, tags: [ct.label] } };
-        paths[publicPaths.item(base).replace(":slug", "{slug}")] = {
+        paths[versionedPaths.collection(base)] = { get: { summary: `List published ${ct.label}`, tags: [ct.label] } };
+        paths[versionedPaths.item(base).replace(":slug", "{slug}")] = {
           get: { summary: `Get ${ct.label} by slug`, tags: [ct.label] }
         };
       }
     }
     for (const tt of Object.values(registry.taxonomy_types)) {
-      paths[publicPaths.taxonomyCollection(tt.name)] = { get: { summary: `List published ${tt.label}`, tags: [tt.label] } };
-      paths[publicPaths.taxonomyItem(tt.name).replace(":id", "{id}")] = {
+      paths[versionedPaths.taxonomyCollection(tt.name)] = { get: { summary: `List published ${tt.label}`, tags: [tt.label] } };
+      paths[versionedPaths.taxonomyItem(tt.name).replace(":id", "{id}")] = {
         get: { summary: `Get ${tt.label} by id`, tags: [tt.label] }
       };
     }
@@ -3265,35 +3361,166 @@ function createCmsApp(options) {
       paths: {}
     })
   );
-  registerPublicContentRoutes(app, registry, publicRepos, projectors, publicPaths, listRateLimit, programmaticResolver);
+  const model = options.versions ?? {
+    current: "v1",
+    live: ["v1"],
+    projections: {}
+  };
+  const passes = [
+    ...options.versions !== void 0 ? model.live.map((v) => ({ version: v, projectionVersion: v })) : [],
+    { version: null, projectionVersion: model.current }
+  ];
+  for (const pass of passes) {
+    const surface = buildVersionSurface({ ...pass, prefix, registry, model, makeRepo });
+    const headers = deprecationHeaders({
+      requested: pass.version,
+      model,
+      // The version root, with no trailing slash — never
+      // createVersionedPaths(prefix, model.current).collection(''), which
+      // would yield `${prefix}/${model.current}/` in every Link header.
+      successor: `${prefix}/${model.current}`
+    });
+    if (headers !== null) {
+      const attachDeprecationHeaders = async (c, next) => {
+        await next();
+        for (const [key, value] of Object.entries(headers)) c.res.headers.set(key, value);
+      };
+      for (const path of versionRoutePaths(registry, surface.paths)) {
+        app.use(path, attachDeprecationHeaders);
+      }
+    }
+    registerPublicContentRoutes(app, registry, surface.repos, surface.projectors, surface.paths, listRateLimit, programmaticResolver);
+  }
+  if (options.versions !== void 0) {
+    app.all(`${prefix}/:version/*`, async (c, next) => {
+      const kind = classifyVersion(c.req.param("version"), model);
+      if (kind === "not-a-version" || kind === "live") return next();
+      const live = model.live.join(", ");
+      return kind === "retired" ? c.json(
+        {
+          ok: false,
+          error: {
+            code: "VERSION_RETIRED",
+            message: `Version ${c.req.param("version")} is no longer served. Live versions: ${live}.`
+          }
+        },
+        410
+      ) : c.json(
+        {
+          ok: false,
+          error: {
+            code: "VERSION_NOT_FOUND",
+            message: `No version ${c.req.param("version")} is served. Live versions: ${live}.`
+          }
+        },
+        404
+      );
+    });
+  }
   registerPublicMediaRoutes(app, mediaRepo, publicPaths, listRateLimit);
   if (options.graphql?.enabled) {
     const gqlOptions = options.graphql;
-    let gqlHandler = null;
-    let initError = null;
-    const ready = import("./handler-45O5OX2C.mjs").then(({ createGraphQLHandler }) => {
-      gqlHandler = createGraphQLHandler(registry, graphqlRepos, fieldKeyMaps, programmaticResolver, db, gqlOptions);
+    const makeGraphqlRepo = (_typeName, tableName, sortableColumns) => createDrizzleContentRepository(db, tableName, { sortableColumns });
+    const gqlPasses = [
+      ...options.versions !== void 0 ? model.live.map((v) => ({ version: v, projectionVersion: v })) : [],
+      { version: null, projectionVersion: model.current }
+    ];
+    const mounts = gqlPasses.map((pass) => ({
+      path: pass.version === null ? "/graphql" : `/graphql/${pass.version}`,
+      version: pass.version,
+      handler: null,
+      error: null
+    }));
+    const ready = import("./handler-XZVDLKZ2.mjs").then(({ createGraphQLHandler }) => {
+      gqlPasses.forEach((pass, i) => {
+        const mount = mounts[i];
+        try {
+          const surface = buildVersionSurface({
+            ...pass,
+            prefix,
+            registry,
+            model,
+            makeRepo: makeGraphqlRepo
+          });
+          const projection = model.projections[pass.projectionVersion];
+          const currentProjection = model.projections[model.current];
+          mount.handler = createGraphQLHandler(
+            registry,
+            surface.repos,
+            surface.fieldKeyMaps,
+            programmaticResolver,
+            db,
+            gqlOptions,
+            {
+              endpoint: mount.path,
+              currentVersion: model.current,
+              ...projection !== void 0 && { projection },
+              ...currentProjection !== void 0 && { currentProjection }
+            }
+          );
+        } catch (err) {
+          mount.error = err;
+          const message = err instanceof Error ? err.message : String(err);
+          process.stderr.write(
+            `\u2717 GraphQL schema failed to initialize for ${mount.path}; it will return 500. ${message}
+`
+          );
+        }
+      });
     }).catch((err) => {
-      initError = err;
+      for (const m of mounts) m.error = err;
       const message = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`\u2717 GraphQL schema failed to initialize; /graphql will return 500. ${message}
+      const paths = mounts.map((m) => m.path).join(", ");
+      process.stderr.write(`\u2717 GraphQL module failed to load; ${paths} will return 500. ${message}
 `);
     });
-    const invokeGraphQL = async (c) => {
-      if (!gqlHandler && !initError) await ready;
-      if (!gqlHandler) {
+    const invokeFor = (mount) => async (c) => {
+      if (!mount.handler && !mount.error) await ready;
+      if (!mount.handler) {
         return c.json(
           { ok: false, error: { code: "GRAPHQL_INIT_FAILED", message: "GraphQL schema failed to initialize" } },
           500
         );
       }
-      return gqlHandler(c, async () => {
+      return mount.handler(c, async () => {
       });
     };
-    if (listRateLimit) {
-      app.all("/graphql", listRateLimit, invokeGraphQL);
-    } else {
-      app.all("/graphql", invokeGraphQL);
+    for (const mount of mounts) {
+      const headers = deprecationHeaders({
+        requested: mount.version,
+        model,
+        successor: `/graphql/${model.current}`
+      });
+      if (headers === null) continue;
+      const attach = async (c, next) => {
+        await next();
+        for (const [key, value] of Object.entries(headers)) c.res.headers.set(key, value);
+      };
+      app.use(mount.path, attach);
+    }
+    for (const mount of mounts) {
+      if (listRateLimit) app.all(mount.path, listRateLimit, invokeFor(mount));
+      else app.all(mount.path, invokeFor(mount));
+    }
+    if (options.versions !== void 0) {
+      app.all("/graphql/:version", async (c, next) => {
+        const segment = c.req.param("version");
+        const kind = classifyVersion(segment, model);
+        if (kind === "not-a-version" || kind === "live") return next();
+        const live = model.live.join(", ");
+        return c.json({
+          errors: [
+            {
+              message: kind === "retired" ? `Version ${segment} is no longer served. Live versions: ${live}.` : `Version ${segment} does not exist. Live versions: ${live}.`,
+              extensions: {
+                code: kind === "retired" ? "VERSION_RETIRED" : "VERSION_UNKNOWN",
+                current: model.current,
+                live: model.live
+              }
+            }
+          ]
+        });
+      });
     }
   }
   registerConfigRoute(