@kyro-cms/core 0.9.5 → 0.9.6

package/dist/chunk-PONTBXR5.js

@@ -0,0 +1,842 @@
+import { checkCollectionAccess, checkGlobalAccess } from './chunk-NZEUU7QB.js';
+import { GraphQLObjectType, GraphQLString, GraphQLInputObjectType, GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLSchema, printSchema, GraphQLUnionType, GraphQLFloat, GraphQLEnumType } from 'graphql';
+export { printSchema } from 'graphql';
+
+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;
+}
+async function checkAccess(config, operation, context) {
+  const result = await 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 checkGlobalAccess(config, operation, context);
+  if (!result.allowed) {
+    throw gqlError(result.error || "Access denied", "FORBIDDEN");
+  }
+}
+function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false, loader) {
+  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 GraphQLString;
+    case "number":
+      return field.integer ? GraphQLInt : GraphQLFloat;
+    case "checkbox":
+      return GraphQLBoolean;
+    case "json":
+    case "richtext":
+      return GraphQLString;
+    case "relationship":
+      if (typeof field.relationTo === "string") {
+        if (isInputType) {
+          if (field.hasMany) {
+            return new GraphQLList(GraphQLString);
+          }
+          return GraphQLString;
+        }
+        if (collectionTypes?.[field.relationTo]) {
+          const refType = collectionTypes[field.relationTo];
+          if (field.hasMany) {
+            return new GraphQLList(refType);
+          }
+          return refType;
+        }
+        const relatedCollection = registry.getCollection(field.relationTo);
+        if (relatedCollection) {
+          const refName = `${field.relationTo.replace(/-/g, "_")}_ref`;
+          const refType = new GraphQLObjectType({
+            name: refName,
+            fields: () => ({
+              id: { type: GraphQLString },
+              ...buildFieldsFromCollection(relatedCollection, registry, collectionTypes)
+            })
+          });
+          if (collectionTypes) {
+            collectionTypes[field.relationTo] = refType;
+          }
+          if (field.hasMany) {
+            return new GraphQLList(refType);
+          }
+          return refType;
+        }
+      }
+      return field.hasMany ? new GraphQLList(GraphQLString) : GraphQLString;
+    case "array": {
+      if (isInputType) return 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, loader);
+        return new GraphQLList(itemType);
+      }
+      return new GraphQLList(GraphQLString);
+    }
+    case "group": {
+      if (isInputType) return GraphQLString;
+      const groupFields = field.fields;
+      if (groupFields && groupFields.length > 0) {
+        const groupTypeName = `${field.name?.replace(/-/g, "_") || "group"}_group`;
+        return fieldsToGraphQLObjectType(groupTypeName, groupFields, registry, collectionTypes, loader);
+      }
+      return GraphQLString;
+    }
+    case "blocks": {
+      if (isInputType) return GraphQLString;
+      const blocks = field.blocks;
+      if (blocks && blocks.length > 0) {
+        const blockTypes = [];
+        for (const block of blocks) {
+          const blockTypeName = `Block_${block.slug.replace(/-/g, "_")}`;
+          const bType = new GraphQLObjectType({
+            name: blockTypeName,
+            fields: () => {
+              const out = {
+                blockType: { type: new GraphQLNonNull(GraphQLString) },
+                id: { type: GraphQLString }
+              };
+              if (block.fields) {
+                for (const bf of block.fields) {
+                  if (!bf.name) continue;
+                  const bfConfig = buildFieldConfig(bf, registry, collectionTypes, loader);
+                  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 GraphQLUnionType({
+            name: unionName,
+            types: blockTypes,
+            resolveType(value) {
+              const blockName = `Block_${(value?.blockType || "").replace(/-/g, "_")}`;
+              const blockType = blockTypes.find(
+                (bt) => bt.name === blockName
+              );
+              return blockType?.name || void 0;
+            }
+          });
+        }
+      }
+      return new GraphQLList(GraphQLString);
+    }
+    case "row":
+    case "collapsible":
+    case "tabs":
+      return GraphQLString;
+    default:
+      return GraphQLString;
+  }
+}
+function buildFieldsFromCollection(config, registry, collectionTypes, loader) {
+  const fields = {};
+  for (const field of config.fields) {
+    if (field.name && field.admin?.hidden !== true) {
+      const fc = buildFieldConfig(field, registry, collectionTypes, loader);
+      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 GraphQLEnumType({
+    name: `${config.slug.replace(/-/g, "_")}_sort`,
+    values: sortFields
+  });
+}
+function buildFieldFilterType(field, namePrefix) {
+  const safeName = `${namePrefix}_${field.name?.replace(/-/g, "_") || "field"}_filter`;
+  const stringOps = {
+    equals: { type: GraphQLString },
+    not_equals: { type: GraphQLString },
+    contains: { type: GraphQLString },
+    not_contains: { type: GraphQLString },
+    in: { type: new GraphQLList(GraphQLString) },
+    not_in: { type: new GraphQLList(GraphQLString) },
+    exists: { type: GraphQLBoolean }
+  };
+  const numberOps = {
+    equals: { type: GraphQLFloat },
+    not_equals: { type: GraphQLFloat },
+    greater_than: { type: GraphQLFloat },
+    less_than: { type: GraphQLFloat },
+    greater_than_equal: { type: GraphQLFloat },
+    less_than_equal: { type: GraphQLFloat },
+    in: { type: new GraphQLList(GraphQLFloat) },
+    not_in: { type: new GraphQLList(GraphQLFloat) },
+    exists: { type: GraphQLBoolean }
+  };
+  const boolOps = {
+    equals: { type: GraphQLBoolean },
+    exists: { type: GraphQLBoolean }
+  };
+  const dateOps = {
+    equals: { type: GraphQLString },
+    not_equals: { type: GraphQLString },
+    greater_than: { type: GraphQLString },
+    less_than: { type: GraphQLString },
+    exists: { type: GraphQLBoolean }
+  };
+  const relationOps = {
+    equals: { type: GraphQLString },
+    not_equals: { type: GraphQLString },
+    in: { type: new GraphQLList(GraphQLString) },
+    not_in: { type: new GraphQLList(GraphQLString) },
+    exists: { type: GraphQLBoolean }
+  };
+  const jsonOps = {
+    exists: { type: 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: GraphQLBoolean } };
+  }
+  return new GraphQLInputObjectType({
+    name: safeName,
+    fields: ops
+  });
+}
+function buildCollectionFilterType(config, namePrefix) {
+  const fields = {
+    AND: { type: new GraphQLList(GraphQLString) },
+    OR: { type: new GraphQLList(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 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 fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, loader) {
+  return new 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, loader);
+              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, loader);
+                  if (fc) out[sf.name] = fc;
+                }
+              }
+            }
+          }
+        } else {
+          const fc = buildFieldConfig(field, registry, collectionTypes, loader);
+          if (fc) out[field.name] = fc;
+        }
+      }
+      return out;
+    }
+  });
+}
+function buildFieldConfig(field, registry, collectionTypes, loader) {
+  if (!field.name) return null;
+  if (field.type === "relationship" && !field.hasMany) {
+    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false, loader);
+    return {
+      type: field.required ? new GraphQLNonNull(gqlType) : gqlType,
+      description: field.admin?.description || field.label,
+      resolve: (source) => {
+        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, loader);
+    return {
+      type: gqlType,
+      description: field.admin?.description || field.label,
+      resolve: (source) => {
+        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 GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false, loader)) : fieldToGraphQLType(field, registry, collectionTypes, false, loader),
+    description: field.admin?.description || field.label
+  };
+}
+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 relationLoader = new RelationLoader({ db, tenantID, user });
+  const collectionTypes = {};
+  const collectionInputTypes = {};
+  for (const collection of collections) {
+    collectionTypes[collection.slug] = new GraphQLObjectType({
+      name: `${collection.slug.replace(/-/g, "_")}_type`,
+      fields: () => ({
+        id: { type: GraphQLString },
+        ...buildFieldsFromCollection(collection, registry, collectionTypes, relationLoader),
+        ...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: `${collection.slug.replace(/-/g, "_")}_input`,
+      fields: () => inputFields
+    });
+  }
+  const globalTypes = {};
+  const globalInputTypes = {};
+  for (const global of globals) {
+    globalTypes[global.slug] = new GraphQLObjectType({
+      name: `${global.slug.replace(/-/g, "_")}_global_type`,
+      fields: () => ({
+        id: { type: GraphQLString },
+        ...buildFieldsFromCollection(
+          { slug: global.slug, fields: global.fields },
+          registry,
+          collectionTypes,
+          relationLoader
+        )
+      })
+    });
+    globalInputTypes[global.slug] = new GraphQLInputObjectType({
+      name: `${global.slug.replace(/-/g, "_")}_global_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 queryFields = {};
+  for (const collection of collections) {
+    const type = collectionTypes[collection.slug];
+    if (!type) continue;
+    const filterType = buildCollectionFilterType(collection, collection.slug.replace(/-/g, "_"));
+    const sortEnum = buildSortEnum(collection);
+    queryFields[`${collection.slug.replace(/-/g, "_")}Find`] = {
+      type: new GraphQLObjectType({
+        name: `${collection.slug.replace(/-/g, "_")}_find_result`,
+        fields: {
+          docs: { type: new GraphQLList(type) },
+          totalDocs: { type: GraphQLInt },
+          page: { type: GraphQLInt },
+          totalPages: { type: GraphQLInt },
+          hasNextPage: { type: GraphQLBoolean },
+          hasPrevPage: { type: GraphQLBoolean }
+        }
+      }),
+      args: {
+        where: { type: filterType },
+        sort: { type: sortEnum || GraphQLString },
+        limit: { type: GraphQLInt },
+        page: { type: GraphQLInt },
+        draft: { type: GraphQLBoolean }
+      },
+      resolve: async (_, args, ctx) => {
+        const extraWhere = await checkAccess(collection, "read", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.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 ?? !!user;
+        return RelationLoader.withBatch(relationLoader, async () => {
+          return db.find({
+            collection: collection.slug,
+            where,
+            sort: args.sort,
+            limit: args.limit || 10,
+            page: args.page || 1,
+            tenantID,
+            draft: isDraft
+          });
+        });
+      }
+    };
+    queryFields[`${collection.slug.replace(/-/g, "_")}FindByID`] = {
+      type,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLString) },
+        draft: { type: GraphQLBoolean }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkAccess(collection, "read", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        }
+        const isDraft = args.draft ?? !!user;
+        return RelationLoader.withBatch(relationLoader, async () => {
+          const doc = await db.findByID({
+            collection: collection.slug,
+            id: args.id,
+            tenantID,
+            draft: isDraft
+          });
+          return doc;
+        });
+      }
+    };
+    queryFields[`${collection.slug.replace(/-/g, "_")}Count`] = {
+      type: new GraphQLObjectType({
+        name: `${collection.slug.replace(/-/g, "_")}_count`,
+        fields: {
+          totalDocs: { type: GraphQLInt }
+        }
+      }),
+      args: {
+        where: { type: GraphQLString }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkAccess(collection, "read", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        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 db.count({
+          collection: collection.slug,
+          where,
+          tenantID
+        });
+        return { totalDocs: count };
+      }
+    };
+  }
+  for (const global of globals) {
+    const type = globalTypes[global.slug];
+    if (!type) continue;
+    queryFields[`${global.slug.replace(/-/g, "_")}Get`] = {
+      type,
+      resolve: async () => {
+        await checkGqlGlobalAccess(global, "read", {
+          user,
+          req,
+          tenantID
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        }
+        return db.findOne({
+          collection: `_globals_${global.slug}`,
+          where: {},
+          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[`${collection.slug.replace(/-/g, "_")}Create`] = {
+      type: new GraphQLObjectType({
+        name: `${collection.slug.replace(/-/g, "_")}_create_result`,
+        fields: {
+          doc: { type },
+          message: { type: GraphQLString }
+        }
+      }),
+      args: {
+        data: { type: new GraphQLNonNull(inputType) },
+        draft: { type: GraphQLBoolean }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkAccess(collection, "create", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: 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
+        });
+        return { doc, message: "Created successfully" };
+      }
+    };
+    mutationFields[`${collection.slug.replace(/-/g, "_")}Update`] = {
+      type: new GraphQLObjectType({
+        name: `${collection.slug.replace(/-/g, "_")}_update_result`,
+        fields: {
+          doc: { type },
+          message: { type: GraphQLString }
+        }
+      }),
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLString) },
+        data: { type: new GraphQLNonNull(inputType) },
+        baseUpdatedAt: { type: GraphQLString },
+        draft: { type: GraphQLBoolean }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkAccess(collection, "update", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        }
+        if (args.baseUpdatedAt) {
+          const originalDoc = await db.findByID({
+            collection: collection.slug,
+            id: args.id,
+            tenantID,
+            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 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
+        });
+        return { doc, message: "Updated successfully" };
+      }
+    };
+    mutationFields[`${collection.slug.replace(/-/g, "_")}Delete`] = {
+      type: new GraphQLObjectType({
+        name: `${collection.slug.replace(/-/g, "_")}_delete_result`,
+        fields: {
+          doc: { type },
+          message: { type: GraphQLString }
+        }
+      }),
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLString) }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkAccess(collection, "delete", {
+          user,
+          req,
+          tenantID,
+          apiKey
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        }
+        const doc = await db.delete({
+          collection: collection.slug,
+          id: args.id,
+          tenantID
+        });
+        return { doc, message: "Deleted successfully" };
+      }
+    };
+  }
+  for (const global of globals) {
+    const inputType = globalInputTypes[global.slug];
+    if (!inputType) continue;
+    mutationFields[`${global.slug.replace(/-/g, "_")}Update`] = {
+      type: new GraphQLObjectType({
+        name: `${global.slug.replace(/-/g, "_")}_update_result`,
+        fields: {
+          doc: { type: globalTypes[global.slug] || GraphQLString },
+          message: { type: GraphQLString }
+        }
+      }),
+      args: {
+        data: { type: new GraphQLNonNull(inputType) }
+      },
+      resolve: async (_, args, ctx) => {
+        await checkGqlGlobalAccess(global, "update", {
+          user,
+          req,
+          tenantID
+        });
+        if (tenantID) {
+          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        }
+        const doc = await db.findOne({
+          collection: `_globals_${global.slug}`,
+          where: {},
+          tenantID
+        });
+        let result;
+        if (doc) {
+          result = await db.update({
+            collection: `_globals_${global.slug}`,
+            id: doc.id,
+            data: args.data,
+            tenantID
+          });
+        } else {
+          result = await db.create({
+            collection: `_globals_${global.slug}`,
+            data: args.data,
+            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) {
+  const schema = buildGraphQLSchema({
+    registry,
+    db,
+    user: options?.user,
+    req: options?.req,
+    tenantID: options?.tenantID,
+    apiKey: options?.apiKey
+  });
+  return Object.assign(schema, { sdl: printSchema(schema) });
+}
+
+export { buildGraphQLSchema, createGraphQLSchema };
+//# sourceMappingURL=chunk-PONTBXR5.js.map
+//# sourceMappingURL=chunk-PONTBXR5.js.map