@bobbykim/manguito-cms-api 0.2.0 → 0.3.0

package/dist/chunk-QXMW74MR.mjs

@@ -0,0 +1,589 @@
+import {
+  buildRelationsMap,
+  resolveRelationField
+} from "./chunk-FBS2RQI3.mjs";
+
+// src/graphql/handler.ts
+import { createYoga } from "graphql-yoga";
+
+// src/graphql/schema.ts
+import {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLEnumType as GraphQLEnumType2,
+  GraphQLNonNull as GraphQLNonNull2,
+  GraphQLList as GraphQLList2,
+  GraphQLID,
+  GraphQLString as GraphQLString3,
+  GraphQLInt as GraphQLInt3,
+  GraphQLBoolean as GraphQLBoolean3
+} from "graphql";
+
+// src/graphql/scalars.ts
+import { GraphQLScalarType, Kind, valueFromASTUntyped } from "graphql";
+var DateTimeScalar = new 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 !== Kind.STRING) throw new TypeError("DateTime must be a string");
+    return ast.value;
+  }
+});
+var JSONScalar = new GraphQLScalarType({
+  name: "JSON",
+  description: "Arbitrary JSON value",
+  serialize: (value) => value,
+  parseValue: (value) => value,
+  parseLiteral: (ast, variables) => valueFromASTUntyped(ast, variables ?? void 0)
+});
+
+// src/graphql/type-mapping.ts
+import {
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLBoolean
+} from "graphql";
+function scalarOutputType(fieldType) {
+  switch (fieldType) {
+    case "text/plain":
+    case "text/rich":
+      return GraphQLString;
+    case "integer":
+      return GraphQLInt;
+    case "float":
+      return GraphQLFloat;
+    case "boolean":
+      return 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
+import {
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLString as GraphQLString2,
+  GraphQLBoolean as GraphQLBoolean2,
+  GraphQLInt as GraphQLInt2,
+  GraphQLFloat as GraphQLFloat2
+} from "graphql";
+var SortOrderEnum = new 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 GraphQLEnumType({
+    name: `${typeName}SortField`,
+    values: Object.fromEntries(SORTABLE.map((s) => [s.gql, { value: s.column }]))
+  });
+}
+function comparableFilterInput(name, scalar) {
+  return new GraphQLInputObjectType({
+    name,
+    fields: {
+      eq: { type: scalar },
+      in: { type: new GraphQLList(new GraphQLNonNull(scalar)) },
+      gt: { type: scalar },
+      gte: { type: scalar },
+      lt: { type: scalar },
+      lte: { type: scalar }
+    }
+  });
+}
+function equalityFilterInput(name, scalar) {
+  return new GraphQLInputObjectType({
+    name,
+    fields: {
+      eq: { type: scalar },
+      in: { type: new GraphQLList(new GraphQLNonNull(scalar)) }
+    }
+  });
+}
+var StringFilter = equalityFilterInput("StringFilter", GraphQLString2);
+var BooleanFilter = new GraphQLInputObjectType({
+  name: "BooleanFilter",
+  fields: { eq: { type: GraphQLBoolean2 } }
+});
+var DateTimeFilter = comparableFilterInput("DateTimeFilter", DateTimeScalar);
+var IDFilter = equalityFilterInput("IDFilter", GraphQLString2);
+var IntFilter = comparableFilterInput("IntFilter", GraphQLInt2);
+var FloatFilter = comparableFilterInput("FloatFilter", GraphQLFloat2);
+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 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
+import { GraphQLError } from "graphql";
+function codeError(code, message) {
+  return new 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) {
+  return async (parent, _args, ctx) => {
+    let p = ctx.programmaticMemo.get(parent);
+    if (!p) {
+      p = ctx.resolver.resolveItem(typeName, parent);
+      ctx.programmaticMemo.set(parent, p);
+    }
+    return (await p)[schemaFieldName];
+  };
+}
+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 GraphQLObjectType({
+  name: "PageMeta",
+  fields: {
+    total: { type: new GraphQLNonNull2(GraphQLInt3), resolve: (m) => m.total },
+    page: { type: new GraphQLNonNull2(GraphQLInt3), resolve: (m) => m.page },
+    perPage: { type: new GraphQLNonNull2(GraphQLInt3), resolve: (m) => m.per_page },
+    totalPages: { type: new GraphQLNonNull2(GraphQLInt3), resolve: (m) => m.total_pages },
+    hasNext: { type: new GraphQLNonNull2(GraphQLBoolean3), resolve: (m) => m.has_next },
+    hasPrev: { type: new GraphQLNonNull2(GraphQLBoolean3), resolve: (m) => m.has_prev }
+  }
+});
+var MEDIA = new GraphQLObjectType({
+  name: "Media",
+  fields: {
+    id: { type: new GraphQLNonNull2(GraphQLID), resolve: (m) => m.id },
+    type: { type: new GraphQLNonNull2(GraphQLString3), resolve: (m) => m.type },
+    url: { type: new GraphQLNonNull2(GraphQLString3), resolve: (m) => m.url },
+    mimeType: { type: new GraphQLNonNull2(GraphQLString3), resolve: (m) => m.mime_type },
+    alt: { type: GraphQLString3, resolve: (m) => m.alt },
+    fileSize: { type: GraphQLInt3, resolve: (m) => m.file_size },
+    width: { type: GraphQLInt3, resolve: (m) => m.width },
+    height: { type: GraphQLInt3, resolve: (m) => m.height },
+    duration: { type: GraphQLInt3, 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 GraphQLEnumType2({
+          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 GraphQLNonNull2(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 ?? GraphQLString3;
+      return field.required ? new GraphQLNonNull2(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 GraphQLList2(new GraphQLNonNull2(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 GraphQLList2(new GraphQLNonNull2(t)) : t;
+    }
+    return GraphQLString3;
+  }
+  function buildObjectType(machineName, type) {
+    return new GraphQLObjectType({
+      name: graphqlTypeName(machineName),
+      fields: () => {
+        const fields = {};
+        fields["id"] = { type: new GraphQLNonNull2(GraphQLID), resolve: (p) => p["id"] };
+        if (type.schema_type !== "paragraph-type") {
+          fields["published"] = { type: new GraphQLNonNull2(GraphQLBoolean3), resolve: (p) => p["published"] };
+        }
+        if (type.schema_type === "content-type") {
+          fields["slug"] = { type: new GraphQLNonNull2(GraphQLString3), resolve: (p) => p["slug"] };
+        }
+        fields["createdAt"] = { type: new GraphQLNonNull2(DateTimeScalar), resolve: (p) => p["created_at"] };
+        fields["updatedAt"] = { type: new GraphQLNonNull2(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);
+          } 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 GraphQLObjectType({
+      name: `${graphqlTypeName(name)}List`,
+      fields: {
+        data: { type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(objType))), resolve: (r) => r.data },
+        meta: { type: new GraphQLNonNull2(PAGE_META), resolve: (r) => r.meta }
+      }
+    });
+    const filterType = buildFilterInputType(ct);
+    queryFields[collectionQueryName(name)] = {
+      type: new GraphQLNonNull2(listType),
+      args: {
+        page: { type: GraphQLInt3 },
+        perPage: { type: GraphQLInt3 },
+        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 GraphQLNonNull2(GraphQLString3) } },
+      resolve: singleBySlugResolver(name)
+    };
+  }
+  for (const [name, tt] of Object.entries(registry.taxonomy_types)) {
+    const objType = objectTypes.get(name);
+    const listType = new GraphQLObjectType({
+      name: `${graphqlTypeName(name)}List`,
+      fields: {
+        data: { type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(objType))), resolve: (r) => r.data },
+        meta: { type: new GraphQLNonNull2(PAGE_META), resolve: (r) => r.meta }
+      }
+    });
+    queryFields[collectionQueryName(name)] = {
+      type: new GraphQLNonNull2(listType),
+      args: { page: { type: GraphQLInt3 }, perPage: { type: GraphQLInt3 } },
+      resolve: collectionResolver(name, buildFieldNameMap(tt.fields.map((f) => f.name)))
+    };
+    queryFields[singleQueryName(name)] = {
+      type: objType,
+      args: { id: { type: new GraphQLNonNull2(GraphQLID) } },
+      resolve: taxonomySingleResolver(name)
+    };
+  }
+  return new GraphQLSchema({
+    query: new GraphQLObjectType({ name: "Query", fields: queryFields })
+  });
+}
+
+// src/graphql/dataloaders.ts
+import DataLoader from "dataloader";
+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 DataLoader(
+        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
+import { EnvelopArmor } from "@escape.tech/graphql-armor";
+import { NoSchemaIntrospectionCustomRule } from "graphql";
+function buildArmorPlugin(options) {
+  const armor = new 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(NoSchemaIntrospectionCustomRule);
+    }
+  };
+}
+
+// src/graphql/handler.ts
+function createGraphQLHandler(registry, repos, resolver, db, options) {
+  const schema = buildGraphQLSchema(registry);
+  const { plugins } = buildArmorPlugin({
+    maxDepth: options.maxDepth,
+    maxComplexity: options.maxComplexity
+  });
+  const yoga = createYoga({
+    schema,
+    graphqlEndpoint: "/graphql",
+    graphiql: options.graphiql,
+    landingPage: false,
+    // 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, {});
+}
+
+export {
+  createGraphQLHandler
+};
+//# sourceMappingURL=chunk-QXMW74MR.mjs.map