@smartive/graphql-magic 19.3.0 → 19.3.1-next.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-# [19.3.0](https://github.com/smartive/graphql-magic/compare/v19.2.1...v19.3.0) (2025-06-26)
+## [19.3.1-next.2](https://github.com/smartive/graphql-magic/compare/v19.3.1-next.1...v19.3.1-next.2) (2025-07-02)
 
 
-### Features
+### Bug Fixes
 
-* Restore permissions ([#316](https://github.com/smartive/graphql-magic/issues/316)) ([536fcd5](https://github.com/smartive/graphql-magic/commit/536fcd54c5953acebf470f18ec2292e2090bec19))
+* Sort results ([ed5f07f](https://github.com/smartive/graphql-magic/commit/ed5f07fd4ee9511ac7541370b1b1ba076a6ea960))

package/dist/cjs/index.cjs

@@ -2682,62 +2682,60 @@ var applySubQueries = async (node, entries, parentVerifiedPermissionStacks) => {
 };
 
 // src/resolvers/mutations.ts
-var mutationResolver = async (_parent, args2, partialCtx, info) => {
-  return await partialCtx.knex.transaction(async (knex) => {
-    const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
-    const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
-    switch (mutation) {
-      case "create": {
-        const id = await createEntity(modelName, args2.data, ctx, "mutation");
-        return await resolve(ctx, id);
-      }
-      case "update": {
-        const id = args2.where.id;
-        await updateEntity(modelName, id, args2.data, ctx, "mutation");
-        return await resolve(ctx, id);
-      }
-      case "delete": {
-        const id = args2.where.id;
-        await deleteEntity(modelName, id, ctx, {
-          dryRun: args2.dryRun,
-          trigger: "mutation"
-        });
-        return id;
-      }
-      case "restore": {
-        const id = args2.where.id;
-        await restoreEntity(modelName, id, ctx, "mutation");
-        return id;
-      }
+var withTransaction = async (ctx, fn) => await ctx.knex.transaction(async (knex) => fn({ ...ctx, knex }));
+var mutationResolver = async (_parent, args2, partialCtx, info) => withTransaction({ ...partialCtx, info, aliases: new AliasGenerator() }, async (ctx) => {
+  const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
+  switch (mutation) {
+    case "create": {
+      const id = await createEntity(modelName, args2.data, ctx, "mutation");
+      return await resolve(ctx, id);
+    }
+    case "update": {
+      const id = args2.where.id;
+      await updateEntity(modelName, id, args2.data, ctx, "mutation");
+      return await resolve(ctx, id);
+    }
+    case "delete": {
+      const id = args2.where.id;
+      await deleteEntity(modelName, id, ctx, {
+        dryRun: args2.dryRun,
+        trigger: "mutation"
+      });
+      return id;
     }
-  });
-};
-var createEntity = async (modelName, input2, ctx, trigger = "direct-call") => {
-  const model = ctx.models.getModel(modelName, "entity");
+    case "restore": {
+      const id = args2.where.id;
+      await restoreEntity(modelName, id, ctx, "mutation");
+      return id;
+    }
+  }
+});
+var createEntity = async (modelName, input2, ctx, trigger = "direct-call") => withTransaction(ctx, async (ctx2) => {
+  const model = ctx2.models.getModel(modelName, "entity");
   const normalizedInput = { ...input2 };
   if (!normalizedInput.id) {
     normalizedInput.id = (0, import_uuid.v4)();
   }
   const id = normalizedInput.id;
   if (!normalizedInput.createdAt) {
-    normalizedInput.createdAt = ctx.now;
+    normalizedInput.createdAt = ctx2.now;
   }
   if (!normalizedInput.createdById) {
-    normalizedInput.createdById = ctx.user?.id;
+    normalizedInput.createdById = ctx2.user?.id;
   }
   if (model.parent) {
     normalizedInput.type = model.name;
   }
-  sanitize(ctx, model, normalizedInput);
-  await checkCanWrite(ctx, model, normalizedInput, "CREATE");
-  await ctx.handleUploads?.(normalizedInput);
-  await ctx.mutationHook?.({
+  sanitize(ctx2, model, normalizedInput);
+  await checkCanWrite(ctx2, model, normalizedInput, "CREATE");
+  await ctx2.handleUploads?.(normalizedInput);
+  await ctx2.mutationHook?.({
     model,
     action: "create",
     trigger,
     when: "before",
     data: { prev: {}, input: input2, normalizedInput, next: normalizedInput },
-    ctx
+    ctx: ctx2
   });
   if (model.parent) {
     const rootInput = {};
@@ -2752,75 +2750,75 @@ var createEntity = async (modelName, input2, ctx, trigger = "direct-call") => {
         }
       }
     }
-    await ctx.knex(model.parent).insert(rootInput);
-    await ctx.knex(model.name).insert(childInput);
+    await ctx2.knex(model.parent).insert(rootInput);
+    await ctx2.knex(model.name).insert(childInput);
   } else {
-    await ctx.knex(model.name).insert(normalizedInput);
+    await ctx2.knex(model.name).insert(normalizedInput);
   }
-  await createRevision(model, normalizedInput, ctx);
-  await ctx.mutationHook?.({
+  await createRevision(model, normalizedInput, ctx2);
+  await ctx2.mutationHook?.({
     model,
     action: "create",
     trigger,
     when: "after",
     data: { prev: {}, input: input2, normalizedInput, next: normalizedInput },
-    ctx
+    ctx: ctx2
   });
   return normalizedInput.id;
-};
-var updateEntities = async (modelName, where, updateFields, ctx) => {
-  const entities = await ctx.knex(modelName).where(where).select("id");
+});
+var updateEntities = async (modelName, where, updateFields, ctx) => withTransaction(ctx, async (ctx2) => {
+  const entities = await ctx2.knex(modelName).where(where).select("id");
   for (const entity of entities) {
-    await updateEntity(modelName, entity.id, updateFields, ctx);
+    await updateEntity(modelName, entity.id, updateFields, ctx2);
   }
-};
-var updateEntity = async (modelName, id, input2, ctx, trigger = "direct-call") => {
-  const model = ctx.models.getModel(modelName, "entity");
+});
+var updateEntity = async (modelName, id, input2, ctx, trigger = "direct-call") => withTransaction(ctx, async (ctx2) => {
+  const model = ctx2.models.getModel(modelName, "entity");
   const normalizedInput = { ...input2 };
-  sanitize(ctx, model, normalizedInput);
-  const currentEntity = await getEntityToMutate(ctx, model, { id }, "UPDATE");
+  sanitize(ctx2, model, normalizedInput);
+  const currentEntity = await getEntityToMutate(ctx2, model, { id }, "UPDATE");
   for (const key of Object.keys(normalizedInput)) {
     if (normalizedInput[key] === currentEntity[key]) {
       delete normalizedInput[key];
     }
   }
   if (Object.keys(normalizedInput).length > 0) {
-    await checkCanWrite(ctx, model, normalizedInput, "UPDATE");
-    await ctx.handleUploads?.(normalizedInput);
-    await ctx.mutationHook?.({
+    await checkCanWrite(ctx2, model, normalizedInput, "UPDATE");
+    await ctx2.handleUploads?.(normalizedInput);
+    await ctx2.mutationHook?.({
       model,
       action: "update",
       trigger,
       when: "before",
       data: { prev: currentEntity, input: input2, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-      ctx
+      ctx: ctx2
     });
-    await doUpdate(model, currentEntity, normalizedInput, ctx);
-    await ctx.mutationHook?.({
+    await doUpdate(model, currentEntity, normalizedInput, ctx2);
+    await ctx2.mutationHook?.({
       model,
       action: "update",
       trigger,
       when: "after",
       data: { prev: currentEntity, input: input2, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-      ctx
+      ctx: ctx2
     });
   }
-};
-var deleteEntities = async (modelName, where, ctx) => {
-  const entities = await ctx.knex(modelName).where(where).select("id");
+});
+var deleteEntities = async (modelName, where, ctx) => withTransaction(ctx, async (ctx2) => {
+  const entities = await ctx2.knex(modelName).where(where).select("id");
   for (const entity of entities) {
-    await deleteEntity(modelName, entity.id, ctx, {
+    await deleteEntity(modelName, entity.id, ctx2, {
       trigger: "direct-call"
     });
   }
-};
+});
 var deleteEntity = async (modelName, id, ctx, {
   dryRun = false,
   trigger = "direct-call"
-} = {}) => {
-  const model = ctx.models.getModel(modelName, "entity");
+} = {}) => withTransaction(ctx, async (ctx2) => {
+  const model = ctx2.models.getModel(modelName, "entity");
   const rootModel = model.rootModel;
-  const entity = await getEntityToMutate(ctx, rootModel, { id }, "DELETE");
+  const entity = await getEntityToMutate(ctx2, rootModel, { id }, "DELETE");
   if (entity.deleted) {
     throw new ForbiddenError(`${getTechnicalDisplay(model, entity)} is already deleted.`);
   }
@@ -2830,7 +2828,7 @@ var deleteEntity = async (modelName, id, ctx, {
   const beforeHooks = [];
   const mutations = [];
   const afterHooks = [];
-  const mutationHook = ctx.mutationHook;
+  const mutationHook = ctx2.mutationHook;
   const deleteCascade = async (currentModel, currentEntity, currentTrigger) => {
     if (!(currentModel.name in toDelete)) {
       toDelete[currentModel.name] = {};
@@ -2838,12 +2836,12 @@ var deleteEntity = async (modelName, id, ctx, {
     if (currentEntity.id in toDelete[currentModel.name]) {
       return;
     }
-    toDelete[currentModel.name][currentEntity.id] = await fetchDisplay(ctx.knex, currentModel, currentEntity);
+    toDelete[currentModel.name][currentEntity.id] = await fetchDisplay(ctx2.knex, currentModel, currentEntity);
     if (!dryRun) {
       const normalizedInput = {
         deleted: true,
-        deletedAt: ctx.now,
-        deletedById: ctx.user?.id,
+        deletedAt: ctx2.now,
+        deletedById: ctx2.user?.id,
         deleteRootType: rootModel.name,
         deleteRootId: entity.id
       };
@@ -2855,12 +2853,12 @@ var deleteEntity = async (modelName, id, ctx, {
             trigger: currentTrigger,
             when: "before",
             data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-            ctx
+            ctx: ctx2
           });
         });
       }
       mutations.push(async () => {
-        await doUpdate(currentModel, currentEntity, normalizedInput, ctx);
+        await doUpdate(currentModel, currentEntity, normalizedInput, ctx2);
       });
       if (mutationHook) {
         afterHooks.push(async () => {
@@ -2870,7 +2868,7 @@ var deleteEntity = async (modelName, id, ctx, {
             trigger: currentTrigger,
             when: "after",
             data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-            ctx
+            ctx: ctx2
           });
         });
       }
@@ -2879,7 +2877,7 @@ var deleteEntity = async (modelName, id, ctx, {
       targetModel: descendantModel,
       field: { name: name2, foreignKey, onDelete }
     } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited)) {
-      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: false });
+      const query = ctx2.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: false }).orderBy("createdAt", "asc").orderBy("id", "asc");
       const descendants = await query;
       if (descendants.length) {
         switch (onDelete) {
@@ -2891,7 +2889,7 @@ var deleteEntity = async (modelName, id, ctx, {
                 }
                 if (!toUnlink[descendantModel.name][descendant.id]) {
                   toUnlink[descendantModel.name][descendant.id] = {
-                    display: await fetchDisplay(ctx.knex, descendantModel, descendant),
+                    display: await fetchDisplay(ctx2.knex, descendantModel, descendant),
                     fields: []
                   };
                 }
@@ -2906,12 +2904,12 @@ var deleteEntity = async (modelName, id, ctx, {
                       trigger: "set-null",
                       when: "before",
                       data: { prev: descendant, input: {}, normalizedInput, next: { ...descendant, ...normalizedInput } },
-                      ctx
+                      ctx: ctx2
                     });
                   });
                 }
                 mutations.push(async () => {
-                  await doUpdate(descendantModel, descendant, normalizedInput, ctx);
+                  await doUpdate(descendantModel, descendant, normalizedInput, ctx2);
                 });
                 if (mutationHook) {
                   afterHooks.push(async () => {
@@ -2921,7 +2919,7 @@ var deleteEntity = async (modelName, id, ctx, {
                       trigger: "set-null",
                       when: "after",
                       data: { prev: descendant, input: {}, normalizedInput, next: { ...descendant, ...normalizedInput } },
-                      ctx
+                      ctx: ctx2
                     });
                   });
                 }
@@ -2936,7 +2934,7 @@ var deleteEntity = async (modelName, id, ctx, {
               for (const descendant of descendants) {
                 if (!restricted[descendantModel.name][descendant.id]) {
                   restricted[descendantModel.name][descendant.id] = {
-                    display: await fetchDisplay(ctx.knex, descendantModel, descendant),
+                    display: await fetchDisplay(ctx2.knex, descendantModel, descendant),
                     fields: [name2]
                   };
                 }
@@ -2955,7 +2953,7 @@ var deleteEntity = async (modelName, id, ctx, {
                 `${getTechnicalDisplay(model, entity)} depends on ${getTechnicalDisplay(descendantModel, descendants[0])}${descendants.length > 1 ? ` (among others)` : ""} which cannot be deleted.`
               );
             }
-            applyPermissions(ctx, descendantModel.name, descendantModel.name, query, "DELETE");
+            applyPermissions(ctx2, descendantModel.name, descendantModel.name, query, "DELETE");
             const deletableDescendants = await query;
             const notDeletableDescendants = descendants.filter(
               (descendant) => !deletableDescendants.some((d) => d.id === descendant.id)
@@ -2986,11 +2984,11 @@ var deleteEntity = async (modelName, id, ctx, {
       restricted
     });
   }
-};
-var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
-  const model = ctx.models.getModel(modelName, "entity");
+});
+var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => withTransaction(ctx, async (ctx2) => {
+  const model = ctx2.models.getModel(modelName, "entity");
   const rootModel = model.rootModel;
-  const entity = await getEntityToMutate(ctx, rootModel, { id }, "RESTORE");
+  const entity = await getEntityToMutate(ctx2, rootModel, { id }, "RESTORE");
   if (!entity.deleted) {
     throw new ForbiddenError(`${getTechnicalDisplay(model, entity)} is not deleted.`);
   }
@@ -3010,7 +3008,7 @@ var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
       if (!(currentEntity.deleteRootType === model.name && currentEntity.deleteRootId === entity.id)) {
         return;
       }
-    } else if (!anyDateToLuxon(currentEntity.deletedAt, ctx.timeZone).equals(anyDateToLuxon(entity.deletedAt, ctx.timeZone))) {
+    } else if (!anyDateToLuxon(currentEntity.deletedAt, ctx2.timeZone).equals(anyDateToLuxon(entity.deletedAt, ctx2.timeZone))) {
       return;
     }
     if (!(currentModel.name in toRestore)) {
@@ -3024,15 +3022,15 @@ var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
       deleteRootType: null,
       deleteRootId: null
     };
-    if (ctx.mutationHook) {
+    if (ctx2.mutationHook) {
       beforeHooks.push(async () => {
-        await ctx.mutationHook({
+        await ctx2.mutationHook({
           model: currentModel,
           action: "restore",
           trigger: currentTrigger,
           when: "before",
           data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-          ctx
+          ctx: ctx2
         });
       });
     }
@@ -3045,24 +3043,24 @@ var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
         if (toRestore[relation.targetModel.name]?.has(parentId)) {
           continue;
         }
-        const parent = await ctx.knex(relation.targetModel.name).where({ id: parentId }).first();
+        const parent = await ctx2.knex(relation.targetModel.name).where({ id: parentId }).first();
         if (parent?.deleted) {
           throw new ForbiddenError(
             `Can't restore ${getTechnicalDisplay(model, entity)} because it depends on deleted ${relation.targetModel.name} ${parentId}.`
           );
         }
       }
-      await doUpdate(currentModel, currentEntity, normalizedInput, ctx);
+      await doUpdate(currentModel, currentEntity, normalizedInput, ctx2);
     });
-    if (ctx.mutationHook) {
+    if (ctx2.mutationHook) {
       afterHooks.push(async () => {
-        await ctx.mutationHook({
+        await ctx2.mutationHook({
           model: currentModel,
           action: "restore",
           trigger: currentTrigger,
           when: "after",
           data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
-          ctx
+          ctx: ctx2
         });
       });
     }
@@ -3070,14 +3068,14 @@ var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
       targetModel: descendantModel,
       field: { foreignKey }
     } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited).filter(({ targetModel: { deletable } }) => deletable)) {
-      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: true });
+      const query = ctx2.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: true }).orderBy("createdAt", "asc").orderBy("id", "asc");
       if (currentEntity.deleteRootId) {
         query.where({ deleteRootType: currentEntity.deleteRootType, deleteRootId: currentEntity.deleteRootId });
       } else {
         query.where({ deletedAt: currentEntity.deletedAt });
       }
       const descendantsToRestore = await query;
-      applyPermissions(ctx, descendantModel.name, descendantModel.name, query, "RESTORE");
+      applyPermissions(ctx2, descendantModel.name, descendantModel.name, query, "RESTORE");
       const restorableDescendants = await query;
       const notRestorableDescendants = descendantsToRestore.filter(
         (descendant) => !restorableDescendants.some((d) => d.id === descendant.id)
@@ -3096,7 +3094,7 @@ var restoreEntity = async (modelName, id, ctx, trigger = "direct-call") => {
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
   }
-};
+});
 var createRevision = async (model, data, ctx) => {
   if (model.updatable) {
     const revisionId = (0, import_uuid.v4)();

package/dist/esm/resolvers/mutations.d.ts

@@ -3,13 +3,13 @@ import { Context } from '../context';
 import { EntityModel } from '../models/models';
 import { Entity, MutationContext, Trigger } from '../models/mutation-hook';
 export declare const mutationResolver: (_parent: any, args: any, partialCtx: Context, info: GraphQLResolveInfo) => Promise<any>;
-export declare const createEntity: (modelName: string, input: Entity, ctx: MutationContext, trigger?: Trigger) => Promise<string>;
-export declare const updateEntities: (modelName: string, where: Record<string, unknown>, updateFields: Entity, ctx: MutationContext) => Promise<void>;
-export declare const updateEntity: (modelName: string, id: string, input: Entity, ctx: MutationContext, trigger?: Trigger) => Promise<void>;
-export declare const deleteEntities: (modelName: string, where: Record<string, unknown>, ctx: MutationContext) => Promise<void>;
+export declare const createEntity: (modelName: string, input: Entity, ctx: MutationContext, trigger?: Trigger) => Promise<any>;
+export declare const updateEntities: (modelName: string, where: Record<string, unknown>, updateFields: Entity, ctx: MutationContext) => Promise<any>;
+export declare const updateEntity: (modelName: string, id: string, input: Entity, ctx: MutationContext, trigger?: Trigger) => Promise<any>;
+export declare const deleteEntities: (modelName: string, where: Record<string, unknown>, ctx: MutationContext) => Promise<any>;
 export declare const deleteEntity: (modelName: string, id: string, ctx: MutationContext, { dryRun, trigger, }?: {
     dryRun?: boolean;
     trigger?: Trigger;
-}) => Promise<void>;
-export declare const restoreEntity: (modelName: string, id: string, ctx: MutationContext, trigger?: Trigger) => Promise<void>;
+}) => Promise<any>;
+export declare const restoreEntity: (modelName: string, id: string, ctx: MutationContext, trigger?: Trigger) => Promise<any>;
 export declare const createRevision: (model: EntityModel, data: Entity, ctx: MutationContext) => Promise<void>;

package/dist/esm/resolvers/mutations.js

@@ -5,37 +5,35 @@ import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissio
 import { anyDateToLuxon } from '../utils';
 import { resolve } from './resolver';
 import { AliasGenerator, fetchDisplay, getTechnicalDisplay } from './utils';
-export const mutationResolver = async (_parent, args, partialCtx, info) => {
-    return await partialCtx.knex.transaction(async (knex) => {
-        const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
-        const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
-        switch (mutation) {
-            case 'create': {
-                const id = await createEntity(modelName, args.data, ctx, 'mutation');
-                return await resolve(ctx, id);
-            }
-            case 'update': {
-                const id = args.where.id;
-                await updateEntity(modelName, id, args.data, ctx, 'mutation');
-                return await resolve(ctx, id);
-            }
-            case 'delete': {
-                const id = args.where.id;
-                await deleteEntity(modelName, id, ctx, {
-                    dryRun: args.dryRun,
-                    trigger: 'mutation',
-                });
-                return id;
-            }
-            case 'restore': {
-                const id = args.where.id;
-                await restoreEntity(modelName, id, ctx, 'mutation');
-                return id;
-            }
+const withTransaction = async (ctx, fn) => await ctx.knex.transaction(async (knex) => fn({ ...ctx, knex }));
+export const mutationResolver = async (_parent, args, partialCtx, info) => withTransaction({ ...partialCtx, info, aliases: new AliasGenerator() }, async (ctx) => {
+    const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
+    switch (mutation) {
+        case 'create': {
+            const id = await createEntity(modelName, args.data, ctx, 'mutation');
+            return await resolve(ctx, id);
         }
-    });
-};
-export const createEntity = async (modelName, input, ctx, trigger = 'direct-call') => {
+        case 'update': {
+            const id = args.where.id;
+            await updateEntity(modelName, id, args.data, ctx, 'mutation');
+            return await resolve(ctx, id);
+        }
+        case 'delete': {
+            const id = args.where.id;
+            await deleteEntity(modelName, id, ctx, {
+                dryRun: args.dryRun,
+                trigger: 'mutation',
+            });
+            return id;
+        }
+        case 'restore': {
+            const id = args.where.id;
+            await restoreEntity(modelName, id, ctx, 'mutation');
+            return id;
+        }
+    }
+});
+export const createEntity = async (modelName, input, ctx, trigger = 'direct-call') => withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
     const normalizedInput = { ...input };
     if (!normalizedInput.id) {
@@ -92,14 +90,14 @@ export const createEntity = async (modelName, input, ctx, trigger = 'direct-call
         ctx,
     });
     return normalizedInput.id;
-};
-export const updateEntities = async (modelName, where, updateFields, ctx) => {
+});
+export const updateEntities = async (modelName, where, updateFields, ctx) => withTransaction(ctx, async (ctx) => {
     const entities = await ctx.knex(modelName).where(where).select('id');
     for (const entity of entities) {
         await updateEntity(modelName, entity.id, updateFields, ctx);
     }
-};
-export const updateEntity = async (modelName, id, input, ctx, trigger = 'direct-call') => {
+});
+export const updateEntity = async (modelName, id, input, ctx, trigger = 'direct-call') => withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
     const normalizedInput = { ...input };
     sanitize(ctx, model, normalizedInput);
@@ -131,16 +129,16 @@ export const updateEntity = async (modelName, id, input, ctx, trigger = 'direct-
             ctx,
         });
     }
-};
-export const deleteEntities = async (modelName, where, ctx) => {
+});
+export const deleteEntities = async (modelName, where, ctx) => withTransaction(ctx, async (ctx) => {
     const entities = await ctx.knex(modelName).where(where).select('id');
     for (const entity of entities) {
         await deleteEntity(modelName, entity.id, ctx, {
             trigger: 'direct-call',
         });
     }
-};
-export const deleteEntity = async (modelName, id, ctx, { dryRun = false, trigger = 'direct-call', } = {}) => {
+});
+export const deleteEntity = async (modelName, id, ctx, { dryRun = false, trigger = 'direct-call', } = {}) => withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
     const rootModel = model.rootModel;
     const entity = await getEntityToMutate(ctx, rootModel, { id }, 'DELETE');
@@ -199,7 +197,11 @@ export const deleteEntity = async (modelName, id, ctx, { dryRun = false, trigger
             }
         }
         for (const { targetModel: descendantModel, field: { name, foreignKey, onDelete }, } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited)) {
-            const query = ctx.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: false });
+            const query = ctx
+                .knex(descendantModel.name)
+                .where({ [foreignKey]: currentEntity.id, deleted: false })
+                .orderBy('createdAt', 'asc')
+                .orderBy('id', 'asc');
             const descendants = await query;
             if (descendants.length) {
                 switch (onDelete) {
@@ -300,8 +302,8 @@ export const deleteEntity = async (modelName, id, ctx, { dryRun = false, trigger
             restricted,
         });
     }
-};
-export const restoreEntity = async (modelName, id, ctx, trigger = 'direct-call') => {
+});
+export const restoreEntity = async (modelName, id, ctx, trigger = 'direct-call') => withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
     const rootModel = model.rootModel;
     const entity = await getEntityToMutate(ctx, rootModel, { id }, 'RESTORE');
@@ -381,7 +383,11 @@ export const restoreEntity = async (modelName, id, ctx, trigger = 'direct-call')
         for (const { targetModel: descendantModel, field: { foreignKey }, } of currentModel.reverseRelations
             .filter((reverseRelation) => !reverseRelation.field.inherited)
             .filter(({ targetModel: { deletable } }) => deletable)) {
-            const query = ctx.knex(descendantModel.name).where({ [foreignKey]: currentEntity.id, deleted: true });
+            const query = ctx
+                .knex(descendantModel.name)
+                .where({ [foreignKey]: currentEntity.id, deleted: true })
+                .orderBy('createdAt', 'asc')
+                .orderBy('id', 'asc');
             if (currentEntity.deleteRootId) {
                 query.where({ deleteRootType: currentEntity.deleteRootType, deleteRootId: currentEntity.deleteRootId });
             }
@@ -405,7 +411,7 @@ export const restoreEntity = async (modelName, id, ctx, trigger = 'direct-call')
     for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
         await callback();
     }
-};
+});
 export const createRevision = async (model, data, ctx) => {
     if (model.updatable) {
         const revisionId = uuid();