on-zero 0.4.3 → 0.4.4

package/dist/cjs/createZeroServer.cjs

@@ -3,41 +3,43 @@ 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: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  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;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var createZeroServer_exports = {};
 __export(createZeroServer_exports, {
   createZeroServer: () => createZeroServer
 });
 module.exports = __toCommonJS(createZeroServer_exports);
-var import_zero = require("@rocicorp/zero"),
-  import_pg = require("@rocicorp/zero/pg"),
-  import_server = require("@rocicorp/zero/server"),
-  import_pg2 = require("@rocicorp/zero/server/adapters/pg"),
-  import_helpers = require("@take-out/helpers"),
-  import_pg3 = require("pg"),
-  import_createPermissions = require("./createPermissions.cjs"),
-  import_createMutators = require("./helpers/createMutators.cjs"),
-  import_mutatorContext = require("./helpers/mutatorContext.cjs"),
-  import_queryContext = require("./helpers/queryContext.cjs"),
-  import_modelRegistry = require("./modelRegistry.cjs"),
-  import_run = require("./run.cjs"),
-  import_state = require("./state.cjs"),
-  import_where = require("./where.cjs"),
-  import_zeroRunner = require("./zeroRunner.cjs");
+var import_zero = require("@rocicorp/zero");
+var import_pg = require("@rocicorp/zero/pg");
+var import_server = require("@rocicorp/zero/server");
+var import_pg2 = require("@rocicorp/zero/server/adapters/pg");
+var import_helpers = require("@take-out/helpers");
+var import_pg3 = require("pg");
+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 createZeroServer({
   createServerActions,
   database,
@@ -51,118 +53,146 @@ function createZeroServer({
   defaultAllowAdminRole = "all",
   defaultMutateAuthData = {}
 }) {
-  (0, import_state.setSchema)(schema), (0, import_state.setEnvironment)("server");
+  (0, import_state.setSchema)(schema);
+  (0, import_state.setEnvironment)("server");
   let pool;
-  if (externalPool) pool = externalPool;else {
-    const dbString = (0, import_helpers.assertString)(database, 'createZeroServer "database"'),
-      pgPool = new import_pg3.Pool({
-        connectionString: dbString,
-        // handle self-signed certificates in production
-        ssl: dbString.includes("sslmode=require") ? {
-          rejectUnauthorized: !1
-        } : void 0
-      });
+  if (externalPool) {
+    pool = externalPool;
+  } else {
+    const dbString = (0, import_helpers.assertString)(database, `createZeroServer "database"`);
+    const pgPool = new import_pg3.Pool({
+      connectionString: dbString,
+      // handle self-signed certificates in production
+      ssl: dbString.includes("sslmode=require") ? {
+        rejectUnauthorized: false
+      } : void 0
+    });
     pgPool.on("error", error => {
-      console.error("[on-zero] pool error", error.message);
-    }), pgPool.on("connect", client => {
+      console.error(`[on-zero] pool error`, error.message);
+    });
+    pgPool.on("connect", client => {
       client.on("error", error => {
-        console.error("[on-zero] client error", error.message);
+        console.error(`[on-zero] client error`, error.message);
       });
-    }), pool = pgPool;
+    });
+    pool = pgPool;
   }
-  const zeroDb = (0, import_pg2.zeroNodePg)(schema, pool),
-    permissions = (0, import_createPermissions.createPermissions)({
+  const zeroDb = (0, import_pg2.zeroNodePg)(schema, pool);
+  const permissions = (0, import_createPermissions.createPermissions)({
+    environment: "server",
+    schema,
+    adminRoleMode: defaultAllowAdminRole
+  });
+  const processor = new import_pg.PushProcessor(zeroDb);
+  const handleMutationRequest = async ({
+    authData,
+    request,
+    skipAsyncTasks
+  }) => {
+    const asyncTasks = [];
+    const mutators = (0, import_createMutators.createMutators)({
+      asyncTasks,
+      can: permissions.can,
+      createServerActions,
       environment: "server",
-      schema,
-      adminRoleMode: defaultAllowAdminRole
-    }),
-    processor = new import_pg.PushProcessor(zeroDb),
-    handleMutationRequest = async ({
+      models,
       authData,
-      request,
-      skipAsyncTasks
-    }) => {
-      const asyncTasks = [],
-        mutators = (0, import_createMutators.createMutators)({
-          asyncTasks,
-          can: permissions.can,
-          createServerActions,
-          environment: "server",
-          models,
+      validateMutation,
+      mutationValidators
+    });
+    const response = await processor.process(mutators, request);
+    if (!skipAsyncTasks && asyncTasks.length) {
+      Promise.all(asyncTasks.map(task => (0, import_mutatorContext.runWithAuthScope)(authData, task))).catch(err => {
+        console.error(`[push] async tasks failed`, err);
+      });
+    }
+    return {
+      response,
+      asyncTasks
+    };
+  };
+  const handleQueryRequest = async ({
+    authData,
+    request
+  }) => {
+    if (!queries) {
+      throw new Error("No queries registered with createZeroServer. Pass the syncedQueries registry to createZeroServer via the queries option.");
+    }
+    const response = await (0, import_queryContext.runWithQueryContext)({
+      authData: authData || {}
+    }, () => (0, import_server.handleQueryRequest)((name, args) => {
+      if (name.startsWith("permission.")) {
+        const table = name.slice("permission.".length);
+        const {
+          objOrId
+        } = args;
+        const perm = (0, import_modelRegistry.getMutationsPermissions)(table);
+        if (!perm) {
+          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, perm, objOrId, table);
+          }).one();
+        } finally {
+          (0, import_where.setEvaluatingPermission)(false);
+        }
+      }
+      if (validateQuery) {
+        validateQuery({
           authData,
-          validateMutation,
-          mutationValidators
-        }),
-        response = await processor.process(mutators, request);
-      return !skipAsyncTasks && asyncTasks.length && Promise.all(asyncTasks.map(task => (0, import_mutatorContext.runWithAuthScope)(authData, task))).catch(err => {
-        console.error("[push] async tasks failed", err);
-      }), {
-        response,
-        asyncTasks
-      };
-    },
-    handleQueryRequest = async ({
-      authData,
-      request
-    }) => {
-      if (!queries) throw new Error("No queries registered with createZeroServer. Pass the syncedQueries registry to createZeroServer via the queries option.");
-      return {
-        response: await (0, import_queryContext.runWithQueryContext)({
-          authData: authData || {}
-        }, () => (0, import_server.handleQueryRequest)((name, args) => {
-          if (name.startsWith("permission.")) {
-            const table = name.slice(11),
-              {
-                objOrId
-              } = args,
-              perm = (0, import_modelRegistry.getMutationsPermissions)(table);
-            if (!perm) throw new Error(`[permission] no permission defined for table: ${table}`);
-            (0, import_where.setEvaluatingPermission)(!0);
-            try {
-              return (0, import_state.getZQL)()[table].where(eb => permissions.buildPermissionQuery(authData, eb, perm, objOrId, table)).one();
-            } finally {
-              (0, import_where.setEvaluatingPermission)(!1);
-            }
-          }
-          return validateQuery && validateQuery({
-            authData,
-            queryName: name,
-            params: args
-          }), (0, import_zero.mustGetQuery)(queries, name).fn({
-            args,
-            ctx: authData
-          });
-        }, schema, request))
-      };
+          queryName: name,
+          params: args
+        });
+      }
+      const query2 = (0, import_zero.mustGetQuery)(queries, name);
+      return query2.fn({
+        args,
+        ctx: authData
+      });
+    }, schema, request));
+    return {
+      response
     };
+  };
   async function runMutate(modelName, mutatorName, mutatorArg, options) {
     let authData = options?.authData;
     if (!authData) {
       const scoped = (0, import_mutatorContext.getScopedAuthData)();
-      scoped && (authData = scoped);
+      if (scoped) {
+        authData = scoped;
+      }
     }
-    const asyncTasks = [],
-      mutator = (0, import_createMutators.createMutators)({
-        models,
-        environment: "server",
-        asyncTasks,
-        authData: {
-          ...defaultMutateAuthData,
-          ...authData
-        },
-        createServerActions,
-        can: permissions.can,
-        validateMutation,
-        mutationValidators
-      })[modelName][mutatorName];
-    if (await transaction(async tx => {
+    const asyncTasks = [];
+    const mutators = (0, import_createMutators.createMutators)({
+      models,
+      environment: "server",
+      asyncTasks,
+      authData: {
+        ...defaultMutateAuthData,
+        ...authData
+      },
+      createServerActions,
+      can: permissions.can,
+      validateMutation,
+      mutationValidators
+    });
+    const modelMutators = mutators[modelName];
+    const mutator = modelMutators[mutatorName];
+    await transaction(async tx => {
       await mutator(tx, mutatorArg);
-    }), asyncTasks.length) {
-      const resolvedAuth = authData ?? null,
-        promise = Promise.all(asyncTasks.map(t => (0, import_mutatorContext.runWithAuthScope)(resolvedAuth, t)));
-      options?.awaitEffects ? await promise : promise.catch(err => {
-        console.error("[mutate] async tasks failed", err);
-      });
+    });
+    if (asyncTasks.length) {
+      const resolvedAuth = authData ?? null;
+      const promise = Promise.all(asyncTasks.map(t => (0, import_mutatorContext.runWithAuthScope)(resolvedAuth, t)));
+      if (options?.awaitEffects) {
+        await promise;
+      } else {
+        promise.catch(err => {
+          console.error(`[mutate] async tasks failed`, err);
+        });
+      }
     }
   }
   const mutate = new Proxy({}, {
@@ -182,18 +212,34 @@ function createZeroServer({
         } = (0, import_mutatorContext.mutatorContext)();
         return await query2(tx);
       }
-      return await zeroDb.transaction(query2, dummyTransactionInput);
+      const output = await zeroDb.transaction(query2, dummyTransactionInput);
+      return output;
     } catch (err) {
-      throw err?.name !== "PermissionError" && console.error(`Error running transaction(): ${err}`), err;
+      if (err?.name !== "PermissionError") {
+        console.error(`Error running transaction(): ${err}`);
+      }
+      throw err;
     }
   }
   function query(cb, authData) {
-    const run = () => transaction(async tx => tx.run(cb((0, import_state.getZQL)())));
-    return authData !== void 0 ? (0, import_queryContext.runWithQueryContext)({
-      authData
-    }, run) : run();
+    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);
   }
-  queries && (0, import_run.setCustomQueries)(queries), (0, import_zeroRunner.setRunner)(queryObj => transaction(async tx => tx.run(queryObj)));
+  (0, import_zeroRunner.setRunner)(queryObj => {
+    return transaction(async tx => {
+      return tx.run(queryObj);
+    });
+  });
   const dummyTransactionInput = {
     clientGroupID: "unused",
     clientID: "unused",