wabe 0.5.13 → 0.5.15

package/dist/index.js

@@ -60334,35 +60334,6 @@ var require_create_node_ponyfill2 = __commonJS((exports, module) => {
   };
 });
 
-// src/cache/InMemoryCache.ts
-class InMemoryCache {
-  options;
-  store;
-  intervalId = undefined;
-  constructor(options) {
-    this.options = options;
-    this.store = {};
-    this._init();
-  }
-  _init() {
-    this.intervalId = setInterval(() => {
-      this.clear();
-    }, this.options.interval);
-  }
-  set(key, value) {
-    this.store[key] = value;
-  }
-  get(key) {
-    return this.store[key];
-  }
-  clear() {
-    this.store = {};
-  }
-  stop() {
-    clearInterval(this.intervalId);
-  }
-}
-
 // src/files/hookUploadFile.ts
 var handleFile = async (hookObject) => {
   const newData = hookObject.getNewData();
@@ -60386,23 +60357,26 @@ class HookObject {
   operationType;
   context;
   object;
+  originalObject;
   constructor({
     newData,
     className,
     operationType,
     context,
-    object
+    object,
+    originalObject
   }) {
     this.newData = newData;
     this.className = className;
     this.operationType = operationType;
     this.context = context;
     this.object = object;
+    this.originalObject = originalObject;
   }
   getUser() {
     return this.context.user;
   }
-  isFieldUpdate(field) {
+  isFieldUpdated(field) {
     return this.newData && !!this.newData[field];
   }
   upsertNewData(field, value) {
@@ -60415,6 +60389,20 @@ class HookObject {
   getNewData() {
     return this.newData || {};
   }
+  fetch() {
+    const databaseController = this.context.wabe.controllers.database;
+    if (!this.object?.id)
+      return Promise.resolve(null);
+    return databaseController.getObject({
+      className: this.className,
+      id: this.object.id,
+      context: {
+        ...this.context,
+        isRoot: true
+      },
+      fields: ["*"]
+    });
+  }
 }
 
 // src/authentication/utils.ts
@@ -60438,7 +60426,7 @@ var hashPassword = (password) => hash(password, {
 
 // src/hooks/authentication.ts
 var defaultCallAuthenticationProviderOnBeforeCreateUser = async (hookObject) => {
-  if (!hookObject.isFieldUpdate("authentication") || hookObject.getNewData().isOauth)
+  if (!hookObject.isFieldUpdated("authentication") || hookObject.getNewData().isOauth)
     return;
   const context = hookObject.context;
   const authentication = hookObject.getNewData().authentication;
@@ -60456,7 +60444,7 @@ var defaultCallAuthenticationProviderOnBeforeCreateUser = async (hookObject) =>
   });
 };
 var defaultCallAuthenticationProviderOnBeforeUpdateUser = async (hookObject) => {
-  if (!hookObject.isFieldUpdate("authentication") || hookObject.getNewData().isOauth)
+  if (!hookObject.isFieldUpdated("authentication") || hookObject.getNewData().isOauth)
     return;
   const context = hookObject.context;
   const authentication = hookObject.getNewData().authentication;
@@ -60464,6 +60452,8 @@ var defaultCallAuthenticationProviderOnBeforeUpdateUser = async (hookObject) =>
   if (!provider.onUpdateAuthenticationData)
     return;
   const inputOfTheGoodAuthenticationMethod = authentication[name];
+  if (!hookObject.object?.id)
+    return;
   const { authenticationDataToSave } = await provider.onUpdateAuthenticationData({
     context,
     input: inputOfTheGoodAuthenticationMethod,
@@ -60501,9 +60491,9 @@ var tokenize = (value) => {
 
 // src/hooks/defaultFields.ts
 var defaultBeforeCreateForCreatedAt = (object) => {
-  if (!object.isFieldUpdate("createdAt"))
+  if (!object.isFieldUpdated("createdAt"))
     object.upsertNewData("createdAt", new Date);
-  if (!object.isFieldUpdate("updatedAt"))
+  if (!object.isFieldUpdated("updatedAt"))
     object.upsertNewData("updatedAt", new Date);
 };
 var defaultBeforeUpdateForUpdatedAt = (object) => {
@@ -60514,14 +60504,14 @@ var defaultBeforeCreateForDefaultValue = async (object) => {
   const allFields = Object.keys(schemaClass.fields);
   allFields.map((field) => {
     const currentSchemaField = schemaClass.fields[field];
-    if (!object.isFieldUpdate(field) && currentSchemaField.type !== "Pointer" && currentSchemaField.type !== "Relation" && currentSchemaField.type !== "File" && currentSchemaField.defaultValue !== undefined)
+    if (!object.isFieldUpdated(field) && currentSchemaField.type !== "Pointer" && currentSchemaField.type !== "Relation" && currentSchemaField.type !== "File" && currentSchemaField.defaultValue !== undefined)
       object.upsertNewData(field, currentSchemaField.defaultValue);
   });
 };
 
 // src/hooks/deleteSession.ts
 var defaultDeleteSessionOnDeleteUser = async (object) => {
-  const userId = object.object.id;
+  const userId = object.object?.id;
   await object.context.wabe.controllers.database.deleteObjects({
     className: "_Session",
     context: {
@@ -61291,41 +61281,23 @@ class MongoAdapter {
   async createObject(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, data, fields, context } = params;
+    const { className, data, context } = params;
     const collection = await this.createClassIfNotExist(className, context);
     const res = await collection.insertOne(data, {});
-    const object = await context.wabe.controllers.database.getObject({
-      className,
-      id: res.insertedId.toString(),
-      context,
-      fields
-    });
-    return object;
+    return { id: res.insertedId.toString() };
   }
   async createObjects(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, data, fields, offset, first, context, order } = params;
+    const { className, data, context } = params;
     const collection = await this.createClassIfNotExist(className, context);
     const res = await collection.insertMany(data, {});
-    const orStatement = Object.entries(res.insertedIds).map(([, value]) => ({
-      id: { equalTo: value }
-    }));
-    const allObjects = await context.wabe.controllers.database.getObjects({
-      className,
-      where: { OR: orStatement },
-      fields,
-      offset,
-      first,
-      context,
-      order
-    });
-    return allObjects;
+    return Object.values(res.insertedIds).map((id) => ({ id: id.toString() }));
   }
   async updateObject(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, id, data, fields, context, where } = params;
+    const { className, id, data, context, where } = params;
     const whereBuilded = where ? buildMongoWhereQuery(where) : {};
     const collection = await this.createClassIfNotExist(className, context);
     const res = await collection.updateOne({
@@ -61336,18 +61308,12 @@ class MongoAdapter {
     });
     if (res.matchedCount === 0)
       throw new Error("Object not found");
-    const object = await context.wabe.controllers.database.getObject({
-      className,
-      context,
-      fields,
-      id
-    });
-    return object;
+    return { id };
   }
   async updateObjects(params) {
     if (!this.database)
       throw new Error("Connection to database is not established");
-    const { className, where, data, fields, offset, first, context, order } = params;
+    const { className, where, data, offset, first, context, order } = params;
     const whereBuilded = buildMongoWhereQuery(where);
     const collection = await this.createClassIfNotExist(className, context);
     const objectsBeforeUpdate = await context.wabe.controllers.database.getObjects({
@@ -61356,28 +61322,20 @@ class MongoAdapter {
       fields: ["id"],
       offset,
       first,
-      context,
+      context: {
+        ...context,
+        isRoot: true
+      },
       order
     });
     if (objectsBeforeUpdate.length === 0)
-      throw new Error("Object not found");
+      return [];
     await collection.updateMany(whereBuilded, {
       $set: data
     });
-    const orStatement = objectsBeforeUpdate.map((object) => ({
-      id: { equalTo: import_mongodb.ObjectId.createFromHexString(object.id) }
+    return Object.values(objectsBeforeUpdate).filter(notEmpty).map((object) => ({
+      id: object?.id || ""
     }));
-    const objects = await context.wabe.controllers.database.getObjects({
-      className,
-      where: {
-        OR: orStatement
-      },
-      fields,
-      offset,
-      first,
-      context
-    });
-    return objects;
   }
   async deleteObject(params) {
     if (!this.database)
@@ -61521,12 +61479,12 @@ var defaultSearchableFieldsBeforeUpdate = (object) => {
       return;
     return stringExtraction(value);
   }).filter(notEmpty);
-  const oldExtractedSearcFieldForUpdateFields = Object.entries(object.object).flatMap(([key, value]) => {
+  const oldExtractedSearcFieldForUpdateFields = Object.entries(object.object || {}).flatMap(([key, value]) => {
     if (!searchablesFields.includes(key) || !Object.keys(newData).includes(key))
       return;
     return stringExtraction(value);
   }).filter(notEmpty);
-  const actualSearch = object.object.search;
+  const actualSearch = object.object?.search || [];
   const extractedSearchFields = [
     ...actualSearch.filter((element) => !oldExtractedSearcFieldForUpdateFields.includes(element)),
     ...newExtractedSearchField
@@ -61546,12 +61504,12 @@ var updateEmail = (object) => {
     object.upsertNewData("provider", provider);
 };
 var defaultSetEmail = (object) => {
-  if (object.isFieldUpdate("email"))
+  if (object.isFieldUpdated("email"))
     return;
   updateEmail(object);
 };
 var defaultSetEmailOnUpdate = (object) => {
-  if (object.isFieldUpdate("email"))
+  if (object.isFieldUpdated("email"))
     return;
   updateEmail(object);
 };
@@ -61568,7 +61526,7 @@ var setAcl = async ({
   if (!schemaPermissionsObject)
     return;
   const { acl } = schemaPermissionsObject;
-  if (hookObject.isFieldUpdate("acl") || !acl)
+  if (hookObject.isFieldUpdated("acl") || !acl)
     return;
   if (acl.callback) {
     await acl.callback(hookObject);
@@ -61590,8 +61548,8 @@ var setAcl = async ({
   const idOfAllWriteRoles = await getIdOfAllAuthorizedRoles(acl.authorizedRoles, "write");
   const allRolesIdsWithoutDuplicate = [
     ...new Set([
-      ...idOfAllReadRoles.map((role) => role.id),
-      ...idOfAllWriteRoles.map((role) => role.id)
+      ...idOfAllReadRoles.map((role) => role?.id).filter(notEmpty),
+      ...idOfAllWriteRoles.map((role) => role?.id).filter(notEmpty)
     ])
   ];
   const isReadOrWriteSpecified = acl.authorizedUsers.read && acl.authorizedUsers.read.length > 0 || acl.authorizedUsers.write && acl.authorizedUsers.write.length > 0;
@@ -61600,14 +61558,14 @@ var setAcl = async ({
     roles: [
       ...allRolesIdsWithoutDuplicate.map((roleId) => ({
         roleId,
-        read: idOfAllReadRoles.some((role) => role.id === roleId),
-        write: idOfAllWriteRoles.some((role) => role.id === roleId)
+        read: idOfAllReadRoles.some((role) => role?.id === roleId),
+        write: idOfAllWriteRoles.some((role) => role?.id === roleId)
       }))
     ]
   };
   if (isBeforeHook)
     hookObject.upsertNewData("acl", aclObject);
-  else {
+  else
     await hookObject.context.wabe.controllers.database.updateObject({
       className: hookObject.className,
       context: { ...hookObject.context, isRoot: true },
@@ -61617,7 +61575,6 @@ var setAcl = async ({
       },
       fields: []
     });
-  }
 };
 var defaultSetupAclBeforeCreate = async (hookObject) => {
   const userId = hookObject.getUser()?.id;
@@ -61626,7 +61583,7 @@ var defaultSetupAclBeforeCreate = async (hookObject) => {
   await setAcl({ hookObject, userId, isBeforeHook: true });
 };
 var defaultSetupAclOnUserAfterCreate = async (hookObject) => {
-  const userId = hookObject.object.id;
+  const userId = hookObject.object?.id;
   if (!userId)
     return;
   await setAcl({ hookObject, userId, isBeforeHook: false });
@@ -61661,16 +61618,10 @@ var initializeHook = ({
   context
 }) => {
   const computeObject = ({
-    id,
-    object,
-    operationType
+    id
   }) => {
-    if (object)
-      return Promise.resolve(object);
-    if (operationType === "beforeCreate" /* BeforeCreate */)
-      return newData;
     if (!id)
-      throw new Error("Object not found");
+      return {};
     return context.wabe.controllers.database.getObject({
       className,
       context: {
@@ -61683,21 +61634,18 @@ var initializeHook = ({
     });
   };
   const computeObjects = async ({
-    objects,
-    operationType,
-    where
+    where,
+    ids
   }) => {
-    if (objects)
-      return objects;
-    if (operationType === "beforeCreate" /* BeforeCreate */)
-      return [newData];
+    if (!where && ids.length === 0)
+      return [{}];
     const res = await context.wabe.controllers.database.getObjects({
       className,
       context: {
         ...context,
         isRoot: true
       },
-      where,
+      where: where ? where : { id: { in: ids } },
       fields: ["*"],
       skipHooks: true
     });
@@ -61707,30 +61655,25 @@ var initializeHook = ({
   };
   const hooksOrderByPriorities = _getHooksOrderByPriorities(context.wabe.config);
   return {
-    runOnSingleObject: async ({
-      operationType,
-      id,
-      object: inputObject
-    }) => {
+    runOnSingleObject: async (options) => {
       if (hooksOrderByPriorities.length === 0)
         return { object: undefined, newData: {} };
       const object = await computeObject({
-        id,
-        operationType,
-        object: inputObject
+        id: options.id
       });
       const hookObject = new HookObject({
         className,
         newData,
-        operationType,
+        operationType: options.operationType,
         context,
-        object
+        object,
+        originalObject: options.originalObject
       });
       await hooksOrderByPriorities.reduce(async (acc, priority) => {
         await acc;
         const hooksToCompute = await _findHooksByPriority({
           className,
-          operationType,
+          operationType: options.operationType,
           priority,
           config: context.wabe.config
         });
@@ -61738,31 +61681,29 @@ var initializeHook = ({
       }, Promise.resolve());
       return { object, newData: hookObject.getNewData() };
     },
-    runOnMultipleObjects: async ({
-      operationType,
-      where,
-      objects: inputObjects
-    }) => {
+    runOnMultipleObjects: async (options) => {
       if (hooksOrderByPriorities.length === 0)
         return { objects: [], newData: [newData || {}] };
       const objects = await computeObjects({
-        where,
-        operationType,
-        objects: inputObjects
+        where: options.where,
+        ids: options.ids || []
       });
-      const newDataAfterHooks = await Promise.all(objects.map(async (object) => {
+      const objectsToUseInMap = (options.operationType === "afterDelete" /* AfterDelete */ ? options.originalObjects : objects) || [];
+      const newDataAfterHooks = await Promise.all(objectsToUseInMap.map(async (object) => {
+        const originalObjectToUse = (options.originalObjects || []).find((originalObject) => originalObject?.id === object?.id);
         const hookObject = new HookObject({
           className,
           newData,
-          operationType,
+          operationType: options.operationType,
           context,
-          object
+          object,
+          originalObject: originalObjectToUse
         });
         await hooksOrderByPriorities.reduce(async (acc, priority) => {
           await acc;
           const hooksToCompute = await _findHooksByPriority({
             className,
-            operationType,
+            operationType: options.operationType,
             priority,
             config: context.wabe.config
           });
@@ -61876,19 +61817,8 @@ var getDefaultHooks = () => [
 // src/database/controllers/DatabaseController.ts
 class DatabaseController2 {
   adapter;
-  inMemoryCache;
   constructor(adapter) {
     this.adapter = adapter;
-    this.inMemoryCache = new InMemoryCache({ interval: 5000 });
-  }
-  connect() {
-    return this.adapter.connect();
-  }
-  close() {
-    return this.adapter.close();
-  }
-  createClassIfNotExist(className, context) {
-    return this.adapter.createClassIfNotExist(className, context);
   }
   _getPointerObject(className, fields, context) {
     const realClass = context.wabe.config.schema?.classes?.find((c) => c.name.toLowerCase() === className.toLowerCase());
@@ -61992,7 +61922,7 @@ class DatabaseController2 {
       return {
         ...acc,
         [typedWhereKey]: {
-          in: objects.map((object) => object.id)
+          in: objects.map((object) => object?.id).filter(notEmpty)
         }
       };
     }, Promise.resolve({}));
@@ -62075,8 +62005,14 @@ class DatabaseController2 {
       ].filter(notEmpty)
     };
   }
-  _buildCacheKey(className, id, fields) {
-    return `${String(className)}-${id}-${fields.join(",")}`;
+  connect() {
+    return this.adapter.connect();
+  }
+  close() {
+    return this.adapter.close();
+  }
+  createClassIfNotExist(className, context) {
+    return this.adapter.createClassIfNotExist(className, context);
   }
   count(params) {
     return this.adapter.count(params);
@@ -62108,21 +62044,11 @@ class DatabaseController2 {
       ...fieldsWithoutPointers,
       ...pointersFieldsId || []
     ];
-    const object = await this.adapter.getObject({
-      className,
-      context,
-      id,
-      fields: fieldsWithPointerFields,
-      where: whereWithACLCondition
-    });
-    const keyCache = this._buildCacheKey(className, object.id, fieldsWithPointerFields);
-    this.inMemoryCache.set(keyCache, object);
     await hook?.runOnSingleObject({
       operationType: "afterRead" /* AfterRead */,
-      object
+      id
     });
-    const cacheObject = this.inMemoryCache.get(keyCache);
-    const objectToReturn = cacheObject ? cacheObject : await this.adapter.getObject({
+    const objectToReturn = await this.adapter.getObject({
       className,
       id,
       context,
@@ -62158,19 +62084,9 @@ class DatabaseController2 {
       ...fieldsWithoutPointers,
       ...pointersFieldsId || []
     ];
-    const objects = await this.adapter.getObjects({
-      className,
-      context,
-      first,
-      offset,
-      where: whereWithACLCondition,
-      fields: fieldsWithPointerFields,
-      order
-    });
-    objects.map((object) => this.inMemoryCache.set(this._buildCacheKey(className, object.id, fieldsWithPointerFields), object));
     await hook?.runOnMultipleObjects({
       operationType: "afterRead" /* AfterRead */,
-      objects
+      where: whereWithACLCondition
     });
     const objectsToReturn = await this.adapter.getObjects({
       className,
@@ -62197,31 +62113,25 @@ class DatabaseController2 {
     const { newData } = await hook.runOnSingleObject({
       operationType: "beforeCreate" /* BeforeCreate */
     });
-    const object = await this.adapter.createObject({
+    const { id } = await this.adapter.createObject({
       className,
       context,
       fields,
       data: newData
     });
-    const keyCache = this._buildCacheKey(className, object.id, fields);
-    this.inMemoryCache.set(keyCache, undefined);
-    const res = await hook.runOnSingleObject({
+    await hook.runOnSingleObject({
       operationType: "afterCreate" /* AfterCreate */,
-      object
+      id
     });
-    if (!res.object)
-      return object;
-    const objectToReturn = await this.getObject({
+    if (fields.length === 0)
+      return null;
+    return this.getObject({
       className,
-      context: {
-        ...context,
-        isRoot: true
-      },
+      context,
       fields,
-      id: object.id,
+      id,
       skipHooks: true
     });
-    return objectToReturn;
   }
   async createObjects({
     data,
@@ -62242,7 +62152,7 @@ class DatabaseController2 {
     const arrayOfComputedData = await Promise.all(hooks.map(async (hook) => (await hook.runOnMultipleObjects({
       operationType: "beforeCreate" /* BeforeCreate */
     }))?.newData[0]));
-    const objects = await this.adapter.createObjects({
+    const listOfIds = await this.adapter.createObjects({
       className,
       fields,
       context,
@@ -62251,28 +62161,23 @@ class DatabaseController2 {
       offset,
       order
     });
-    const objectsId = objects.map((object) => object.id);
-    for (const id of objectsId) {
-      const keyCache = this._buildCacheKey(className, id, fields);
-      this.inMemoryCache.set(keyCache, undefined);
-    }
-    const res = await Promise.all(hooks.map((hook) => hook.runOnMultipleObjects({
+    const ids = listOfIds.map(({ id }) => id);
+    await Promise.all(hooks.map((hook) => hook.runOnMultipleObjects({
       operationType: "afterCreate" /* AfterCreate */,
-      objects
+      ids
     })));
-    if (res.filter((hook) => hook.objects.length > 0).length === 0)
-      return objects;
-    const objectsToReturn = await this.getObjects({
+    if (fields.length === 0)
+      return [];
+    return this.getObjects({
       className,
       context,
       fields,
-      where: { id: { in: objectsId } },
+      where: { id: { in: ids } },
       skipHooks: true,
       first,
       offset,
       order
     });
-    return objectsToReturn;
   }
   async updateObject({
     id,
@@ -62286,12 +62191,12 @@ class DatabaseController2 {
       context,
       newData: data
     });
-    const { newData } = await hook.runOnSingleObject({
+    const { newData, object } = await hook.runOnSingleObject({
       operationType: "beforeUpdate" /* BeforeUpdate */,
       id
     });
     const whereWithACLCondition = this._buildWhereWithACL({}, context, "write");
-    const object = await this.adapter.updateObject({
+    await this.adapter.updateObject({
       className,
       fields,
       id,
@@ -62299,22 +62204,20 @@ class DatabaseController2 {
       data: newData,
       where: whereWithACLCondition
     });
-    const keyCache = this._buildCacheKey(className, object.id, fields);
-    this.inMemoryCache.set(keyCache, undefined);
-    const res = await hook.runOnSingleObject({
+    await hook.runOnSingleObject({
       operationType: "afterUpdate" /* AfterUpdate */,
-      object
+      id,
+      originalObject: object
     });
-    if (!res.object)
-      return object;
-    const objectToReturn = await this.getObject({
+    if (fields.length === 0)
+      return null;
+    return this.getObject({
       className,
       context,
       fields,
-      id: object.id,
+      id,
       skipHooks: true
     });
-    return objectToReturn;
   }
   async updateObjects({
     className,
@@ -62333,7 +62236,7 @@ class DatabaseController2 {
       newData: data
     });
     const whereWithACLCondition = this._buildWhereWithACL(whereObject, context, "write");
-    const { newData } = await hook.runOnMultipleObjects({
+    const { newData, objects: objectsAfterBeforeUpdate } = await hook.runOnMultipleObjects({
       operationType: "beforeUpdate" /* BeforeUpdate */,
       where: whereWithACLCondition
     });
@@ -62347,18 +62250,15 @@ class DatabaseController2 {
       offset,
       order
     });
-    const objectsId = objects.map((object) => object.id);
-    for (const id of objectsId) {
-      const keyCache = this._buildCacheKey(className, id, fields);
-      this.inMemoryCache.set(keyCache, undefined);
-    }
-    const res = await hook.runOnMultipleObjects({
+    const objectsId = objects.map((object) => object?.id).filter(notEmpty);
+    await hook.runOnMultipleObjects({
       operationType: "afterUpdate" /* AfterUpdate */,
-      objects
+      ids: objectsId,
+      originalObjects: objectsAfterBeforeUpdate
     });
-    if (res.objects.length === 0)
-      return objects;
-    const objectsToReturn = await this.getObjects({
+    if (fields.length === 0)
+      return [];
+    return this.getObjects({
       className,
       context,
       fields,
@@ -62368,7 +62268,6 @@ class DatabaseController2 {
       offset,
       order
     });
-    return objectsToReturn;
   }
   async deleteObject({
     context,
@@ -62381,13 +62280,15 @@ class DatabaseController2 {
       context
     });
     const whereWithACLCondition = this._buildWhereWithACL({}, context, "write");
-    const objectBeforeDelete = await this.getObject({
-      className,
-      fields,
-      id,
-      context
-    });
-    const { object } = await hook.runOnSingleObject({
+    let objectBeforeDelete = null;
+    if (fields.length > 0)
+      objectBeforeDelete = await this.getObject({
+        className,
+        fields,
+        id,
+        context
+      });
+    const resultOfBeforeDelete = await hook.runOnSingleObject({
       operationType: "beforeDelete" /* BeforeDelete */,
       id
     });
@@ -62400,7 +62301,7 @@ class DatabaseController2 {
     });
     await hook.runOnSingleObject({
       operationType: "afterDelete" /* AfterDelete */,
-      object
+      originalObject: resultOfBeforeDelete.object
     });
     return objectBeforeDelete;
   }
@@ -62419,18 +62320,18 @@ class DatabaseController2 {
       context
     });
     const whereWithACLCondition = this._buildWhereWithACL(whereObject, context, "write");
-    const objectsBeforeDelete = await this.getObjects({
-      className,
-      where,
-      fields,
-      context,
-      first,
-      offset,
-      order
-    });
-    if (objectsBeforeDelete.length === 0)
-      return objectsBeforeDelete;
-    const { objects } = await hook.runOnMultipleObjects({
+    let objectsBeforeDelete = [];
+    if (fields.length > 0)
+      objectsBeforeDelete = await this.getObjects({
+        className,
+        where,
+        fields,
+        context,
+        first,
+        offset,
+        order
+      });
+    const resultOfBeforeDelete = await hook.runOnMultipleObjects({
       operationType: "beforeDelete" /* BeforeDelete */,
       where: whereWithACLCondition
     });
@@ -62445,7 +62346,7 @@ class DatabaseController2 {
     });
     await hook.runOnMultipleObjects({
       operationType: "afterDelete" /* AfterDelete */,
-      objects
+      originalObjects: resultOfBeforeDelete.objects
     });
     return objectsBeforeDelete;
   }
@@ -62491,7 +62392,7 @@ class Session {
         accessToken: { equalTo: accessToken }
       },
       first: 1,
-      fields: ["user.*", "user.role.*"],
+      fields: ["user.*", "user.role.*", "id"],
       context
     });
     if (sessions.length === 0)
@@ -62511,7 +62412,7 @@ class Session {
       iat: Date.now(),
       exp: this.getRefreshTokenExpireAt(context.wabe.config).getTime()
     }, import.meta.env.JWT_SECRET || "dev");
-    const { id } = await context.wabe.controllers.database.createObject({
+    const res = await context.wabe.controllers.database.createObject({
       className: "_Session",
       context,
       data: {
@@ -62523,10 +62424,12 @@ class Session {
       },
       fields: ["id"]
     });
+    if (!res)
+      throw new Error("Session not created");
     return {
       accessToken: this.accessToken,
       refreshToken: this.refreshToken,
-      sessionId: id
+      sessionId: res.id
     };
   }
   async delete(context) {
@@ -62561,6 +62464,8 @@ class Session {
         accessToken: null,
         refreshToken: null
       };
+    if (!session[0])
+      throw new Error("Session not found");
     const {
       refreshTokenExpiresAt,
       user,
@@ -62659,7 +62564,7 @@ var signInWithResolver = async (_, {
 var signUpWithResolver = async (_, {
   input
 }, context) => {
-  const { id: userId } = await context.wabe.controllers.database.createObject({
+  const res = await context.wabe.controllers.database.createObject({
     className: "User",
     data: {
       authentication: input.authentication
@@ -62671,7 +62576,9 @@ var signUpWithResolver = async (_, {
     fields: ["id"]
   });
   const session = new Session;
-  const { accessToken, refreshToken } = await session.create(userId, {
+  if (!res)
+    throw new Error("User not created");
+  const { accessToken, refreshToken } = await session.create(res.id, {
     ...context,
     isRoot: true
   });
@@ -62691,7 +62598,7 @@ var signUpWithResolver = async (_, {
       expires: session.getAccessTokenExpireAt(context.wabe.config)
     });
   }
-  return { accessToken, refreshToken, id: userId };
+  return { accessToken, refreshToken, id: res.id };
 };
 // src/authentication/oauth/utils.ts
 import crypto from "node:crypto";
@@ -62943,7 +62850,9 @@ var resetPasswordResolver = async (_, { input: { email, password, otp, provider
   });
   if (user.length === 0)
     return true;
-  const userId = user[0].id;
+  const userId = user[0]?.id;
+  if (!userId)
+    return false;
   const otpClass = new OTP(context.wabe.config.rootKey);
   const isOtpValid = otpClass.verify(otp, userId);
   if (false)
@@ -63113,7 +63022,9 @@ var sendOtpCodeResolver = async (_, { input }, context) => {
   });
   if (user.length === 0)
     return true;
-  const userId = user[0].id;
+  const userId = user[0]?.id;
+  if (!userId)
+    return false;
   const otpClass = new OTP(context.wabe.config.rootKey);
   const otp = otpClass.generate(userId);
   const mainEmail = context.wabe.config.email?.mainEmail || "noreply@wabe.com";
@@ -64239,13 +64150,13 @@ var createAndLink = async ({
   className
 }) => {
   const classInSchema = getClassFromClassName(className, context.wabe.config);
-  const { id } = await context.wabe.controllers.database.createObject({
+  const res = await context.wabe.controllers.database.createObject({
     className: classInSchema.fields[fieldName].class,
     data: createAndLink2,
     fields: ["id"],
     context
   });
-  return id;
+  return res?.id;
 };
 var createAndAdd = async ({
   createAndAdd: createAndAdd2,
@@ -64282,7 +64193,7 @@ var add = async ({
       fields: [fieldName],
       context
     });
-    return [...currentValue[fieldName] || [], ...add2];
+    return [...currentValue?.[fieldName] || [], ...add2];
   }
   if (typeOfExecution === "updateMany" && where) {
     const allObjectsMatchedWithWhere = await context.wabe.controllers.database.getObjects({
@@ -64323,7 +64234,7 @@ var remove = async ({
       fields: [fieldName],
       context
     });
-    const olderValues = currentValue[fieldName] || [];
+    const olderValues = currentValue?.[fieldName] || [];
     return olderValues.filter((olderValue) => !remove2.includes(olderValue));
   }
   if (typeOfExecution === "updateMany" && where) {
@@ -64373,6 +64284,24 @@ 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,
@@ -64469,7 +64398,11 @@ var queryForMultipleObject = async (_, { where, offset, first, order }, context,
   };
 };
 var mutationToCreateObject = async (_, args, context, info, className) => {
-  const fields = getFieldsFromInfo(info, className);
+  const { classFields, othersFields } = getFieldsOfClassName({
+    fields: getFieldsFromInfo(info, className),
+    className,
+    context
+  });
   const updatedFieldsToCreate = await executeRelationOnFields({
     className,
     fields: args.input?.fields,
@@ -64479,9 +64412,10 @@ var mutationToCreateObject = async (_, args, context, info, className) => {
     [firstLetterInLowerCase(className)]: await context.wabe.controllers.database.createObject({
       className,
       data: updatedFieldsToCreate,
-      fields,
+      fields: classFields,
       context
-    })
+    }),
+    ...othersFields.includes("ok") ? { ok: true } : {}
   };
 };
 var mutationToCreateMultipleObjects = async (_, { input: { fields, offset, first, order } }, context, info, className) => {
@@ -64506,7 +64440,11 @@ var mutationToCreateMultipleObjects = async (_, { input: { fields, offset, first
   };
 };
 var mutationToUpdateObject = async (_, args, context, info, className) => {
-  const fields = getFieldsFromInfo(info, className);
+  const { classFields, othersFields } = getFieldsOfClassName({
+    fields: getFieldsFromInfo(info, className),
+    className,
+    context
+  });
   const updatedFields = await executeRelationOnFields({
     className,
     fields: args.input?.fields,
@@ -64519,9 +64457,10 @@ var mutationToUpdateObject = async (_, args, context, info, className) => {
       className,
       id: args.input?.id,
       data: updatedFields,
-      fields,
+      fields: classFields,
       context
-    })
+    }),
+    ...othersFields.includes("ok") ? { ok: true } : {}
   };
 };
 var mutationToUpdateMultipleObjects = async (_, { input: { fields, where, offset, first, order } }, context, info, className) => {
@@ -64548,14 +64487,19 @@ var mutationToUpdateMultipleObjects = async (_, { input: { fields, where, offset
   };
 };
 var mutationToDeleteObject = async (_, args, context, info, className) => {
-  const fields = getFieldsFromInfo(info, className);
+  const { classFields, othersFields } = getFieldsOfClassName({
+    fields: getFieldsFromInfo(info, className),
+    className,
+    context
+  });
   return {
     [firstLetterInLowerCase(className)]: await context.wabe.controllers.database.deleteObject({
       className,
       id: args.input?.id,
-      fields,
+      fields: classFields,
       context
-    })
+    }),
+    ...othersFields.includes("ok") ? { ok: true } : {}
   };
 };
 var mutationToDeleteMultipleObjects = async (_, { input: { where, offset, first, order } }, context, info, className) => {
@@ -65025,7 +64969,7 @@ class GraphQLSchema {
       name: `Create${className}Payload`,
       fields: () => ({
         [classNameWithFirstLetterLowerCase]: { type: object },
-        clientMutationId: { type: import_graphql5.GraphQLString }
+        ok: { type: import_graphql5.GraphQLBoolean }
       })
     });
     const createInputType = new import_graphql5.GraphQLInputObjectType({
@@ -65049,7 +64993,7 @@ class GraphQLSchema {
       name: `Update${className}Payload`,
       fields: () => ({
         [classNameWithFirstLetterLowerCase]: { type: object },
-        clientMutationId: { type: import_graphql5.GraphQLString }
+        ok: { type: import_graphql5.GraphQLBoolean }
       })
     });
     const updateInputType = new import_graphql5.GraphQLInputObjectType({
@@ -65073,7 +65017,7 @@ class GraphQLSchema {
       name: `Delete${className}Payload`,
       fields: () => ({
         [classNameWithFirstLetterLowerCase]: { type: object },
-        clientMutationId: { type: import_graphql5.GraphQLString }
+        ok: { type: import_graphql5.GraphQLBoolean }
       })
     });
     const deleteInputType = new import_graphql5.GraphQLInputObjectType({
@@ -65438,13 +65382,13 @@ class EmailPassword {
         ...context,
         isRoot: true
       },
-      fields: ["authentication"],
+      fields: ["id", "authentication"],
       first: 1
     });
     if (users.length === 0)
       throw new Error("Invalid authentication credentials");
     const user = users[0];
-    const userDatabasePassword = user.authentication?.emailPassword?.password;
+    const userDatabasePassword = user?.authentication?.emailPassword?.password;
     if (!userDatabasePassword)
       throw new Error("Invalid authentication credentials");
     const isPasswordEquals = await verify(userDatabasePassword, input.password, {
@@ -65500,8 +65444,8 @@ class EmailPassword {
     const user = users[0];
     return {
       authenticationDataToSave: {
-        email: input.email ?? user.authentication?.emailPassword?.email,
-        password: input.password ? await hashPassword(input.password) : user.authentication?.emailPassword?.password
+        email: input.email ?? user?.authentication?.emailPassword?.email,
+        password: input.password ? await hashPassword(input.password) : user?.authentication?.emailPassword?.password
       }
     };
   }
@@ -65562,8 +65506,10 @@ class Google3 {
           ...context,
           isRoot: true
         },
-        fields: ["*"]
+        fields: ["*", "id"]
       });
+      if (!createdUser)
+        throw new Error("User not found");
       return {
         user: createdUser,
         oauth: {
@@ -65574,6 +65520,8 @@ class Google3 {
         }
       };
     }
+    if (!user[0])
+      throw new Error("User not found");
     return {
       user: user[0],
       oauth: {
@@ -75634,7 +75582,7 @@ var initializeRoles = async (wabe) => {
       }
     }
   });
-  const alreadyCreatedRoles = res.map((role) => role.name);
+  const alreadyCreatedRoles = res.map((role) => role?.name).filter(notEmpty);
   const objectsToCreate = roles.filter((role) => !alreadyCreatedRoles.includes(role)).map((role) => ({ name: role }));
   if (objectsToCreate.length === 0)
     return;