@bobbykim/manguito-cms-api 0.4.3 → 0.6.0

package/dist/index.js

@@ -30,6 +30,105 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/field-keys.ts
+function isColumnBacked(field) {
+  const col = field.db_column;
+  if (col === null) return false;
+  if (col.column_name === "") return false;
+  if (col.junction) return false;
+  return true;
+}
+function buildFieldKeyMap(pairs, allLabels, droppedKeys) {
+  const labelToColumn = /* @__PURE__ */ new Map();
+  const columnToLabel = /* @__PURE__ */ new Map();
+  for (const { label, column } of pairs) {
+    labelToColumn.set(label, column);
+    columnToLabel.set(column, label);
+  }
+  for (const { label, ownColumn } of allLabels) {
+    if (ownColumn === label) continue;
+    const columnOwner = columnToLabel.get(label);
+    if (columnOwner !== void 0 && columnOwner !== label) {
+      throw new Error(
+        `Fatal: field key map failed to build \u2014 field label "${label}" collides with the storage column of field "${columnOwner}". A field label may not reuse another field's column name. Rename the field, then run \`manguito validate\` to check your schema.`
+      );
+    }
+  }
+  for (const label of labelToColumn.keys()) {
+    if (droppedKeys.has(label)) labelToColumn.delete(label);
+  }
+  for (const column of columnToLabel.keys()) {
+    if (droppedKeys.has(column)) columnToLabel.delete(column);
+  }
+  const diverges = [...labelToColumn].some(([label, column]) => label !== column);
+  function remap(input, lookup) {
+    const out = {};
+    for (const key of Object.keys(input)) {
+      if (droppedKeys.has(key)) continue;
+      out[lookup.get(key) ?? key] = input[key];
+    }
+    return out;
+  }
+  return {
+    toStorage: (input) => remap(input, labelToColumn),
+    toLabels: (row) => remap(row, columnToLabel),
+    columnFor: (label) => labelToColumn.get(label),
+    labelFor: (column) => columnToLabel.get(column),
+    labels: [...labelToColumn.keys()],
+    diverges
+  };
+}
+function createFieldKeyMap(fields) {
+  const droppedKeys = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (const f of fields) {
+    if (!isColumnBacked(f)) continue;
+    pairs.push({ label: f.name, column: f.db_column.column_name });
+    if (f.removed === true) {
+      droppedKeys.add(f.name);
+      droppedKeys.add(f.db_column.column_name);
+    }
+  }
+  return buildFieldKeyMap(
+    pairs,
+    fields.map((f) => ({
+      label: f.name,
+      // Conditional spread, not a plain assignment — exactOptionalPropertyTypes
+      // forbids present-and-undefined.
+      ...isColumnBacked(f) && { ownColumn: f.db_column.column_name }
+    })),
+    droppedKeys
+  );
+}
+function createFieldKeyMapFromProjection(projectionType, allFields) {
+  const pairs = projectionType.fields.map((f) => ({ label: f.exposed_as, column: f.column_name }));
+  const projected = new Set(pairs.map((p) => p.label));
+  const dropped = /* @__PURE__ */ new Set();
+  for (const f of allFields) {
+    if (!isColumnBacked(f)) continue;
+    dropped.add(f.name);
+    dropped.add(f.db_column.column_name);
+  }
+  for (const p of pairs) dropped.delete(p.column);
+  for (const label of projected) dropped.delete(label);
+  return buildFieldKeyMap(
+    pairs,
+    allFields.map((f) => ({
+      label: f.name,
+      // See buildFieldKeyMap's collision check: this is what lets it tell a
+      // version exposing a field's own column under a new label (fine) from a
+      // label that reuses another field's column (not fine).
+      ...isColumnBacked(f) && { ownColumn: f.db_column.column_name }
+    })),
+    dropped
+  );
+}
+var init_field_keys = __esm({
+  "src/field-keys.ts"() {
+    "use strict";
+  }
+});
+
 // src/relations.ts
 function quoteIdent(name) {
   if (!/^[a-z][a-z0-9_-]*$/.test(name)) throw new Error(`Unsafe identifier: ${name}`);
@@ -333,65 +432,6 @@ var init_relations = __esm({
   }
 });
 
-// src/field-keys.ts
-function isColumnBacked(field) {
-  const col = field.db_column;
-  if (col === null) return false;
-  if (col.column_name === "") return false;
-  if (col.junction) return false;
-  return true;
-}
-function createFieldKeyMap(fields) {
-  const labelToColumn = /* @__PURE__ */ new Map();
-  const columnToLabel = /* @__PURE__ */ new Map();
-  const droppedKeys = /* @__PURE__ */ new Set();
-  for (const f of fields) {
-    if (!isColumnBacked(f)) continue;
-    columnToLabel.set(f.db_column.column_name, f.name);
-    if (f.removed === true) {
-      droppedKeys.add(f.name);
-      droppedKeys.add(f.db_column.column_name);
-      continue;
-    }
-    labelToColumn.set(f.name, f.db_column.column_name);
-  }
-  for (const f of fields) {
-    const columnOwner = columnToLabel.get(f.name);
-    if (columnOwner !== void 0 && columnOwner !== f.name) {
-      throw new Error(
-        `Fatal: field key map failed to build \u2014 field label "${f.name}" collides with the storage column of field "${columnOwner}". A field label may not reuse another field's column name. Rename the field, then run \`manguito validate\` to check your schema.`
-      );
-    }
-  }
-  for (const f of fields) {
-    if (isColumnBacked(f) && f.removed === true) {
-      columnToLabel.delete(f.db_column.column_name);
-    }
-  }
-  const diverges = [...labelToColumn].some(([label, column]) => label !== column);
-  function remap(input, lookup) {
-    const out = {};
-    for (const key of Object.keys(input)) {
-      if (droppedKeys.has(key)) continue;
-      out[lookup.get(key) ?? key] = input[key];
-    }
-    return out;
-  }
-  return {
-    toStorage: (input) => remap(input, labelToColumn),
-    toLabels: (row) => remap(row, columnToLabel),
-    columnFor: (label) => labelToColumn.get(label),
-    labelFor: (column) => columnToLabel.get(column),
-    labels: [...labelToColumn.keys()],
-    diverges
-  };
-}
-var init_field_keys = __esm({
-  "src/field-keys.ts"() {
-    "use strict";
-  }
-});
-
 // src/graphql/scalars.ts
 var import_graphql, DateTimeScalar, JSONScalar;
 var init_scalars = __esm({
@@ -509,10 +549,13 @@ var init_naming = __esm({
 });
 
 // src/graphql/filters.ts
-function buildSortFieldEnum(typeName) {
+function buildSortFieldEnum(typeName, fieldKeys) {
+  const resolvable = SORTABLE.filter(
+    (s) => s.gql === "createdAt" || s.gql === "updatedAt" || fieldKeys === void 0 || fieldKeys.columnFor(s.value) !== void 0
+  );
   return new import_graphql3.GraphQLEnumType({
     name: `${typeName}SortField`,
-    values: Object.fromEntries(SORTABLE.map((s) => [s.gql, { value: s.value }]))
+    values: Object.fromEntries(resolvable.map((s) => [s.gql, { value: s.value }]))
   });
 }
 function comparableFilterInput(name, scalar) {
@@ -547,18 +590,19 @@ function filterInputForField(fieldType) {
   if (scalar === null) return null;
   return StringFilter;
 }
-function buildFilterInputType(type) {
+function buildFilterInputType(type, viewFields) {
   const fields = {};
   fields["id"] = { type: IDFilter };
   fields["published"] = { type: BooleanFilter };
   fields["createdAt"] = { type: DateTimeFilter };
   fields["updatedAt"] = { type: DateTimeFilter };
   if (type.schema_type === "content-type") fields["slug"] = { type: StringFilter };
-  for (const f of type.fields) {
+  const entries = viewFields !== void 0 ? viewFields.map((v) => ({ field: v.field, exposedAs: v.exposedAs })) : type.fields.filter((f) => f.removed !== true).map((f) => ({ field: f, exposedAs: f.name }));
+  for (const { field: f, exposedAs } of entries) {
     if (f.field_type === "programmatic" || f.field_type === "paragraph") continue;
     if (f.field_type === "image" || f.field_type === "video" || f.field_type === "file") continue;
     const input = filterInputForField(f.field_type);
-    if (input) fields[buildFieldNameMap([f.name]).toGraphql(f.name)] = { type: input };
+    if (input) fields[buildFieldNameMap([exposedAs]).toGraphql(exposedAs)] = { type: input };
   }
   if (Object.keys(fields).length === 0) return null;
   return new import_graphql3.GraphQLInputObjectType({ name: `${graphqlTypeName(type.name)}Filter`, fields });
@@ -621,32 +665,41 @@ function codeError2(code, message) {
 function isPublished2(item) {
   return !!item && item["published"] === true;
 }
-function resolveFieldValue(field, row) {
+function resolveFieldValue(field, row, fallback) {
   const key = isColumnBacked(field) ? field.db_column.column_name : field.name;
-  return row[key] ?? null;
+  const value = row[key];
+  if ((value === null || value === void 0) && fallback !== void 0) return fallback;
+  return value ?? null;
 }
-function scalarFieldResolver(field) {
-  return (parent) => resolveFieldValue(field, parent);
+function scalarFieldResolver(field, fallback) {
+  return (parent) => resolveFieldValue(field, parent, fallback);
 }
 function relationFieldResolver(typeName, schemaFieldName) {
   return (parent, _args, ctx) => ctx.loaders.load(typeName, schemaFieldName, parent);
 }
-function programmaticFieldResolver(typeName, schemaFieldName, mediaFieldNames = [], fieldKeys) {
+function programmaticFieldResolver(typeName, schemaFieldName, mediaFields = [], fieldKeys) {
   return async (parent, _args, ctx) => {
     let p = ctx.programmaticMemo.get(parent);
     if (!p) {
-      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys);
+      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFields, fieldKeys);
       ctx.programmaticMemo.set(parent, p);
     }
     return (await p)[schemaFieldName];
   };
 }
-async function resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys) {
+async function resolveProgrammaticRow(typeName, parent, ctx, mediaFields, fieldKeys) {
   const toLabels = (row) => fieldKeys ? fieldKeys.toLabels(row) : row;
-  if (mediaFieldNames.length === 0) return ctx.resolver.resolveItem(typeName, toLabels(parent));
+  if (mediaFields.length === 0) return ctx.resolver.resolveItem(typeName, toLabels(parent));
   const enriched = { ...parent };
-  await Promise.all(mediaFieldNames.map((name) => ctx.loaders.load(typeName, name, enriched)));
-  return ctx.resolver.resolveItem(typeName, toLabels(enriched));
+  await Promise.all(mediaFields.map((m) => ctx.loaders.load(typeName, m.name, enriched)));
+  return ctx.resolver.resolveItem(typeName, relabelMedia(toLabels(enriched), enriched, mediaFields));
+}
+function relabelMedia(record, enriched, mediaFields) {
+  for (const { name, exposedAs } of mediaFields) {
+    if (!(name in enriched)) continue;
+    record[exposedAs] = enriched[name];
+  }
+  return record;
 }
 function collectionResolver(typeName, nameMap, fieldKeys) {
   return async (_root, args, ctx) => {
@@ -704,7 +757,7 @@ var init_resolvers = __esm({
 });
 
 // src/graphql/schema.ts
-function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
+function buildGraphQLSchema(registry, fieldKeyMaps = {}, view) {
   const objectTypes = /* @__PURE__ */ new Map();
   const enumTypes = /* @__PURE__ */ new Map();
   for (const [name, enumType] of Object.entries(registry.enum_types)) {
@@ -723,14 +776,14 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
       );
     }
   }
-  function outputTypeForField(field) {
+  function outputTypeForField(field, required) {
     const scalar = scalarOutputType(field.field_type);
-    if (scalar) return field.required ? new import_graphql5.GraphQLNonNull(scalar) : scalar;
+    if (scalar) return required ? new import_graphql5.GraphQLNonNull(scalar) : scalar;
     if (field.field_type === "enum") {
       const ref = field.ui_component.component === "select" ? field.ui_component.enum_ref : void 0;
       const et = ref ? enumTypes.get(ref) : void 0;
       const t = et ?? import_graphql5.GraphQLString;
-      return field.required ? new import_graphql5.GraphQLNonNull(t) : t;
+      return required ? new import_graphql5.GraphQLNonNull(t) : t;
     }
     if (field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
       return MEDIA;
@@ -760,8 +813,17 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
     }
     return import_graphql5.GraphQLString;
   }
+  function exposedFields(type) {
+    return type.fields.filter((f) => f.removed !== true);
+  }
+  function viewFieldsFor(machineName, type) {
+    return view?.[machineName]?.fields ?? exposedFields(type).map((f) => ({ field: f, exposedAs: f.name, required: f.required }));
+  }
   function buildObjectType(machineName, type) {
-    const mediaFieldNames = type.fields.filter((f) => f.field_type === "image" || f.field_type === "video" || f.field_type === "file").map((f) => f.name);
+    const visible = viewFieldsFor(machineName, type);
+    const mediaFields = visible.filter(
+      (v) => v.field.field_type === "image" || v.field.field_type === "video" || v.field.field_type === "file"
+    ).map((v) => ({ name: v.field.name, exposedAs: v.exposedAs }));
     return new import_graphql5.GraphQLObjectType({
       name: graphqlTypeName(machineName),
       fields: () => {
@@ -775,23 +837,25 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
         }
         fields["createdAt"] = { type: new import_graphql5.GraphQLNonNull(DateTimeScalar), resolve: (p) => p["created_at"] };
         fields["updatedAt"] = { type: new import_graphql5.GraphQLNonNull(DateTimeScalar), resolve: (p) => p["updated_at"] };
-        for (const field of type.fields) {
-          const gqlName = toCamelCase(field.name);
-          const outType = outputTypeForField(field);
+        for (const vf of visible) {
+          const field = vf.field;
+          const gqlName = toCamelCase(vf.exposedAs);
+          const outType = outputTypeForField(field, vf.required);
           let resolve;
           if (field.field_type === "programmatic") {
-            resolve = programmaticFieldResolver(
-              machineName,
-              field.name,
-              mediaFieldNames,
-              fieldKeyMaps[machineName]
-            );
+            resolve = programmaticFieldResolver(machineName, field.name, mediaFields, fieldKeyMaps[machineName]);
           } else if (field.field_type === "reference" || field.field_type === "paragraph" || field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
             resolve = relationFieldResolver(machineName, field.name);
           } else {
-            resolve = scalarFieldResolver(field);
+            resolve = scalarFieldResolver(field, vf.fallback);
           }
-          fields[gqlName] = { type: outType, resolve };
+          fields[gqlName] = {
+            type: outType,
+            resolve,
+            // Conditional spread, not `deprecationReason: vf.deprecationReason`
+            // — exactOptionalPropertyTypes forbids present-and-undefined.
+            ...vf.deprecationReason !== void 0 && { deprecationReason: vf.deprecationReason }
+          };
         }
         return fields;
       }
@@ -823,7 +887,8 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
   const queryFields = {};
   for (const [name, ct] of Object.entries(registry.content_types)) {
     const objType = objectTypes.get(name);
-    const nameMap = buildFieldNameMap(ct.fields.map((f) => f.name));
+    const visible = viewFieldsFor(name, ct);
+    const nameMap = buildFieldNameMap(visible.map((v) => v.exposedAs));
     if (ct.only_one) {
       queryFields[singleQueryName(name)] = { type: objType, resolve: singletonResolver(name) };
       continue;
@@ -835,13 +900,13 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
         meta: { type: new import_graphql5.GraphQLNonNull(PAGE_META), resolve: (r) => r.meta }
       }
     });
-    const filterType = buildFilterInputType(ct);
+    const filterType = buildFilterInputType(ct, visible);
     queryFields[collectionQueryName(name)] = {
       type: new import_graphql5.GraphQLNonNull(listType),
       args: {
         page: { type: import_graphql5.GraphQLInt },
         perPage: { type: import_graphql5.GraphQLInt },
-        sortBy: { type: buildSortFieldEnum(graphqlTypeName(name)) },
+        sortBy: { type: buildSortFieldEnum(graphqlTypeName(name), fieldKeyMaps[name]) },
         sortOrder: { type: SortOrderEnum },
         ...filterType ? { filter: { type: filterType } } : {}
       },
@@ -865,7 +930,11 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
     queryFields[collectionQueryName(name)] = {
       type: new import_graphql5.GraphQLNonNull(listType),
       args: { page: { type: import_graphql5.GraphQLInt }, perPage: { type: import_graphql5.GraphQLInt } },
-      resolve: collectionResolver(name, buildFieldNameMap(tt.fields.map((f) => f.name)), fieldKeyMaps[name])
+      resolve: collectionResolver(
+        name,
+        buildFieldNameMap(viewFieldsFor(name, tt).map((v) => v.exposedAs)),
+        fieldKeyMaps[name]
+      )
     };
     queryFields[singleQueryName(name)] = {
       type: objType,
@@ -915,6 +984,76 @@ var init_schema = __esm({
   }
 });
 
+// src/graphql/version-view.ts
+function byColumn(fields) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    if (!isColumnBacked(f)) continue;
+    out.set(f.db_column.column_name, f);
+  }
+  return out;
+}
+function deprecationFor(field, currentLabels, currentVersion) {
+  const currentLabel = currentLabels.get(field.column_name);
+  if (currentLabel === void 0) {
+    return `Removed in ${currentVersion}; column retained while this version is live.`;
+  }
+  if (currentLabel !== field.exposed_as) {
+    return `Renamed to '${currentLabel}' in ${currentVersion}.`;
+  }
+  return void 0;
+}
+function buildVersionView(input) {
+  const { registry, projection, currentProjection, currentVersion } = input;
+  const out = {};
+  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];
+      if (projectionType === void 0) {
+        out[typeName] = {
+          fields: type.fields.filter((f) => f.removed !== true).map((f) => ({ field: f, exposedAs: f.name, required: f.required }))
+        };
+        continue;
+      }
+      const columns = byColumn(type.fields);
+      const currentLabels = /* @__PURE__ */ new Map();
+      for (const f of currentProjection?.types[typeName]?.fields ?? []) {
+        currentLabels.set(f.column_name, f.exposed_as);
+      }
+      const fields = [];
+      for (const pf of projectionType.fields) {
+        const field = columns.get(pf.column_name);
+        if (field === void 0) continue;
+        const reason = deprecationFor(pf, currentLabels, currentVersion);
+        fields.push({
+          field,
+          exposedAs: pf.exposed_as,
+          required: pf.required,
+          ...pf.fallback !== void 0 && { fallback: pf.fallback },
+          ...reason !== void 0 && { deprecationReason: reason }
+        });
+      }
+      for (const f of type.fields) {
+        if (isColumnBacked(f) || f.removed === true) continue;
+        fields.push({ field: f, exposedAs: f.name, required: f.required });
+      }
+      out[typeName] = { fields };
+    }
+  }
+  return out;
+}
+var init_version_view = __esm({
+  "src/graphql/version-view.ts"() {
+    "use strict";
+    init_field_keys();
+  }
+});
+
 // src/graphql/dataloaders.ts
 function createRelationLoaders(db, registry) {
   const relMaps = /* @__PURE__ */ new Map();
@@ -1007,15 +1146,29 @@ function isClientSafeGraphQLError(error) {
   }
   return false;
 }
-function createGraphQLHandler(registry, repos, fieldKeyMaps, resolver, db, options) {
-  const schema = buildGraphQLSchema(registry, fieldKeyMaps);
+function createGraphQLHandler(registry, repos, fieldKeyMaps, resolver, db, options, versioning = {}) {
+  let view;
+  if (versioning.projection !== void 0) {
+    if (versioning.currentVersion === void 0) {
+      throw new Error(
+        'createGraphQLHandler: currentVersion is required when a projection is supplied \u2014 deprecation reasons name it, and an empty one ships "Removed in ." into published SDL.'
+      );
+    }
+    view = buildVersionView({
+      registry,
+      projection: versioning.projection,
+      currentProjection: versioning.currentProjection,
+      currentVersion: versioning.currentVersion
+    });
+  }
+  const schema = buildGraphQLSchema(registry, fieldKeyMaps, view);
   const { plugins } = buildArmorPlugin({
     maxDepth: options.maxDepth,
     maxComplexity: options.maxComplexity
   });
   const yoga = (0, import_graphql_yoga.createYoga)({
     schema,
-    graphqlEndpoint: "/graphql",
+    graphqlEndpoint: versioning.endpoint ?? "/graphql",
     graphiql: options.graphiql,
     landingPage: false,
     maskedErrors: {
@@ -1043,6 +1196,7 @@ var init_handler = __esm({
     "use strict";
     import_graphql_yoga = require("graphql-yoga");
     init_schema();
+    init_version_view();
     init_dataloaders();
     init_security();
   }
@@ -1069,15 +1223,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
 var import_hono = require("hono");
@@ -1147,7 +1306,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);
   };
 }
@@ -1673,7 +1832,7 @@ function nestedTargets(fields) {
   }
   return out;
 }
-function buildProjectors(registry, fieldKeyMaps) {
+function buildProjectors(registry, fieldKeyMaps, fallbacks) {
   const projectors = {};
   const sources = [
     registry.content_types,
@@ -1684,7 +1843,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;
@@ -1693,6 +1859,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;
@@ -1705,6 +1876,9 @@ function projectRow(row, typeName, projectors) {
   return out;
 }
 
+// src/routes/content.ts
+init_field_keys();
+
 // src/routes/query-params.ts
 var SORTABLE_FIELDS = /* @__PURE__ */ new Set(["title", "created_at", "updated_at"]);
 var RELATION_FIELD_TYPES = /* @__PURE__ */ new Set([
@@ -1786,13 +1960,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 });
@@ -1808,8 +1993,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(
@@ -1824,13 +2007,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
@@ -1877,7 +2060,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,
@@ -3759,7 +3942,7 @@ function registerUserRoutes(app, db, requirePermission, requireHierarchy) {
 var import_drizzle_orm6 = require("drizzle-orm");
 var API_VERSION = (() => {
   try {
-    return "0.4.3";
+    return "0.6.0";
   } catch {
     return "0.0.0";
   }
@@ -4166,6 +4349,95 @@ function createMediaRepository(db) {
 
 // src/app.ts
 init_field_keys();
+
+// src/versions.ts
+init_field_keys();
+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:
 
@@ -4181,6 +4453,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;
@@ -4229,9 +4502,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,
@@ -4250,41 +4532,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);
@@ -4293,17 +4548,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] }
       };
     }
@@ -4323,35 +4578,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 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 = Promise.resolve().then(() => (init_handler(), handler_exports)).then(({ createGraphQLHandler: createGraphQLHandler2 }) => {
-      gqlHandler = createGraphQLHandler2(registry, graphqlRepos, fieldKeyMaps, programmaticResolver, db, gqlOptions);
+      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 = createGraphQLHandler2(
+            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(