@kyro-cms/core 0.9.6 → 0.9.8

package/dist/{chunk-PONTBXR5.js → chunk-6DURKQ6W.js}

@@ -1,7 +1,22 @@
-import { checkCollectionAccess, checkGlobalAccess } from './chunk-NZEUU7QB.js';
-import { GraphQLObjectType, GraphQLString, GraphQLInputObjectType, GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLSchema, printSchema, GraphQLUnionType, GraphQLFloat, GraphQLEnumType } from 'graphql';
+import { checkCollectionAccess, checkGlobalAccess } from './chunk-2GXALYKV.js';
+import { GraphQLError, GraphQLObjectType, GraphQLString, GraphQLNonNull, GraphQLInputObjectType, GraphQLBoolean, GraphQLInt, GraphQLList, GraphQLDirective, DirectiveLocation, printSchema, GraphQLSchema, GraphQLUnionType, GraphQLFloat, GraphQLEnumType } from 'graphql';
 export { printSchema } from '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;
@@ -68,6 +83,24 @@ function gqlError(message, code) {
   err.extensions = { code };
   return err;
 }
+function depthLimit(maxDepth) {
+  return (validationContext) => {
+    let depth = 0;
+    return {
+      Field() {
+        depth++;
+        if (depth > maxDepth) {
+          validationContext.reportError(
+            new GraphQLError(`Query exceeds max depth of ${maxDepth}`)
+          );
+        }
+      },
+      leaveField() {
+        depth--;
+      }
+    };
+  };
+}
 async function checkAccess(config, operation, context) {
   const result = await checkCollectionAccess(config, operation, context);
   if (!result.allowed) {
@@ -81,7 +114,7 @@ async function checkGqlGlobalAccess(config, operation, context) {
     throw gqlError(result.error || "Access denied", "FORBIDDEN");
   }
 }
-function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false, loader) {
+function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false) {
   switch (field.type) {
     case "text":
     case "email":
@@ -119,9 +152,8 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
         }
         const relatedCollection = registry.getCollection(field.relationTo);
         if (relatedCollection) {
-          const refName = `${field.relationTo.replace(/-/g, "_")}_ref`;
           const refType = new GraphQLObjectType({
-            name: refName,
+            name: toPascalSingular(field.relationTo),
             fields: () => ({
               id: { type: GraphQLString },
               ...buildFieldsFromCollection(relatedCollection, registry, collectionTypes)
@@ -138,21 +170,35 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
       }
       return field.hasMany ? new GraphQLList(GraphQLString) : GraphQLString;
     case "array": {
-      if (isInputType) return GraphQLString;
+      if (isInputType) {
+        const arrFields2 = field.fields;
+        if (arrFields2 && arrFields2.length > 0) {
+          const arrTypeName = `${field.name?.replace(/-/g, "_") || "array"}_input_item`;
+          return new GraphQLList(fieldsToGraphQLInputObjectType(arrTypeName, arrFields2, registry));
+        }
+        return new GraphQLList(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);
+        const itemType = fieldsToGraphQLObjectType(arrTypeName, arrFields, registry, collectionTypes);
         return new GraphQLList(itemType);
       }
       return new GraphQLList(GraphQLString);
     }
     case "group": {
-      if (isInputType) return GraphQLString;
+      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 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 fieldsToGraphQLObjectType(groupTypeName, groupFields, registry, collectionTypes);
       }
       return GraphQLString;
     }
@@ -162,7 +208,7 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
       if (blocks && blocks.length > 0) {
         const blockTypes = [];
         for (const block of blocks) {
-          const blockTypeName = `Block_${block.slug.replace(/-/g, "_")}`;
+          const blockTypeName = `Block${toPascalCase(block.slug)}`;
           const bType = new GraphQLObjectType({
             name: blockTypeName,
             fields: () => {
@@ -173,7 +219,7 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
               if (block.fields) {
                 for (const bf of block.fields) {
                   if (!bf.name) continue;
-                  const bfConfig = buildFieldConfig(bf, registry, collectionTypes, loader);
+                  const bfConfig = buildFieldConfig(bf, registry, collectionTypes);
                   if (bfConfig) out[bf.name] = bfConfig;
                 }
               }
@@ -188,7 +234,7 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
             name: unionName,
             types: blockTypes,
             resolveType(value) {
-              const blockName = `Block_${(value?.blockType || "").replace(/-/g, "_")}`;
+              const blockName = `Block${value?.blockType ? toPascalCase(value.blockType) : ""}`;
               const blockType = blockTypes.find(
                 (bt) => bt.name === blockName
               );
@@ -207,11 +253,11 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
       return GraphQLString;
   }
 }
-function buildFieldsFromCollection(config, registry, collectionTypes, loader) {
+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, loader);
+      const fc = buildFieldConfig(field, registry, collectionTypes);
       if (fc) fields[field.name] = fc;
     }
   }
@@ -231,7 +277,7 @@ function buildSortEnum(config) {
     }
   }
   return new GraphQLEnumType({
-    name: `${config.slug.replace(/-/g, "_")}_sort`,
+    name: `${toPascalSingular(config.slug)}Sort`,
     values: sortFields
   });
 }
@@ -329,7 +375,7 @@ function buildCollectionFilterType(config, namePrefix) {
     }
   }
   return new GraphQLInputObjectType({
-    name: `${namePrefix}_filter`,
+    name: `${namePrefix}Filter`,
     fields
   });
 }
@@ -342,7 +388,42 @@ function translateFilter(filter) {
   }
   return result;
 }
-function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, loader) {
+function fieldsToGraphQLInputObjectType(name, fields, registry) {
+  return new 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 GraphQLObjectType({
     name,
     fields: () => {
@@ -354,7 +435,7 @@ function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, load
           if (subFields) {
             for (const sf of subFields) {
               if (!sf.name) continue;
-              const fc = buildFieldConfig(sf, registry, collectionTypes, loader);
+              const fc = buildFieldConfig(sf, registry, collectionTypes);
               if (fc) out[sf.name] = fc;
             }
           }
@@ -365,14 +446,14 @@ function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, load
               if (tab.fields) {
                 for (const sf of tab.fields) {
                   if (!sf.name) continue;
-                  const fc = buildFieldConfig(sf, registry, collectionTypes, loader);
+                  const fc = buildFieldConfig(sf, registry, collectionTypes);
                   if (fc) out[sf.name] = fc;
                 }
               }
             }
           }
         } else {
-          const fc = buildFieldConfig(field, registry, collectionTypes, loader);
+          const fc = buildFieldConfig(field, registry, collectionTypes);
           if (fc) out[field.name] = fc;
         }
       }
@@ -380,14 +461,17 @@ function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, load
     }
   });
 }
-function buildFieldConfig(field, registry, collectionTypes, loader) {
+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, loader);
+    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false);
     return {
       type: field.required ? new GraphQLNonNull(gqlType) : gqlType,
       description: field.admin?.description || field.label,
-      resolve: (source) => {
+      deprecationReason,
+      resolve: (source, args, ctx) => {
+        const loader = ctx?.relationLoader;
         const relField = field;
         const id = source?.[relField.name];
         if (!id) return null;
@@ -401,11 +485,13 @@ function buildFieldConfig(field, registry, collectionTypes, loader) {
     };
   }
   if (field.type === "relationship" && field.hasMany) {
-    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false, loader);
+    const gqlType = fieldToGraphQLType(field, registry, collectionTypes, false);
     return {
       type: gqlType,
       description: field.admin?.description || field.label,
-      resolve: (source) => {
+      deprecationReason,
+      resolve: (source, args, ctx) => {
+        const loader = ctx?.relationLoader;
         const relField = field;
         const ids = source?.[relField.name] || [];
         if (!ids.length) return [];
@@ -426,27 +512,27 @@ function buildFieldConfig(field, registry, collectionTypes, loader) {
     };
   }
   return {
-    type: field.required ? new GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false, loader)) : fieldToGraphQLType(field, registry, collectionTypes, false, loader),
-    description: field.admin?.description || field.label
+    type: field.required ? new GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false)) : fieldToGraphQLType(field, registry, collectionTypes, false),
+    description: field.admin?.description || field.label,
+    deprecationReason
   };
 }
 function buildGraphQLSchema(options) {
-  const { registry, db, user, req, tenantID, apiKey, settings } = 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 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`,
+      name: toPascalSingular(collection.slug),
       fields: () => ({
-        id: { type: GraphQLString },
-        ...buildFieldsFromCollection(collection, registry, collectionTypes, relationLoader),
+        id: { type: new GraphQLNonNull(GraphQLString) },
+        ...buildFieldsFromCollection(collection, registry, collectionTypes),
         ...collection.timestamps ? {
           createdAt: { type: GraphQLString },
           updatedAt: { type: GraphQLString }
@@ -465,7 +551,7 @@ function buildGraphQLSchema(options) {
       }
     }
     collectionInputTypes[collection.slug] = new GraphQLInputObjectType({
-      name: `${collection.slug.replace(/-/g, "_")}_input`,
+      name: `${toPascalSingular(collection.slug)}Input`,
       fields: () => inputFields
     });
   }
@@ -473,19 +559,18 @@ function buildGraphQLSchema(options) {
   const globalInputTypes = {};
   for (const global of globals) {
     globalTypes[global.slug] = new GraphQLObjectType({
-      name: `${global.slug.replace(/-/g, "_")}_global_type`,
+      name: toPascalCase(global.slug),
       fields: () => ({
         id: { type: GraphQLString },
         ...buildFieldsFromCollection(
           { slug: global.slug, fields: global.fields },
           registry,
-          collectionTypes,
-          relationLoader
+          collectionTypes
         )
       })
     });
     globalInputTypes[global.slug] = new GraphQLInputObjectType({
-      name: `${global.slug.replace(/-/g, "_")}_global_input`,
+      name: `${toPascalCase(global.slug)}Input`,
       fields: () => {
         const inputFields = {};
         for (const field of global.fields) {
@@ -499,15 +584,24 @@ function buildGraphQLSchema(options) {
       }
     });
   }
+  const pageInfoType = new GraphQLObjectType({
+    name: "PageInfo",
+    fields: {
+      hasNextPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+      hasPreviousPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+      startCursor: { type: GraphQLString },
+      endCursor: { type: GraphQLString }
+    }
+  });
   const queryFields = {};
   for (const collection of collections) {
     const type = collectionTypes[collection.slug];
     if (!type) continue;
-    const filterType = buildCollectionFilterType(collection, collection.slug.replace(/-/g, "_"));
+    const filterType = buildCollectionFilterType(collection, toPascalSingular(collection.slug));
     const sortEnum = buildSortEnum(collection);
-    queryFields[`${collection.slug.replace(/-/g, "_")}Find`] = {
+    queryFields[toCamelCase(collection.slug)] = {
       type: new GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_find_result`,
+        name: `${toPascalSingular(collection.slug)}FindResult`,
         fields: {
           docs: { type: new GraphQLList(type) },
           totalDocs: { type: GraphQLInt },
@@ -525,14 +619,15 @@ function buildGraphQLSchema(options) {
         draft: { type: 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,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
         let where = {};
         if (args.where) {
@@ -548,51 +643,52 @@ function buildGraphQLSchema(options) {
         if (extraWhere) {
           where = { ...where, ...extraWhere };
         }
-        const isDraft = args.draft ?? !!user;
-        return RelationLoader.withBatch(relationLoader, async () => {
-          return db.find({
+        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,
+            tenantID: ctxTenant,
             draft: isDraft
           });
         });
       }
     };
-    queryFields[`${collection.slug.replace(/-/g, "_")}FindByID`] = {
+    queryFields[toCamelSingular(collection.slug)] = {
       type,
       args: {
         id: { type: new GraphQLNonNull(GraphQLString) },
         draft: { type: GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
         await checkAccess(collection, "read", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
-        const isDraft = args.draft ?? !!user;
-        return RelationLoader.withBatch(relationLoader, async () => {
-          const doc = await db.findByID({
+        const isDraft = args.draft ?? !!ctxUser;
+        return RelationLoader.withBatch(ctxLoader, async () => {
+          const doc = await ctxDb.findByID({
             collection: collection.slug,
             id: args.id,
-            tenantID,
+            tenantID: ctxTenant,
             draft: isDraft
           });
           return doc;
         });
       }
     };
-    queryFields[`${collection.slug.replace(/-/g, "_")}Count`] = {
+    queryFields[`count${toPascalSingular(collection.slug)}s`] = {
       type: new GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_count`,
+        name: `${toPascalSingular(collection.slug)}Count`,
         fields: {
           totalDocs: { type: GraphQLInt }
         }
@@ -601,11 +697,12 @@ function buildGraphQLSchema(options) {
         where: { type: GraphQLString }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
         await checkAccess(collection, "read", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
         let where = {};
         if (args.where) {
@@ -618,33 +715,129 @@ function buildGraphQLSchema(options) {
             where = translateFilter(args.where);
           }
         }
-        const count = await db.count({
+        const count = await ctxDb.count({
           collection: collection.slug,
           where,
-          tenantID
+          tenantID: ctxTenant
         });
         return { totalDocs: count };
       }
     };
+    const edgeType = new GraphQLObjectType({
+      name: `${toPascalSingular(collection.slug)}Edge`,
+      fields: {
+        node: { type },
+        cursor: { type: new GraphQLNonNull(GraphQLString) }
+      }
+    });
+    const connectionType = new GraphQLObjectType({
+      name: `${toPascalSingular(collection.slug)}Connection`,
+      fields: {
+        edges: { type: new GraphQLList(edgeType) },
+        pageInfo: { type: new GraphQLNonNull(pageInfoType) },
+        totalCount: { type: GraphQLInt }
+      }
+    });
+    queryFields[`${toCamelCase(collection.slug)}Connection`] = {
+      type: connectionType,
+      args: {
+        first: { type: GraphQLInt },
+        after: { type: GraphQLString },
+        last: { type: GraphQLInt },
+        before: { type: GraphQLString },
+        where: { type: filterType },
+        sort: { type: sortEnum || GraphQLString },
+        draft: { type: 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[`${global.slug.replace(/-/g, "_")}Get`] = {
+    queryFields[toCamelCase(global.slug)] = {
       type,
-      resolve: async () => {
+      resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, db: ctxDb } = ctx;
         await checkGqlGlobalAccess(global, "read", {
-          user,
-          req,
-          tenantID
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
-        return db.findOne({
+        return ctxDb.findOne({
           collection: `_globals_${global.slug}`,
           where: {},
-          tenantID
+          tenantID: ctxTenant
         });
       }
     };
@@ -658,9 +851,9 @@ function buildGraphQLSchema(options) {
     const type = collectionTypes[collection.slug];
     const inputType = collectionInputTypes[collection.slug];
     if (!type || !inputType) continue;
-    mutationFields[`${collection.slug.replace(/-/g, "_")}Create`] = {
+    mutationFields[`create${toPascalSingular(collection.slug)}`] = {
       type: new GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_create_result`,
+        name: `${toPascalSingular(collection.slug)}CreateResult`,
         fields: {
           doc: { type },
           message: { type: GraphQLString }
@@ -671,28 +864,38 @@ function buildGraphQLSchema(options) {
         draft: { type: GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
         await checkAccess(collection, "create", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
-        const schema = registry.getCreateZodSchema(collection.slug);
-        const validated = schema.parse(args.data);
-        const doc = await db.create({
+        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
+          tenantID: ctxTenant
         });
         return { doc, message: "Created successfully" };
       }
     };
-    mutationFields[`${collection.slug.replace(/-/g, "_")}Update`] = {
+    mutationFields[`update${toPascalSingular(collection.slug)}`] = {
       type: new GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_update_result`,
+        name: `${toPascalSingular(collection.slug)}UpdateResult`,
         fields: {
           doc: { type },
           message: { type: GraphQLString }
@@ -705,20 +908,21 @@ function buildGraphQLSchema(options) {
         draft: { type: GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
         await checkAccess(collection, "update", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
         if (args.baseUpdatedAt) {
-          const originalDoc = await db.findByID({
+          const originalDoc = await ctxDb.findByID({
             collection: collection.slug,
             id: args.id,
-            tenantID,
+            tenantID: ctxTenant,
             draft: true
           });
           if (originalDoc && originalDoc.updatedAt && args.baseUpdatedAt !== originalDoc.updatedAt) {
@@ -728,20 +932,29 @@ function buildGraphQLSchema(options) {
             );
           }
         }
-        const schema = registry.getUpdateZodSchema(collection.slug);
-        const validated = schema.parse(args.data);
-        const doc = await db.update({
+        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
+          tenantID: ctxTenant
         });
         return { doc, message: "Updated successfully" };
       }
     };
-    mutationFields[`${collection.slug.replace(/-/g, "_")}Delete`] = {
+    mutationFields[`delete${toPascalSingular(collection.slug)}`] = {
       type: new GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_delete_result`,
+        name: `${toPascalSingular(collection.slug)}DeleteResult`,
         fields: {
           doc: { type },
           message: { type: GraphQLString }
@@ -751,19 +964,20 @@ function buildGraphQLSchema(options) {
         id: { type: new GraphQLNonNull(GraphQLString) }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
         await checkAccess(collection, "delete", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
-        const doc = await db.delete({
+        const doc = await ctxDb.delete({
           collection: collection.slug,
           id: args.id,
-          tenantID
+          tenantID: ctxTenant
         });
         return { doc, message: "Deleted successfully" };
       }
@@ -772,9 +986,9 @@ function buildGraphQLSchema(options) {
   for (const global of globals) {
     const inputType = globalInputTypes[global.slug];
     if (!inputType) continue;
-    mutationFields[`${global.slug.replace(/-/g, "_")}Update`] = {
+    mutationFields[`update${toPascalCase(global.slug)}`] = {
       type: new GraphQLObjectType({
-        name: `${global.slug.replace(/-/g, "_")}_update_result`,
+        name: `${toPascalCase(global.slug)}UpdateResult`,
         fields: {
           doc: { type: globalTypes[global.slug] || GraphQLString },
           message: { type: GraphQLString }
@@ -784,32 +998,33 @@ function buildGraphQLSchema(options) {
         data: { type: new GraphQLNonNull(inputType) }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, db: ctxDb } = ctx;
         await checkGqlGlobalAccess(global, "update", {
-          user,
-          req,
-          tenantID
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant
         });
-        if (tenantID) {
-          db.setTenantContext({ tenantId: tenantID, userId: user?.id ?? "", role: user?.role, isSuperAdmin: user?.role === "super_admin" });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
         }
-        const doc = await db.findOne({
+        const doc = await ctxDb.findOne({
           collection: `_globals_${global.slug}`,
           where: {},
-          tenantID
+          tenantID: ctxTenant
         });
         let result;
         if (doc) {
-          result = await db.update({
+          result = await ctxDb.update({
             collection: `_globals_${global.slug}`,
             id: doc.id,
             data: args.data,
-            tenantID
+            tenantID: ctxTenant
           });
         } else {
-          result = await db.create({
+          result = await ctxDb.create({
             collection: `_globals_${global.slug}`,
             data: args.data,
-            tenantID
+            tenantID: ctxTenant
           });
         }
         return { doc: result, message: "Updated successfully" };
@@ -820,23 +1035,38 @@ function buildGraphQLSchema(options) {
     name: "Mutation",
     fields: mutationFields
   });
+  const keyDirective = new GraphQLDirective({
+    name: "key",
+    locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
+    args: {
+      fields: { type: new GraphQLNonNull(GraphQLString) }
+    }
+  });
+  const serviceSdl = printSchema(new GraphQLSchema({
+    query: new GraphQLObjectType({ name: "Query", fields: { ...queryFields } }),
+    mutation: Mutation,
+    directives: [keyDirective]
+  }));
+  queryFields._service = {
+    type: new GraphQLObjectType({
+      name: "_Service",
+      fields: {
+        sdl: { type: GraphQLString }
+      }
+    }),
+    resolve: () => ({ sdl: serviceSdl })
+  };
   return new GraphQLSchema({
     query: Query,
-    mutation: Mutation
+    mutation: Mutation,
+    directives: [keyDirective]
   });
 }
-function createGraphQLSchema(registry, db, options) {
-  const schema = buildGraphQLSchema({
-    registry,
-    db,
-    user: options?.user,
-    req: options?.req,
-    tenantID: options?.tenantID,
-    apiKey: options?.apiKey
-  });
+function createGraphQLSchema(registry, db) {
+  const schema = buildGraphQLSchema({ registry, db });
   return Object.assign(schema, { sdl: printSchema(schema) });
 }
 
-export { buildGraphQLSchema, createGraphQLSchema };
-//# sourceMappingURL=chunk-PONTBXR5.js.map
-//# sourceMappingURL=chunk-PONTBXR5.js.map
+export { RelationLoader, buildGraphQLSchema, createGraphQLSchema, depthLimit };
+//# sourceMappingURL=chunk-6DURKQ6W.js.map
+//# sourceMappingURL=chunk-6DURKQ6W.js.map