wabe 0.6.0 → 0.6.2

package/dist/index.js

@@ -49426,13 +49426,13 @@ var require_tslib = __commonJS((exports, module) => {
       }
       return next();
     };
-    __rewriteRelativeImportExtension = function(path, preserveJsx) {
-      if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+    __rewriteRelativeImportExtension = function(path2, preserveJsx) {
+      if (typeof path2 === "string" && /^\.\.?\//.test(path2)) {
+        return path2.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
           return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
         });
       }
-      return path;
+      return path2;
     };
     exporter("__extends", __extends);
     exporter("__assign", __assign);
@@ -49839,18 +49839,18 @@ var require_utils4 = __commonJS((exports, module) => {
     if (decode)
       return decode(data, hint);
   }
-  function basename(path) {
-    if (typeof path !== "string")
+  function basename(path2) {
+    if (typeof path2 !== "string")
       return "";
-    for (let i = path.length - 1;i >= 0; --i) {
-      switch (path.charCodeAt(i)) {
+    for (let i = path2.length - 1;i >= 0; --i) {
+      switch (path2.charCodeAt(i)) {
         case 47:
         case 92:
-          path = path.slice(i + 1);
-          return path === ".." || path === "." ? "" : path;
+          path2 = path2.slice(i + 1);
+          return path2 === ".." || path2 === "." ? "" : path2;
       }
     }
-    return path === ".." || path === "." ? "" : path;
+    return path2 === ".." || path2 === "." ? "" : path2;
   }
   var TOKEN = [
     0,
@@ -55458,7 +55458,7 @@ var require_parse2 = __commonJS((exports, module) => {
   var Empty = function() {
   };
   Empty.prototype = Object.create(null);
-  function parse5(input) {
+  function parse4(input) {
     const result2 = new Empty;
     if (typeof input !== "string") {
       return result2;
@@ -55538,7 +55538,7 @@ var require_parse2 = __commonJS((exports, module) => {
     }
     return result2;
   }
-  module.exports = parse5;
+  module.exports = parse4;
 });
 
 // ../../node_modules/fast-querystring/lib/internals/querystring.js
@@ -55778,15 +55778,15 @@ var require_stringify = __commonJS((exports, module) => {
 
 // ../../node_modules/fast-querystring/lib/index.js
 var require_lib7 = __commonJS((exports, module) => {
-  var parse5 = require_parse2();
+  var parse4 = require_parse2();
   var stringify = require_stringify();
   var fastQuerystring = {
-    parse: parse5,
+    parse: parse4,
     stringify
   };
   module.exports = fastQuerystring;
   module.exports.default = fastQuerystring;
-  module.exports.parse = parse5;
+  module.exports.parse = parse4;
   module.exports.stringify = stringify;
 });
 
@@ -56447,13 +56447,13 @@ var require_urlparser = __commonJS((exports, module) => {
       this.pathname = prePath === "" ? "/" : prePath;
       return;
     }
-    var path;
+    var path2;
     if (escape2) {
-      path = this._getComponentEscaped(str, pathStart, pathEnd, false);
+      path2 = this._getComponentEscaped(str, pathStart, pathEnd, false);
     } else {
-      path = str.slice(pathStart, pathEnd + 1);
+      path2 = str.slice(pathStart, pathEnd + 1);
     }
-    this.pathname = prePath === "" ? this._prependSlash ? "/" + path : path : prePath + path;
+    this.pathname = prePath === "" ? this._prependSlash ? "/" + path2 : path2 : prePath + path2;
   };
   Url.prototype._parseQuery = function Url$_parseQuery(str, start, end, disableAutoEscapeChars) {
     var queryStart = start;
@@ -57051,8 +57051,8 @@ var require_fetch = __commonJS((exports) => {
   var utils_js_1 = require_utils5();
   var BASE64_SUFFIX = ";base64";
   function getResponseForFile(url) {
-    const path = (0, url_1.fileURLToPath)(url);
-    const readable = (0, fs_1.createReadStream)(path);
+    const path2 = (0, url_1.fileURLToPath)(url);
+    const readable = (0, fs_1.createReadStream)(path2);
     return new Response_js_1.PonyfillResponse(readable);
   }
   function getResponseForDataUri(url) {
@@ -59878,8 +59878,8 @@ var require_fetch2 = __commonJS((exports) => {
   var utils_js_1 = require_utils6();
   var BASE64_SUFFIX = ";base64";
   function getResponseForFile(url) {
-    const path = (0, url_1.fileURLToPath)(url);
-    const readable = (0, fs_1.createReadStream)(path);
+    const path2 = (0, url_1.fileURLToPath)(url);
+    const readable = (0, fs_1.createReadStream)(path2);
     return new Response_js_1.PonyfillResponse(readable);
   }
   function getResponseForDataUri(url) {
@@ -60553,8 +60553,6 @@ var require_create_node_ponyfill2 = __commonJS((exports, module) => {
 
 // src/files/hookDeleteFile.ts
 var deleteFile = async (hookObject) => {
-  if (!hookObject.context.wabe.controllers.file)
-    return;
   const schema = hookObject.context.wabe.config.schema?.classes?.find((currentClass) => currentClass.name === hookObject.className);
   if (!schema)
     return;
@@ -60562,6 +60560,8 @@ var deleteFile = async (hookObject) => {
     const fileName = hookObject.originalObject?.[fieldName]?.name;
     if (!fileName)
       return;
+    if (!hookObject.context.wabe.controllers.file)
+      throw new Error("No file adapter found");
     await hookObject.context.wabe.controllers.file?.deleteFile(fileName);
   });
 };
@@ -60569,8 +60569,6 @@ var defaultAfterDeleteFile = (hookObject) => deleteFile(hookObject);
 
 // src/files/hookReadFile.ts
 var getFile = async (hookObject) => {
-  if (!hookObject.context.wabe.controllers.file)
-    return;
   const schema = hookObject.context.wabe.config.schema?.classes?.find((currentClass) => currentClass.name === hookObject.className);
   if (!schema)
     return;
@@ -60580,9 +60578,13 @@ var getFile = async (hookObject) => {
     if (!fileInfo)
       return;
     const fileName = fileInfo.name;
+    if (!fileName && fileInfo.url)
+      return fileInfo.url;
     const fileUrlGeneratedAt = fileInfo.urlGeneratedAt;
     if (fileUrlGeneratedAt && fileUrlGeneratedAt.getTime() + urlCacheInSeconds * 1000 > new Date().getTime())
       return;
+    if (!hookObject.context.wabe.controllers.file)
+      throw new Error("No file adapter found");
     const fileUrlFromBucket = await hookObject.context.wabe.controllers.file?.readFile(fileName);
     return hookObject.context.wabe.controllers.database.updateObject({
       className: hookObject.className,
@@ -60595,7 +60597,6 @@ var getFile = async (hookObject) => {
           url: fileUrlFromBucket || fileInfo.url
         }
       },
-      fields: ["*"],
       skipHooks: true
     });
   }));
@@ -60604,21 +60605,23 @@ var defaultAfterReadFile = (hookObject) => getFile(hookObject);
 
 // src/files/hookUploadFile.ts
 var handleFile = async (hookObject) => {
-  if (!hookObject.context.wabe.controllers.file)
-    return;
   const newData = hookObject.getNewData();
   const schema = hookObject.context.wabe.config.schema?.classes?.find((currentClass) => currentClass.name === hookObject.className);
   if (!schema)
     return;
   await Promise.all(Object.keys(newData).map(async (keyName) => {
-    const file = newData[keyName].file;
-    const url = newData[keyName].url;
+    const file = newData[keyName]?.file;
+    const url = newData[keyName]?.url;
+    if (!file && !url)
+      return;
     if (url) {
       hookObject.upsertNewData(keyName, { url, isPresignedUrl: false });
       return;
     }
     if (schema.fields[keyName].type !== "File" || !(file instanceof File))
       return;
+    if (!hookObject.context.wabe.controllers.file)
+      throw new Error("No file adapter found");
     await hookObject.context.wabe.controllers.file?.uploadFile(file);
     hookObject.upsertNewData(keyName, {
       name: file.name,
@@ -60643,7 +60646,7 @@ class HookObject {
   context;
   object;
   originalObject;
-  fields;
+  select;
   constructor({
     newData,
     className,
@@ -60651,7 +60654,7 @@ class HookObject {
     context,
     object,
     originalObject,
-    fields
+    select
   }) {
     this.newData = newData;
     this.className = className;
@@ -60659,7 +60662,7 @@ class HookObject {
     this.context = context;
     this.object = object;
     this.originalObject = originalObject;
-    this.fields = fields;
+    this.select = Object.keys(select || {});
   }
   getUser() {
     return this.context.user;
@@ -60687,8 +60690,7 @@ class HookObject {
       context: {
         ...this.context,
         isRoot: true
-      },
-      fields: ["*"]
+      }
     });
   }
   async addACL(type, options) {
@@ -60703,7 +60705,7 @@ class HookObject {
             data: {
               acl: newACLObject
             },
-            fields: []
+            select: {}
           });
         return;
       }
@@ -60711,7 +60713,7 @@ class HookObject {
     };
     const result = this.className === "User" ? await this.context.wabe.controllers.database.getObject({
       className: "User",
-      fields: ["acl"],
+      select: { acl: true },
       id: this.object?.id,
       context: {
         ...this.context,
@@ -60732,7 +60734,7 @@ class HookObject {
     if (role) {
       const result2 = await this.context.wabe.controllers.database.getObjects({
         className: "Role",
-        fields: ["id"],
+        select: { id: true },
         where: {
           name: {
             equalTo: role
@@ -60817,6 +60819,10 @@ var defaultCallAuthenticationProviderOnBeforeUpdateUser = async (hookObject) =>
 };
 
 // src/utils/index.ts
+var firstLetterInUpperCase = (str) => {
+  const indexOfFirstLetter = str.search(/[a-z]/i);
+  return str.slice(0, indexOfFirstLetter) + str[indexOfFirstLetter].toUpperCase() + str.slice(indexOfFirstLetter + 1);
+};
 var firstLetterInLowerCase = (str) => {
   const indexOfFirstLetter = str.search(/[a-z]/i);
   return str.slice(0, indexOfFirstLetter) + str[indexOfFirstLetter].toLowerCase() + str.slice(indexOfFirstLetter + 1);
@@ -60873,7 +60879,7 @@ var defaultDeleteSessionOnDeleteUser = async (object) => {
     where: {
       user: { id: { equalTo: userId } }
     },
-    fields: []
+    select: {}
   });
 };
 
@@ -60927,7 +60933,7 @@ var _checkCLP = async (object, operationType) => {
   const res = await object.context.wabe.controllers.database.getObject({
     className: "_Session",
     id: sessionId,
-    fields: ["id", "user.id"],
+    select: { id: true, user: { id: true } },
     context: {
       ...object.context,
       isRoot: true
@@ -61698,19 +61704,14 @@ class MongoAdapter {
   async getObject(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, id, fields, where, context } = params;
+    const { className, id, select, where, context } = params;
     const whereBuilded = buildMongoWhereQuery(where);
-    const objectOfFieldsToGet = fields?.reduce((acc, prev) => {
-      acc[prev] = 1;
-      return acc;
-    }, {});
     const collection = await this.createClassIfNotExist(className, context);
     const res = await collection.findOne({ _id: new import_mongodb.ObjectId(id), ...whereBuilded }, {
-      projection: fields && fields.length > 0 && !fields.includes("*") ? { ...objectOfFieldsToGet, _id: 1 } : {}
+      projection: select ? { ...select, _id: 1 } : undefined
     });
-    if (!res) {
+    if (!res)
       throw new Error("Object not found");
-    }
     const { _id, ...resultWithout_Id } = res;
     return {
       ...resultWithout_Id,
@@ -61720,19 +61721,12 @@ class MongoAdapter {
   async getObjects(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, fields, where, offset, first, context, order } = params;
+    const { className, select, where, offset, first, context, order } = params;
     const whereBuilded = buildMongoWhereQuery(where);
     const orderBuilded = buildMongoOrderQuery(order);
-    const objectOfFieldsToGet = fields?.reduce((acc, prev) => {
-      acc[prev] = 1;
-      return acc;
-    }, {});
     const collection = await this.createClassIfNotExist(className, context);
     const res = await collection.find(whereBuilded, {
-      projection: fields && fields.length > 0 && !fields.includes("*") ? {
-        ...objectOfFieldsToGet,
-        _id: 1
-      } : {}
+      projection: select ? { ...select, _id: 1 } : undefined
     }).limit(first || 0).skip(offset || 0).sort(orderBuilded).toArray();
     return res.map((object) => {
       const { _id, ...resultWithout_Id } = object;
@@ -61783,7 +61777,7 @@ class MongoAdapter {
     const objectsBeforeUpdate = await context.wabe.controllers.database.getObjects({
       className,
       where,
-      fields: ["id"],
+      select: { id: true },
       offset,
       first,
       context: contextWithRoot(context),
@@ -61894,18 +61888,21 @@ var PaymentReccuringInterval;
 })(PaymentReccuringInterval ||= {});
 // src/files/FileDevAdapter.ts
 import { writeFile, mkdir, rm, access, constants } from "node:fs/promises";
+import path from "node:path";
 
 class FileDevAdapter {
   basePath;
+  rootPath = process.cwd();
   constructor(basePath) {
     this.basePath = basePath;
   }
   async uploadFile(file) {
-    await mkdir(this.basePath, { recursive: true });
-    await writeFile(`${this.basePath}/${file.name}`, await file.text());
+    const fullPath = path.join(this.rootPath, this.basePath);
+    await mkdir(fullPath, { recursive: true });
+    await writeFile(path.join(fullPath, file.name), await file.text());
   }
   async readFile(fileName) {
-    const filePath = `${this.basePath}/${fileName}`;
+    const filePath = path.join(this.rootPath, this.basePath, fileName);
     try {
       await access(filePath, constants.F_OK);
       return filePath;
@@ -61914,7 +61911,7 @@ class FileDevAdapter {
     }
   }
   async deleteFile(fileName) {
-    await rm(`${this.basePath}/${fileName}`);
+    await rm(path.join(this.rootPath, this.basePath, fileName));
   }
 }
 
@@ -62047,7 +62044,7 @@ var initializeHook = ({
   className,
   newData,
   context,
-  fields
+  select
 }) => {
   const computeObject = ({
     id
@@ -62058,8 +62055,7 @@ var initializeHook = ({
       className,
       context: contextWithRoot(context),
       id,
-      skipHooks: true,
-      fields: ["*"]
+      skipHooks: true
     });
   };
   const computeObjects = async ({
@@ -62072,7 +62068,6 @@ var initializeHook = ({
       className,
       context: contextWithRoot(context),
       where: where ? where : { id: { in: ids } },
-      fields: ["*"],
       skipHooks: true
     });
     if (res.length === 0)
@@ -62094,7 +62089,7 @@ var initializeHook = ({
         context,
         object,
         originalObject: options.originalObject,
-        fields
+        select
       });
       await hooksOrderByPriorities.reduce(async (acc, priority) => {
         await acc;
@@ -62125,7 +62120,7 @@ var initializeHook = ({
           context,
           object,
           originalObject: originalObjectToUse,
-          fields
+          select
         });
         await hooksOrderByPriorities.reduce(async (acc, priority) => {
           await acc;
@@ -62258,32 +62253,38 @@ class DatabaseController2 {
   constructor(adapter) {
     this.adapter = adapter;
   }
-  _getPointerObject(className, fields, context) {
+  _getSelectMinusPointersAndRelations({
+    className,
+    context,
+    select
+  }) {
     const realClass = context.wabe.config.schema?.classes?.find((c) => c.name.toLowerCase() === className.toLowerCase());
     if (!realClass)
       throw new Error("Class not found in schema");
-    return fields.reduce((acc, field) => {
-      const splittedField = field.split(".");
-      if (splittedField.length === 1)
-        return acc;
-      const pointerField = splittedField[0];
-      const pointerClass = realClass.fields[pointerField].class;
-      const pointerFields = splittedField.slice(1).join(".");
+    if (!select)
+      return { pointers: {}, selectWithoutPointers: {} };
+    const pointerOrRelationFields = Object.keys(realClass.fields).filter((fieldName) => realClass.fields[fieldName].type === "Pointer" || realClass.fields[fieldName].type === "Relation");
+    return Object.entries(select).reduce((acc, [fieldName, value]) => {
+      if (!pointerOrRelationFields.includes(fieldName))
+        return {
+          ...acc,
+          selectWithoutPointers: {
+            ...acc.selectWithoutPointers,
+            [fieldName]: true
+          }
+        };
+      const classOfPointerOrRelation = realClass.fields[fieldName].class;
       return {
+        ...acc,
         pointers: {
           ...acc.pointers,
-          [pointerField]: {
-            ...acc.pointers?.[pointerField] || [],
-            pointerClass,
-            fieldsOfPointerClass: [
-              ...acc.pointers?.[pointerField]?.fieldsOfPointerClass || [],
-              pointerFields
-            ]
+          [fieldName]: {
+            className: classOfPointerOrRelation,
+            select: value === true ? undefined : value
           }
-        },
-        pointersFieldsId: acc.pointersFieldsId?.includes(pointerField) ? acc.pointersFieldsId : [...acc.pointersFieldsId || [], pointerField]
+        }
       };
-    }, { pointers: {} });
+    }, { pointers: {}, selectWithoutPointers: {} });
   }
   _isRelationField(originClassName, context, pointerClassName) {
     if (!pointerClassName)
@@ -62295,44 +62296,6 @@ class DatabaseController2 {
       return false;
     return context.wabe.config.schema?.classes?.some((c) => c.name.toLowerCase() === originClassName.toLowerCase() && Object.values(c.fields).find((field) => field.type === "Pointer" && field.class.toLowerCase() === pointerClassName.toLowerCase()));
   }
-  async _getFinalObjectWithPointer(objectData, pointersObject, originClassName, context) {
-    return Object.entries(pointersObject).reduce(async (accPromise, [pointerField, { fieldsOfPointerClass, pointerClass }]) => {
-      const acc = await accPromise;
-      const isPointer = this._isPointerField(originClassName, context, pointerClass);
-      if (isPointer && pointerClass && objectData?.[pointerField]) {
-        const pointerObject = await this.getObject({
-          className: pointerClass,
-          fields: fieldsOfPointerClass,
-          id: objectData[pointerField],
-          context
-        });
-        return {
-          ...acc,
-          [pointerField]: pointerObject
-        };
-      }
-      const isRelation = this._isRelationField(originClassName, context, pointerClass);
-      if (isRelation && pointerClass) {
-        const relationObjects = await this.getObjects({
-          className: pointerClass,
-          fields: fieldsOfPointerClass,
-          where: { id: { in: objectData[pointerField] } },
-          context
-        });
-        return {
-          ...acc,
-          [pointerField]: {
-            edges: relationObjects.map((object) => ({
-              node: object
-            }))
-          }
-        };
-      }
-      return acc;
-    }, Promise.resolve({
-      ...objectData
-    }));
-  }
   async _getWhereObjectWithPointerOrRelation(className, where, context) {
     const whereKeys = Object.keys(where);
     const realClass = context.wabe.config.schema?.classes?.find((c) => c.name.toLowerCase() === className.toLowerCase());
@@ -62353,7 +62316,7 @@ class DatabaseController2 {
       const defaultWhere = where[typedWhereKey];
       const objects = await this.getObjects({
         className: fieldTargetClass,
-        fields: ["id"],
+        select: { id: true },
         where: defaultWhere,
         context
       });
@@ -62443,6 +62406,56 @@ class DatabaseController2 {
       ].filter(notEmpty)
     };
   }
+  _getFinalObjectWithPointerAndRelation({
+    pointers,
+    context,
+    originClassName,
+    object,
+    isGraphQLCall
+  }) {
+    return Object.entries(pointers).reduce(async (acc, [pointerField, { className: currentClassName, select: currentSelect }]) => {
+      const accObject = await acc;
+      const isPointer = this._isPointerField(originClassName, context, currentClassName);
+      if (isPointer) {
+        if (!object[pointerField]) {
+          return {
+            ...accObject,
+            [pointerField]: null
+          };
+        }
+        const objectOfPointerClass = await this.getObject({
+          className: currentClassName,
+          id: object[pointerField],
+          context,
+          select: currentSelect,
+          skipHooks: true
+        });
+        return {
+          ...accObject,
+          [pointerField]: objectOfPointerClass
+        };
+      }
+      const isRelation = this._isRelationField(originClassName, context, currentClassName);
+      if (isRelation) {
+        const relationObjects = await this.getObjects({
+          className: currentClassName,
+          select: currentSelect,
+          where: { id: { in: object[pointerField] } },
+          context
+        });
+        return {
+          ...acc,
+          [pointerField]: isGraphQLCall ? {
+            totalCount: relationObjects.length,
+            edges: relationObjects.map((object2) => ({
+              node: object2
+            }))
+          } : relationObjects
+        };
+      }
+      return accObject;
+    }, Promise.resolve({}));
+  }
   connect() {
     return this.adapter.connect();
   }
@@ -62459,30 +62472,33 @@ class DatabaseController2 {
     await this.adapter.clearDatabase();
   }
   async getObject({
-    fields,
+    select,
     className,
     context,
     skipHooks,
     id,
-    where
+    where,
+    isGraphQLCall = false
   }) {
-    const typedFields = fields;
-    const { pointersFieldsId, pointers } = this._getPointerObject(className, typedFields, context);
+    const { pointers, selectWithoutPointers } = this._getSelectMinusPointersAndRelations({
+      className,
+      context,
+      select
+    });
     const hook = !skipHooks ? initializeHook({
       className,
       context,
-      fields
+      select: selectWithoutPointers
     }) : undefined;
     await hook?.runOnSingleObject({
       operationType: "beforeRead" /* BeforeRead */,
       id
     });
     const whereWithACLCondition = this._buildWhereWithACL(where || {}, context, "read");
-    const fieldsWithoutPointers = typedFields.filter((field) => !field.includes("."));
-    const fieldsWithPointerFields = [
-      ...fieldsWithoutPointers,
-      ...pointersFieldsId || []
-    ];
+    const selectWithPointersAndRelationsToGetId = Object.keys(pointers).reduce((acc, fieldName) => {
+      acc[fieldName] = true;
+      return acc;
+    }, selectWithoutPointers);
     await hook?.runOnSingleObject({
       operationType: "afterRead" /* AfterRead */,
       id
@@ -62491,40 +62507,52 @@ class DatabaseController2 {
       className,
       id,
       context,
-      fields: fieldsWithPointerFields,
+      select: !select ? undefined : selectWithPointersAndRelationsToGetId,
       where: whereWithACLCondition,
       skipHooks: true
     });
-    return this._getFinalObjectWithPointer(objectToReturn, pointers, className, context);
+    return {
+      ...objectToReturn,
+      ...await this._getFinalObjectWithPointerAndRelation({
+        context,
+        originClassName: className,
+        pointers,
+        object: objectToReturn,
+        isGraphQLCall
+      })
+    };
   }
   async getObjects({
     className,
-    fields,
+    select,
     context,
     where,
     skipHooks,
     first,
     offset,
-    order
+    order,
+    isGraphQLCall = false
   }) {
-    const typedFields = fields;
-    const { pointersFieldsId, pointers } = this._getPointerObject(className, typedFields, context);
-    const fieldsWithoutPointers = typedFields.filter((field) => !field.includes("."));
+    const { pointers, selectWithoutPointers } = this._getSelectMinusPointersAndRelations({
+      className,
+      context,
+      select
+    });
     const whereWithPointer = await this._getWhereObjectWithPointerOrRelation(className, where || {}, context);
-    const whereWithACLCondition = this._buildWhereWithACL(whereWithPointer, context, "read");
+    const whereWithACLCondition = this._buildWhereWithACL(whereWithPointer || {}, context, "read");
+    const selectWithPointersAndRelationsToGetId = Object.keys(pointers).reduce((acc, fieldName) => {
+      acc[fieldName] = true;
+      return acc;
+    }, selectWithoutPointers);
     const hook = !skipHooks ? initializeHook({
       className,
-      fields,
+      select: selectWithoutPointers,
       context
     }) : undefined;
     await hook?.runOnMultipleObjects({
       operationType: "beforeRead" /* BeforeRead */,
       where: whereWithACLCondition
     });
-    const fieldsWithPointerFields = [
-      ...fieldsWithoutPointers,
-      ...pointersFieldsId || []
-    ];
     await hook?.runOnMultipleObjects({
       operationType: "afterRead" /* AfterRead */,
       where: whereWithACLCondition
@@ -62535,23 +62563,33 @@ class DatabaseController2 {
       first,
       offset,
       where: whereWithACLCondition,
-      fields: fieldsWithPointerFields,
+      select: !select ? undefined : selectWithPointersAndRelationsToGetId,
       order,
       skipHooks: true
     });
-    return Promise.all(objectsToReturn.map((object) => this._getFinalObjectWithPointer(object, pointers, className, context)));
+    return Promise.all(objectsToReturn.map(async (object) => ({
+      ...object,
+      ...await this._getFinalObjectWithPointerAndRelation({
+        object,
+        context,
+        originClassName: className,
+        pointers,
+        isGraphQLCall
+      })
+    })));
   }
   async createObject({
     className,
     context,
     data,
-    fields
+    select,
+    isGraphQLCall = false
   }) {
     const hook = initializeHook({
       className,
       context,
       newData: data,
-      fields
+      select
     });
     const { newData } = await hook.runOnSingleObject({
       operationType: "beforeCreate" /* BeforeCreate */
@@ -62559,31 +62597,33 @@ class DatabaseController2 {
     const { id } = await this.adapter.createObject({
       className,
       context,
-      fields,
+      select,
       data: newData
     });
     await hook.runOnSingleObject({
       operationType: "afterCreate" /* AfterCreate */,
       id
     });
-    if (fields.length === 0)
+    if (select && Object.keys(select).length === 0)
       return null;
     return this.getObject({
       className,
       context: contextWithRoot(context),
-      fields,
+      select,
       id,
-      skipHooks: true
+      skipHooks: true,
+      isGraphQLCall
     });
   }
   async createObjects({
     data,
-    fields,
+    select,
     className,
     context,
     first,
     offset,
-    order
+    order,
+    isGraphQLCall = false
   }) {
     if (data.length === 0)
       return [];
@@ -62591,14 +62631,14 @@ class DatabaseController2 {
       className,
       context,
       newData,
-      fields
+      select
     })));
     const arrayOfComputedData = await Promise.all(hooks.map(async (hook) => (await hook.runOnMultipleObjects({
       operationType: "beforeCreate" /* BeforeCreate */
     }))?.newData[0]));
     const listOfIds = await this.adapter.createObjects({
       className,
-      fields,
+      select,
       context,
       data: arrayOfComputedData,
       first,
@@ -62610,17 +62650,18 @@ class DatabaseController2 {
       operationType: "afterCreate" /* AfterCreate */,
       ids
     })));
-    if (fields.length === 0)
+    if (select && Object.keys(select).length === 0)
       return [];
     return this.getObjects({
       className,
       context,
-      fields,
+      select,
       where: { id: { in: ids } },
       skipHooks: true,
       first,
       offset,
-      order
+      order,
+      isGraphQLCall
     });
   }
   async updateObject({
@@ -62628,14 +62669,15 @@ class DatabaseController2 {
     className,
     context,
     data,
-    fields,
-    skipHooks
+    select,
+    skipHooks,
+    isGraphQLCall = false
   }) {
     const hook = !skipHooks ? initializeHook({
       className,
       context,
       newData: data,
-      fields
+      select
     }) : undefined;
     const resultsAfterBeforeUpdate = await hook?.runOnSingleObject({
       operationType: "beforeUpdate" /* BeforeUpdate */,
@@ -62644,7 +62686,7 @@ class DatabaseController2 {
     const whereWithACLCondition = this._buildWhereWithACL({}, context, "write");
     await this.adapter.updateObject({
       className,
-      fields,
+      select,
       id,
       context,
       data: resultsAfterBeforeUpdate?.newData || data,
@@ -62655,33 +62697,35 @@ class DatabaseController2 {
       id,
       originalObject: resultsAfterBeforeUpdate?.object
     });
-    if (fields.length === 0)
+    if (select && Object.keys(select).length === 0)
       return null;
     return this.getObject({
       className,
       context,
-      fields,
+      select,
       id,
-      skipHooks: true
+      skipHooks: true,
+      isGraphQLCall
     });
   }
   async updateObjects({
     className,
     where,
     context,
-    fields,
+    select,
     data,
     first,
     offset,
     order,
-    skipHooks
+    skipHooks,
+    isGraphQLCall = false
   }) {
     const whereObject = await this._getWhereObjectWithPointerOrRelation(className, where || {}, context);
     const hook = !skipHooks ? initializeHook({
       className,
       context,
       newData: data,
-      fields
+      select
     }) : undefined;
     const whereWithACLCondition = this._buildWhereWithACL(whereObject, context, "write");
     const resultsAfterBeforeUpdate = await hook?.runOnMultipleObjects({
@@ -62691,7 +62735,7 @@ class DatabaseController2 {
     const objects = await this.adapter.updateObjects({
       className,
       context,
-      fields,
+      select,
       data: resultsAfterBeforeUpdate?.newData[0] || data,
       where: whereWithACLCondition,
       first,
@@ -62704,39 +62748,42 @@ class DatabaseController2 {
       ids: objectsId,
       originalObjects: resultsAfterBeforeUpdate?.objects || []
     });
-    if (fields.length === 0)
+    if (select && Object.keys(select).length === 0)
       return [];
     return this.getObjects({
       className,
       context,
-      fields,
+      select,
       where: { id: { in: objectsId } },
       skipHooks: true,
       first,
       offset,
-      order
+      order,
+      isGraphQLCall
     });
   }
   async deleteObject({
     context,
     className,
     id,
-    fields
+    select,
+    isGraphQLCall = false
   }) {
     const hook = initializeHook({
       className,
       context,
-      fields
+      select
     });
     const whereWithACLCondition = this._buildWhereWithACL({}, context, "write");
     let objectBeforeDelete = null;
-    if (fields.length > 0)
+    if (select && Object.keys(select).length > 0)
       objectBeforeDelete = await this.getObject({
         className,
-        fields,
+        select,
         id,
         context,
-        skipHooks: true
+        skipHooks: true,
+        isGraphQLCall
       });
     const resultOfBeforeDelete = await hook.runOnSingleObject({
       operationType: "beforeDelete" /* BeforeDelete */,
@@ -62745,7 +62792,7 @@ class DatabaseController2 {
     await this.adapter.deleteObject({
       className,
       context,
-      fields,
+      select,
       id,
       where: whereWithACLCondition
     });
@@ -62758,30 +62805,32 @@ class DatabaseController2 {
   async deleteObjects({
     className,
     context,
-    fields,
+    select,
     where,
     first,
     offset,
-    order
+    order,
+    isGraphQLCall = false
   }) {
     const whereObject = await this._getWhereObjectWithPointerOrRelation(className, where || {}, context);
     const hook = initializeHook({
       className,
       context,
-      fields
+      select
     });
     const whereWithACLCondition = this._buildWhereWithACL(whereObject, context, "write");
     let objectsBeforeDelete = [];
-    if (fields.length > 0)
+    if (select && Object.keys(select).length > 0)
       objectsBeforeDelete = await this.getObjects({
         className,
         where,
-        fields,
+        select,
         context,
         first,
         offset,
         order,
-        skipHooks: true
+        skipHooks: true,
+        isGraphQLCall
       });
     const resultOfBeforeDelete = await hook.runOnMultipleObjects({
       operationType: "beforeDelete" /* BeforeDelete */,
@@ -62790,7 +62839,7 @@ class DatabaseController2 {
     await this.adapter.deleteObjects({
       className,
       context,
-      fields,
+      select,
       first,
       offset,
       where: whereWithACLCondition,
@@ -62844,15 +62893,34 @@ class Session {
       where: {
         accessToken: { equalTo: accessToken }
       },
+      select: {
+        id: true,
+        user: true
+      },
       first: 1,
-      fields: ["user.*", "user.role.*", "id"],
       context
     });
     if (sessions.length === 0)
       return { sessionId: null, user: null };
     const session = sessions[0];
     const user = session?.user;
-    return { sessionId: session?.id ?? null, user: user ?? null };
+    if (!user)
+      return { sessionId: session?.id ?? null, user: null };
+    const userWithRole = await context.wabe.controllers.database.getObject({
+      className: "User",
+      select: {
+        role: true
+      },
+      context,
+      id: user.id
+    });
+    return {
+      sessionId: session?.id ?? null,
+      user: {
+        ...user,
+        role: userWithRole?.role
+      }
+    };
   }
   async create(userId, context) {
     this.accessToken = import_jsonwebtoken.default.sign({
@@ -62875,7 +62943,7 @@ class Session {
         refreshTokenExpiresAt: this.getRefreshTokenExpireAt(context.wabe.config),
         user: userId
       },
-      fields: ["id"]
+      select: { id: true }
     });
     if (!res)
       throw new Error("Session not created");
@@ -62892,7 +62960,7 @@ class Session {
       className: "_Session",
       context: contextWithRoot(context),
       id: context.sessionId,
-      fields: []
+      select: {}
     });
   }
   _isRefreshTokenExpired(userRefreshTokenExpiresAt, refreshTokenAgeInMs) {
@@ -62906,7 +62974,18 @@ class Session {
       where: {
         accessToken: { equalTo: accessToken }
       },
-      fields: ["id", "user", "refreshToken", "refreshTokenExpiresAt"],
+      select: {
+        id: true,
+        user: {
+          id: true,
+          role: {
+            id: true,
+            name: true
+          }
+        },
+        refreshToken: true,
+        refreshTokenExpiresAt: true
+      },
       context: contextWithRoot(context)
     });
     if (!session.length)
@@ -62922,10 +63001,10 @@ class Session {
       refreshToken: databaseRefreshToken,
       id
     } = session[0];
-    if (refreshTokenExpiresAt < new Date(Date.now()))
+    if (new Date(refreshTokenExpiresAt) < new Date(Date.now()))
       throw new Error("Refresh token expired");
     const expiresInMs = this._getRefreshTokenExpiresInMs(context.wabe.config);
-    if (!this._isRefreshTokenExpired(refreshTokenExpiresAt, expiresInMs))
+    if (!this._isRefreshTokenExpired(new Date(refreshTokenExpiresAt), expiresInMs))
       return {
         accessToken,
         refreshToken
@@ -62958,7 +63037,7 @@ class Session {
         refreshToken: newRefreshToken,
         refreshTokenExpiresAt: this.getRefreshTokenExpireAt(context.wabe.config)
       },
-      fields: []
+      select: {}
     });
     return {
       accessToken: newAccessToken,
@@ -63017,7 +63096,7 @@ var signUpWithResolver = async (_, {
       authentication: input.authentication
     },
     context,
-    fields: ["id"]
+    select: { id: true }
   });
   const createdUserId = res?.id;
   const session = new Session;
@@ -63232,6 +63311,8 @@ var verifyChallengeResolver = async (_, {
 
 // src/schema/resolvers/meResolver.ts
 var meResolver = (_, __, context) => {
+  if (!context.user?.id)
+    return { user: undefined };
   return {
     user: context.user
   };
@@ -63284,7 +63365,7 @@ var resetPasswordResolver = async (_, { input: { email, password, otp, provider
         equalTo: email
       }
     },
-    fields: ["id"],
+    select: { id: true },
     first: 1,
     context: contextWithRoot(context)
   });
@@ -63310,7 +63391,7 @@ var resetPasswordResolver = async (_, { input: { email, password, otp, provider
         }
       }
     },
-    fields: [],
+    select: {},
     context: contextWithRoot(context)
   });
   return true;
@@ -63450,7 +63531,7 @@ var sendOtpCodeResolver = async (_, { input }, context) => {
         equalTo: input.email
       }
     },
-    fields: ["id"],
+    select: { id: true },
     first: 1,
     context: contextWithRoot(context)
   });
@@ -66604,7 +66685,7 @@ var GraphqlParser = ({ scalars, enums }) => ({
           const graphqlType2 = getGraphqlType({
             type: currentField.type,
             typeValue: currentField.typeValue,
-            isWhereType: false,
+            isWhereType,
             requiredValue: currentField.requiredValue
           });
           acc[key] = {
@@ -66883,7 +66964,7 @@ var createAndLink = async ({
   const res = await context.wabe.controllers.database.createObject({
     className: classInSchema.fields[fieldName].class,
     data: createAndLink2,
-    fields: ["id"],
+    select: { id: true },
     context
   });
   return res?.id;
@@ -66898,7 +66979,7 @@ var createAndAdd = async ({
   const result2 = await context.wabe.controllers.database.createObjects({
     className: classInSchema.fields[fieldName].class,
     data: createAndAdd2,
-    fields: ["id"],
+    select: { id: true },
     context
   });
   return result2.map((object) => object.id);
@@ -66920,16 +67001,16 @@ var add = async ({
     const currentValue = await context.wabe.controllers.database.getObject({
       className,
       id,
-      fields: [fieldName],
+      select: { id: true },
       context
     });
-    return [...currentValue?.[fieldName] || [], ...add2];
+    return [currentValue?.id, ...add2];
   }
   if (typeOfExecution === "updateMany" && where) {
     const allObjectsMatchedWithWhere = await context.wabe.controllers.database.getObjects({
       className: fieldInClass.class,
       where,
-      fields: [fieldName],
+      select: { [fieldName]: true },
       context
     });
     await Promise.all(allObjectsMatchedWithWhere.map((object) => {
@@ -66941,7 +67022,7 @@ var add = async ({
           [fieldName]: [...currentValue || [], ...add2]
         },
         context,
-        fields: []
+        select: {}
       });
     }));
   }
@@ -66961,17 +67042,17 @@ var remove = async ({
     const currentValue = await context.wabe.controllers.database.getObject({
       className,
       id,
-      fields: [fieldName],
+      select: { id: true },
       context
     });
-    const olderValues = currentValue?.[fieldName] || [];
+    const olderValues = [currentValue?.id || ""];
     return olderValues.filter((olderValue) => !remove2.includes(olderValue));
   }
   if (typeOfExecution === "updateMany" && where) {
     const allObjectsMatchedWithWhere = await context.wabe.controllers.database.getObjects({
       className,
       where,
-      fields: ["id"],
+      select: { id: true },
       context
     });
     await Promise.all(allObjectsMatchedWithWhere.map(async (object) => {
@@ -66983,7 +67064,7 @@ var remove = async ({
           [fieldName]: olderValues.filter((olderValue) => !remove2.includes(olderValue))
         },
         context,
-        fields: []
+        select: {}
       });
     }));
   }
@@ -66994,16 +67075,23 @@ var extractFieldsFromSetNode = (selectionSet, className) => {
   const ignoredFields = ["edges", "node"];
   if (className)
     ignoredFields.push(firstLetterInLowerCase(className));
-  return selectionSet.selections?.flatMap((selection) => {
+  return selectionSet.selections?.reduce((acc, selection) => {
     const currentValue = selection.name.value;
     if (selection.selectionSet?.selections && selection.selectionSet?.selections?.length > 0) {
       const res = extractFieldsFromSetNode(selection.selectionSet, className);
       if (ignoredFields.indexOf(currentValue) === -1)
-        return res.map((field) => `${currentValue}.${field}`);
-      return res;
+        return {
+          ...acc,
+          [currentValue]: res
+        };
+      return {
+        ...acc,
+        ...res
+      };
     }
-    return currentValue;
-  }).filter((value) => ignoredFields.indexOf(value) === -1);
+    acc[currentValue] = true;
+    return acc;
+  }, {});
 };
 var getFieldsFromInfo = (info, className) => {
   const selectionSet = info.fieldNodes[0].selectionSet;
@@ -67014,24 +67102,6 @@ var getFieldsFromInfo = (info, className) => {
     throw new Error("No fields provided");
   return fields;
 };
-var getFieldsOfClassName = ({
-  fields,
-  className,
-  context
-}) => {
-  const classFields = context.wabe.config.schema?.classes?.find((schemaClass) => schemaClass.name === className)?.fields;
-  if (!classFields)
-    return { classFields: [], othersFields: fields };
-  const sameFieldsAsClass = fields.filter((field) => {
-    if (classFields[field] || field === "id")
-      return true;
-    if (Object.keys(classFields).find((classField) => field.includes(classField)))
-      return true;
-    return false;
-  });
-  const othersFields = fields.filter((field) => !sameFieldsAsClass.includes(field));
-  return { classFields: sameFieldsAsClass, othersFields };
-};
 var executeRelationOnFields = ({
   className,
   fields,
@@ -67099,27 +67169,29 @@ var transformOrder = (order) => order?.reduce((acc, currentOrder) => {
   return acc;
 }, {}) || {};
 var queryForOneObject = (_, { id }, context, info, className) => {
-  const fields = getFieldsFromInfo(info, className);
+  const select = getFieldsFromInfo(info, className);
   return context.wabe.controllers.database.getObject({
     className,
     id,
-    fields,
-    context
+    select,
+    context,
+    isGraphQLCall: true
   });
 };
 var queryForMultipleObject = async (_, { where, offset, first, order }, context, info, className) => {
-  const fields = getFieldsFromInfo(info, className);
+  const select = getFieldsFromInfo(info, className);
   const objects = await context.wabe.controllers.database.getObjects({
     className,
     where,
-    fields,
+    select,
     offset,
     first,
     context,
-    order: transformOrder(order)
+    order: transformOrder(order),
+    isGraphQLCall: true
   });
   return {
-    totalCount: fields.includes("totalCount") ? await context.wabe.controllers.database.count({
+    totalCount: select.totalCount ? await context.wabe.controllers.database.count({
       className,
       where,
       context
@@ -67130,11 +67202,7 @@ var queryForMultipleObject = async (_, { where, offset, first, order }, context,
   };
 };
 var mutationToCreateObject = async (_, args, context, info, className) => {
-  const { classFields, othersFields } = getFieldsOfClassName({
-    fields: getFieldsFromInfo(info, className),
-    className,
-    context
-  });
+  const select = getFieldsFromInfo(info, className);
   const updatedFieldsToCreate = await executeRelationOnFields({
     className,
     fields: args.input?.fields,
@@ -67144,14 +67212,15 @@ var mutationToCreateObject = async (_, args, context, info, className) => {
     [firstLetterInLowerCase(className)]: await context.wabe.controllers.database.createObject({
       className,
       data: updatedFieldsToCreate,
-      fields: classFields,
-      context
+      select,
+      context,
+      isGraphQLCall: true
     }),
-    ...othersFields.includes("ok") ? { ok: true } : {}
+    ...select.ok ? { ok: true } : {}
   };
 };
 var mutationToCreateMultipleObjects = async (_, { input: { fields, offset, first, order } }, context, info, className) => {
-  const outputFields = getFieldsFromInfo(info, className);
+  const select = getFieldsFromInfo(info, className);
   const inputFields = fields;
   const updatedFieldsToCreate = await Promise.all(inputFields.map((inputField) => executeRelationOnFields({
     className,
@@ -67161,22 +67230,19 @@ var mutationToCreateMultipleObjects = async (_, { input: { fields, offset, first
   const objects = await context.wabe.controllers.database.createObjects({
     className,
     data: updatedFieldsToCreate,
-    fields: outputFields,
+    select,
     offset,
     first,
     context,
-    order: transformOrder(order)
+    order: transformOrder(order),
+    isGraphQLCall: true
   });
   return {
     edges: objects.map((object) => ({ node: object }))
   };
 };
 var mutationToUpdateObject = async (_, args, context, info, className) => {
-  const { classFields, othersFields } = getFieldsOfClassName({
-    fields: getFieldsFromInfo(info, className),
-    className,
-    context
-  });
+  const select = getFieldsFromInfo(info, className);
   const updatedFields = await executeRelationOnFields({
     className,
     fields: args.input?.fields,
@@ -67189,14 +67255,15 @@ var mutationToUpdateObject = async (_, args, context, info, className) => {
       className,
       id: args.input?.id,
       data: updatedFields,
-      fields: classFields,
-      context
+      select,
+      context,
+      isGraphQLCall: true
     }),
-    ...othersFields.includes("ok") ? { ok: true } : {}
+    ...select.ok ? { ok: true } : {}
   };
 };
 var mutationToUpdateMultipleObjects = async (_, { input: { fields, where, offset, first, order } }, context, info, className) => {
-  const outputFields = getFieldsFromInfo(info, className);
+  const select = getFieldsFromInfo(info, className);
   const updatedFields = await executeRelationOnFields({
     className,
     fields,
@@ -67208,42 +67275,41 @@ var mutationToUpdateMultipleObjects = async (_, { input: { fields, where, offset
     className,
     where,
     data: updatedFields,
-    fields: outputFields,
+    select,
     offset,
     first,
     context,
-    order
+    order,
+    isGraphQLCall: true
   });
   return {
     edges: objects.map((object) => ({ node: object }))
   };
 };
 var mutationToDeleteObject = async (_, args, context, info, className) => {
-  const { classFields, othersFields } = getFieldsOfClassName({
-    fields: getFieldsFromInfo(info, className),
-    className,
-    context
-  });
+  const select = getFieldsFromInfo(info, className);
   return {
     [firstLetterInLowerCase(className)]: await context.wabe.controllers.database.deleteObject({
       className,
       id: args.input?.id,
-      fields: classFields,
-      context
+      select,
+      context,
+      isGraphQLCall: true
     }),
-    ...othersFields.includes("ok") ? { ok: true } : {}
+    ...select.ok ? { ok: true } : {}
   };
 };
 var mutationToDeleteMultipleObjects = async (_, { input: { where, offset, first, order } }, context, info, className) => {
-  const outputFields = getFieldsFromInfo(info, className);
+  const select = getFieldsFromInfo(info, className);
   const objects = await context.wabe.controllers.database.deleteObjects({
     className,
     where,
-    fields: outputFields,
+    select,
     offset,
     first,
     context,
-    order
+    order,
+    isGraphQLCall: true
   });
   return {
     edges: objects.map((object) => ({ node: object }))
@@ -68056,130 +68122,206 @@ var defaultRoutes = () => {
 // src/server/generateCodegen.ts
 var import_graphql6 = __toESM(require_graphql2(), 1);
 import { writeFile as writeFile2, readFile } from "node:fs/promises";
-var defaultScalars = {
-  ID: { input: "string", output: "string" },
-  String: { input: "string", output: "string" },
-  Boolean: { input: "boolean", output: "boolean" },
-  Int: { input: "number", output: "number" },
-  Float: { input: "number", output: "number" },
-  Email: { input: "string", output: "string" },
-  Phone: { input: "string", output: "string" },
-  Date: { input: "Date", output: "string" },
-  Search: { input: "any", output: "any" },
-  Any: { input: "any", output: "any" },
-  File: { input: "any", output: "any" }
+var wabePrimaryTypesToTypescriptTypes = {
+  Boolean: "boolean",
+  Int: "number",
+  Float: "number",
+  String: "string",
+  Email: "string",
+  Phone: "string",
+  Date: "Date",
+  File: "{url: string, name: string}"
 };
-var getScalarsCode = () => Object.keys(defaultScalars).reduce((acc, scalarName) => {
-  const scalarDef = defaultScalars[scalarName];
-  return `${acc}  ${scalarName}: { input: ${scalarDef.input}; output: ${scalarDef.output}; };
-`;
-}, `export type Scalars = {
-`);
-var customScalars = new Set;
-var generateTypescriptFromSchema = (schema) => {
-  const documentNode = import_graphql6.parse(schema);
-  const scalarsCode = getScalarsCode();
-  let typescriptCode = scalarsCode + `};
-
-`;
-  import_graphql6.visit(documentNode, {
-    ScalarTypeDefinition(node) {
-      const typeName = node.name.value;
-      if (!defaultScalars[typeName]) {
-        typescriptCode += `type ${typeName} = Scalars['${typeName}']; // Custom Scalar
-`;
-      }
-    },
-    ObjectTypeDefinition(node) {
-      const typeName = node.name.value;
-      let fieldsCode = "";
-      for (const field of node.fields || []) {
-        const fieldName = field.name.value;
-        const fieldType = getFieldType(field.type, false);
-        const isOptional = field.type.kind !== "NonNullType";
-        fieldsCode += `  ${fieldName}${isOptional ? "?" : ""}: ${fieldType};
-`;
-      }
-      typescriptCode += `
-export type ${typeName} = {
-${fieldsCode}};
-`;
-      if (typeName === "Mutation" || typeName === "Query") {
-        for (const field of node.fields || []) {
-          const fieldName = field.name.value;
-          const args = field.arguments || [];
-          if (args.length === 1 && args[0].name.value === "input") {
-            const inputType = getFieldType(args[0].type, true);
-            typescriptCode += `
-export type ${firstLetterUpperCase(typeName)}${firstLetterUpperCase(fieldName)}Args = {
-  input: ${inputType};
+var wabeTypesToTypescriptTypes = ({
+  field,
+  isInput = false
+}) => {
+  switch (field.type) {
+    case "Date":
+      if (isInput)
+        return "Date";
+      return "string";
+    case "Boolean":
+    case "Int":
+    case "Float":
+    case "String":
+    case "Email":
+    case "Phone":
+    case "File":
+      return wabePrimaryTypesToTypescriptTypes[field.type];
+    case "Array":
+      if (field.typeValue === "Object")
+        return `Array<${field.object.name}>`;
+      return `Array<${wabePrimaryTypesToTypescriptTypes[field.typeValue]}>`;
+    case "Pointer":
+      return field.class;
+    case "Relation":
+      return `Array<${field.class}>`;
+    case "Object":
+      return `${field.object.name}`;
+    default:
+      return field.type;
+  }
 };
-`;
-          } else if (args.length > 0) {
-            const argsCode = args.reduce((acc, arg) => {
-              const argName = arg.name.value;
-              const argType = getFieldType(arg.type, true);
-              const isOptional = arg.type.kind !== "NonNullType";
-              return `${acc}  ${argName}${isOptional ? "?" : ""}: ${argType};
-`;
-            }, `
-export type ${firstLetterUpperCase(typeName)}${firstLetterUpperCase(fieldName)}Args = {
-`);
-            typescriptCode += `${argsCode}};
-`;
+var generateWabeObject = (object, prefix = "") => {
+  const objectName = object.name;
+  return Object.entries(object.fields).reduce((acc, [fieldName, field]) => {
+    const type = wabeTypesToTypescriptTypes({ field });
+    const objectNameWithPrefix = `${prefix}${firstLetterUpperCase(objectName)}`;
+    if (field.type === "Object" || field.type === "Array" && field.typeValue === "Object") {
+      const subObject = generateWabeObject(field.object, objectNameWithPrefix);
+      const isArray = field.type === "Array";
+      return {
+        ...acc,
+        ...subObject,
+        ...{
+          [objectNameWithPrefix]: {
+            ...acc[objectNameWithPrefix],
+            [`${fieldName}${field.required ? "" : "undefined"}`]: `${isArray ? "Array<" : ""}${objectNameWithPrefix}${firstLetterUpperCase(field.object.name)}${isArray ? ">" : ""}`
           }
         }
+      };
+    }
+    return {
+      ...acc,
+      ...{
+        [objectNameWithPrefix]: {
+          ...acc[objectNameWithPrefix],
+          [`${fieldName}${field.required ? "" : "undefined"}`]: `${type}`
+        }
       }
-    },
-    InputObjectTypeDefinition(node) {
-      const inputTypeName = node.name.value;
-      let inputFieldsCode = "";
-      for (const field of node.fields || []) {
-        const fieldName = field.name.value;
-        const fieldType = getFieldType(field.type, true);
-        const isOptional = field.type.kind !== "NonNullType";
-        inputFieldsCode += `  ${fieldName}${isOptional ? "?" : ""}: ${fieldType};
-`;
+    };
+  }, {});
+};
+var generateWabeTypes = (classes) => {
+  const wabeTypes = classes.reduce((acc, classType) => {
+    const { name, fields } = classType;
+    const objectsToLoad = [];
+    const currentClass = Object.entries(fields).reduce((acc2, [name2, field]) => {
+      const type = wabeTypesToTypescriptTypes({ field });
+      if (field.type === "Object" || field.type === "Array" && field.typeValue === "Object") {
+        const wabeObject = generateWabeObject(field.object);
+        objectsToLoad.push(wabeObject);
       }
-      typescriptCode += `
-export type ${inputTypeName} = {
-${inputFieldsCode}};
+      return {
+        ...acc2,
+        [`${name2}${field.required ? "" : "undefined"}`]: type
+      };
+    }, {});
+    const objects = objectsToLoad.reduce((acc2, object) => {
+      return {
+        ...acc2,
+        ...object
+      };
+    }, {});
+    return {
+      ...acc,
+      ...objects,
+      [name]: { id: "string", ...currentClass }
+    };
+  }, {});
+  return wabeTypes;
+};
+var generateWabeEnumTypes = (enums) => {
+  return Object.values(enums).reduce((acc, { name, values }) => {
+    return {
+      ...acc,
+      [name]: values
+    };
+  }, {});
+};
+var generateWabeScalarTypes = (scalars) => {
+  return Object.values(scalars).reduce((acc, { name }) => {
+    return {
+      ...acc,
+      [name]: "string"
+    };
+  }, {});
+};
+var generateWabeMutationOrQueryInput = (mutationOrQueryName, resolver, isMutation) => {
+  const objectsToLoad = [];
+  const mutationNameWithFirstLetterUpperCase = firstLetterUpperCase(mutationOrQueryName);
+  const mutationObject = Object.entries((isMutation ? resolver.args?.input : resolver.args) || {}).reduce((acc, [name, field]) => {
+    let type = wabeTypesToTypescriptTypes({ field, isInput: true });
+    if (field.type === "Object") {
+      type = firstLetterInUpperCase(name);
+      const wabeObject = generateWabeObject({
+        ...field.object,
+        name: type
+      }, mutationNameWithFirstLetterUpperCase);
+      objectsToLoad.push(wabeObject);
+      return {
+        ...acc,
+        [`${name}${field.required ? "" : "undefined"}`]: `${mutationNameWithFirstLetterUpperCase}${type}`
+      };
+    }
+    return {
+      ...acc,
+      [`${name}${field.required ? "" : "undefined"}`]: type
+    };
+  }, {});
+  const objects = objectsToLoad.reduce((acc2, object) => {
+    return {
+      ...acc2,
+      ...object
+    };
+  }, {});
+  return {
+    ...isMutation ? {
+      [`${firstLetterInUpperCase(mutationOrQueryName)}Input`]: mutationObject
+    } : {},
+    [`${isMutation ? "Mutation" : "Query"}${firstLetterInUpperCase(mutationOrQueryName)}Args`]: isMutation ? {
+      input: `${firstLetterInUpperCase(mutationOrQueryName)}Input`
+    } : mutationObject,
+    ...objects
+  };
+};
+var generateWabeMutationsAndQueriesTypes = (resolver) => {
+  const mutationsObject = Object.entries(resolver.mutations || {}).reduce((acc, [mutationName, mutation]) => {
+    return {
+      ...acc,
+      ...generateWabeMutationOrQueryInput(mutationName, mutation, true)
+    };
+  }, {});
+  const queriesObject = Object.entries(resolver.queries || {}).reduce((acc, [queryName, query]) => {
+    return {
+      ...acc,
+      ...generateWabeMutationOrQueryInput(queryName, query, false)
+    };
+  }, {});
+  return {
+    ...mutationsObject,
+    ...queriesObject
+  };
+};
+var wabeClassRecordToString = (wabeClass) => {
+  return Object.entries(wabeClass).reduce((acc, [className, fields]) => {
+    return `${acc}export type ${className} = {
+${Object.entries(fields).map(([fieldName, fieldType]) => `	${fieldName.replace("undefined", "?")}: ${fieldType}`).join(`,
+`)}
+}
+
 `;
-    },
-    EnumTypeDefinition(node) {
-      const enumName = node.name.value;
-      const values = node.values?.map((value) => `  ${value.name.value} = "${value.name.value}",`).join(`
-`) || "";
-      typescriptCode += `
-export enum ${enumName} {
-${values}
+  }, "");
+};
+var wabeEnumRecordToString = (wabeEnum) => {
+  return Object.entries(wabeEnum).reduce((acc, [enumName, values]) => {
+    return `${acc}export enum ${enumName} {
+${Object.entries(values).map(([valueName, value]) => `	${valueName} = "${value}"`).join(`,
+`)}
 }
+
 `;
-    }
-  });
-  return typescriptCode;
+  }, "");
 };
-var getFieldType = (typeNode, isInputField = false) => {
-  const getNamedType = (node) => {
-    const typeName = node.name.value;
-    if (defaultScalars[typeName])
-      return `Scalars['${typeName}']['${isInputField ? "input" : "output"}']`;
-    if (customScalars.has(typeName))
-      return `Scalars['${typeName}']['${isInputField ? "input" : "output"}']`;
-    return typeName;
-  };
-  switch (typeNode.kind) {
-    case "NamedType":
-      return getNamedType(typeNode);
-    case "NonNullType":
-      return getFieldType(typeNode.type, isInputField);
-    case "ListType":
-      return `${getFieldType(typeNode.type, isInputField)}[]`;
-    default:
-      return "any";
-  }
+var wabeScalarRecordToString = (wabeScalar) => {
+  return Object.entries(wabeScalar).reduce((acc, [scalarName, scalarType]) => {
+    return `${acc}export type ${scalarName} = ${scalarType}
+
+`;
+  }, "");
 };
-var generateAdditionalTypes = ({
+var generateWabeDevTypes = ({
   scalars,
   enums,
   classes
@@ -68204,27 +68346,32 @@ ${globalWabeTypeString}`;
 };
 var generateCodegen = async ({
   schema,
-  path,
+  path: path2,
   graphqlSchema
 }) => {
   const graphqlSchemaContent = import_graphql6.printSchema(graphqlSchema);
-  const typescriptCode = generateTypescriptFromSchema(graphqlSchemaContent);
-  const wabeOutput = generateAdditionalTypes({
+  const wabeClasses = generateWabeTypes(schema.classes || []);
+  const mutationsAndQueries = generateWabeMutationsAndQueriesTypes(schema.resolvers || {});
+  const wabeEnumsInString = wabeEnumRecordToString(generateWabeEnumTypes(schema.enums || []));
+  const wabeScalarsInString = wabeScalarRecordToString(generateWabeScalarTypes(schema.scalars || []));
+  const wabeObjectsInString = wabeClassRecordToString({
+    ...wabeClasses,
+    ...mutationsAndQueries
+  });
+  const wabeDevTypes = generateWabeDevTypes({
     scalars: schema.scalars,
     enums: schema.enums,
     classes: schema.classes || []
   });
-  const wabeTsContent = `${typescriptCode}
-
-${wabeOutput}`;
+  const wabeTsContent = `${wabeEnumsInString}${wabeScalarsInString}${wabeObjectsInString}${wabeDevTypes}`;
   try {
-    const contentOfGraphqlSchema = (await readFile(`${path}/schema.graphql`)).toString();
+    const contentOfGraphqlSchema = (await readFile(`${path2}/schema.graphql`)).toString();
     if (!process.env.CODEGEN && contentOfGraphqlSchema === graphqlSchemaContent.toString())
       return;
   } catch {
   }
-  await writeFile2(`${path}/wabe.ts`, wabeTsContent);
-  await writeFile2(`${path}/schema.graphql`, graphqlSchemaContent);
+  await writeFile2(`${path2}/wabe.ts`, wabeTsContent);
+  await writeFile2(`${path2}/schema.graphql`, graphqlSchemaContent);
 };
 
 // src/authentication/providers/EmailPassword.ts
@@ -68244,7 +68391,7 @@ class EmailPassword {
         }
       },
       context: contextWithRoot(context),
-      fields: ["id", "authentication"],
+      select: { id: true, authentication: true },
       first: 1
     });
     if (users.length === 0)
@@ -68299,7 +68446,7 @@ class EmailPassword {
         }
       },
       context,
-      fields: ["authentication"]
+      select: { authentication: true }
     });
     if (users.length === 0)
       throw new Error("User not found");
@@ -68336,7 +68483,7 @@ class Google3 {
       },
       context: contextWithRoot(context),
       first: 1,
-      fields: ["id"]
+      select: { id: true }
     });
     const authenticationDataToSave = {
       email,
@@ -68352,8 +68499,7 @@ class Google3 {
             google: authenticationDataToSave
           }
         },
-        context: contextWithRoot(context),
-        fields: ["*", "id"]
+        context: contextWithRoot(context)
       });
       if (!createdUser)
         throw new Error("User not found");
@@ -68396,7 +68542,7 @@ class GitHub2 {
       },
       context: contextWithRoot(context),
       first: 1,
-      fields: ["id"]
+      select: { id: true }
     });
     const authenticationDataToSave = {
       email,
@@ -68413,8 +68559,7 @@ class GitHub2 {
             github: authenticationDataToSave
           }
         },
-        context: contextWithRoot(context),
-        fields: ["*", "id"]
+        context: contextWithRoot(context)
       });
       if (!createdUser)
         throw new Error("User not found");
@@ -68452,7 +68597,7 @@ class PhonePassword {
         }
       },
       context: contextWithRoot(context),
-      fields: ["id", "authentication"],
+      select: { id: true, authentication: true },
       first: 1
     });
     if (users.length === 0)
@@ -68507,7 +68652,7 @@ class PhonePassword {
         }
       },
       context,
-      fields: ["authentication"]
+      select: { authentication: true }
     });
     if (users.length === 0)
       throw new Error("User not found");
@@ -68631,8 +68776,8 @@ import { createServer as createHttpsServer } from "https";
 class RadixTree {
   root = { name: "/", children: [] };
   isOptimized = false;
-  addRoute(method, path, handler) {
-    const pathParts = path.split("/").filter(Boolean);
+  addRoute(method, path2, handler) {
+    const pathParts = path2.split("/").filter(Boolean);
     let currentNode = this.root;
     for (let i = 0;i < pathParts.length; i++) {
       const pathPart = pathParts[i];
@@ -68640,7 +68785,7 @@ class RadixTree {
       const isWildcardNode = pathPart[0] === "*";
       let foundNode = currentNode.children.find((node) => node.name === (i === 0 ? "" : "/") + pathPart && (node.method === method || !node.method));
       if (foundNode && foundNode.method === method && i === pathParts.length - 1)
-        throw new Error(`Route ${method} ${path} already exists`);
+        throw new Error(`Route ${method} ${path2} already exists`);
       if (!foundNode) {
         foundNode = {
           name: (i === 0 ? "" : "/") + pathPart,
@@ -68682,11 +68827,11 @@ class RadixTree {
         break;
     }
   }
-  addHook(hook, path, handler, method, node) {
+  addHook(hook, path2, handler, method, node) {
     if (this.isOptimized)
       throw new Error("Cannot add hooks after the tree has been optimized");
     let currentNode = node || this.root;
-    if (path === "*") {
+    if (path2 === "*") {
       const addHookToChildren = (node2) => {
         for (let i = 0;i < node2.children.length; i++) {
           const child = node2.children[i];
@@ -68705,7 +68850,7 @@ class RadixTree {
       }
       return;
     }
-    const pathParts = path.split("/").filter(Boolean);
+    const pathParts = path2.split("/").filter(Boolean);
     for (let i = 0;i < pathParts.length; i++) {
       const pathPart = pathParts[i];
       const isWildcardNode = pathPart[0] === "*";
@@ -68724,10 +68869,10 @@ class RadixTree {
     }
     this._addHookToNode(currentNode, hook, handler);
   }
-  findRoute(method, path) {
-    let localPath = path;
-    if (path[0] !== "/")
-      localPath = "/" + path;
+  findRoute(method, path2) {
+    let localPath = path2;
+    if (path2[0] !== "/")
+      localPath = "/" + path2;
     const { length: pathLength } = localPath;
     if (pathLength === 1 && localPath === "/")
       return this.root;
@@ -68815,7 +68960,7 @@ class WobeResponse {
     if (options) {
       const {
         httpOnly,
-        path,
+        path: path2,
         domain,
         expires,
         sameSite,
@@ -68824,8 +68969,8 @@ class WobeResponse {
       } = options;
       if (httpOnly)
         cookie = `${cookie} HttpOnly;`;
-      if (path)
-        cookie = `${cookie} Path=${path};`;
+      if (path2)
+        cookie = `${cookie} Path=${path2};`;
       if (domain)
         cookie = `${cookie} Domain=${domain};`;
       if (expires)
@@ -68907,7 +69052,7 @@ var extractPathnameAndSearchParams = (url) => {
   const queryIndex = url.indexOf("?", 8);
   const urlLength = url.length;
   const isQueryContainsSearchParams = queryIndex !== -1;
-  const path = url.slice(url.indexOf("/", 8), !isQueryContainsSearchParams ? urlLength : queryIndex);
+  const path2 = url.slice(url.indexOf("/", 8), !isQueryContainsSearchParams ? urlLength : queryIndex);
   if (isQueryContainsSearchParams) {
     const searchParams = {};
     let indexOfLastParam = queryIndex + 1;
@@ -68923,9 +69068,9 @@ var extractPathnameAndSearchParams = (url) => {
         indexOfLastParam = i + 1;
       }
     }
-    return { pathName: path, searchParams };
+    return { pathName: path2, searchParams };
   }
-  return { pathName: path };
+  return { pathName: path2 };
 };
 
 class Context {
@@ -69134,53 +69279,53 @@ class Wobe {
     this.server = null;
     this.router = new RadixTree;
   }
-  get(path, handler, hook) {
+  get(path2, handler, hook) {
     if (hook)
-      this._addHook("beforeHandler", "GET")(path, hook);
-    this.router.addRoute("GET", path, handler);
+      this._addHook("beforeHandler", "GET")(path2, hook);
+    this.router.addRoute("GET", path2, handler);
     return this;
   }
-  post(path, handler, hook) {
+  post(path2, handler, hook) {
     if (hook)
-      this._addHook("beforeHandler", "POST")(path, hook);
-    this.router.addRoute("POST", path, handler);
+      this._addHook("beforeHandler", "POST")(path2, hook);
+    this.router.addRoute("POST", path2, handler);
     return this;
   }
-  put(path, handler, hook) {
+  put(path2, handler, hook) {
     if (hook)
-      this._addHook("beforeHandler", "PUT")(path, hook);
-    this.router.addRoute("PUT", path, handler);
+      this._addHook("beforeHandler", "PUT")(path2, hook);
+    this.router.addRoute("PUT", path2, handler);
     return this;
   }
-  delete(path, handler, hook) {
+  delete(path2, handler, hook) {
     if (hook)
-      this._addHook("beforeHandler", "DELETE")(path, hook);
-    this.router.addRoute("DELETE", path, handler);
+      this._addHook("beforeHandler", "DELETE")(path2, hook);
+    this.router.addRoute("DELETE", path2, handler);
     return this;
   }
-  options(path, handler, hook) {
+  options(path2, handler, hook) {
     if (hook)
-      this._addHook("beforeHandler", "OPTIONS")(path, hook);
-    this.router.addRoute("OPTIONS", path, handler);
+      this._addHook("beforeHandler", "OPTIONS")(path2, hook);
+    this.router.addRoute("OPTIONS", path2, handler);
     return this;
   }
-  all(path, handler, hook) {
+  all(path2, handler, hook) {
     if (hook) {
-      this.httpMethods.map((method) => this._addHook("beforeHandler", method)(path, hook));
+      this.httpMethods.map((method) => this._addHook("beforeHandler", method)(path2, hook));
     }
-    this.router.addRoute("ALL", path, handler);
+    this.router.addRoute("ALL", path2, handler);
     return this;
   }
   _addHook = (hook, method) => (arg1, ...handlers) => {
-    let path = arg1;
+    let path2 = arg1;
     if (typeof arg1 !== "string") {
-      path = "*";
+      path2 = "*";
       handlers.unshift(arg1);
     }
     handlers.map((handler) => {
-      if (typeof path === "string")
+      if (typeof path2 === "string")
         this.hooks.push({
-          pathname: path,
+          pathname: path2,
           handler,
           hook,
           method
@@ -70320,11 +70465,11 @@ function pushComment(node, entity, field, argument) {
       keys.push(argument);
     }
   }
-  const path = keys.join(".");
-  if (!commentsRegistry[path]) {
-    commentsRegistry[path] = [];
+  const path2 = keys.join(".");
+  if (!commentsRegistry[path2]) {
+    commentsRegistry[path2] = [];
   }
-  commentsRegistry[path].push(comment);
+  commentsRegistry[path2].push(comment);
 }
 function printComment(comment) {
   return `
@@ -70339,9 +70484,9 @@ function hasMultilineItems(maybeArray) {
 `)) ?? false;
 }
 function addDescription(cb) {
-  return (node, _key, _parent, path, ancestors) => {
+  return (node, _key, _parent, path2, ancestors) => {
     const keys = [];
-    const parent = path.reduce((prev, key2) => {
+    const parent = path2.reduce((prev, key2) => {
       if (["fields", "arguments", "values"].includes(key2) && prev.name) {
         keys.push(prev.name.value);
       }
@@ -70352,7 +70497,7 @@ function addDescription(cb) {
     if (node.kind.includes("Definition") && commentsRegistry[key]) {
       items.push(...commentsRegistry[key]);
     }
-    return join([...items.map(printComment), node.description, cb(node, _key, _parent, path, ancestors)], `
+    return join([...items.map(printComment), node.description, cb(node, _key, _parent, path2, ancestors)], `
 `);
   };
 }
@@ -71781,17 +71926,17 @@ function isDocumentNode(object) {
 function addPath(prev, key, typename) {
   return { prev, key, typename };
 }
-function pathToArray(path) {
+function pathToArray(path2) {
   const flattened = [];
-  let curr = path;
+  let curr = path2;
   while (curr) {
     flattened.push(curr.key);
     curr = curr.prev;
   }
   return flattened.reverse();
 }
-function printPathArray(path) {
-  return path.map((key) => typeof key === "number" ? "[" + key.toString() + "]" : "." + key).join("");
+function printPathArray(path2) {
+  return path2.map((key) => typeof key === "number" ? "[" + key.toString() + "]" : "." + key).join("");
 }
 // ../../node_modules/graphql-yoga/esm/error.js
 function isAggregateError(obj) {
@@ -73302,7 +73447,7 @@ function throwEngineFunctionError(name) {
 function createEnvelopOrchestrator({ plugins }) {
   let schema = null;
   let initDone = false;
-  const parse5 = () => throwEngineFunctionError("parse");
+  const parse4 = () => throwEngineFunctionError("parse");
   const validate = () => throwEngineFunctionError("validate");
   const execute = () => throwEngineFunctionError("execute");
   const subscribe = () => throwEngineFunctionError("subscribe");
@@ -73367,7 +73512,7 @@ function createEnvelopOrchestrator({ plugins }) {
   };
   const customParse = beforeCallbacks.parse.length ? (initialContext) => (source, parseOptions) => {
     let result2 = null;
-    let parseFn = parse5;
+    let parseFn = parse4;
     const context = initialContext;
     const afterCalls = [];
     for (const onParse of beforeCallbacks.parse) {
@@ -73414,7 +73559,7 @@ function createEnvelopOrchestrator({ plugins }) {
     }
     documentStringMap.set(result2, source.toString());
     return result2;
-  } : () => parse5;
+  } : () => parse4;
   const customValidate = beforeCallbacks.validate.length ? (initialContext) => (schema2, documentAST, rules, typeInfo, validationOptions) => {
     let actualRules = rules ? [...rules] : undefined;
     let validateFn = validate;
@@ -74019,10 +74164,10 @@ function coerceVariableValues(schema, varDefNodes, inputs, onError) {
       }));
       continue;
     }
-    coercedValues[varName] = import_graphql42.coerceInputValue(value, varType, (path, invalidValue, error) => {
+    coercedValues[varName] = import_graphql42.coerceInputValue(value, varType, (path2, invalidValue, error) => {
       let prefix = `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
-      if (path.length > 0) {
-        prefix += ` at "${varName}${printPathArray(path)}"`;
+      if (path2.length > 0) {
+        prefix += ` at "${varName}${printPathArray(path2)}"`;
       }
       onError(createGraphQLError(prefix + "; " + error.message, {
         nodes: varDefNode,
@@ -74163,22 +74308,22 @@ function executeOperation(exeContext) {
     });
   }
   const { fields: rootFields, patches } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
-  const path = undefined;
+  const path2 = undefined;
   let result2;
   if (operation.operation === "mutation") {
-    result2 = executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
+    result2 = executeFieldsSerially(exeContext, rootType, rootValue, path2, rootFields);
   } else {
-    result2 = executeFields(exeContext, rootType, rootValue, path, rootFields);
+    result2 = executeFields(exeContext, rootType, rootValue, path2, rootFields);
   }
   for (const patch of patches) {
     const { label, fields: patchFields } = patch;
-    executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path);
+    executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path2);
   }
   return result2;
 }
-function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields2) {
+function executeFieldsSerially(exeContext, parentType, sourceValue, path2, fields2) {
   return promiseReduce(fields2, (results, [responseName, fieldNodes]) => {
-    const fieldPath = addPath(path, responseName, parentType.name);
+    const fieldPath = addPath(path2, responseName, parentType.name);
     if (exeContext.signal?.aborted) {
       throw exeContext.signal.reason;
     }
@@ -74191,7 +74336,7 @@ function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields
     });
   }, Object.create(null)).resolve();
 }
-function executeFields(exeContext, parentType, sourceValue, path, fields2, asyncPayloadRecord) {
+function executeFields(exeContext, parentType, sourceValue, path2, fields2, asyncPayloadRecord) {
   const results = Object.create(null);
   let containsPromise = false;
   try {
@@ -74199,7 +74344,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields2, async
       if (exeContext.signal?.aborted) {
         throw exeContext.signal.reason;
       }
-      const fieldPath = addPath(path, responseName, parentType.name);
+      const fieldPath = addPath(path2, responseName, parentType.name);
       const result2 = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
       if (result2 !== undefined) {
         results[responseName] = result2;
@@ -74221,7 +74366,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields2, async
   }
   return promiseForObject(results, exeContext.signal);
 }
-function executeField(exeContext, parentType, source, fieldNodes, path, asyncPayloadRecord) {
+function executeField(exeContext, parentType, source, fieldNodes, path2, asyncPayloadRecord) {
   const errors2 = asyncPayloadRecord?.errors ?? exeContext.errors;
   const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
   if (!fieldDef) {
@@ -74229,32 +74374,32 @@ function executeField(exeContext, parentType, source, fieldNodes, path, asyncPay
   }
   const returnType = fieldDef.type;
   const resolveFn = fieldDef.resolve ?? exeContext.fieldResolver;
-  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path);
+  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path2);
   try {
     const args = getArgumentValues(fieldDef, fieldNodes[0], exeContext.variableValues);
     const contextValue = exeContext.contextValue;
     const result2 = resolveFn(source, args, contextValue, info);
     let completed;
     if (isPromise(result2)) {
-      completed = result2.then((resolved) => completeValue(exeContext, returnType, fieldNodes, info, path, resolved, asyncPayloadRecord));
+      completed = result2.then((resolved) => completeValue(exeContext, returnType, fieldNodes, info, path2, resolved, asyncPayloadRecord));
     } else {
-      completed = completeValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord);
+      completed = completeValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord);
     }
     if (isPromise(completed)) {
       return completed.then(undefined, (rawError) => {
         if (rawError instanceof AggregateError) {
           return new AggregateError(rawError.errors.map((rawErrorItem) => {
             rawErrorItem = coerceError(rawErrorItem);
-            const error2 = import_graphql43.locatedError(rawErrorItem, fieldNodes, pathToArray(path));
+            const error2 = import_graphql43.locatedError(rawErrorItem, fieldNodes, pathToArray(path2));
             const handledError2 = handleFieldError(error2, returnType, errors2);
-            filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+            filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
             return handledError2;
           }));
         }
         rawError = coerceError(rawError);
-        const error = import_graphql43.locatedError(rawError, fieldNodes, pathToArray(path));
+        const error = import_graphql43.locatedError(rawError, fieldNodes, pathToArray(path2));
         const handledError = handleFieldError(error, returnType, errors2);
-        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+        filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
         return handledError;
       });
     }
@@ -74263,24 +74408,24 @@ function executeField(exeContext, parentType, source, fieldNodes, path, asyncPay
     if (rawError instanceof AggregateError) {
       return new AggregateError(rawError.errors.map((rawErrorItem) => {
         const coercedError2 = coerceError(rawErrorItem);
-        const error2 = import_graphql43.locatedError(coercedError2, fieldNodes, pathToArray(path));
+        const error2 = import_graphql43.locatedError(coercedError2, fieldNodes, pathToArray(path2));
         return handleFieldError(error2, returnType, errors2);
       }));
     }
     const coercedError = coerceError(rawError);
-    const error = import_graphql43.locatedError(coercedError, fieldNodes, pathToArray(path));
+    const error = import_graphql43.locatedError(coercedError, fieldNodes, pathToArray(path2));
     const handledError = handleFieldError(error, returnType, errors2);
-    filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+    filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
     return handledError;
   }
 }
-function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
+function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path2) {
   return {
     fieldName: fieldDef.name,
     fieldNodes,
     returnType: fieldDef.type,
     parentType,
-    path,
+    path: path2,
     schema: exeContext.schema,
     fragments: exeContext.fragments,
     rootValue: exeContext.rootValue,
@@ -74299,12 +74444,12 @@ function handleFieldError(error, returnType, errors2) {
   errors2.push(error);
   return null;
 }
-function completeValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord) {
+function completeValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord) {
   if (result2 instanceof Error) {
     throw result2;
   }
   if (import_graphql43.isNonNullType(returnType)) {
-    const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result2, asyncPayloadRecord);
+    const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path2, result2, asyncPayloadRecord);
     if (completed === null) {
       throw new Error(`Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`);
     }
@@ -74314,21 +74459,21 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result2,
     return null;
   }
   if (import_graphql43.isListType(returnType)) {
-    return completeListValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord);
+    return completeListValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord);
   }
   if (import_graphql43.isLeafType(returnType)) {
     return completeLeafValue(returnType, result2);
   }
   if (import_graphql43.isAbstractType(returnType)) {
-    return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord);
+    return completeAbstractValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord);
   }
   if (import_graphql43.isObjectType(returnType)) {
-    return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord);
+    return completeObjectValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord);
   }
   console.assert(false, "Cannot complete value of unexpected output type: " + inspect(returnType));
 }
-function getStreamValues(exeContext, fieldNodes, path) {
-  if (typeof path.key === "number") {
+function getStreamValues(exeContext, fieldNodes, path2) {
+  if (typeof path2.key === "number") {
     return;
   }
   const stream = import_graphql43.getDirectiveValues(GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
@@ -74345,21 +74490,21 @@ function getStreamValues(exeContext, fieldNodes, path) {
     label: typeof stream["label"] === "string" ? stream["label"] : undefined
   };
 }
-async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord) {
+async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path2, iterator, asyncPayloadRecord) {
   exeContext.signal?.addEventListener("abort", () => {
     iterator.return?.();
   });
   const errors2 = asyncPayloadRecord?.errors ?? exeContext.errors;
-  const stream = getStreamValues(exeContext, fieldNodes, path);
+  const stream = getStreamValues(exeContext, fieldNodes, path2);
   let containsPromise = false;
   const completedResults = [];
   let index = 0;
   while (true) {
     if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
-      executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord);
+      executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path2, stream.label, asyncPayloadRecord);
       break;
     }
-    const itemPath = addPath(path, index, undefined);
+    const itemPath = addPath(path2, index, undefined);
     let iteration;
     try {
       iteration = await iterator.next();
@@ -74379,25 +74524,25 @@ async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info
   }
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
-function completeListValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord) {
+function completeListValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord) {
   const itemType = returnType.ofType;
   const errors2 = asyncPayloadRecord?.errors ?? exeContext.errors;
   if (isAsyncIterable(result2)) {
     const iterator = result2[Symbol.asyncIterator]();
-    return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord);
+    return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path2, iterator, asyncPayloadRecord);
   }
   if (!isIterableObject(result2)) {
     throw createGraphQLError(`Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`);
   }
-  const stream = getStreamValues(exeContext, fieldNodes, path);
+  const stream = getStreamValues(exeContext, fieldNodes, path2);
   let containsPromise = false;
   let previousAsyncPayloadRecord = asyncPayloadRecord;
   const completedResults = [];
   let index = 0;
   for (const item of result2) {
-    const itemPath = addPath(path, index, undefined);
+    const itemPath = addPath(path2, index, undefined);
     if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
-      previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
+      previousAsyncPayloadRecord = executeStreamField(path2, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
       index++;
       continue;
     }
@@ -74451,14 +74596,14 @@ function completeLeafValue(returnType, result2) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord) {
+function completeAbstractValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord) {
   const resolveTypeFn = returnType.resolveType ?? exeContext.typeResolver;
   const contextValue = exeContext.contextValue;
   const runtimeType = resolveTypeFn(result2, contextValue, info, returnType);
   if (isPromise(runtimeType)) {
-    return runtimeType.then((resolvedRuntimeType) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result2), fieldNodes, info, path, result2, asyncPayloadRecord));
+    return runtimeType.then((resolvedRuntimeType) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result2), fieldNodes, info, path2, result2, asyncPayloadRecord));
   }
-  return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result2), fieldNodes, info, path, result2, asyncPayloadRecord);
+  return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result2), fieldNodes, info, path2, result2, asyncPayloadRecord);
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNodes, info, result2) {
   if (runtimeTypeName == null) {
@@ -74485,7 +74630,7 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNo
   }
   return runtimeType;
 }
-function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result2, asyncPayloadRecord) {
+function completeObjectValue(exeContext, returnType, fieldNodes, info, path2, result2, asyncPayloadRecord) {
   if (returnType.isTypeOf) {
     const isTypeOf = returnType.isTypeOf(result2, exeContext.contextValue, info);
     if (isPromise(isTypeOf)) {
@@ -74493,26 +74638,26 @@ function completeObjectValue(exeContext, returnType, fieldNodes, info, path, res
         if (!resolvedIsTypeOf) {
           throw invalidReturnTypeError(returnType, result2, fieldNodes);
         }
-        return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result2, asyncPayloadRecord);
+        return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path2, result2, asyncPayloadRecord);
       });
     }
     if (!isTypeOf) {
       throw invalidReturnTypeError(returnType, result2, fieldNodes);
     }
   }
-  return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result2, asyncPayloadRecord);
+  return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path2, result2, asyncPayloadRecord);
 }
 function invalidReturnTypeError(returnType, result2, fieldNodes) {
   return createGraphQLError(`Expected value of type "${returnType.name}" but got: ${inspect(result2)}.`, {
     nodes: fieldNodes
   });
 }
-function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result2, asyncPayloadRecord) {
+function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path2, result2, asyncPayloadRecord) {
   const { fields: subFieldNodes, patches: subPatches } = collectSubfields2(exeContext, returnType, fieldNodes);
-  const subFields = executeFields(exeContext, returnType, result2, path, subFieldNodes, asyncPayloadRecord);
+  const subFields = executeFields(exeContext, returnType, result2, path2, subFieldNodes, asyncPayloadRecord);
   for (const subPatch of subPatches) {
     const { label, fields: subPatchFieldNodes } = subPatch;
-    executeDeferredFragment(exeContext, returnType, result2, subPatchFieldNodes, label, path, asyncPayloadRecord);
+    executeDeferredFragment(exeContext, returnType, result2, subPatchFieldNodes, label, path2, asyncPayloadRecord);
   }
   return subFields;
 }
@@ -74662,8 +74807,8 @@ function executeSubscription(exeContext) {
       nodes: fieldNodes
     });
   }
-  const path = addPath(undefined, responseName, rootType.name);
-  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, rootType, path);
+  const path2 = addPath(undefined, responseName, rootType.name);
+  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, rootType, path2);
   try {
     const args = getArgumentValues(fieldDef, fieldNodes[0], variableValues);
     const contextValue = exeContext.contextValue;
@@ -74671,12 +74816,12 @@ function executeSubscription(exeContext) {
     const result2 = resolveFn(rootValue, args, contextValue, info);
     if (isPromise(result2)) {
       return result2.then(assertEventStream).then(undefined, (error) => {
-        throw import_graphql43.locatedError(error, fieldNodes, pathToArray(path));
+        throw import_graphql43.locatedError(error, fieldNodes, pathToArray(path2));
       });
     }
     return assertEventStream(result2, exeContext.signal);
   } catch (error) {
-    throw import_graphql43.locatedError(error, fieldNodes, pathToArray(path));
+    throw import_graphql43.locatedError(error, fieldNodes, pathToArray(path2));
   }
 }
 function assertEventStream(result2, signal) {
@@ -74696,16 +74841,16 @@ function assertEventStream(result2, signal) {
     }
   };
 }
-function executeDeferredFragment(exeContext, parentType, sourceValue, fields2, label, path, parentContext) {
+function executeDeferredFragment(exeContext, parentType, sourceValue, fields2, label, path2, parentContext) {
   const asyncPayloadRecord = new DeferredFragmentRecord({
     label,
-    path,
+    path: path2,
     parentContext,
     exeContext
   });
   let promiseOrData;
   try {
-    promiseOrData = executeFields(exeContext, parentType, sourceValue, path, fields2, asyncPayloadRecord);
+    promiseOrData = executeFields(exeContext, parentType, sourceValue, path2, fields2, asyncPayloadRecord);
     if (isPromise(promiseOrData)) {
       promiseOrData = promiseOrData.then(null, (e) => {
         asyncPayloadRecord.errors.push(e);
@@ -74718,7 +74863,7 @@ function executeDeferredFragment(exeContext, parentType, sourceValue, fields2, l
   }
   asyncPayloadRecord.addData(promiseOrData);
 }
-function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext) {
+function executeStreamField(path2, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext) {
   const asyncPayloadRecord = new StreamRecord({
     label,
     path: itemPath,
@@ -74750,7 +74895,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info,
     }
   } catch (error) {
     asyncPayloadRecord.errors.push(error);
-    filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+    filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
     asyncPayloadRecord.addItems(null);
     return asyncPayloadRecord;
   }
@@ -74758,7 +74903,7 @@ function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info,
   if (isPromise(completedItem)) {
     completedItems = completedItem.then((value) => [value], (error) => {
       asyncPayloadRecord.errors.push(error);
-      filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+      filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
       return null;
     });
   } else {
@@ -74801,11 +74946,11 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
     return { done: false, value };
   }
 }
-async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path, label, parentContext) {
+async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path2, label, parentContext) {
   let index = initialIndex;
   let previousAsyncPayloadRecord = parentContext ?? undefined;
   while (true) {
-    const itemPath = addPath(path, index, undefined);
+    const itemPath = addPath(path2, index, undefined);
     const asyncPayloadRecord = new StreamRecord({
       label,
       path: itemPath,
@@ -74818,7 +74963,7 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
       iteration = await executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath);
     } catch (error) {
       asyncPayloadRecord.errors.push(error);
-      filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+      filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
       asyncPayloadRecord.addItems(null);
       if (iterator?.return) {
         iterator.return().catch(() => {
@@ -74831,7 +74976,7 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
     if (isPromise(completedItem)) {
       completedItems = completedItem.then((value) => [value], (error) => {
         asyncPayloadRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+        filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
         return null;
       });
     } else {
@@ -78605,7 +78750,7 @@ var initializeRoles = async (wabe) => {
       isRoot: true,
       wabe
     },
-    fields: ["name"],
+    select: { name: true },
     where: {
       name: {
         in: roles
@@ -78623,7 +78768,7 @@ var initializeRoles = async (wabe) => {
       wabe
     },
     data: objectsToCreate,
-    fields: []
+    select: {}
   });
 };