@bobbykim/manguito-cms-api 0.2.0 → 0.3.2

package/dist/graphql/index.js

@@ -0,0 +1,747 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/graphql/index.ts
+var graphql_exports = {};
+__export(graphql_exports, {
+  createGraphQLHandler: () => createGraphQLHandler
+});
+module.exports = __toCommonJS(graphql_exports);
+
+// src/graphql/handler.ts
+var import_graphql_yoga = require("graphql-yoga");
+
+// src/graphql/schema.ts
+var import_graphql5 = require("graphql");
+
+// src/graphql/scalars.ts
+var import_graphql = require("graphql");
+var DateTimeScalar = new import_graphql.GraphQLScalarType({
+  name: "DateTime",
+  description: "ISO-8601 date-time string",
+  serialize(value) {
+    if (value instanceof Date) return value.toISOString();
+    if (typeof value === "string") return value;
+    if (typeof value === "number") return new Date(value).toISOString();
+    throw new TypeError(`DateTime cannot serialize value: ${String(value)}`);
+  },
+  parseValue(value) {
+    if (typeof value !== "string") throw new TypeError("DateTime must be a string");
+    return value;
+  },
+  parseLiteral(ast) {
+    if (ast.kind !== import_graphql.Kind.STRING) throw new TypeError("DateTime must be a string");
+    return ast.value;
+  }
+});
+var JSONScalar = new import_graphql.GraphQLScalarType({
+  name: "JSON",
+  description: "Arbitrary JSON value",
+  serialize: (value) => value,
+  parseValue: (value) => value,
+  parseLiteral: (ast, variables) => (0, import_graphql.valueFromASTUntyped)(ast, variables ?? void 0)
+});
+
+// src/graphql/type-mapping.ts
+var import_graphql2 = require("graphql");
+function scalarOutputType(fieldType) {
+  switch (fieldType) {
+    case "text/plain":
+    case "text/rich":
+      return import_graphql2.GraphQLString;
+    case "integer":
+      return import_graphql2.GraphQLInt;
+    case "float":
+      return import_graphql2.GraphQLFloat;
+    case "boolean":
+      return import_graphql2.GraphQLBoolean;
+    case "date":
+      return DateTimeScalar;
+    case "programmatic":
+      return JSONScalar;
+    default:
+      return null;
+  }
+}
+
+// src/graphql/naming.ts
+function schemaSegment(machineName) {
+  const idx = machineName.indexOf("--");
+  return idx === -1 ? machineName : machineName.slice(idx + 2);
+}
+function words(input) {
+  return input.split(/[_\s-]+/).filter(Boolean);
+}
+function toPascalCase(input) {
+  return words(input).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function toCamelCase(input) {
+  const pascal = toPascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function pluralize(word) {
+  if (/[^aeiou]y$/.test(word)) return word.slice(0, -1) + "ies";
+  if (/(s|x|z|ch|sh)$/.test(word)) return word + "es";
+  return word + "s";
+}
+var GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
+function isValidGraphQLName(name) {
+  return GRAPHQL_NAME.test(name);
+}
+function graphqlTypeName(machineName) {
+  return toPascalCase(schemaSegment(machineName));
+}
+function singleQueryName(machineName) {
+  return toCamelCase(schemaSegment(machineName));
+}
+function collectionQueryName(machineName) {
+  return pluralize(singleQueryName(machineName));
+}
+function buildFieldNameMap(schemaNames) {
+  const toG = /* @__PURE__ */ new Map();
+  const toS = /* @__PURE__ */ new Map();
+  for (const name of schemaNames) {
+    const g = toCamelCase(name);
+    toG.set(name, g);
+    toS.set(g, name);
+  }
+  return {
+    toGraphql: (schemaName) => toG.get(schemaName) ?? toCamelCase(schemaName),
+    toSchema: (graphqlName) => toS.get(graphqlName) ?? graphqlName
+  };
+}
+
+// src/graphql/filters.ts
+var import_graphql3 = require("graphql");
+var SortOrderEnum = new import_graphql3.GraphQLEnumType({
+  name: "SortOrder",
+  values: { ASC: { value: "asc" }, DESC: { value: "desc" } }
+});
+var SORTABLE = [
+  { gql: "title", column: "title" },
+  { gql: "createdAt", column: "created_at" },
+  { gql: "updatedAt", column: "updated_at" }
+];
+function buildSortFieldEnum(typeName) {
+  return new import_graphql3.GraphQLEnumType({
+    name: `${typeName}SortField`,
+    values: Object.fromEntries(SORTABLE.map((s) => [s.gql, { value: s.column }]))
+  });
+}
+function comparableFilterInput(name, scalar) {
+  return new import_graphql3.GraphQLInputObjectType({
+    name,
+    fields: {
+      eq: { type: scalar },
+      in: { type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(scalar)) },
+      gt: { type: scalar },
+      gte: { type: scalar },
+      lt: { type: scalar },
+      lte: { type: scalar }
+    }
+  });
+}
+function equalityFilterInput(name, scalar) {
+  return new import_graphql3.GraphQLInputObjectType({
+    name,
+    fields: {
+      eq: { type: scalar },
+      in: { type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(scalar)) }
+    }
+  });
+}
+var StringFilter = equalityFilterInput("StringFilter", import_graphql3.GraphQLString);
+var BooleanFilter = new import_graphql3.GraphQLInputObjectType({
+  name: "BooleanFilter",
+  fields: { eq: { type: import_graphql3.GraphQLBoolean } }
+});
+var DateTimeFilter = comparableFilterInput("DateTimeFilter", DateTimeScalar);
+var IDFilter = equalityFilterInput("IDFilter", import_graphql3.GraphQLString);
+var IntFilter = comparableFilterInput("IntFilter", import_graphql3.GraphQLInt);
+var FloatFilter = comparableFilterInput("FloatFilter", import_graphql3.GraphQLFloat);
+function filterInputForField(fieldType) {
+  const scalar = scalarOutputType(fieldType);
+  if (fieldType === "boolean") return BooleanFilter;
+  if (fieldType === "date") return DateTimeFilter;
+  if (fieldType === "integer") return IntFilter;
+  if (fieldType === "float") return FloatFilter;
+  if (fieldType === "reference") return IDFilter;
+  if (scalar === null) return null;
+  return StringFilter;
+}
+function buildFilterInputType(type) {
+  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) {
+    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 (Object.keys(fields).length === 0) return null;
+  return new import_graphql3.GraphQLInputObjectType({ name: `${graphqlTypeName(type.name)}Filter`, fields });
+}
+function translateFilters(input, nameMap) {
+  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 spec = raw;
+    if (spec["eq"] !== void 0) {
+      out[column] = spec["eq"];
+    } else if (Array.isArray(spec["in"])) {
+      out[column] = spec["in"];
+    } else {
+      const op = {};
+      for (const k of ["gt", "gte", "lt", "lte"]) {
+        if (spec[k] !== void 0) op[k] = spec[k];
+      }
+      if (Object.keys(op).length > 0) out[column] = op;
+    }
+  }
+  return out;
+}
+
+// src/graphql/resolvers.ts
+var import_graphql4 = require("graphql");
+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 relationFieldResolver(typeName, schemaFieldName) {
+  return (parent, _args, ctx) => ctx.loaders.load(typeName, schemaFieldName, parent);
+}
+function programmaticFieldResolver(typeName, schemaFieldName, mediaFieldNames = []) {
+  return async (parent, _args, ctx) => {
+    let p = ctx.programmaticMemo.get(parent);
+    if (!p) {
+      p = resolveProgrammaticRow(typeName, parent, ctx, mediaFieldNames);
+      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);
+  const enriched = { ...parent };
+  await Promise.all(mediaFieldNames.map((name) => ctx.loaders.load(typeName, name, enriched)));
+  return ctx.resolver.resolveItem(typeName, enriched);
+}
+function collectionResolver(typeName, nameMap) {
+  return async (_root, args, ctx) => {
+    const page = args.page ?? 1;
+    const perPage = args.perPage ?? 10;
+    if (!Number.isInteger(page) || page < 1) {
+      throw codeError("INVALID_PAGINATION", "page must be \u2265 1");
+    }
+    if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) {
+      throw codeError("INVALID_PAGINATION", "perPage must be between 1 and 100");
+    }
+    const repo = ctx.repos[typeName];
+    const result = await repo.findMany({
+      published_only: true,
+      page,
+      per_page: perPage,
+      sort_by: args.sortBy ?? "created_at",
+      sort_order: args.sortOrder ?? "asc",
+      filters: translateFilters(args.filter, nameMap)
+    });
+    return { data: result.data, meta: result.meta };
+  };
+}
+function singleBySlugResolver(typeName) {
+  return async (_root, args, ctx) => {
+    const repo = ctx.repos[typeName];
+    const item = await repo.findBySlug(args.slug);
+    return isPublished(item) ? item : null;
+  };
+}
+function singletonResolver(typeName) {
+  return async (_root, _args, ctx) => {
+    const repo = ctx.repos[typeName];
+    const result = await repo.findMany({ published_only: true, page: 1, per_page: 1 });
+    return result.data[0] ?? null;
+  };
+}
+function taxonomySingleResolver(typeName) {
+  return async (_root, args, ctx) => {
+    const repo = ctx.repos[typeName];
+    const item = await repo.findOne(args.id);
+    return isPublished(item) ? item : null;
+  };
+}
+
+// src/graphql/schema.ts
+var PAGE_META = new import_graphql5.GraphQLObjectType({
+  name: "PageMeta",
+  fields: {
+    total: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt), resolve: (m) => m.total },
+    page: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt), resolve: (m) => m.page },
+    perPage: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt), resolve: (m) => m.per_page },
+    totalPages: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt), resolve: (m) => m.total_pages },
+    hasNext: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLBoolean), resolve: (m) => m.has_next },
+    hasPrev: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLBoolean), resolve: (m) => m.has_prev }
+  }
+});
+var MEDIA = new import_graphql5.GraphQLObjectType({
+  name: "Media",
+  fields: {
+    id: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLID), resolve: (m) => m.id },
+    type: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString), resolve: (m) => m.type },
+    url: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString), resolve: (m) => m.url },
+    mimeType: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString), resolve: (m) => m.mime_type },
+    alt: { type: import_graphql5.GraphQLString, resolve: (m) => m.alt },
+    fileSize: { type: import_graphql5.GraphQLInt, resolve: (m) => m.file_size },
+    width: { type: import_graphql5.GraphQLInt, resolve: (m) => m.width },
+    height: { type: import_graphql5.GraphQLInt, resolve: (m) => m.height },
+    duration: { type: import_graphql5.GraphQLInt, resolve: (m) => m.duration }
+  }
+});
+function buildGraphQLSchema(registry) {
+  const objectTypes = /* @__PURE__ */ new Map();
+  const enumTypes = /* @__PURE__ */ new Map();
+  for (const [name, enumType] of Object.entries(registry.enum_types)) {
+    if (enumType.values.every(isValidGraphQLName)) {
+      enumTypes.set(
+        name,
+        new import_graphql5.GraphQLEnumType({
+          name: graphqlTypeName(name),
+          values: Object.fromEntries(enumType.values.map((v) => [v, { value: v }]))
+        })
+      );
+    } else {
+      process.stderr.write(
+        `\u26A0 enum '${name}' has values that aren't valid GraphQL identifiers; exposing as String
+`
+      );
+    }
+  }
+  function outputTypeForField(field) {
+    const scalar = scalarOutputType(field.field_type);
+    if (scalar) return field.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;
+    }
+    if (field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
+      return MEDIA;
+    }
+    if (field.field_type === "paragraph") {
+      const ref = field.ui_component.component === "paragraph-embed" ? field.ui_component.ref : void 0;
+      const target = ref ? objectTypes.get(ref) : void 0;
+      if (ref && !target) {
+        process.stderr.write(
+          `\u26A0 paragraph field '${field.name}' targets unknown paragraph type '${ref}'; exposing as Media
+`
+        );
+      }
+      return new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(target ?? MEDIA));
+    }
+    if (field.field_type === "reference") {
+      const ref = field.ui_component.component === "typeahead-select" ? field.ui_component.ref : void 0;
+      const target = ref ? objectTypes.get(ref) : void 0;
+      if (ref && !target) {
+        process.stderr.write(`\u26A0 reference field '${field.name}' targets unknown type '${ref}'; exposing as Media
+`);
+      }
+      const rel = field.ui_component.component === "typeahead-select" ? field.ui_component.rel : void 0;
+      const isMany = rel === "many-to-many" || rel === "one-to-many";
+      const t = target ?? MEDIA;
+      return isMany ? new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(t)) : t;
+    }
+    return import_graphql5.GraphQLString;
+  }
+  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);
+    return new import_graphql5.GraphQLObjectType({
+      name: graphqlTypeName(machineName),
+      fields: () => {
+        const fields = {};
+        fields["id"] = { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLID), resolve: (p) => p["id"] };
+        if (type.schema_type !== "paragraph-type") {
+          fields["published"] = { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLBoolean), resolve: (p) => p["published"] };
+        }
+        if (type.schema_type === "content-type") {
+          fields["slug"] = { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString), resolve: (p) => p["slug"] };
+        }
+        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);
+          let resolve;
+          if (field.field_type === "programmatic") {
+            resolve = programmaticFieldResolver(machineName, field.name, mediaFieldNames);
+          } 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);
+          }
+          fields[gqlName] = { type: outType, resolve };
+        }
+        return fields;
+      }
+    });
+  }
+  const typeNameOwners = /* @__PURE__ */ new Map();
+  function registerTypeName(machineName) {
+    const gqlName = graphqlTypeName(machineName);
+    const owner = typeNameOwners.get(gqlName);
+    if (owner !== void 0 && owner !== machineName) {
+      throw new Error(
+        `GraphQL type name collision: '${gqlName}' is produced by both '${owner}' and '${machineName}'. Rename one schema's machine name segment so their GraphQL type names differ.`
+      );
+    }
+    typeNameOwners.set(gqlName, machineName);
+  }
+  for (const [name, ct] of Object.entries(registry.content_types)) {
+    registerTypeName(name);
+    objectTypes.set(name, buildObjectType(name, ct));
+  }
+  for (const [name, tt] of Object.entries(registry.taxonomy_types)) {
+    registerTypeName(name);
+    objectTypes.set(name, buildObjectType(name, tt));
+  }
+  for (const [name, pt] of Object.entries(registry.paragraph_types)) {
+    registerTypeName(name);
+    objectTypes.set(name, buildObjectType(name, pt));
+  }
+  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));
+    if (ct.only_one) {
+      queryFields[singleQueryName(name)] = { type: objType, resolve: singletonResolver(name) };
+      continue;
+    }
+    const listType = new import_graphql5.GraphQLObjectType({
+      name: `${graphqlTypeName(name)}List`,
+      fields: {
+        data: { type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(objType))), resolve: (r) => r.data },
+        meta: { type: new import_graphql5.GraphQLNonNull(PAGE_META), resolve: (r) => r.meta }
+      }
+    });
+    const filterType = buildFilterInputType(ct);
+    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)) },
+        sortOrder: { type: SortOrderEnum },
+        ...filterType ? { filter: { type: filterType } } : {}
+      },
+      resolve: collectionResolver(name, nameMap)
+    };
+    queryFields[singleQueryName(name)] = {
+      type: objType,
+      args: { slug: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString) } },
+      resolve: singleBySlugResolver(name)
+    };
+  }
+  for (const [name, tt] of Object.entries(registry.taxonomy_types)) {
+    const objType = objectTypes.get(name);
+    const listType = new import_graphql5.GraphQLObjectType({
+      name: `${graphqlTypeName(name)}List`,
+      fields: {
+        data: { type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(objType))), resolve: (r) => r.data },
+        meta: { type: new import_graphql5.GraphQLNonNull(PAGE_META), resolve: (r) => r.meta }
+      }
+    });
+    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)))
+    };
+    queryFields[singleQueryName(name)] = {
+      type: objType,
+      args: { id: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLID) } },
+      resolve: taxonomySingleResolver(name)
+    };
+  }
+  return new import_graphql5.GraphQLSchema({
+    query: new import_graphql5.GraphQLObjectType({ name: "Query", fields: queryFields })
+  });
+}
+
+// src/graphql/dataloaders.ts
+var import_dataloader = __toESM(require("dataloader"));
+
+// src/relations.ts
+var import_node_crypto = __toESM(require("crypto"));
+var import_drizzle_orm = require("drizzle-orm");
+function quoteIdent(name) {
+  if (!/^[a-z][a-z0-9_-]*$/.test(name)) throw new Error(`Unsafe identifier: ${name}`);
+  return `"${name}"`;
+}
+function buildRelationsMap(fields, registry) {
+  const relations = {};
+  for (const field of fields) {
+    if (field.field_type === "image" || field.field_type === "video" || field.field_type === "file") {
+      if (!field.db_column) continue;
+      relations[field.name] = { type: "media", fk_column: field.db_column.column_name };
+    } else if (field.field_type === "paragraph") {
+      const ref = field.ui_component.ref;
+      const pType = ref ? registry.paragraph_types[ref] : void 0;
+      if (!pType) continue;
+      relations[field.name] = { type: "paragraph", table: pType.db.table_name };
+    } else if (field.field_type === "reference") {
+      if (!field.db_column) continue;
+      if (field.db_column.junction) {
+        const j = field.db_column.junction;
+        relations[field.name] = {
+          type: "junction",
+          table: j.right_table,
+          junction_table: j.table_name,
+          left_column: j.left_column,
+          right_column: j.right_column,
+          order_column: j.order_column
+        };
+      } else if (field.db_column.foreign_key) {
+        relations[field.name] = {
+          type: "reference",
+          table: field.db_column.foreign_key.table,
+          fk_column: field.db_column.column_name
+        };
+      }
+    }
+  }
+  return relations;
+}
+function groupBy(items, key) {
+  const result = {};
+  for (const item of items) {
+    const k = String(item[key]);
+    if (!result[k]) result[k] = [];
+    result[k].push(item);
+  }
+  return result;
+}
+async function resolveRelationField(db, rows, fieldName, rel, cache, publishedOnly = false) {
+  if (rows.length === 0) return;
+  if (rel.type === "paragraph") {
+    const parentIds = rows.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) {
+      row[fieldName] = byParent[row["id"]] ?? [];
+    }
+  } else if (rel.type === "reference") {
+    const fkValues = rows.map((r) => r[rel.fk_column]).filter(Boolean);
+    if (fkValues.length === 0) {
+      for (const row of rows) row[fieldName] = null;
+      return;
+    }
+    const unique = [...new Set(fkValues)];
+    const uncached = unique.filter((id) => !cache.has(`${rel.table}:${id}`));
+    if (uncached.length > 0) {
+      const inList = import_drizzle_orm.sql.join(uncached.map((id) => import_drizzle_orm.sql`${id}`), import_drizzle_orm.sql`, `);
+      const publishedCond = publishedOnly ? import_drizzle_orm.sql` AND published = true` : import_drizzle_orm.sql``;
+      const result = await db.execute(
+        import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(quoteIdent(rel.table))} WHERE id IN (${inList})${publishedCond}`
+      );
+      for (const item of result.rows) {
+        cache.set(`${rel.table}:${item["id"]}`, item);
+      }
+    }
+    for (const row of rows) {
+      const fkVal = row[rel.fk_column];
+      row[fieldName] = fkVal ? cache.get(`${rel.table}:${fkVal}`) ?? null : null;
+    }
+  } else if (rel.type === "junction") {
+    const parentIds = rows.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(
+      import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(quoteIdent(rel.junction_table))} WHERE ${import_drizzle_orm.sql.raw(quoteIdent(rel.left_column))} IN (${inList})${orderBy}`
+    );
+    const jRows = junctionResult.rows;
+    const rightIds = [...new Set(jRows.map((r) => r[rel.right_column]))];
+    const uncached = rightIds.filter((id) => !cache.has(`${rel.table}:${id}`));
+    if (uncached.length > 0) {
+      const rightInList = import_drizzle_orm.sql.join(uncached.map((id) => import_drizzle_orm.sql`${id}`), import_drizzle_orm.sql`, `);
+      const publishedCond = publishedOnly ? import_drizzle_orm.sql` AND published = true` : import_drizzle_orm.sql``;
+      const entitiesResult = await db.execute(
+        import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(quoteIdent(rel.table))} WHERE id IN (${rightInList})${publishedCond}`
+      );
+      for (const item of entitiesResult.rows) {
+        cache.set(`${rel.table}:${item["id"]}`, item);
+      }
+    }
+    const byLeft = groupBy(jRows, rel.left_column);
+    for (const row of rows) {
+      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);
+    if (fkValues.length === 0) {
+      for (const row of rows) row[fieldName] = null;
+      return;
+    }
+    const unique = [...new Set(fkValues)];
+    const uncached = unique.filter((id) => !cache.has(`media:${id}`));
+    if (uncached.length > 0) {
+      const inList = import_drizzle_orm.sql.join(uncached.map((id) => import_drizzle_orm.sql`${id}`), import_drizzle_orm.sql`, `);
+      const result = await db.execute(import_drizzle_orm.sql`SELECT * FROM "media" WHERE id IN (${inList})`);
+      for (const item of result.rows) {
+        cache.set(`media:${item["id"]}`, item);
+      }
+    }
+    for (const row of rows) {
+      const fkVal = row[rel.fk_column];
+      row[fieldName] = fkVal ? cache.get(`media:${fkVal}`) ?? null : null;
+    }
+  }
+}
+
+// src/graphql/dataloaders.ts
+function createRelationLoaders(db, registry) {
+  const relMaps = /* @__PURE__ */ new Map();
+  const loaders = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  function relationsFor(typeName) {
+    let m = relMaps.get(typeName);
+    if (!m) {
+      const type = registry.content_types[typeName] ?? registry.taxonomy_types[typeName] ?? registry.paragraph_types[typeName];
+      m = type ? buildRelationsMap(type.fields, registry) : {};
+      relMaps.set(typeName, m);
+    }
+    return m;
+  }
+  function loaderFor(typeName, fieldName, rel) {
+    const key = `${typeName}:${fieldName}`;
+    let dl = loaders.get(key);
+    if (!dl) {
+      dl = new import_dataloader.default(
+        async (parents) => {
+          const rows = parents;
+          await resolveRelationField(db, rows, fieldName, rel, cache, true);
+          return rows.map((r) => r[fieldName]);
+        },
+        // Batch within a tick; do not memoize by parent identity (rows are mutated
+        // and may recur across nesting levels).
+        { cache: false }
+      );
+      loaders.set(key, dl);
+    }
+    return dl;
+  }
+  return {
+    async load(typeName, fieldName, parent) {
+      const rel = relationsFor(typeName)[fieldName];
+      if (!rel) return null;
+      return loaderFor(typeName, fieldName, rel).load(parent);
+    }
+  };
+}
+
+// src/graphql/security.ts
+var import_graphql_armor = require("@escape.tech/graphql-armor");
+var import_graphql6 = require("graphql");
+function buildArmorPlugin(options) {
+  const armor = new import_graphql_armor.EnvelopArmor({
+    maxDepth: { n: options.maxDepth },
+    costLimit: { maxCost: options.maxComplexity },
+    maxAliases: { n: 15 },
+    maxDirectives: { n: 50 },
+    blockFieldSuggestion: { enabled: true }
+    // maxTokens is intentionally left at Armor's secure default (n=1000) to bound
+    // GraphQL document token count at parse time, a layer the depth/cost/alias/directive
+    // limits do not cover.
+  });
+  return armor.protect();
+}
+function introspectionPlugin(enabled) {
+  return {
+    onValidate({ addValidationRule }) {
+      if (!enabled) addValidationRule(import_graphql6.NoSchemaIntrospectionCustomRule);
+    }
+  };
+}
+
+// src/graphql/handler.ts
+function isClientSafeGraphQLError(error) {
+  let current = error;
+  while (current != null && typeof current === "object" && current.name === "GraphQLError") {
+    if (current.originalError == null) return true;
+    current = current.originalError;
+  }
+  return false;
+}
+function createGraphQLHandler(registry, repos, resolver, db, options) {
+  const schema = buildGraphQLSchema(registry);
+  const { plugins } = buildArmorPlugin({
+    maxDepth: options.maxDepth,
+    maxComplexity: options.maxComplexity
+  });
+  const yoga = (0, import_graphql_yoga.createYoga)({
+    schema,
+    graphqlEndpoint: "/graphql",
+    graphiql: options.graphiql,
+    landingPage: false,
+    maskedErrors: {
+      maskError: (error, message, isDev) => isClientSafeGraphQLError(error) ? error : (0, import_graphql_yoga.maskError)(error, message, isDev)
+    },
+    // buildArmorPlugin's return type is `unknown[]` (see security.ts) since Armor's
+    // plugin shapes aren't part of its public typings; Yoga's `plugins` option only
+    // accepts its own `Plugin` type, so the cast bridges the two.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    plugins: [...plugins, introspectionPlugin(options.introspection)],
+    context: () => ({
+      db,
+      registry,
+      repos,
+      resolver,
+      loaders: createRelationLoaders(db, registry),
+      programmaticMemo: /* @__PURE__ */ new WeakMap()
+    })
+  });
+  return (c) => yoga.fetch(c.req.raw, {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGraphQLHandler
+});
+//# sourceMappingURL=index.js.map