@bobbykim/manguito-cms-cli 0.5.0 → 0.6.1

package/dist/{chunk-LFMOJRYP.js → chunk-SW3T2M64.js}

@@ -49,7 +49,7 @@ var init_esm_shims = __esm({
   }
 });
 
-// ../api/dist/chunk-4Y4G564P.mjs
+// ../api/dist/chunk-JVP33FI2.mjs
 init_esm_shims();
 import crypto from "crypto";
 
@@ -1212,7 +1212,99 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
-// ../api/dist/chunk-4Y4G564P.mjs
+// ../api/dist/chunk-JVP33FI2.mjs
+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
+  );
+}
 function quoteIdent(name) {
   if (!/^[a-z][a-z0-9_-]*$/.test(name)) throw new Error(`Unsafe identifier: ${name}`);
   return `"${name}"`;
@@ -1506,58 +1598,6 @@ async function resolveRelationBareIds(db, rows, fieldName, rel) {
     }
   }
 }
-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
-  };
-}
 
 export {
   __require,
@@ -1590,12 +1630,13 @@ export {
   Placeholder,
   fillPlaceholders,
   View,
+  isColumnBacked,
+  createFieldKeyMap,
+  createFieldKeyMapFromProjection,
   persistParagraphField,
   deleteParagraphField,
   persistJunctionField,
   buildRelationsMap,
   resolveRelationField,
-  resolveRelationBareIds,
-  isColumnBacked,
-  createFieldKeyMap
+  resolveRelationBareIds
 };

package/dist/{handler-45O5OX2C-OIEJ52PN.js → handler-XZVDLKZ2-2TIH4GG7.js}

@@ -11,7 +11,7 @@ import {
   init_esm_shims,
   isColumnBacked,
   resolveRelationField
-} from "./chunk-LFMOJRYP.js";
+} from "./chunk-SW3T2M64.js";
 
 // ../../node_modules/.pnpm/@whatwg-node+fetch@0.10.13/node_modules/@whatwg-node/fetch/dist/shouldSkipPonyfill.js
 var require_shouldSkipPonyfill = __commonJS({
@@ -10786,10 +10786,10 @@ var require_parser = __commonJS({
   }
 });
 
-// ../api/dist/handler-45O5OX2C.mjs
+// ../api/dist/handler-XZVDLKZ2.mjs
 init_esm_shims();
 
-// ../api/dist/chunk-HEYT5CH5.mjs
+// ../api/dist/chunk-XNXM4W4K.mjs
 init_esm_shims();
 
 // ../../node_modules/.pnpm/graphql-yoga@5.21.2_graphql@16.14.2/node_modules/graphql-yoga/esm/index.js
@@ -30122,7 +30122,7 @@ function createYoga(options) {
   });
 }
 
-// ../api/dist/chunk-HEYT5CH5.mjs
+// ../api/dist/chunk-XNXM4W4K.mjs
 var import_dataloader = __toESM(require_dataloader(), 1);
 
 // ../../node_modules/.pnpm/@escape.tech+graphql-armor@3.2.0_@envelop+core@5.5.1_@escape.tech+graphql-armor-types@0.7.0/node_modules/@escape.tech/graphql-armor/dist/graphql-armor.esm.js
@@ -30880,7 +30880,7 @@ var EnvelopArmor = class {
   }
 };
 
-// ../api/dist/chunk-HEYT5CH5.mjs
+// ../api/dist/chunk-XNXM4W4K.mjs
 var DateTimeScalar = new GraphQLScalarType({
   name: "DateTime",
   description: "ISO-8601 date-time string",
@@ -30979,10 +30979,13 @@ var SORTABLE = [
   { gql: "createdAt", value: "created_at" },
   { gql: "updatedAt", value: "updated_at" }
 ];
-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 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) {
@@ -31026,18 +31029,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 GraphQLInputObjectType({ name: `${graphqlTypeName(type.name)}Filter`, fields });
@@ -31070,32 +31074,41 @@ function codeError(code, message) {
 function isPublished(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) => {
@@ -31167,7 +31180,7 @@ var MEDIA = new GraphQLObjectType({
     duration: { type: GraphQLInt, resolve: (m) => m.duration }
   }
 });
-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)) {
@@ -31186,14 +31199,14 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
       );
     }
   }
-  function outputTypeForField(field) {
+  function outputTypeForField(field, required) {
     const scalar = scalarOutputType(field.field_type);
-    if (scalar) return field.required ? new GraphQLNonNull(scalar) : scalar;
+    if (scalar) return required ? new 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 ?? GraphQLString;
-      return field.required ? new GraphQLNonNull(t) : t;
+      return required ? new GraphQLNonNull(t) : t;
     }
     if (field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
       return MEDIA;
@@ -31223,8 +31236,17 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
     }
     return 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 GraphQLObjectType({
       name: graphqlTypeName(machineName),
       fields: () => {
@@ -31238,23 +31260,25 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
         }
         fields["createdAt"] = { type: new GraphQLNonNull(DateTimeScalar), resolve: (p) => p["created_at"] };
         fields["updatedAt"] = { type: new 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;
       }
@@ -31286,7 +31310,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;
@@ -31298,13 +31323,13 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
         meta: { type: new GraphQLNonNull(PAGE_META), resolve: (r) => r.meta }
       }
     });
-    const filterType = buildFilterInputType(ct);
+    const filterType = buildFilterInputType(ct, visible);
     queryFields[collectionQueryName(name)] = {
       type: new GraphQLNonNull(listType),
       args: {
         page: { type: GraphQLInt },
         perPage: { type: GraphQLInt },
-        sortBy: { type: buildSortFieldEnum(graphqlTypeName(name)) },
+        sortBy: { type: buildSortFieldEnum(graphqlTypeName(name), fieldKeyMaps[name]) },
         sortOrder: { type: SortOrderEnum },
         ...filterType ? { filter: { type: filterType } } : {}
       },
@@ -31328,7 +31353,11 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
     queryFields[collectionQueryName(name)] = {
       type: new GraphQLNonNull(listType),
       args: { page: { type: GraphQLInt }, perPage: { type: 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,
@@ -31340,6 +31369,68 @@ function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
     query: new GraphQLObjectType({ name: "Query", fields: queryFields })
   });
 }
+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;
+}
 function createRelationLoaders(db, registry) {
   const relMaps = /* @__PURE__ */ new Map();
   const loaders = /* @__PURE__ */ new Map();
@@ -31407,15 +31498,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 = createYoga({
     schema,
-    graphqlEndpoint: "/graphql",
+    graphqlEndpoint: versioning.endpoint ?? "/graphql",
     graphiql: options.graphiql,
     landingPage: false,
     maskedErrors: {