@kyro-cms/core 0.10.4 → 0.10.6

package/dist/chunk-5RPRLTTN.js

@@ -1,861 +0,0 @@
-import { hasApiKeyPermission, evaluateAccess } from './chunk-3AKCVYDB.js';
-import { hasPermission } from './chunk-L4EZKIEX.js';
-import { GraphQLScalarType, Kind, GraphQLObjectType, GraphQLString, GraphQLInputObjectType, GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLSchema, GraphQLFloat } from 'graphql';
-export { printSchema } from 'graphql';
-
-var RelationLoader = class {
-  db;
-  tenantID;
-  user;
-  caches = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  waiting = /* @__PURE__ */ new Map();
-  flushScheduled = false;
-  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);
-    if (!this.flushScheduled) {
-      this.flushScheduled = true;
-      queueMicrotask(() => {
-        this.flushScheduled = false;
-        this.flushAll();
-      });
-    }
-    return new Promise((resolve) => {
-      this.waiting.set(`${key}:${id}`, resolve);
-    });
-  }
-  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);
-          const resolve = this.waiting.get(`${key}:${doc.id}`);
-          if (resolve) {
-            resolve(doc);
-            this.waiting.delete(`${key}:${doc.id}`);
-          }
-        }
-      }
-    }
-    for (const [keyId, resolve] of this.waiting) {
-      resolve(void 0);
-    }
-    this.waiting.clear();
-    this.pending.clear();
-  }
-  resolveOne(collection, id) {
-    return this.caches.get(this.getCacheKey(collection))?.get(id);
-  }
-};
-var GraphQLJSON = new GraphQLScalarType({
-  name: "JSON",
-  description: "Arbitrary JSON value",
-  serialize(value) {
-    return value;
-  },
-  parseValue(value) {
-    return value;
-  },
-  parseLiteral(ast) {
-    switch (ast.kind) {
-      case Kind.STRING:
-        return ast.value;
-      case Kind.INT:
-      case Kind.FLOAT:
-        return parseFloat(ast.value);
-      case Kind.BOOLEAN:
-        return ast.value;
-      case Kind.OBJECT: {
-        const obj = {};
-        for (const field of ast.fields) {
-          obj[field.name.value] = GraphQLJSON.parseLiteral(field.value);
-        }
-        return obj;
-      }
-      case Kind.LIST:
-        return ast.values.map((v) => GraphQLJSON.parseLiteral(v));
-      case Kind.NULL:
-        return null;
-      default:
-        return null;
-    }
-  }
-});
-function depthLimit(maxDepth) {
-  return (validationContext) => {
-    let depth = 0;
-    return {
-      Field() {
-        depth++;
-        if (depth > maxDepth) {
-          validationContext.reportError(
-            new Error(`Query exceeds max depth of ${maxDepth}`)
-          );
-        }
-      },
-      leaveField() {
-        depth--;
-      }
-    };
-  };
-}
-function toPascal(slug) {
-  return slug.split(/[-_]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-}
-function toCamel(slug) {
-  const p = toPascal(slug);
-  return p.charAt(0).toLowerCase() + p.slice(1);
-}
-function toSingular(slug) {
-  return slug.endsWith("s") && slug.length > 1 ? slug.slice(0, -1) : slug;
-}
-async function checkGraphQLAccess(collection, operation, context) {
-  const accessRule = collection.access?.[operation];
-  if (context.apiKey) {
-    if (context.apiKey.permissions?.length > 0) {
-      const resource = collection.slug;
-      const action = operation === "read" ? "read" : operation === "create" ? "create" : "update";
-      const permission = `${resource}:${action}`;
-      if (!hasApiKeyPermission(context.apiKey.permissions, permission) && !hasApiKeyPermission(context.apiKey.permissions, `${resource}:admin`)) {
-        return { allowed: false };
-      }
-      return { allowed: true };
-    }
-    if (accessRule) {
-      const result2 = await evaluateAccess(accessRule, {
-        req: context.req,
-        user: context.user,
-        tenantID: context.tenantID
-      });
-      if (typeof result2 === "boolean") {
-        return { allowed: result2 };
-      }
-      return { allowed: true, extraWhere: result2 };
-    }
-    return { allowed: true };
-  }
-  if (context.user) {
-    const resource = collection.slug;
-    const action = operation === "read" ? "read" : operation === "create" ? "create" : operation === "update" ? "update" : "delete";
-    const permission = `${resource}:${action}`;
-    const userHasPermission = hasPermission(
-      { id: context.user.id, email: context.user.email, role: context.user.role },
-      permission
-    );
-    if (!userHasPermission && !hasPermission(
-      { id: context.user.id, email: context.user.email, role: context.user.role },
-      `${resource}:admin`
-    )) {
-      if (!accessRule) {
-        return { allowed: false };
-      }
-    }
-  }
-  if (!accessRule) {
-    if (!context.user) {
-      return { allowed: false };
-    }
-    return { allowed: true };
-  }
-  const result = await evaluateAccess(accessRule, {
-    req: context.req,
-    user: context.user,
-    tenantID: context.tenantID
-  });
-  if (typeof result === "boolean") {
-    return { allowed: result };
-  }
-  return { allowed: true, extraWhere: result };
-}
-async function checkGlobalAccess(global, operation, context) {
-  const accessRule = global.access?.[operation];
-  if (context.apiKey) {
-    if (context.apiKey.permissions?.length > 0) {
-      const resource = global.slug;
-      const permission = `${resource}:${operation}`;
-      if (!hasApiKeyPermission(context.apiKey.permissions, permission) && !hasApiKeyPermission(context.apiKey.permissions, `${resource}:admin`) && !hasApiKeyPermission(context.apiKey.permissions, `${resource}:*`)) {
-        return { allowed: false };
-      }
-      return { allowed: true };
-    }
-    if (accessRule) {
-      const result2 = await evaluateAccess(accessRule, {
-        req: context.req,
-        user: context.user,
-        tenantID: context.tenantID
-      });
-      return { allowed: typeof result2 === "boolean" ? result2 : true };
-    }
-    return { allowed: true };
-  }
-  if (!accessRule) {
-    if (!context.user) {
-      return { allowed: false };
-    }
-    const userRole = context.user.role;
-    if (userRole === "super_admin" || userRole === "admin") {
-      return { allowed: true };
-    }
-    return { allowed: false };
-  }
-  const result = await evaluateAccess(accessRule, {
-    req: context.req,
-    user: context.user,
-    tenantID: context.tenantID
-  });
-  if (typeof result === "boolean") {
-    return { allowed: result };
-  }
-  return { allowed: true };
-}
-function resolveMediaUrl(url, origin) {
-  if (!url) return null;
-  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("blob:") || url.startsWith("data:")) return url;
-  const base = (process.env.KYRO_BASE_URL || origin || "http://localhost:4321").replace(/\/+$/, "");
-  return `${base}${url.startsWith("/") ? "" : "/"}${url}`;
-}
-function processMediaDoc(doc, origin) {
-  if (!doc) return doc;
-  if (doc.url) doc.url = resolveMediaUrl(doc.url, origin);
-  if (doc.thumbnailUrl) doc.thumbnailUrl = resolveMediaUrl(doc.thumbnailUrl, origin);
-  return doc;
-}
-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":
-      return GraphQLString;
-    case "upload": {
-      const uploadField = field;
-      if (isInputType) {
-        return uploadField.hasMany ? new GraphQLList(GraphQLString) : GraphQLString;
-      }
-      if (uploadField.relationTo && collectionTypes?.[uploadField.relationTo]) {
-        const refType = collectionTypes[uploadField.relationTo];
-        return uploadField.hasMany ? new GraphQLList(refType) : refType;
-      }
-      return GraphQLJSON;
-    }
-    case "image": {
-      if (isInputType) return GraphQLString;
-      const imageField = field;
-      if (imageField.relationTo && collectionTypes?.[imageField.relationTo]) {
-        return collectionTypes[imageField.relationTo];
-      }
-      return GraphQLJSON;
-    }
-    case "number":
-      return field.integer ? GraphQLInt : GraphQLFloat;
-    case "checkbox":
-      return GraphQLBoolean;
-    case "json":
-    case "richtext":
-    case "blocks":
-    case "tabs":
-      return isInputType ? GraphQLJSON : GraphQLJSON;
-    case "relationship":
-      if (typeof field.relationTo === "string") {
-        if (isInputType) {
-          return field.hasMany ? new GraphQLList(GraphQLString) : GraphQLString;
-        }
-        if (collectionTypes?.[field.relationTo]) {
-          return field.hasMany ? new GraphQLList(collectionTypes[field.relationTo]) : collectionTypes[field.relationTo];
-        }
-        const relatedCollection = registry.getCollection(field.relationTo);
-        if (relatedCollection) {
-          return new GraphQLObjectType({
-            name: `${toPascal(field.relationTo)}Ref`,
-            fields: () => ({
-              id: { type: GraphQLString },
-              ...buildFieldsFromCollection(relatedCollection, registry, collectionTypes)
-            })
-          });
-        }
-      }
-      return GraphQLString;
-    case "array":
-      return new GraphQLList(GraphQLString);
-    case "group":
-      return isInputType ? GraphQLJSON : GraphQLJSON;
-    default:
-      return GraphQLString;
-  }
-}
-function buildFieldsFromCollection(config, registry, collectionTypes) {
-  const fields = {};
-  for (const field of config.fields) {
-    if (field.name && field.admin?.hidden !== true) {
-      const fieldConfig = buildFieldConfig(field, registry, collectionTypes);
-      if (fieldConfig) {
-        fields[field.name] = fieldConfig;
-      }
-    }
-  }
-  return fields;
-}
-function buildFieldConfig(field, registry, collectionTypes) {
-  if (!field.name) return null;
-  const deprecationReason = field.deprecated || void 0;
-  if (field.type === "upload") {
-    const gqlType2 = fieldToGraphQLType(field, registry, collectionTypes, false);
-    const uploadField = field;
-    return {
-      type: field.required ? new GraphQLNonNull(gqlType2) : gqlType2,
-      description: field.admin?.description || field.label,
-      deprecationReason,
-      resolve: async (source, args, ctx) => {
-        const loader = ctx?.relationLoader;
-        const value = source?.[uploadField.name];
-        const origin = ctx?.req?.url ? new URL(ctx.req.url).origin : void 0;
-        if (!value) return null;
-        if (uploadField.hasMany) {
-          const items = Array.isArray(value) ? value : [];
-          return Promise.all(items.map(async (item) => {
-            const id2 = typeof item === "string" ? item : item?.id;
-            if (!id2) return processMediaDoc(item, origin);
-            if (typeof item === "object" && item?.url) return processMediaDoc(item, origin);
-            if (loader) {
-              const cached = loader.resolveOne(uploadField.relationTo, id2);
-              if (cached) return processMediaDoc(cached, origin);
-              const loaded = await loader.load(uploadField.relationTo, id2);
-              if (loaded) return processMediaDoc(loaded, origin);
-            }
-            return { id: id2 };
-          }));
-        }
-        const id = typeof value === "string" ? value : value?.id;
-        if (!id) return processMediaDoc(value, origin);
-        if (typeof value === "object" && value?.url) return processMediaDoc(value, origin);
-        if (loader) {
-          const cached = loader.resolveOne(uploadField.relationTo, id);
-          if (cached) return processMediaDoc(cached, origin);
-          const loaded = await loader.load(uploadField.relationTo, id);
-          if (loaded) return processMediaDoc(loaded, origin);
-        }
-        return { id };
-      }
-    };
-  }
-  if (field.type === "relationship" && !field.hasMany) {
-    const gqlType2 = fieldToGraphQLType(field, registry, collectionTypes, false);
-    return {
-      type: field.required ? new GraphQLNonNull(gqlType2) : gqlType2,
-      description: field.admin?.description || field.label,
-      deprecationReason,
-      resolve: async (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;
-          const loaded = await loader.load(relField.relationTo, id);
-          if (loaded) return loaded;
-        }
-        return { id };
-      }
-    };
-  }
-  if (field.type === "relationship" && field.hasMany) {
-    const gqlType2 = fieldToGraphQLType(field, registry, collectionTypes, false);
-    return {
-      type: gqlType2,
-      description: field.admin?.description || field.label,
-      deprecationReason,
-      resolve: async (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 {
-              const loaded = await loader.load(relField.relationTo, id);
-              results.push(loaded || { id });
-            }
-          }
-          return results;
-        }
-        return ids.map((id) => ({ id }));
-      }
-    };
-  }
-  const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false);
-  return {
-    type: field.required ? new GraphQLNonNull(gqlType) : gqlType,
-    description: field.admin?.description || field.label,
-    deprecationReason
-  };
-}
-function buildGraphQLSchema(options) {
-  const { registry, db, user, req, tenantID, apiKey, 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 GraphQLObjectType({
-      name: toPascal(toSingular(collection.slug)),
-      fields: () => ({
-        id: { type: GraphQLString },
-        ...buildFieldsFromCollection(collection, registry, collectionTypes),
-        ...collection.timestamps ? {
-          createdAt: { type: GraphQLString },
-          updatedAt: { type: GraphQLString }
-        } : {},
-        ...collection.tenantScoped ? {
-          tenantID: { type: 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 GraphQLInputObjectType({
-      name: `${toPascal(toSingular(collection.slug))}Input`,
-      fields: () => inputFields
-    });
-  }
-  const globalTypes = {};
-  const globalInputTypes = {};
-  for (const global of globals) {
-    globalTypes[global.slug] = new GraphQLObjectType({
-      name: `${toPascal(global.slug)}Global`,
-      fields: () => ({
-        id: { type: GraphQLString },
-        ...buildFieldsFromCollection(
-          { slug: global.slug, fields: global.fields },
-          registry,
-          collectionTypes
-        )
-      })
-    });
-    globalInputTypes[global.slug] = new GraphQLInputObjectType({
-      name: `${toPascal(global.slug)}GlobalInput`,
-      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 queryFields = {};
-  for (const collection of collections) {
-    const type = collectionTypes[collection.slug];
-    if (!type) continue;
-    queryFields[toCamel(collection.slug)] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(toSingular(collection.slug))}FindResult`,
-        fields: {
-          docs: { type: new GraphQLList(type) },
-          totalDocs: { type: GraphQLInt },
-          page: { type: GraphQLInt },
-          totalPages: { type: GraphQLInt },
-          hasNextPage: { type: GraphQLBoolean },
-          hasPrevPage: { type: GraphQLBoolean }
-        }
-      }),
-      args: {
-        where: { type: GraphQLString },
-        sort: { type: GraphQLString },
-        limit: { type: GraphQLInt },
-        page: { type: GraphQLInt },
-        draft: { type: GraphQLBoolean }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGraphQLAccess(collection, "read", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        let where = {};
-        if (args.where) {
-          try {
-            where = JSON.parse(args.where);
-          } catch {
-          }
-        }
-        if (access.extraWhere) {
-          where = { ...where, ...access.extraWhere };
-        }
-        const isDraft = args.draft ?? !!context.user;
-        return db.find({
-          collection: collection.slug,
-          where,
-          sort: args.sort,
-          limit: args.limit || 10,
-          page: args.page || 1,
-          tenantID: context.tenantID,
-          draft: isDraft
-        });
-      }
-    };
-    queryFields[toCamel(toSingular(collection.slug))] = {
-      type,
-      args: {
-        id: { type: GraphQLString },
-        slug: { type: GraphQLString },
-        draft: { type: GraphQLBoolean }
-      },
-      resolve: async (_, args, context) => {
-        if (!args.id && !args.slug) {
-          throw new Error("Either id or slug is required");
-        }
-        const access = await checkGraphQLAccess(collection, "read", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        const isDraft = args.draft ?? !!context.user;
-        if (args.id) {
-          return db.findByID({
-            collection: collection.slug,
-            id: args.id,
-            tenantID: context.tenantID,
-            draft: isDraft
-          });
-        }
-        const result = await db.find({
-          collection: collection.slug,
-          where: { slug: { equals: args.slug } },
-          limit: 1,
-          page: 1,
-          tenantID: context.tenantID,
-          draft: isDraft
-        });
-        return result.docs?.[0] || null;
-      }
-    };
-    queryFields[`count${toPascal(collection.slug)}`] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(toSingular(collection.slug))}Count`,
-        fields: {
-          totalDocs: { type: GraphQLInt }
-        }
-      }),
-      args: {
-        where: { type: GraphQLString }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGraphQLAccess(collection, "read", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          return { totalDocs: 0 };
-        }
-        let where = {};
-        if (args.where) {
-          try {
-            where = JSON.parse(args.where);
-          } catch {
-          }
-        }
-        const count = await db.count({
-          collection: collection.slug,
-          where,
-          tenantID: context.tenantID
-        });
-        return { totalDocs: count };
-      }
-    };
-  }
-  for (const global of globals) {
-    const type = globalTypes[global.slug];
-    if (!type) continue;
-    queryFields[toCamel(toSingular(global.slug))] = {
-      type,
-      resolve: async (_, args, context) => {
-        const access = await checkGlobalAccess(global, "read", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied: cannot read global");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        return db.findOne({
-          collection: `_globals_${global.slug}`,
-          where: {},
-          tenantID: context.tenantID
-        });
-      }
-    };
-  }
-  const Query = new 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${toPascal(toSingular(collection.slug))}`] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(toSingular(collection.slug))}CreateResult`,
-        fields: {
-          doc: { type },
-          message: { type: GraphQLString }
-        }
-      }),
-      args: {
-        data: { type: new GraphQLNonNull(inputType) }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGraphQLAccess(collection, "create", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied: cannot create");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        const schema = registry.getCreateZodSchema(collection.slug);
-        const validated = schema.parse(args.data);
-        const doc = await db.create({
-          collection: collection.slug,
-          data: validated,
-          tenantID: context.tenantID
-        });
-        return { doc, message: "Created successfully" };
-      }
-    };
-    mutationFields[`update${toPascal(toSingular(collection.slug))}`] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(toSingular(collection.slug))}UpdateResult`,
-        fields: {
-          doc: { type },
-          message: { type: GraphQLString }
-        }
-      }),
-      args: {
-        id: { type: new GraphQLNonNull(GraphQLString) },
-        data: { type: new GraphQLNonNull(inputType) },
-        baseUpdatedAt: { type: GraphQLString }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGraphQLAccess(collection, "update", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied: cannot update");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        if (args.baseUpdatedAt) {
-          const originalDoc = await db.findByID({
-            collection: collection.slug,
-            id: args.id,
-            tenantID: context.tenantID,
-            draft: true
-          });
-          if (originalDoc && originalDoc.updatedAt && args.baseUpdatedAt !== originalDoc.updatedAt) {
-            throw new Error(`Revision conflict: document has changed since ${args.baseUpdatedAt}. Current updatedAt: ${originalDoc.updatedAt}`);
-          }
-        }
-        const schema = registry.getUpdateZodSchema(collection.slug);
-        const validated = schema.parse(args.data);
-        const doc = await db.update({
-          collection: collection.slug,
-          id: args.id,
-          data: validated,
-          tenantID: context.tenantID
-        });
-        return { doc, message: "Updated successfully" };
-      }
-    };
-    mutationFields[`delete${toPascal(toSingular(collection.slug))}`] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(toSingular(collection.slug))}DeleteResult`,
-        fields: {
-          doc: { type },
-          message: { type: GraphQLString }
-        }
-      }),
-      args: {
-        id: { type: new GraphQLNonNull(GraphQLString) }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGraphQLAccess(collection, "delete", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied: cannot delete");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        const doc = await db.delete({
-          collection: collection.slug,
-          id: args.id,
-          tenantID: context.tenantID
-        });
-        return { doc, message: "Deleted successfully" };
-      }
-    };
-  }
-  for (const global of globals) {
-    const inputType = globalInputTypes[global.slug];
-    if (!inputType) continue;
-    mutationFields[`update${toPascal(global.slug)}`] = {
-      type: new GraphQLObjectType({
-        name: `${toPascal(global.slug)}UpdateResult`,
-        fields: {
-          doc: { type: globalTypes[global.slug] || GraphQLString },
-          message: { type: GraphQLString }
-        }
-      }),
-      args: {
-        data: { type: new GraphQLNonNull(inputType) }
-      },
-      resolve: async (_, args, context) => {
-        const access = await checkGlobalAccess(global, "update", {
-          user: context.user,
-          req: context.req,
-          tenantID: context.tenantID,
-          apiKey: context.apiKey
-        });
-        if (!access.allowed) {
-          throw new Error("Access denied: cannot update global");
-        }
-        if (context.tenantID) {
-          db.setTenantContext({ tenantId: context.tenantID, userId: context.user?.id ?? "", role: context.user?.role, isSuperAdmin: context.user?.role === "super_admin" });
-        }
-        const doc = await db.findOne({
-          collection: `_globals_${global.slug}`,
-          where: {},
-          tenantID: context.tenantID
-        });
-        let result;
-        if (doc) {
-          result = await db.update({
-            collection: `_globals_${global.slug}`,
-            id: doc.id,
-            data: args.data,
-            tenantID: context.tenantID
-          });
-        } else {
-          result = await db.create({
-            collection: `_globals_${global.slug}`,
-            data: args.data,
-            tenantID: context.tenantID
-          });
-        }
-        return { doc: result, message: "Updated successfully" };
-      }
-    };
-  }
-  const Mutation = new GraphQLObjectType({
-    name: "Mutation",
-    fields: mutationFields
-  });
-  return new GraphQLSchema({
-    query: Query,
-    mutation: Mutation
-  });
-}
-function createGraphQLSchema(registry, db, options) {
-  return buildGraphQLSchema({
-    registry,
-    db,
-    user: options?.user,
-    req: options?.req,
-    tenantID: options?.tenantID,
-    apiKey: options?.apiKey
-  });
-}
-
-export { RelationLoader, buildGraphQLSchema, createGraphQLSchema, depthLimit };
-//# sourceMappingURL=chunk-5RPRLTTN.js.map
-//# sourceMappingURL=chunk-5RPRLTTN.js.map