@bobbykim/manguito-cms-api 0.3.3 → 0.4.1

package/dist/graphql/index.js

@@ -144,14 +144,14 @@ var SortOrderEnum = new import_graphql3.GraphQLEnumType({
   values: { ASC: { value: "asc" }, DESC: { value: "desc" } }
 });
 var SORTABLE = [
-  { gql: "title", column: "title" },
-  { gql: "createdAt", column: "created_at" },
-  { gql: "updatedAt", column: "updated_at" }
+  { gql: "title", value: "title" },
+  { gql: "createdAt", value: "created_at" },
+  { gql: "updatedAt", value: "updated_at" }
 ];
 function buildSortFieldEnum(typeName) {
   return new import_graphql3.GraphQLEnumType({
     name: `${typeName}SortField`,
-    values: Object.fromEntries(SORTABLE.map((s) => [s.gql, { value: s.column }]))
+    values: Object.fromEntries(SORTABLE.map((s) => [s.gql, { value: s.value }]))
   });
 }
 function comparableFilterInput(name, scalar) {
@@ -211,12 +211,13 @@ function buildFilterInputType(type) {
   if (Object.keys(fields).length === 0) return null;
   return new import_graphql3.GraphQLInputObjectType({ name: `${graphqlTypeName(type.name)}Filter`, fields });
 }
-function translateFilters(input, nameMap) {
+function translateFilters(input, nameMap, columnFor) {
   const out = {};
   if (!input) return out;
   for (const [gqlField, raw] of Object.entries(input)) {
     if (raw === null || typeof raw !== "object") continue;
-    const column = nameMap.toSchema(gqlField);
+    const label = nameMap.toSchema(gqlField);
+    const column = columnFor?.(label) ?? label;
     const spec = raw;
     if (spec["eq"] !== void 0) {
       out[column] = spec["eq"];
@@ -235,35 +236,51 @@ function translateFilters(input, nameMap) {
 
 // src/graphql/resolvers.ts
 var import_graphql4 = require("graphql");
+
+// 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;
+}
+
+// src/graphql/resolvers.ts
 function codeError(code, message) {
   return new import_graphql4.GraphQLError(message, { extensions: { code } });
 }
 function isPublished(item) {
   return !!item && item["published"] === true;
 }
-function scalarFieldResolver(schemaName) {
-  return (parent) => parent[schemaName];
+function resolveFieldValue(field, row) {
+  const key = isColumnBacked(field) ? field.db_column.column_name : field.name;
+  return row[key] ?? null;
+}
+function scalarFieldResolver(field) {
+  return (parent) => resolveFieldValue(field, parent);
 }
 function relationFieldResolver(typeName, schemaFieldName) {
   return (parent, _args, ctx) => ctx.loaders.load(typeName, schemaFieldName, parent);
 }
-function programmaticFieldResolver(typeName, schemaFieldName, mediaFieldNames = []) {
+function programmaticFieldResolver(typeName, schemaFieldName, mediaFieldNames = [], fieldKeys) {
   return async (parent, _args, ctx) => {
     let p = ctx.programmaticMemo.get(parent);
     if (!p) {
-      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames);
+      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys);
       ctx.programmaticMemo.set(parent, p);
     }
     return (await p)[schemaFieldName];
   };
 }
-async function resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames) {
-  if (mediaFieldNames.length === 0) return ctx.resolver.resolveItem(typeName, parent);
+async function resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames, fieldKeys) {
+  const toLabels = (row) => fieldKeys ? fieldKeys.toLabels(row) : row;
+  if (mediaFieldNames.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, enriched);
+  return ctx.resolver.resolveItem(typeName, toLabels(enriched));
 }
-function collectionResolver(typeName, nameMap) {
+function collectionResolver(typeName, nameMap, fieldKeys) {
   return async (_root, args, ctx) => {
     const page = args.page ?? 1;
     const perPage = args.perPage ?? 10;
@@ -274,13 +291,15 @@ function collectionResolver(typeName, nameMap) {
       throw codeError("INVALID_PAGINATION", "perPage must be between 1 and 100");
     }
     const repo = ctx.repos[typeName];
+    const sortBy = args.sortBy ?? "created_at";
+    const sortColumn = fieldKeys?.columnFor(sortBy) ?? sortBy;
     const result = await repo.findMany({
       published_only: true,
       page,
       per_page: perPage,
-      sort_by: args.sortBy ?? "created_at",
+      sort_by: sortColumn,
       sort_order: args.sortOrder ?? "asc",
-      filters: translateFilters(args.filter, nameMap)
+      filters: translateFilters(args.filter, nameMap, fieldKeys?.columnFor)
     });
     return { data: result.data, meta: result.meta };
   };
@@ -333,7 +352,7 @@ var MEDIA = new import_graphql5.GraphQLObjectType({
     duration: { type: import_graphql5.GraphQLInt, resolve: (m) => m.duration }
   }
 });
-function buildGraphQLSchema(registry) {
+function buildGraphQLSchema(registry, fieldKeyMaps = {}) {
   const objectTypes = /* @__PURE__ */ new Map();
   const enumTypes = /* @__PURE__ */ new Map();
   for (const [name, enumType] of Object.entries(registry.enum_types)) {
@@ -409,11 +428,16 @@ function buildGraphQLSchema(registry) {
           const outType = outputTypeForField(field);
           let resolve;
           if (field.field_type === "programmatic") {
-            resolve = programmaticFieldResolver(machineName, field.name, mediaFieldNames);
+            resolve = programmaticFieldResolver(
+              machineName,
+              field.name,
+              mediaFieldNames,
+              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.name);
+            resolve = scalarFieldResolver(field);
           }
           fields[gqlName] = { type: outType, resolve };
         }
@@ -469,7 +493,7 @@ function buildGraphQLSchema(registry) {
         sortOrder: { type: SortOrderEnum },
         ...filterType ? { filter: { type: filterType } } : {}
       },
-      resolve: collectionResolver(name, nameMap)
+      resolve: collectionResolver(name, nameMap, fieldKeyMaps[name])
     };
     queryFields[singleQueryName(name)] = {
       type: objType,
@@ -489,7 +513,7 @@ function buildGraphQLSchema(registry) {
     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)))
+      resolve: collectionResolver(name, buildFieldNameMap(tt.fields.map((f) => f.name)), fieldKeyMaps[name])
     };
     queryFields[singleQueryName(name)] = {
       type: objType,
@@ -555,22 +579,34 @@ function groupBy(items, key) {
   }
   return result;
 }
+function needsFkResolution(row, fkColumn, fieldName) {
+  if (fkColumn !== fieldName && !(fkColumn in row)) return false;
+  const current = row[fieldName];
+  return !(typeof current === "object" && current !== null);
+}
 async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOnly = false) {
   if (rows.length === 0) return;
+  const batch = [...new Set(rows)];
   if (rel.type === "paragraph") {
-    const parentIds = rows.map((r) => r["id"]);
+    const parentIds = batch.map((r) => r["id"]);
     const inList = import_drizzle_orm.sql.join(parentIds.map((id) => import_drizzle_orm.sql`${id}`), import_drizzle_orm.sql`, `);
     const result = await db.execute(
       import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(quoteIdent(rel.table))} WHERE parent_id IN (${inList}) AND parent_field = ${fieldName} ORDER BY "order" ASC`
     );
     const byParent = groupBy(result.rows, "parent_id");
-    for (const row of rows) {
+    for (const row of batch) {
       row[fieldName] = byParent[row["id"]] ?? [];
     }
   } else if (rel.type === "reference") {
-    const fkValues = rows.map((r) => r[rel.fk_column]).filter(Boolean);
+    const dropFk = rel.fk_column !== fieldName;
+    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column, fieldName));
+    if (pending.length === 0) return;
+    const fkValues = pending.map((r) => r[rel.fk_column]).filter(Boolean);
     if (fkValues.length === 0) {
-      for (const row of rows) row[fieldName] = null;
+      for (const row of pending) {
+        row[fieldName] = null;
+        if (dropFk) delete row[rel.fk_column];
+      }
       return;
     }
     const unique = [...new Set(fkValues)];
@@ -585,12 +621,13 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
         cache.set(`${rel.table}:${item["id"]}`, item);
       }
     }
-    for (const row of rows) {
+    for (const row of pending) {
       const fkVal = row[rel.fk_column];
       row[fieldName] = fkVal ? cache.get(`${rel.table}:${fkVal}`) ?? null : null;
+      if (dropFk) delete row[rel.fk_column];
     }
   } else if (rel.type === "junction") {
-    const parentIds = rows.map((r) => r["id"]);
+    const parentIds = batch.map((r) => r["id"]);
     const inList = import_drizzle_orm.sql.join(parentIds.map((id) => import_drizzle_orm.sql`${id}`), import_drizzle_orm.sql`, `);
     const orderBy = rel.order_column ? import_drizzle_orm.sql` ORDER BY "order" ASC` : import_drizzle_orm.sql``;
     const junctionResult = await db.execute(
@@ -610,14 +647,20 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
       }
     }
     const byLeft = groupBy(jRows, rel.left_column);
-    for (const row of rows) {
+    for (const row of batch) {
       const jEntries = byLeft[row["id"]] ?? [];
       row[fieldName] = jEntries.map((jr) => cache.get(`${rel.table}:${jr[rel.right_column]}`)).filter(Boolean);
     }
   } else if (rel.type === "media") {
-    const fkValues = rows.map((r) => r[rel.fk_column]).filter(Boolean);
+    const dropFk = rel.fk_column !== fieldName;
+    const pending = batch.filter((r) => needsFkResolution(r, rel.fk_column, fieldName));
+    if (pending.length === 0) return;
+    const fkValues = pending.map((r) => r[rel.fk_column]).filter(Boolean);
     if (fkValues.length === 0) {
-      for (const row of rows) row[fieldName] = null;
+      for (const row of pending) {
+        row[fieldName] = null;
+        if (dropFk) delete row[rel.fk_column];
+      }
       return;
     }
     const unique = [...new Set(fkValues)];
@@ -629,9 +672,10 @@ async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOn
         cache.set(`media:${item["id"]}`, item);
       }
     }
-    for (const row of rows) {
+    for (const row of pending) {
       const fkVal = row[rel.fk_column];
       row[fieldName] = fkVal ? cache.get(`media:${fkVal}`) ?? null : null;
+      if (dropFk) delete row[rel.fk_column];
     }
   }
 }
@@ -710,8 +754,8 @@ function isClientSafeGraphQLError(error) {
   }
   return false;
 }
-function createGraphQLHandler(registry, repos, resolver, db, options) {
-  const schema = buildGraphQLSchema(registry);
+function createGraphQLHandler(registry, repos, fieldKeyMaps, resolver, db, options) {
+  const schema = buildGraphQLSchema(registry, fieldKeyMaps);
   const { plugins } = buildArmorPlugin({
     maxDepth: options.maxDepth,
     maxComplexity: options.maxComplexity