on-zero 0.6.14 → 0.6.16

package/dist/cjs/asyncTasks.cjs

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var asyncTasks_exports = {};
+__export(asyncTasks_exports, {
+  runAsyncTaskEntries: () => runAsyncTaskEntries
+});
+module.exports = __toCommonJS(asyncTasks_exports);
+async function runAsyncTaskEntries(entries, {
+  background
+} = {}) {
+  const barriers = entries.filter(entry => entry.barrier);
+  const backgroundEntries = entries.filter(entry => !entry.barrier);
+  await Promise.all(barriers.map(({
+    task
+  }) => task()));
+  if (backgroundEntries.length === 0) return;
+  const promise = Promise.allSettled(backgroundEntries.map(({
+    task
+  }) => Promise.resolve().then(task))).then(results => {
+    for (const result of results) {
+      if (result.status === "rejected") {
+        console.error("[on-zero] async task failed", result.reason);
+      }
+    }
+  });
+  if (background) {
+    background(promise);
+  } else {
+    await promise;
+  }
+}

package/dist/cjs/asyncTasks.native.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var asyncTasks_exports = {};
+__export(asyncTasks_exports, {
+  runAsyncTaskEntries: () => runAsyncTaskEntries
+});
+module.exports = __toCommonJS(asyncTasks_exports);
+async function runAsyncTaskEntries(entries) {
+  var {
+    background
+  } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var barriers = entries.filter(function (entry) {
+    return entry.barrier;
+  });
+  var backgroundEntries = entries.filter(function (entry) {
+    return !entry.barrier;
+  });
+  await Promise.all(barriers.map(function (param) {
+    var {
+      task
+    } = param;
+    return task();
+  }));
+  if (backgroundEntries.length === 0) return;
+  var promise = Promise.allSettled(backgroundEntries.map(function (param) {
+    var {
+      task
+    } = param;
+    return Promise.resolve().then(task);
+  })).then(function (results) {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = results[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var result = _step.value;
+        if (result.status === "rejected") {
+          console.error("[on-zero] async task failed", result.reason);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  });
+  if (background) {
+    background(promise);
+  } else {
+    await promise;
+  }
+}
+//# sourceMappingURL=asyncTasks.native.js.map

package/dist/cjs/asyncTasks.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","asyncTasks_exports","__export","runAsyncTaskEntries","module","exports","entries","background","arguments","length","barriers","filter","entry","barrier","backgroundEntries","Promise","all","map","param","task","promise","allSettled","resolve","then","results","_iteratorNormalCompletion","_didIteratorError","_iteratorError"],"sources":["../../src/asyncTasks.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,kBAAA;AAAAC,QAAA,CAAAD,kBAAA;EAAAE,mBAAA,EAAAA,CAAA,KAAAA;AAAA;AAOAC,MAAA,CAAAC,OAAA,GAAsBT,YAAA,CAAAK,kBAElB;AAEF,eAAME,mBAA0BA,CAACG,OAAA;EACjC;IAAMC;EAAA,IAAAC,SAAoB,CAAAC,MAAQ,IAAO,IAACD,SAAW,QAAM,KAAO,IAAAA,SAAA;EAElE,IAAAE,QAAM,GAAQJ,OAAI,CAAAK,MAAS,WAAYC,KAAA,EAAM;IAC7C,OAAIA,KAAA,CAAAC,OAAkB;EAEtB;EAAwB,IACtBC,iBAAkB,GAAIR,OAAG,CAAKK,MAAM,WAAQC,KAAA,EAAQ;IACpD,OAAM,CAAAA,KAAA,CAAAC,OAAY;EAClB;EACE,MAAAE,OAAI,CAAAC,GAAO,CAAAN,QAAW,CAAAO,GAAA,WAAYC,KAAA;IAChC;MAAAC;IAAA,CAAQ,GAAAD,KAAM;IAA4C,OAC5DC,IAAA;EAAA,EACF;EACF,IAACL,iBAAA,CAAAL,MAAA;EAED,IAAIW,OAAA,GAAAL,OAAY,CAAAM,UAAA,CAAAP,iBAAA,CAAAG,GAAA,WAAAC,KAAA;IACd;MAAAC;IAAW,IAAAD,KAAO;IACpB,OAAOH,OAAA,CAAAO,OAAA,GAAAC,IAAA,CAAAJ,IAAA;EACL,IAAAI,IAAM,WAAAC,OAAA;IACR,IAAAC,yBAAA;MAAAC,iBAAA;MAAAC,cAAA;IACF","ignoreList":[]}

package/dist/cjs/cli.cjs

@@ -24,6 +24,12 @@ const generateCommand = (0, import_citty.defineCommand)({
       type: "string",
       description: "Command to run after generation completes",
       required: false
+    },
+    force: {
+      type: "boolean",
+      description: "Ignore cached inputs and regenerate all outputs",
+      required: false,
+      default: false
     }
   },
   async run({
@@ -31,7 +37,8 @@ const generateCommand = (0, import_citty.defineCommand)({
   }) {
     const opts = {
       dir: (0, import_node_path.resolve)(args.dir),
-      after: args.after
+      after: args.after,
+      force: args.force
     };
     if (args.watch) {
       await (0, import_generate.watch)(opts);

package/dist/cjs/cli.native.js

@@ -26,6 +26,12 @@ var generateCommand = (0, import_citty.defineCommand)({
       type: "string",
       description: "Command to run after generation completes",
       required: false
+    },
+    force: {
+      type: "boolean",
+      description: "Ignore cached inputs and regenerate all outputs",
+      required: false,
+      default: false
     }
   },
   async run(param) {
@@ -34,7 +40,8 @@ var generateCommand = (0, import_citty.defineCommand)({
     } = param;
     var opts = {
       dir: (0, import_path.resolve)(args.dir),
-      after: args.after
+      after: args.after,
+      force: args.force
     };
     if (args.watch) {
       await (0, import_generate.watch)(opts);

package/dist/cjs/cli.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["import_path","require","import_citty","import_generate","generateCommand","defineCommand","meta","name","description","args","dir","type","required","default","watch","after","run","param","opts","resolve","Promise","generate","main"],"sources":["../../src/cli.ts"],"sourcesContent":[null],"mappings":";AACA;;AAEA,IAAAA,WAAA,GAAAC,OAAuC;AAEvC,IAAAC,YAAA,GAAAD,OAAgC;AAEhC,IAAAE,eAAM,GAAAF,OAAkB;AAAc,IACpCG,eAAM,OAAAF,YAAA,CAAAG,aAAA;EAAAC,IACJ;IACAC,IAAA,YAAa;IACfC,WAAA;EACA;EAAMC,IACJ;IAAKC,GACH;MACAC,IAAA,cAAa;MACbH,WAAU;MACVI,QAAA,EAAS;MACXC,OAAA;IACA;IAAOC,KACL;MACAH,IAAA,WAAa;MACbH,WAAU;MACVI,QAAA,EAAS;MACXC,OAAA;IACA;IAAOE,KACL;MACAJ,IAAA,UAAa;MACbH,WAAU;MACZI,QAAA;IACF;EAEA;EACE,MAAAI,GAAMA,CAAAC,KAAO,EAAE;IAEf,IAAI;MAAAR;IAAK,IAAAQ,KAAO;IACd,IAAAC,IAAA;MACAR,GAAA,GAAM,GAAAV,WAAY,CAAAmB,OAAM,EAAAV,IAAA,CAAAC,GAAA;MAACK,KAAC,EAAAN,IAAA,CAAAM;IAC5B;IACE,IAAAN,IAAA,CAAAK,KAAM;MACR,UAAAX,eAAA,CAAAW,KAAA,EAAAI,IAAA;MACF,UAAAE,OAAA,cACD;IAED,OAAM;MACJ,MAAM,IAAAjB,eAAA,CAAAkB,QAAA,EAAAH,IAAA;IACJ;EAAM;AACO,EACf;AAAA,IACAI,IAAA,OAAapB,YAAA,CAAAG,aAAA;EAAAC,IACX;IACFC,IAAA;IACDC,WAAA;EAAA","ignoreList":[]}
+{"version":3,"names":["import_path","require","import_citty","import_generate","generateCommand","defineCommand","meta","name","description","args","dir","type","required","default","watch","after","force","run","param","opts","resolve","Promise","generate","main"],"sources":["../../src/cli.ts"],"sourcesContent":[null],"mappings":";AACA;;AAEA,IAAAA,WAAA,GAAAC,OAAuC;AAEvC,IAAAC,YAAA,GAAAD,OAAgC;AAEhC,IAAAE,eAAM,GAAAF,OAAkB;AAAc,IACpCG,eAAM,OAAAF,YAAA,CAAAG,aAAA;EAAAC,IACJ;IACAC,IAAA,YAAa;IACfC,WAAA;EACA;EAAMC,IACJ;IAAKC,GACH;MACAC,IAAA,cAAa;MACbH,WAAU;MACVI,QAAA,EAAS;MACXC,OAAA;IACA;IAAOC,KACL;MACAH,IAAA,WAAa;MACbH,WAAU;MACVI,QAAA,EAAS;MACXC,OAAA;IACA;IAAOE,KACL;MACAJ,IAAA,UAAa;MACbH,WAAU;MACZI,QAAA;IACA;IAAOI,KACL;MACAL,IAAA,WAAa;MACbH,WAAU;MACVI,QAAA,EAAS;MACXC,OAAA;IACF;EAEA;EACE,MAAAI,GAAMA,CAAAC,KAAO,EAAE;IAEf,IAAI;MAAAT;IAAK,IAAAS,KAAO;IACd,IAAAC,IAAA;MACAT,GAAA,GAAM,GAAAV,WAAY,CAAAoB,OAAM,EAAAX,IAAA,CAAAC,GAAA;MAACK,KAAC,EAAAN,IAAA,CAAAM,KAAA;MAC5BC,KAAO,EAAAP,IAAA,CAAAO;IACL;IACF,IAAAP,IAAA,CAAAK,KAAA;MACF,UAAAX,eAAA,CAAAW,KAAA,EAAAK,IAAA;MACD,UAAAE,OAAA,cAEK;IACJ,OAAM;MACJ,MAAM,IAAAlB,eAAA,CAAAmB,QAAA,EAAAH,IAAA;IACN;EACF;AAAA,EACA;AAAa,IACXI,IAAA,OAAUrB,YAAA,CAAAG,aAAA;EACZC,IAAA;IACDC,IAAA;IAEDC,WAAA","ignoreList":[]}

package/dist/cjs/createSchemaFromDrizzle.cjs

@@ -22,11 +22,11 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var createSchemaFromDrizzle_exports = {};
 __export(createSchemaFromDrizzle_exports, {
-  createSchemaFromDrizzle: () => import_drizzle_zero.drizzleZeroConfig,
-  createZeroTableBuilder: () => import_drizzle_zero2.createZeroTableBuilder,
+  createSchemaFromDrizzle: () => import_drizzle_zero_sqlite.drizzleZeroConfig,
+  createZeroTableBuilder: () => import_drizzle_zero_sqlite2.createZeroTableBuilder,
   generateDrizzleSchemaFile: () => import_generate.generateDrizzleSchemaFile
 });
 module.exports = __toCommonJS(createSchemaFromDrizzle_exports);
-var import_drizzle_zero = require("drizzle-zero");
-var import_drizzle_zero2 = require("drizzle-zero");
+var import_drizzle_zero_sqlite = require("drizzle-zero-sqlite");
+var import_drizzle_zero_sqlite2 = require("drizzle-zero-sqlite");
 var import_generate = require("./generate.cjs");

package/dist/cjs/createSchemaFromDrizzle.native.js

@@ -24,12 +24,12 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var createSchemaFromDrizzle_exports = {};
 __export(createSchemaFromDrizzle_exports, {
-  createSchemaFromDrizzle: () => import_drizzle_zero.drizzleZeroConfig,
-  createZeroTableBuilder: () => import_drizzle_zero2.createZeroTableBuilder,
+  createSchemaFromDrizzle: () => import_drizzle_zero_sqlite.drizzleZeroConfig,
+  createZeroTableBuilder: () => import_drizzle_zero_sqlite2.createZeroTableBuilder,
   generateDrizzleSchemaFile: () => import_generate.generateDrizzleSchemaFile
 });
 module.exports = __toCommonJS(createSchemaFromDrizzle_exports);
-var import_drizzle_zero = require("drizzle-zero");
-var import_drizzle_zero2 = require("drizzle-zero");
+var import_drizzle_zero_sqlite = require("drizzle-zero-sqlite");
+var import_drizzle_zero_sqlite2 = require("drizzle-zero-sqlite");
 var import_generate = require("./generate.native.js");
 //# sourceMappingURL=createSchemaFromDrizzle.native.js.map

package/dist/cjs/createSchemaFromDrizzle.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","createSchemaFromDrizzle_exports","__export","createSchemaFromDrizzle","import_drizzle_zero","drizzleZeroConfig","createZeroTableBuilder","import_drizzle_zero2","generateDrizzleSchemaFile","import_generate","module","exports","require"],"sources":["../../src/createSchemaFromDrizzle.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,+BAAA;AAAAC,QAAA,CAAAD,+BAAA;EAAAE,uBAAA,EAAAA,CAAA,KAAAC,mBAAA,CAAAC,iBAAA;EAAAC,sBAAA,EAAAA,CAAA,KAAAC,oBAAA,CAAAD,sBAAA;EAAAE,yBAAA,EAAAA,CAAA,KAAAC,eAAA,CAAAD;AAAA;AAAAE,MAAA,CAAAC,OAAA,GAAAf,YAA6D,CAAAK,+BAAA;AAC7D,IAAAG,mBAAA,GAAAQ,OAAuC;AACvC,IAAAL,oBAA0C,GAAAK,OAAA","ignoreList":[]}
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","createSchemaFromDrizzle_exports","__export","createSchemaFromDrizzle","import_drizzle_zero_sqlite","drizzleZeroConfig","createZeroTableBuilder","import_drizzle_zero_sqlite2","generateDrizzleSchemaFile","import_generate","module","exports","require"],"sources":["../../src/createSchemaFromDrizzle.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,+BAAA;AAAAC,QAAA,CAAAD,+BAAA;EAAAE,uBAAA,EAAAA,CAAA,KAAAC,0BAAA,CAAAC,iBAAA;EAAAC,sBAAA,EAAAA,CAAA,KAAAC,2BAAA,CAAAD,sBAAA;EAAAE,yBAAA,EAAAA,CAAA,KAAAC,eAAA,CAAAD;AAAA;AAAAE,MAAA,CAAAC,OAAA,GAAAf,YAAA,CAAAK,+BAA6D;AAC7D,IAAAG,0BAAA,GAAAQ,OAAuC;AACvC,IAAAL,2BAA0C,GAAAK,OAAA","ignoreList":[]}

package/dist/cjs/createZeroDirectServer.cjs

@@ -0,0 +1,269 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var createZeroDirectServer_exports = {};
+__export(createZeroDirectServer_exports, {
+  createAsyncTaskCollector: () => createAsyncTaskCollector,
+  createZeroDirectServer: () => createZeroDirectServer,
+  createZeroDirectServerRuntime: () => createZeroDirectServerRuntime,
+  resolveServerQuery: () => resolveServerQuery
+});
+module.exports = __toCommonJS(createZeroDirectServer_exports);
+var import_zero = require("@rocicorp/zero");
+var import_asyncTasks = require("./asyncTasks.cjs");
+var import_createPermissions = require("./createPermissions.cjs");
+var import_createMutators = require("./helpers/createMutators.cjs");
+var import_mutatorContext = require("./helpers/mutatorContext.cjs");
+var import_queryContext = require("./helpers/queryContext.cjs");
+var import_modelRegistry = require("./modelRegistry.cjs");
+var import_run = require("./run.cjs");
+var import_state = require("./state.cjs");
+var import_where = require("./where.cjs");
+var import_zeroRunner = require("./zeroRunner.cjs");
+function resolveServerQuery({
+  authData,
+  name,
+  args,
+  queries,
+  permissions,
+  validateQuery
+}) {
+  if (name.startsWith("permission.")) {
+    const table = name.slice("permission.".length);
+    const {
+      objOrId
+    } = args;
+    const permission = (0, import_modelRegistry.getMutationsPermissions)(table);
+    if (!permission) {
+      throw new Error(`[permission] no permission defined for table: ${table}`);
+    }
+    (0, import_where.setEvaluatingPermission)(true);
+    try {
+      return (0, import_state.getZQL)()[table].where(eb => {
+        return permissions.buildPermissionQuery(authData, eb, permission, objOrId, table);
+      }).one();
+    } finally {
+      (0, import_where.setEvaluatingPermission)(false);
+    }
+  }
+  if (validateQuery) {
+    validateQuery({
+      authData,
+      queryName: name,
+      params: args
+    });
+  }
+  const query = (0, import_zero.mustGetQuery)(queries, name);
+  return query.fn({
+    args,
+    ctx: authData
+  });
+}
+function createAsyncTaskCollector() {
+  const committed = [];
+  let attempt;
+  let completedAttempt;
+  const enqueueTask = (task, opts) => {
+    const entries = attempt ?? committed;
+    entries.push({
+      task,
+      barrier: opts?.barrier === true
+    });
+  };
+  const lifecycle = {
+    beginAttempt() {
+      attempt = [];
+      completedAttempt = void 0;
+    },
+    completeAttempt() {
+      completedAttempt = attempt;
+      attempt = void 0;
+    },
+    rollbackAttempt() {
+      attempt = void 0;
+      completedAttempt = void 0;
+    },
+    commitTransaction() {
+      if (completedAttempt) committed.push(...completedAttempt);
+      completedAttempt = void 0;
+    },
+    rollbackTransaction() {
+      attempt = void 0;
+      completedAttempt = void 0;
+    }
+  };
+  return {
+    committed,
+    enqueueTask,
+    lifecycle
+  };
+}
+function createZeroDirectServerRuntime({
+  createDatabase,
+  createServerActions,
+  defaultAllowAdminRole = "all",
+  defaultMutateAuthData = {},
+  models,
+  mutations: mutationValidators,
+  queries,
+  schema,
+  validateMutation,
+  validateQuery
+}) {
+  (0, import_state.setSchema)(schema);
+  (0, import_state.setEnvironment)("server");
+  const permissions = (0, import_createPermissions.createPermissions)({
+    environment: "server",
+    schema,
+    adminRoleMode: defaultAllowAdminRole
+  });
+  async function runTransaction(database, query2) {
+    try {
+      if ((0, import_mutatorContext.isInZeroMutation)()) {
+        const {
+          tx
+        } = (0, import_mutatorContext.mutatorContext)();
+        return await query2(tx);
+      }
+      return await database.transaction(query2, dummyTransactionInput);
+    } catch (err) {
+      if (err?.name !== "PermissionError") {
+        console.error(`Error running transaction(): ${err}`);
+      }
+      throw err;
+    }
+  }
+  async function transaction(query2) {
+    return runTransaction(createDatabase(), query2);
+  }
+  async function runMutate(modelName, mutatorName, mutatorArg, options) {
+    let authData = options?.authData;
+    if (!authData) {
+      const scoped = (0, import_mutatorContext.getScopedAuthData)();
+      if (scoped) authData = scoped;
+    }
+    const tasks = createAsyncTaskCollector();
+    const mutators = (0, import_createMutators.createMutators)({
+      models,
+      environment: "server",
+      enqueueTask: tasks.enqueueTask,
+      authData: {
+        ...defaultMutateAuthData,
+        ...authData
+      },
+      createServerActions,
+      can: permissions.can,
+      validateMutation,
+      mutationValidators
+    });
+    const modelMutators = mutators[modelName];
+    const mutator = modelMutators[mutatorName];
+    await runTransaction(createDatabaseWithLifecycle(createDatabase(), tasks.lifecycle), async tx => {
+      await mutator(tx, mutatorArg);
+    });
+    if (tasks.committed.length) {
+      const resolvedAuth = authData ?? null;
+      const entries = tasks.committed.map(entry => ({
+        ...entry,
+        task: () => (0, import_mutatorContext.runWithAuthScope)(resolvedAuth, entry.task)
+      }));
+      if (options?.awaitEffects) {
+        await Promise.all(entries.map(({
+          task
+        }) => task()));
+      } else {
+        await (0, import_asyncTasks.runAsyncTaskEntries)(entries, {
+          background: () => void 0
+        });
+      }
+    }
+  }
+  const mutate = new Proxy({}, {
+    get(_, modelName) {
+      return new Proxy({}, {
+        get(_2, mutatorName) {
+          return (arg, options) => runMutate(modelName, mutatorName, arg, options);
+        }
+      });
+    }
+  });
+  function query(cb, authData) {
+    const run = () => transaction(async tx => {
+      return tx.run(cb((0, import_state.getZQL)()));
+    });
+    if (authData !== void 0) {
+      return (0, import_queryContext.runWithQueryContext)({
+        authData
+      }, run);
+    }
+    return run();
+  }
+  if (queries) {
+    (0, import_run.setCustomQueries)(queries);
+  }
+  (0, import_zeroRunner.setRunner)(queryObj => {
+    return transaction(async tx => {
+      return tx.run(queryObj);
+    });
+  });
+  return {
+    permissions,
+    server: {
+      transaction,
+      mutate,
+      query
+    }
+  };
+}
+function createZeroDirectServer(options) {
+  return createZeroDirectServerRuntime(options).server;
+}
+function createDatabaseWithLifecycle(database, lifecycle) {
+  return {
+    async transaction(callback, input) {
+      try {
+        const value = await database.transaction(async (tx, hooks) => {
+          lifecycle.beginAttempt();
+          try {
+            const result = await callback(tx, hooks);
+            lifecycle.completeAttempt();
+            return result;
+          } catch (error) {
+            lifecycle.rollbackAttempt();
+            throw error;
+          }
+        }, input);
+        lifecycle.commitTransaction();
+        return value;
+      } catch (error) {
+        lifecycle.rollbackTransaction();
+        throw error;
+      }
+    }
+  };
+}
+const dummyTransactionInput = {
+  clientGroupID: "unused",
+  clientID: "unused",
+  mutationID: 42,
+  upstreamSchema: "unused"
+};