@kyro-cms/core 0.9.8 → 0.10.0

package/dist/chunk-PF642V5O.cjs

@@ -1,1080 +0,0 @@
-'use strict';
-
-var chunkKGJRJ7CU_cjs = require('./chunk-KGJRJ7CU.cjs');
-var graphql = require('graphql');
-
-function toPascalCase(slug) {
-  return slug.split(/[-_]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-}
-function toCamelCase(slug) {
-  const p = toPascalCase(slug);
-  return p.charAt(0).toLowerCase() + p.slice(1);
-}
-function toPascalSingular(slug) {
-  const p = toPascalCase(slug);
-  if (p.endsWith("s") && p.length > 1) return p.slice(0, -1);
-  return p;
-}
-function toCamelSingular(slug) {
-  return toCamelCase(slug).endsWith("s") && slug.length > 1 ? toCamelCase(slug).slice(0, -1) : toCamelCase(slug);
-}
-var RelationLoader = class {
-  db;
-  tenantID;
-  user;
-  caches = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.db = opts.db;
-    this.tenantID = opts.tenantID;
-    this.user = opts.user;
-  }
-  getCacheKey(collection) {
-    return collection;
-  }
-  async load(collection, id) {
-    const key = this.getCacheKey(collection);
-    let cache = this.caches.get(key);
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      this.caches.set(key, cache);
-    }
-    if (cache.has(id)) {
-      return cache.get(id);
-    }
-    let pendingSet = this.pending.get(key);
-    if (!pendingSet) {
-      pendingSet = /* @__PURE__ */ new Set();
-      this.pending.set(key, pendingSet);
-    }
-    pendingSet.add(id);
-    cache.set(id, void 0);
-    return void 0;
-  }
-  async flushAll() {
-    for (const [key, ids] of this.pending) {
-      if (ids.size === 0) continue;
-      const cache = this.caches.get(key);
-      const docs = await this.db.find({
-        collection: key,
-        where: { id: { in: Array.from(ids) } },
-        limit: ids.size,
-        tenantID: this.tenantID,
-        draft: !!this.user
-      });
-      for (const doc of docs.docs || []) {
-        if (doc && doc.id) {
-          cache.set(doc.id, doc);
-        }
-      }
-    }
-    this.pending.clear();
-  }
-  resolveOne(collection, id) {
-    return this.caches.get(this.getCacheKey(collection))?.get(id);
-  }
-  static async withBatch(loader, fn) {
-    const result = await fn();
-    await loader.flushAll();
-    return result;
-  }
-};
-function gqlError(message, code) {
-  const err = new Error(message);
-  err.extensions = { code };
-  return err;
-}
-function depthLimit(maxDepth) {
-  return (validationContext) => {
-    let depth = 0;
-    return {
-      Field() {
-        depth++;
-        if (depth > maxDepth) {
-          validationContext.reportError(
-            new graphql.GraphQLError(`Query exceeds max depth of ${maxDepth}`)
-          );
-        }
-      },
-      leaveField() {
-        depth--;
-      }
-    };
-  };
-}
-async function checkAccess(config, operation, context) {
-  const result = await chunkKGJRJ7CU_cjs.checkCollectionAccess(config, operation, context);
-  if (!result.allowed) {
-    throw gqlError(result.error || "Access denied", "FORBIDDEN");
-  }
-  return result.extraWhere;
-}
-async function checkGqlGlobalAccess(config, operation, context) {
-  const result = await chunkKGJRJ7CU_cjs.checkGlobalAccess(config, operation, context);
-  if (!result.allowed) {
-    throw gqlError(result.error || "Access denied", "FORBIDDEN");
-  }
-}
-function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false) {
-  switch (field.type) {
-    case "text":
-    case "email":
-    case "password":
-    case "textarea":
-    case "color":
-    case "code":
-    case "markdown":
-    case "date":
-    case "select":
-    case "radio":
-    case "upload":
-      return graphql.GraphQLString;
-    case "number":
-      return field.integer ? graphql.GraphQLInt : graphql.GraphQLFloat;
-    case "checkbox":
-      return graphql.GraphQLBoolean;
-    case "json":
-    case "richtext":
-      return graphql.GraphQLString;
-    case "relationship":
-      if (typeof field.relationTo === "string") {
-        if (isInputType) {
-          if (field.hasMany) {
-            return new graphql.GraphQLList(graphql.GraphQLString);
-          }
-          return graphql.GraphQLString;
-        }
-        if (collectionTypes?.[field.relationTo]) {
-          const refType = collectionTypes[field.relationTo];
-          if (field.hasMany) {
-            return new graphql.GraphQLList(refType);
-          }
-          return refType;
-        }
-        const relatedCollection = registry.getCollection(field.relationTo);
-        if (relatedCollection) {
-          const refType = new graphql.GraphQLObjectType({
-            name: toPascalSingular(field.relationTo),
-            fields: () => ({
-              id: { type: graphql.GraphQLString },
-              ...buildFieldsFromCollection(relatedCollection, registry, collectionTypes)
-            })
-          });
-          if (collectionTypes) {
-            collectionTypes[field.relationTo] = refType;
-          }
-          if (field.hasMany) {
-            return new graphql.GraphQLList(refType);
-          }
-          return refType;
-        }
-      }
-      return field.hasMany ? new graphql.GraphQLList(graphql.GraphQLString) : graphql.GraphQLString;
-    case "array": {
-      if (isInputType) {
-        const arrFields2 = field.fields;
-        if (arrFields2 && arrFields2.length > 0) {
-          const arrTypeName = `${field.name?.replace(/-/g, "_") || "array"}_input_item`;
-          return new graphql.GraphQLList(fieldsToGraphQLInputObjectType(arrTypeName, arrFields2, registry));
-        }
-        return new graphql.GraphQLList(graphql.GraphQLString);
-      }
-      const arrFields = field.fields;
-      if (arrFields && arrFields.length > 0) {
-        const arrTypeName = `${field.name?.replace(/-/g, "_") || "array"}_item`;
-        const itemType = fieldsToGraphQLObjectType(arrTypeName, arrFields, registry, collectionTypes);
-        return new graphql.GraphQLList(itemType);
-      }
-      return new graphql.GraphQLList(graphql.GraphQLString);
-    }
-    case "group": {
-      if (isInputType) {
-        const groupFields2 = field.fields;
-        if (groupFields2 && groupFields2.length > 0) {
-          const groupTypeName = `${field.name?.replace(/-/g, "_") || "group"}_input_group`;
-          return fieldsToGraphQLInputObjectType(groupTypeName, groupFields2, registry);
-        }
-        return graphql.GraphQLString;
-      }
-      const groupFields = field.fields;
-      if (groupFields && groupFields.length > 0) {
-        const groupTypeName = `${field.name?.replace(/-/g, "_") || "group"}_group`;
-        return fieldsToGraphQLObjectType(groupTypeName, groupFields, registry, collectionTypes);
-      }
-      return graphql.GraphQLString;
-    }
-    case "blocks": {
-      if (isInputType) return graphql.GraphQLString;
-      const blocks = field.blocks;
-      if (blocks && blocks.length > 0) {
-        const blockTypes = [];
-        for (const block of blocks) {
-          const blockTypeName = `Block${toPascalCase(block.slug)}`;
-          const bType = new graphql.GraphQLObjectType({
-            name: blockTypeName,
-            fields: () => {
-              const out = {
-                blockType: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) },
-                id: { type: graphql.GraphQLString }
-              };
-              if (block.fields) {
-                for (const bf of block.fields) {
-                  if (!bf.name) continue;
-                  const bfConfig = buildFieldConfig(bf, registry, collectionTypes);
-                  if (bfConfig) out[bf.name] = bfConfig;
-                }
-              }
-              return out;
-            }
-          });
-          blockTypes.push(bType);
-        }
-        if (blockTypes.length > 0) {
-          const unionName = `${field.name?.replace(/-/g, "_") || "blocks"}_union`;
-          return new graphql.GraphQLUnionType({
-            name: unionName,
-            types: blockTypes,
-            resolveType(value) {
-              const blockName = `Block${value?.blockType ? toPascalCase(value.blockType) : ""}`;
-              const blockType = blockTypes.find(
-                (bt) => bt.name === blockName
-              );
-              return blockType?.name || void 0;
-            }
-          });
-        }
-      }
-      return new graphql.GraphQLList(graphql.GraphQLString);
-    }
-    case "row":
-    case "collapsible":
-    case "tabs":
-      return graphql.GraphQLString;
-    default:
-      return graphql.GraphQLString;
-  }
-}
-function buildFieldsFromCollection(config, registry, collectionTypes) {
-  const fields = {};
-  for (const field of config.fields) {
-    if (field.name && field.admin?.hidden !== true) {
-      const fc = buildFieldConfig(field, registry, collectionTypes);
-      if (fc) fields[field.name] = fc;
-    }
-  }
-  return fields;
-}
-function buildSortEnum(config) {
-  const sortFields = {
-    id: { value: "id" },
-    createdAt: { value: "createdAt" },
-    updatedAt: { value: "updatedAt" }
-  };
-  for (const field of config.fields) {
-    if (field.name) {
-      sortFields[field.name] = { value: field.name };
-      sortFields[`${field.name}_asc`] = { value: `${field.name}` };
-      sortFields[`${field.name}_desc`] = { value: `-${field.name}` };
-    }
-  }
-  return new graphql.GraphQLEnumType({
-    name: `${toPascalSingular(config.slug)}Sort`,
-    values: sortFields
-  });
-}
-function buildFieldFilterType(field, namePrefix) {
-  const safeName = `${namePrefix}_${field.name?.replace(/-/g, "_") || "field"}_filter`;
-  const stringOps = {
-    equals: { type: graphql.GraphQLString },
-    not_equals: { type: graphql.GraphQLString },
-    contains: { type: graphql.GraphQLString },
-    not_contains: { type: graphql.GraphQLString },
-    in: { type: new graphql.GraphQLList(graphql.GraphQLString) },
-    not_in: { type: new graphql.GraphQLList(graphql.GraphQLString) },
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  const numberOps = {
-    equals: { type: graphql.GraphQLFloat },
-    not_equals: { type: graphql.GraphQLFloat },
-    greater_than: { type: graphql.GraphQLFloat },
-    less_than: { type: graphql.GraphQLFloat },
-    greater_than_equal: { type: graphql.GraphQLFloat },
-    less_than_equal: { type: graphql.GraphQLFloat },
-    in: { type: new graphql.GraphQLList(graphql.GraphQLFloat) },
-    not_in: { type: new graphql.GraphQLList(graphql.GraphQLFloat) },
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  const boolOps = {
-    equals: { type: graphql.GraphQLBoolean },
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  const dateOps = {
-    equals: { type: graphql.GraphQLString },
-    not_equals: { type: graphql.GraphQLString },
-    greater_than: { type: graphql.GraphQLString },
-    less_than: { type: graphql.GraphQLString },
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  const relationOps = {
-    equals: { type: graphql.GraphQLString },
-    not_equals: { type: graphql.GraphQLString },
-    in: { type: new graphql.GraphQLList(graphql.GraphQLString) },
-    not_in: { type: new graphql.GraphQLList(graphql.GraphQLString) },
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  const jsonOps = {
-    exists: { type: graphql.GraphQLBoolean }
-  };
-  let ops;
-  switch (field.type) {
-    case "text":
-    case "email":
-    case "password":
-    case "textarea":
-    case "color":
-    case "code":
-    case "markdown":
-    case "select":
-    case "radio":
-    case "upload":
-      ops = stringOps;
-      break;
-    case "number":
-      ops = numberOps;
-      break;
-    case "checkbox":
-      ops = boolOps;
-      break;
-    case "date":
-      ops = dateOps;
-      break;
-    case "relationship":
-      ops = relationOps;
-      break;
-    case "json":
-    case "richtext":
-      ops = jsonOps;
-      break;
-    default:
-      ops = { exists: { type: graphql.GraphQLBoolean } };
-  }
-  return new graphql.GraphQLInputObjectType({
-    name: safeName,
-    fields: ops
-  });
-}
-function buildCollectionFilterType(config, namePrefix) {
-  const fields = {
-    AND: { type: new graphql.GraphQLList(graphql.GraphQLString) },
-    OR: { type: new graphql.GraphQLList(graphql.GraphQLString) }
-  };
-  for (const field of config.fields) {
-    if (!field.name) continue;
-    const filterType = buildFieldFilterType(field, namePrefix);
-    if (filterType) {
-      fields[field.name] = { type: filterType };
-    }
-  }
-  return new graphql.GraphQLInputObjectType({
-    name: `${namePrefix}Filter`,
-    fields
-  });
-}
-function translateFilter(filter) {
-  if (!filter || typeof filter !== "object") return filter || {};
-  const result = {};
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "AND" || key === "OR") continue;
-    result[key] = value;
-  }
-  return result;
-}
-function fieldsToGraphQLInputObjectType(name, fields, registry) {
-  return new graphql.GraphQLInputObjectType({
-    name,
-    fields: () => {
-      const out = {};
-      for (const field of fields) {
-        if (!field.name) continue;
-        if (field.type === "row" || field.type === "collapsible") {
-          const subFields = field.fields;
-          if (subFields) {
-            for (const sf of subFields) {
-              if (!sf.name) continue;
-              out[sf.name] = { type: fieldToGraphQLType(sf, registry, void 0, true) };
-            }
-          }
-        } else if (field.type === "tabs") {
-          const tabs = field.tabs;
-          if (tabs) {
-            for (const tab of tabs) {
-              if (tab.fields) {
-                for (const sf of tab.fields) {
-                  if (!sf.name) continue;
-                  out[sf.name] = { type: fieldToGraphQLType(sf, registry, void 0, true) };
-                }
-              }
-            }
-          }
-        } else {
-          out[field.name] = { type: fieldToGraphQLType(field, registry, void 0, true) };
-        }
-      }
-      return out;
-    }
-  });
-}
-function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes) {
-  return new graphql.GraphQLObjectType({
-    name,
-    fields: () => {
-      const out = {};
-      for (const field of fields) {
-        if (!field.name) continue;
-        if (field.type === "row" || field.type === "collapsible") {
-          const subFields = field.fields;
-          if (subFields) {
-            for (const sf of subFields) {
-              if (!sf.name) continue;
-              const fc = buildFieldConfig(sf, registry, collectionTypes);
-              if (fc) out[sf.name] = fc;
-            }
-          }
-        } else if (field.type === "tabs") {
-          const tabs = field.tabs;
-          if (tabs) {
-            for (const tab of tabs) {
-              if (tab.fields) {
-                for (const sf of tab.fields) {
-                  if (!sf.name) continue;
-                  const fc = buildFieldConfig(sf, registry, collectionTypes);
-                  if (fc) out[sf.name] = fc;
-                }
-              }
-            }
-          }
-        } else {
-          const fc = buildFieldConfig(field, registry, collectionTypes);
-          if (fc) out[field.name] = fc;
-        }
-      }
-      return out;
-    }
-  });
-}
-function buildFieldConfig(field, registry, collectionTypes) {
-  if (!field.name) return null;
-  const deprecationReason = field.deprecated || void 0;
-  if (field.type === "relationship" && !field.hasMany) {
-    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false);
-    return {
-      type: field.required ? new graphql.GraphQLNonNull(gqlType) : gqlType,
-      description: field.admin?.description || field.label,
-      deprecationReason,
-      resolve: (source, args, ctx) => {
-        const loader = ctx?.relationLoader;
-        const relField = field;
-        const id = source?.[relField.name];
-        if (!id) return null;
-        if (loader && typeof id === "string") {
-          const cached = loader.resolveOne(relField.relationTo, id);
-          if (cached) return cached;
-          loader.load(relField.relationTo, id);
-        }
-        return { id };
-      }
-    };
-  }
-  if (field.type === "relationship" && field.hasMany) {
-    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false);
-    return {
-      type: gqlType,
-      description: field.admin?.description || field.label,
-      deprecationReason,
-      resolve: (source, args, ctx) => {
-        const loader = ctx?.relationLoader;
-        const relField = field;
-        const ids = source?.[relField.name] || [];
-        if (!ids.length) return [];
-        if (loader) {
-          const results = [];
-          for (const id of ids) {
-            const cached = loader.resolveOne(relField.relationTo, id);
-            if (cached) results.push(cached);
-            else {
-              loader.load(relField.relationTo, id);
-              results.push({ id });
-            }
-          }
-          return results;
-        }
-        return ids.map((id) => ({ id }));
-      }
-    };
-  }
-  return {
-    type: field.required ? new graphql.GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false)) : fieldToGraphQLType(field, registry, collectionTypes, false),
-    description: field.admin?.description || field.label,
-    deprecationReason
-  };
-}
-function buildGraphQLSchema(options) {
-  const { registry, db, settings } = options;
-  const apiAccess = settings?.access?.apiAccess;
-  if (apiAccess?.graphqlEnabled === false) {
-    throw new Error("GraphQL API is disabled");
-  }
-  const collections = registry.getCollections();
-  const globals = registry.getGlobals();
-  const collectionTypes = {};
-  const collectionInputTypes = {};
-  for (const collection of collections) {
-    collectionTypes[collection.slug] = new graphql.GraphQLObjectType({
-      name: toPascalSingular(collection.slug),
-      fields: () => ({
-        id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) },
-        ...buildFieldsFromCollection(collection, registry, collectionTypes),
-        ...collection.timestamps ? {
-          createdAt: { type: graphql.GraphQLString },
-          updatedAt: { type: graphql.GraphQLString }
-        } : {},
-        ...collection.tenantScoped ? {
-          tenantID: { type: graphql.GraphQLString }
-        } : {}
-      })
-    });
-    const inputFields = {};
-    for (const field of collection.fields) {
-      if (field.name && field.name !== "id") {
-        inputFields[field.name] = {
-          type: fieldToGraphQLType(field, registry, collectionTypes, true)
-        };
-      }
-    }
-    collectionInputTypes[collection.slug] = new graphql.GraphQLInputObjectType({
-      name: `${toPascalSingular(collection.slug)}Input`,
-      fields: () => inputFields
-    });
-  }
-  const globalTypes = {};
-  const globalInputTypes = {};
-  for (const global of globals) {
-    globalTypes[global.slug] = new graphql.GraphQLObjectType({
-      name: toPascalCase(global.slug),
-      fields: () => ({
-        id: { type: graphql.GraphQLString },
-        ...buildFieldsFromCollection(
-          { slug: global.slug, fields: global.fields },
-          registry,
-          collectionTypes
-        )
-      })
-    });
-    globalInputTypes[global.slug] = new graphql.GraphQLInputObjectType({
-      name: `${toPascalCase(global.slug)}Input`,
-      fields: () => {
-        const inputFields = {};
-        for (const field of global.fields) {
-          if (field.name && field.name !== "id") {
-            inputFields[field.name] = {
-              type: fieldToGraphQLType(field, registry, collectionTypes, true)
-            };
-          }
-        }
-        return inputFields;
-      }
-    });
-  }
-  const pageInfoType = new graphql.GraphQLObjectType({
-    name: "PageInfo",
-    fields: {
-      hasNextPage: { type: new graphql.GraphQLNonNull(graphql.GraphQLBoolean) },
-      hasPreviousPage: { type: new graphql.GraphQLNonNull(graphql.GraphQLBoolean) },
-      startCursor: { type: graphql.GraphQLString },
-      endCursor: { type: graphql.GraphQLString }
-    }
-  });
-  const queryFields = {};
-  for (const collection of collections) {
-    const type = collectionTypes[collection.slug];
-    if (!type) continue;
-    const filterType = buildCollectionFilterType(collection, toPascalSingular(collection.slug));
-    const sortEnum = buildSortEnum(collection);
-    queryFields[toCamelCase(collection.slug)] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalSingular(collection.slug)}FindResult`,
-        fields: {
-          docs: { type: new graphql.GraphQLList(type) },
-          totalDocs: { type: graphql.GraphQLInt },
-          page: { type: graphql.GraphQLInt },
-          totalPages: { type: graphql.GraphQLInt },
-          hasNextPage: { type: graphql.GraphQLBoolean },
-          hasPrevPage: { type: graphql.GraphQLBoolean }
-        }
-      }),
-      args: {
-        where: { type: filterType },
-        sort: { type: sortEnum || graphql.GraphQLString },
-        limit: { type: graphql.GraphQLInt },
-        page: { type: graphql.GraphQLInt },
-        draft: { type: graphql.GraphQLBoolean }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
-        const extraWhere = await checkAccess(collection, "read", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        let where = {};
-        if (args.where) {
-          if (typeof args.where === "string") {
-            try {
-              where = JSON.parse(args.where);
-            } catch {
-            }
-          } else {
-            where = translateFilter(args.where);
-          }
-        }
-        if (extraWhere) {
-          where = { ...where, ...extraWhere };
-        }
-        const isDraft = args.draft ?? !!ctxUser;
-        return RelationLoader.withBatch(ctxLoader, async () => {
-          return ctxDb.find({
-            collection: collection.slug,
-            where,
-            sort: args.sort,
-            limit: args.limit || 10,
-            page: args.page || 1,
-            tenantID: ctxTenant,
-            draft: isDraft
-          });
-        });
-      }
-    };
-    queryFields[toCamelSingular(collection.slug)] = {
-      type,
-      args: {
-        id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) },
-        draft: { type: graphql.GraphQLBoolean }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
-        await checkAccess(collection, "read", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        const isDraft = args.draft ?? !!ctxUser;
-        return RelationLoader.withBatch(ctxLoader, async () => {
-          const doc = await ctxDb.findByID({
-            collection: collection.slug,
-            id: args.id,
-            tenantID: ctxTenant,
-            draft: isDraft
-          });
-          return doc;
-        });
-      }
-    };
-    queryFields[`count${toPascalSingular(collection.slug)}s`] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalSingular(collection.slug)}Count`,
-        fields: {
-          totalDocs: { type: graphql.GraphQLInt }
-        }
-      }),
-      args: {
-        where: { type: graphql.GraphQLString }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
-        await checkAccess(collection, "read", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        let where = {};
-        if (args.where) {
-          if (typeof args.where === "string") {
-            try {
-              where = JSON.parse(args.where);
-            } catch {
-            }
-          } else {
-            where = translateFilter(args.where);
-          }
-        }
-        const count = await ctxDb.count({
-          collection: collection.slug,
-          where,
-          tenantID: ctxTenant
-        });
-        return { totalDocs: count };
-      }
-    };
-    const edgeType = new graphql.GraphQLObjectType({
-      name: `${toPascalSingular(collection.slug)}Edge`,
-      fields: {
-        node: { type },
-        cursor: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
-      }
-    });
-    const connectionType = new graphql.GraphQLObjectType({
-      name: `${toPascalSingular(collection.slug)}Connection`,
-      fields: {
-        edges: { type: new graphql.GraphQLList(edgeType) },
-        pageInfo: { type: new graphql.GraphQLNonNull(pageInfoType) },
-        totalCount: { type: graphql.GraphQLInt }
-      }
-    });
-    queryFields[`${toCamelCase(collection.slug)}Connection`] = {
-      type: connectionType,
-      args: {
-        first: { type: graphql.GraphQLInt },
-        after: { type: graphql.GraphQLString },
-        last: { type: graphql.GraphQLInt },
-        before: { type: graphql.GraphQLString },
-        where: { type: filterType },
-        sort: { type: sortEnum || graphql.GraphQLString },
-        draft: { type: graphql.GraphQLBoolean }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
-        const extraWhere = await checkAccess(collection, "read", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        let where = {};
-        if (args.where) {
-          if (typeof args.where === "string") {
-            try {
-              where = JSON.parse(args.where);
-            } catch {
-            }
-          } else {
-            where = translateFilter(args.where);
-          }
-        }
-        if (extraWhere) where = { ...where, ...extraWhere };
-        const isDraft = args.draft ?? !!ctxUser;
-        return RelationLoader.withBatch(ctxLoader, async () => {
-          let page = 1;
-          let limit = args.first || args.last || 10;
-          if (args.after) {
-            try {
-              const afterIdx = parseInt(Buffer.from(args.after, "base64").toString("utf-8"), 10);
-              if (!isNaN(afterIdx)) page = Math.floor(afterIdx / limit) + 1;
-            } catch {
-            }
-          } else if (args.before) {
-            try {
-              const beforeIdx = parseInt(Buffer.from(args.before, "base64").toString("utf-8"), 10);
-              if (!isNaN(beforeIdx)) page = Math.max(1, Math.floor(beforeIdx / limit));
-            } catch {
-            }
-          }
-          const result = await ctxDb.find({
-            collection: collection.slug,
-            where,
-            sort: args.sort,
-            limit,
-            page,
-            tenantID: ctxTenant,
-            draft: isDraft
-          });
-          const edges = (result.docs || []).map((doc, idx) => {
-            const cursorIdx = (page - 1) * limit + idx;
-            return {
-              node: doc,
-              cursor: Buffer.from(String(cursorIdx)).toString("base64")
-            };
-          });
-          return {
-            edges,
-            pageInfo: {
-              hasNextPage: result.hasNextPage || false,
-              hasPreviousPage: result.hasPrevPage || false,
-              startCursor: edges.length > 0 ? edges[0].cursor : null,
-              endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-            },
-            totalCount: result.totalDocs
-          };
-        });
-      }
-    };
-  }
-  for (const global of globals) {
-    const type = globalTypes[global.slug];
-    if (!type) continue;
-    queryFields[toCamelCase(global.slug)] = {
-      type,
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, db: ctxDb } = ctx;
-        await checkGqlGlobalAccess(global, "read", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        return ctxDb.findOne({
-          collection: `_globals_${global.slug}`,
-          where: {},
-          tenantID: ctxTenant
-        });
-      }
-    };
-  }
-  const Query = new graphql.GraphQLObjectType({
-    name: "Query",
-    fields: queryFields
-  });
-  const mutationFields = {};
-  for (const collection of collections) {
-    const type = collectionTypes[collection.slug];
-    const inputType = collectionInputTypes[collection.slug];
-    if (!type || !inputType) continue;
-    mutationFields[`create${toPascalSingular(collection.slug)}`] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalSingular(collection.slug)}CreateResult`,
-        fields: {
-          doc: { type },
-          message: { type: graphql.GraphQLString }
-        }
-      }),
-      args: {
-        data: { type: new graphql.GraphQLNonNull(inputType) },
-        draft: { type: graphql.GraphQLBoolean }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
-        await checkAccess(collection, "create", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        const createSchema = ctxRegistry.getCreateZodSchema(collection.slug);
-        let validated;
-        try {
-          validated = createSchema.parse(args.data);
-        } catch (err) {
-          if (err?.issues) {
-            const msg = err.issues.map((i) => `${i.path?.join(".")}: ${i.message}`).join("; ");
-            throw gqlError(msg, "BAD_USER_INPUT");
-          }
-          throw err;
-        }
-        const doc = await ctxDb.create({
-          collection: collection.slug,
-          data: validated,
-          tenantID: ctxTenant
-        });
-        return { doc, message: "Created successfully" };
-      }
-    };
-    mutationFields[`update${toPascalSingular(collection.slug)}`] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalSingular(collection.slug)}UpdateResult`,
-        fields: {
-          doc: { type },
-          message: { type: graphql.GraphQLString }
-        }
-      }),
-      args: {
-        id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) },
-        data: { type: new graphql.GraphQLNonNull(inputType) },
-        baseUpdatedAt: { type: graphql.GraphQLString },
-        draft: { type: graphql.GraphQLBoolean }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
-        await checkAccess(collection, "update", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        if (args.baseUpdatedAt) {
-          const originalDoc = await ctxDb.findByID({
-            collection: collection.slug,
-            id: args.id,
-            tenantID: ctxTenant,
-            draft: true
-          });
-          if (originalDoc && originalDoc.updatedAt && args.baseUpdatedAt !== originalDoc.updatedAt) {
-            throw gqlError(
-              `Revision conflict: document has changed since ${args.baseUpdatedAt}. Current updatedAt: ${originalDoc.updatedAt}`,
-              "CONFLICT"
-            );
-          }
-        }
-        const updateSchema = ctxRegistry.getUpdateZodSchema(collection.slug);
-        let validated;
-        try {
-          validated = updateSchema.parse(args.data);
-        } catch (err) {
-          if (err?.issues) {
-            const msg = err.issues.map((i) => `${i.path?.join(".")}: ${i.message}`).join("; ");
-            throw gqlError(msg, "BAD_USER_INPUT");
-          }
-          throw err;
-        }
-        const doc = await ctxDb.update({
-          collection: collection.slug,
-          id: args.id,
-          data: validated,
-          tenantID: ctxTenant
-        });
-        return { doc, message: "Updated successfully" };
-      }
-    };
-    mutationFields[`delete${toPascalSingular(collection.slug)}`] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalSingular(collection.slug)}DeleteResult`,
-        fields: {
-          doc: { type },
-          message: { type: graphql.GraphQLString }
-        }
-      }),
-      args: {
-        id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
-        await checkAccess(collection, "delete", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant,
-          apiKey: ctxApiKey
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        const doc = await ctxDb.delete({
-          collection: collection.slug,
-          id: args.id,
-          tenantID: ctxTenant
-        });
-        return { doc, message: "Deleted successfully" };
-      }
-    };
-  }
-  for (const global of globals) {
-    const inputType = globalInputTypes[global.slug];
-    if (!inputType) continue;
-    mutationFields[`update${toPascalCase(global.slug)}`] = {
-      type: new graphql.GraphQLObjectType({
-        name: `${toPascalCase(global.slug)}UpdateResult`,
-        fields: {
-          doc: { type: globalTypes[global.slug] || graphql.GraphQLString },
-          message: { type: graphql.GraphQLString }
-        }
-      }),
-      args: {
-        data: { type: new graphql.GraphQLNonNull(inputType) }
-      },
-      resolve: async (_, args, ctx) => {
-        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, db: ctxDb } = ctx;
-        await checkGqlGlobalAccess(global, "update", {
-          user: ctxUser,
-          req: ctxReq,
-          tenantID: ctxTenant
-        });
-        if (ctxTenant) {
-          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
-        }
-        const doc = await ctxDb.findOne({
-          collection: `_globals_${global.slug}`,
-          where: {},
-          tenantID: ctxTenant
-        });
-        let result;
-        if (doc) {
-          result = await ctxDb.update({
-            collection: `_globals_${global.slug}`,
-            id: doc.id,
-            data: args.data,
-            tenantID: ctxTenant
-          });
-        } else {
-          result = await ctxDb.create({
-            collection: `_globals_${global.slug}`,
-            data: args.data,
-            tenantID: ctxTenant
-          });
-        }
-        return { doc: result, message: "Updated successfully" };
-      }
-    };
-  }
-  const Mutation = new graphql.GraphQLObjectType({
-    name: "Mutation",
-    fields: mutationFields
-  });
-  const keyDirective = new graphql.GraphQLDirective({
-    name: "key",
-    locations: [graphql.DirectiveLocation.OBJECT, graphql.DirectiveLocation.INTERFACE],
-    args: {
-      fields: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
-    }
-  });
-  const serviceSdl = graphql.printSchema(new graphql.GraphQLSchema({
-    query: new graphql.GraphQLObjectType({ name: "Query", fields: { ...queryFields } }),
-    mutation: Mutation,
-    directives: [keyDirective]
-  }));
-  queryFields._service = {
-    type: new graphql.GraphQLObjectType({
-      name: "_Service",
-      fields: {
-        sdl: { type: graphql.GraphQLString }
-      }
-    }),
-    resolve: () => ({ sdl: serviceSdl })
-  };
-  return new graphql.GraphQLSchema({
-    query: Query,
-    mutation: Mutation,
-    directives: [keyDirective]
-  });
-}
-function createGraphQLSchema(registry, db) {
-  const schema = buildGraphQLSchema({ registry, db });
-  return Object.assign(schema, { sdl: graphql.printSchema(schema) });
-}
-
-Object.defineProperty(exports, "printSchema", {
-  enumerable: true,
-  get: function () { return graphql.printSchema; }
-});
-exports.RelationLoader = RelationLoader;
-exports.buildGraphQLSchema = buildGraphQLSchema;
-exports.createGraphQLSchema = createGraphQLSchema;
-exports.depthLimit = depthLimit;
-//# sourceMappingURL=chunk-PF642V5O.cjs.map
-//# sourceMappingURL=chunk-PF642V5O.cjs.map