@kyro-cms/core 0.9.7 → 0.9.8

package/dist/{chunk-RRKCIAPU.cjs → chunk-PF642V5O.cjs}

@@ -1,8 +1,23 @@
 'use strict';
 
-var chunkFKKQUMXR_cjs = require('./chunk-FKKQUMXR.cjs');
+var chunkKGJRJ7CU_cjs = require('./chunk-KGJRJ7CU.cjs');
 var graphql = require('graphql');
 
+function toPascalCase(slug) {
+  return slug.split(/[-_]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function toCamelCase(slug) {
+  const p = toPascalCase(slug);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+function toPascalSingular(slug) {
+  const p = toPascalCase(slug);
+  if (p.endsWith("s") && p.length > 1) return p.slice(0, -1);
+  return p;
+}
+function toCamelSingular(slug) {
+  return toCamelCase(slug).endsWith("s") && slug.length > 1 ? toCamelCase(slug).slice(0, -1) : toCamelCase(slug);
+}
 var RelationLoader = class {
   db;
   tenantID;
@@ -69,20 +84,38 @@ 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 graphql.GraphQLError(`Query exceeds max depth of ${maxDepth}`)
+          );
+        }
+      },
+      leaveField() {
+        depth--;
+      }
+    };
+  };
+}
 async function checkAccess(config, operation, context) {
-  const result = await chunkFKKQUMXR_cjs.checkCollectionAccess(config, operation, context);
+  const result = await chunkKGJRJ7CU_cjs.checkCollectionAccess(config, operation, context);
   if (!result.allowed) {
     throw gqlError(result.error || "Access denied", "FORBIDDEN");
   }
   return result.extraWhere;
 }
 async function checkGqlGlobalAccess(config, operation, context) {
-  const result = await chunkFKKQUMXR_cjs.checkGlobalAccess(config, operation, context);
+  const result = await chunkKGJRJ7CU_cjs.checkGlobalAccess(config, operation, context);
   if (!result.allowed) {
     throw gqlError(result.error || "Access denied", "FORBIDDEN");
   }
 }
-function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false, loader) {
+function fieldToGraphQLType(field, registry, collectionTypes, isInputType = false) {
   switch (field.type) {
     case "text":
     case "email":
@@ -120,9 +153,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 graphql.GraphQLObjectType({
-            name: refName,
+            name: toPascalSingular(field.relationTo),
             fields: () => ({
               id: { type: graphql.GraphQLString },
               ...buildFieldsFromCollection(relatedCollection, registry, collectionTypes)
@@ -139,21 +171,35 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
       }
       return field.hasMany ? new graphql.GraphQLList(graphql.GraphQLString) : graphql.GraphQLString;
     case "array": {
-      if (isInputType) return graphql.GraphQLString;
+      if (isInputType) {
+        const arrFields2 = field.fields;
+        if (arrFields2 && arrFields2.length > 0) {
+          const arrTypeName = `${field.name?.replace(/-/g, "_") || "array"}_input_item`;
+          return new graphql.GraphQLList(fieldsToGraphQLInputObjectType(arrTypeName, arrFields2, registry));
+        }
+        return new graphql.GraphQLList(graphql.GraphQLString);
+      }
       const arrFields = field.fields;
       if (arrFields && arrFields.length > 0) {
         const arrTypeName = `${field.name?.replace(/-/g, "_") || "array"}_item`;
-        const itemType = fieldsToGraphQLObjectType(arrTypeName, arrFields, registry, collectionTypes, loader);
+        const itemType = fieldsToGraphQLObjectType(arrTypeName, arrFields, registry, collectionTypes);
         return new graphql.GraphQLList(itemType);
       }
       return new graphql.GraphQLList(graphql.GraphQLString);
     }
     case "group": {
-      if (isInputType) return graphql.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 graphql.GraphQLString;
+      }
       const groupFields = field.fields;
       if (groupFields && groupFields.length > 0) {
         const groupTypeName = `${field.name?.replace(/-/g, "_") || "group"}_group`;
-        return fieldsToGraphQLObjectType(groupTypeName, groupFields, registry, collectionTypes, loader);
+        return fieldsToGraphQLObjectType(groupTypeName, groupFields, registry, collectionTypes);
       }
       return graphql.GraphQLString;
     }
@@ -163,7 +209,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 graphql.GraphQLObjectType({
             name: blockTypeName,
             fields: () => {
@@ -174,7 +220,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;
                 }
               }
@@ -189,7 +235,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
               );
@@ -208,11 +254,11 @@ function fieldToGraphQLType(field, registry, collectionTypes, isInputType = fals
       return graphql.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;
     }
   }
@@ -232,7 +278,7 @@ function buildSortEnum(config) {
     }
   }
   return new graphql.GraphQLEnumType({
-    name: `${config.slug.replace(/-/g, "_")}_sort`,
+    name: `${toPascalSingular(config.slug)}Sort`,
     values: sortFields
   });
 }
@@ -330,7 +376,7 @@ function buildCollectionFilterType(config, namePrefix) {
     }
   }
   return new graphql.GraphQLInputObjectType({
-    name: `${namePrefix}_filter`,
+    name: `${namePrefix}Filter`,
     fields
   });
 }
@@ -343,7 +389,42 @@ function translateFilter(filter) {
   }
   return result;
 }
-function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes, loader) {
+function fieldsToGraphQLInputObjectType(name, fields, registry) {
+  return new graphql.GraphQLInputObjectType({
+    name,
+    fields: () => {
+      const out = {};
+      for (const field of fields) {
+        if (!field.name) continue;
+        if (field.type === "row" || field.type === "collapsible") {
+          const subFields = field.fields;
+          if (subFields) {
+            for (const sf of subFields) {
+              if (!sf.name) continue;
+              out[sf.name] = { type: fieldToGraphQLType(sf, registry, void 0, true) };
+            }
+          }
+        } else if (field.type === "tabs") {
+          const tabs = field.tabs;
+          if (tabs) {
+            for (const tab of tabs) {
+              if (tab.fields) {
+                for (const sf of tab.fields) {
+                  if (!sf.name) continue;
+                  out[sf.name] = { type: fieldToGraphQLType(sf, registry, void 0, true) };
+                }
+              }
+            }
+          }
+        } else {
+          out[field.name] = { type: fieldToGraphQLType(field, registry, void 0, true) };
+        }
+      }
+      return out;
+    }
+  });
+}
+function fieldsToGraphQLObjectType(name, fields, registry, collectionTypes) {
   return new graphql.GraphQLObjectType({
     name,
     fields: () => {
@@ -355,7 +436,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;
             }
           }
@@ -366,14 +447,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;
         }
       }
@@ -381,14 +462,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 graphql.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;
@@ -402,11 +486,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 [];
@@ -427,27 +513,27 @@ function buildFieldConfig(field, registry, collectionTypes, loader) {
     };
   }
   return {
-    type: field.required ? new graphql.GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false, loader)) : fieldToGraphQLType(field, registry, collectionTypes, false, loader),
-    description: field.admin?.description || field.label
+    type: field.required ? new graphql.GraphQLNonNull(fieldToGraphQLType(field, registry, collectionTypes, false)) : fieldToGraphQLType(field, registry, collectionTypes, false),
+    description: field.admin?.description || field.label,
+    deprecationReason
   };
 }
 function buildGraphQLSchema(options) {
-  const { registry, db, 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 graphql.GraphQLObjectType({
-      name: `${collection.slug.replace(/-/g, "_")}_type`,
+      name: toPascalSingular(collection.slug),
       fields: () => ({
-        id: { type: graphql.GraphQLString },
-        ...buildFieldsFromCollection(collection, registry, collectionTypes, relationLoader),
+        id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) },
+        ...buildFieldsFromCollection(collection, registry, collectionTypes),
         ...collection.timestamps ? {
           createdAt: { type: graphql.GraphQLString },
           updatedAt: { type: graphql.GraphQLString }
@@ -466,7 +552,7 @@ function buildGraphQLSchema(options) {
       }
     }
     collectionInputTypes[collection.slug] = new graphql.GraphQLInputObjectType({
-      name: `${collection.slug.replace(/-/g, "_")}_input`,
+      name: `${toPascalSingular(collection.slug)}Input`,
       fields: () => inputFields
     });
   }
@@ -474,19 +560,18 @@ function buildGraphQLSchema(options) {
   const globalInputTypes = {};
   for (const global of globals) {
     globalTypes[global.slug] = new graphql.GraphQLObjectType({
-      name: `${global.slug.replace(/-/g, "_")}_global_type`,
+      name: toPascalCase(global.slug),
       fields: () => ({
         id: { type: graphql.GraphQLString },
         ...buildFieldsFromCollection(
           { slug: global.slug, fields: global.fields },
           registry,
-          collectionTypes,
-          relationLoader
+          collectionTypes
         )
       })
     });
     globalInputTypes[global.slug] = new graphql.GraphQLInputObjectType({
-      name: `${global.slug.replace(/-/g, "_")}_global_input`,
+      name: `${toPascalCase(global.slug)}Input`,
       fields: () => {
         const inputFields = {};
         for (const field of global.fields) {
@@ -500,15 +585,24 @@ function buildGraphQLSchema(options) {
       }
     });
   }
+  const pageInfoType = new graphql.GraphQLObjectType({
+    name: "PageInfo",
+    fields: {
+      hasNextPage: { type: new graphql.GraphQLNonNull(graphql.GraphQLBoolean) },
+      hasPreviousPage: { type: new graphql.GraphQLNonNull(graphql.GraphQLBoolean) },
+      startCursor: { type: graphql.GraphQLString },
+      endCursor: { type: graphql.GraphQLString }
+    }
+  });
   const queryFields = {};
   for (const collection of collections) {
     const type = collectionTypes[collection.slug];
     if (!type) continue;
-    const filterType = buildCollectionFilterType(collection, 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 graphql.GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_find_result`,
+        name: `${toPascalSingular(collection.slug)}FindResult`,
         fields: {
           docs: { type: new graphql.GraphQLList(type) },
           totalDocs: { type: graphql.GraphQLInt },
@@ -526,14 +620,15 @@ function buildGraphQLSchema(options) {
         draft: { type: graphql.GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
         const extraWhere = await checkAccess(collection, "read", {
-          user,
-          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) {
@@ -549,51 +644,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 graphql.GraphQLNonNull(graphql.GraphQLString) },
         draft: { type: graphql.GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
         await checkAccess(collection, "read", {
-          user,
-          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 graphql.GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_count`,
+        name: `${toPascalSingular(collection.slug)}Count`,
         fields: {
           totalDocs: { type: graphql.GraphQLInt }
         }
@@ -602,11 +698,12 @@ function buildGraphQLSchema(options) {
         where: { type: graphql.GraphQLString }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
         await checkAccess(collection, "read", {
-          user,
-          req,
-          tenantID,
-          apiKey
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
         });
         let where = {};
         if (args.where) {
@@ -619,33 +716,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 graphql.GraphQLObjectType({
+      name: `${toPascalSingular(collection.slug)}Edge`,
+      fields: {
+        node: { type },
+        cursor: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
+      }
+    });
+    const connectionType = new graphql.GraphQLObjectType({
+      name: `${toPascalSingular(collection.slug)}Connection`,
+      fields: {
+        edges: { type: new graphql.GraphQLList(edgeType) },
+        pageInfo: { type: new graphql.GraphQLNonNull(pageInfoType) },
+        totalCount: { type: graphql.GraphQLInt }
+      }
+    });
+    queryFields[`${toCamelCase(collection.slug)}Connection`] = {
+      type: connectionType,
+      args: {
+        first: { type: graphql.GraphQLInt },
+        after: { type: graphql.GraphQLString },
+        last: { type: graphql.GraphQLInt },
+        before: { type: graphql.GraphQLString },
+        where: { type: filterType },
+        sort: { type: sortEnum || graphql.GraphQLString },
+        draft: { type: graphql.GraphQLBoolean }
+      },
+      resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, relationLoader: ctxLoader } = ctx;
+        const extraWhere = await checkAccess(collection, "read", {
+          user: ctxUser,
+          req: ctxReq,
+          tenantID: ctxTenant,
+          apiKey: ctxApiKey
+        });
+        if (ctxTenant) {
+          ctxDb.setTenantContext({ tenantId: ctxTenant, userId: ctxUser?.id ?? "", role: ctxUser?.role, isSuperAdmin: ctxUser?.role === "super_admin" });
+        }
+        let where = {};
+        if (args.where) {
+          if (typeof args.where === "string") {
+            try {
+              where = JSON.parse(args.where);
+            } catch {
+            }
+          } else {
+            where = translateFilter(args.where);
+          }
+        }
+        if (extraWhere) where = { ...where, ...extraWhere };
+        const isDraft = args.draft ?? !!ctxUser;
+        return RelationLoader.withBatch(ctxLoader, async () => {
+          let page = 1;
+          let limit = args.first || args.last || 10;
+          if (args.after) {
+            try {
+              const afterIdx = parseInt(Buffer.from(args.after, "base64").toString("utf-8"), 10);
+              if (!isNaN(afterIdx)) page = Math.floor(afterIdx / limit) + 1;
+            } catch {
+            }
+          } else if (args.before) {
+            try {
+              const beforeIdx = parseInt(Buffer.from(args.before, "base64").toString("utf-8"), 10);
+              if (!isNaN(beforeIdx)) page = Math.max(1, Math.floor(beforeIdx / limit));
+            } catch {
+            }
+          }
+          const result = await ctxDb.find({
+            collection: collection.slug,
+            where,
+            sort: args.sort,
+            limit,
+            page,
+            tenantID: ctxTenant,
+            draft: isDraft
+          });
+          const edges = (result.docs || []).map((doc, idx) => {
+            const cursorIdx = (page - 1) * limit + idx;
+            return {
+              node: doc,
+              cursor: Buffer.from(String(cursorIdx)).toString("base64")
+            };
+          });
+          return {
+            edges,
+            pageInfo: {
+              hasNextPage: result.hasNextPage || false,
+              hasPreviousPage: result.hasPrevPage || false,
+              startCursor: edges.length > 0 ? edges[0].cursor : null,
+              endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+            },
+            totalCount: result.totalDocs
+          };
+        });
+      }
+    };
   }
   for (const global of globals) {
     const type = globalTypes[global.slug];
     if (!type) continue;
-    queryFields[`${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
         });
       }
     };
@@ -659,9 +852,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 graphql.GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_create_result`,
+        name: `${toPascalSingular(collection.slug)}CreateResult`,
         fields: {
           doc: { type },
           message: { type: graphql.GraphQLString }
@@ -672,28 +865,38 @@ function buildGraphQLSchema(options) {
         draft: { type: graphql.GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
         await checkAccess(collection, "create", {
-          user,
-          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 graphql.GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_update_result`,
+        name: `${toPascalSingular(collection.slug)}UpdateResult`,
         fields: {
           doc: { type },
           message: { type: graphql.GraphQLString }
@@ -706,20 +909,21 @@ function buildGraphQLSchema(options) {
         draft: { type: graphql.GraphQLBoolean }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb, registry: ctxRegistry } = ctx;
         await checkAccess(collection, "update", {
-          user,
-          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) {
@@ -729,20 +933,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 graphql.GraphQLObjectType({
-        name: `${collection.slug.replace(/-/g, "_")}_delete_result`,
+        name: `${toPascalSingular(collection.slug)}DeleteResult`,
         fields: {
           doc: { type },
           message: { type: graphql.GraphQLString }
@@ -752,19 +965,20 @@ function buildGraphQLSchema(options) {
         id: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, apiKey: ctxApiKey, db: ctxDb } = ctx;
         await checkAccess(collection, "delete", {
-          user,
-          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" };
       }
@@ -773,9 +987,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 graphql.GraphQLObjectType({
-        name: `${global.slug.replace(/-/g, "_")}_update_result`,
+        name: `${toPascalCase(global.slug)}UpdateResult`,
         fields: {
           doc: { type: globalTypes[global.slug] || graphql.GraphQLString },
           message: { type: graphql.GraphQLString }
@@ -785,32 +999,33 @@ function buildGraphQLSchema(options) {
         data: { type: new graphql.GraphQLNonNull(inputType) }
       },
       resolve: async (_, args, ctx) => {
+        const { user: ctxUser, req: ctxReq, tenantID: ctxTenant, db: ctxDb } = ctx;
         await checkGqlGlobalAccess(global, "update", {
-          user,
-          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" };
@@ -821,20 +1036,35 @@ function buildGraphQLSchema(options) {
     name: "Mutation",
     fields: mutationFields
   });
+  const keyDirective = new graphql.GraphQLDirective({
+    name: "key",
+    locations: [graphql.DirectiveLocation.OBJECT, graphql.DirectiveLocation.INTERFACE],
+    args: {
+      fields: { type: new graphql.GraphQLNonNull(graphql.GraphQLString) }
+    }
+  });
+  const serviceSdl = graphql.printSchema(new graphql.GraphQLSchema({
+    query: new graphql.GraphQLObjectType({ name: "Query", fields: { ...queryFields } }),
+    mutation: Mutation,
+    directives: [keyDirective]
+  }));
+  queryFields._service = {
+    type: new graphql.GraphQLObjectType({
+      name: "_Service",
+      fields: {
+        sdl: { type: graphql.GraphQLString }
+      }
+    }),
+    resolve: () => ({ sdl: serviceSdl })
+  };
   return new graphql.GraphQLSchema({
     query: Query,
-    mutation: Mutation
+    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: graphql.printSchema(schema) });
 }
 
@@ -842,7 +1072,9 @@ Object.defineProperty(exports, "printSchema", {
   enumerable: true,
   get: function () { return graphql.printSchema; }
 });
+exports.RelationLoader = RelationLoader;
 exports.buildGraphQLSchema = buildGraphQLSchema;
 exports.createGraphQLSchema = createGraphQLSchema;
-//# sourceMappingURL=chunk-RRKCIAPU.cjs.map
-//# sourceMappingURL=chunk-RRKCIAPU.cjs.map
+exports.depthLimit = depthLimit;
+//# sourceMappingURL=chunk-PF642V5O.cjs.map
+//# sourceMappingURL=chunk-PF642V5O.cjs.map