over-zero 0.0.60 → 0.0.62

package/dist/cjs/index.cjs

@@ -1,42 +1,884 @@
+"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: !0
+  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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  batchQuery: () => batchQuery,
+  createMutators: () => createMutators,
+  createPermissions: () => createPermissions,
+  createUseQuery: () => createUseQuery,
+  createZeroClient: () => createZeroClient,
+  ensureLoggedIn: () => ensureLoggedIn,
+  getQueryName: () => getQueryName,
+  getWhereTableName: () => getWhereTableName,
+  isInZeroMutation: () => isInZeroMutation,
+  mutations: () => mutations,
+  mutatorContext: () => mutatorContext,
+  registerQuery: () => registerQuery,
+  resolveQuery: () => resolveQuery,
+  run: () => run,
+  runWithContext: () => runWithContext,
+  serverWhere: () => serverWhere,
+  setRunner: () => setRunner,
+  where: () => where,
+  zql: () => zql2
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/createPermissions.ts
+var import_helpers5 = require("@take-out/helpers");
+
+// src/helpers/didRunPermissionCheck.ts
+var import_helpers = require("@take-out/helpers");
+var PermissionCheckRan = (0, import_helpers.globalValue)(
+  `over-zero:permissions-check`,
+  () => /* @__PURE__ */ new WeakMap()
+);
+var getDidRunPermissionCheck = (ctx) => {
+  return PermissionCheckRan.get(ctx);
+};
+var setDidRunPermissionCheck = (ctx) => {
+  return PermissionCheckRan.set(ctx, true);
+};
+
+// src/helpers/mutatorContext.ts
+var import_helpers2 = require("@take-out/helpers");
+var asyncContext = (0, import_helpers2.createAsyncContext)();
+function mutatorContext() {
+  const currentContext = asyncContext.get();
+  if (!currentContext) {
+    throw new Error("mutatorContext must be called within a mutator");
+  }
+  return currentContext;
+}
+function isInZeroMutation() {
+  return !!asyncContext.get();
+}
+function runWithContext(context, fn) {
+  return asyncContext.run(context, fn);
+}
+
+// src/helpers/prettyFormatZeroQuery.ts
+var import_helpers3 = require("@take-out/helpers");
+var prettyFormatZeroQuery = (query, mode = "full") => {
+  const astObject = query["_completeAst"]?.();
+  if (!astObject) return "";
+  if (mode === "minimal") {
+    return prettyFormatMinimal(astObject);
+  }
+  return prettyFormatFull(astObject);
+};
+var prettyFormatFull = (astObject, indent = 0) => {
+  if (!astObject || !astObject.table) return "";
+  const spaces = "  ".repeat(indent);
+  let query = astObject.table;
+  let hasChainedMethods = false;
+  if (astObject.where) {
+    const whereClause = formatWhere(astObject.where);
+    if (hasChainedMethods) {
+      query += `
+${spaces}  ${whereClause}`;
+    } else {
+      query += whereClause;
+      hasChainedMethods = true;
+    }
+  }
+  if (astObject.limit) {
+    const limitClause = `.limit(${astObject.limit})`;
+    if (hasChainedMethods) {
+      query += `
+${spaces}  ${limitClause}`;
+    } else {
+      query += limitClause;
+      hasChainedMethods = true;
+    }
+  }
+  if (astObject.orderBy && astObject.orderBy.length > 0) {
+    const orderClauses = astObject.orderBy.map(([field, direction]) => `${field}, ${direction}`).join(", ");
+    const orderByClause = `.orderBy(${orderClauses})`;
+    if (hasChainedMethods) {
+      query += `
+${spaces}  ${orderByClause}`;
+    } else {
+      query += orderByClause;
+      hasChainedMethods = true;
+    }
+  }
+  if (astObject.related && astObject.related.length > 0) {
+    astObject.related.forEach((rel) => {
+      if (rel.subquery) {
+        const alias = rel.subquery.alias || rel.subquery.table;
+        const subQuery = prettyFormatFull(rel.subquery, indent + 1);
+        query += `
+${spaces}  .related(${alias}, q => q.${subQuery}`;
+      }
+    });
+    const closingParens = ")".repeat(astObject.related.length);
+    query += `
+${spaces}${closingParens}`;
+  }
+  return query;
+};
+var prettyFormatMinimal = (astObject) => {
+  if (!astObject || !astObject.table) return "";
+  let query = astObject.table;
+  if (astObject.where) {
+    query += formatWhere(astObject.where).replace(".where(", "(");
+  }
+  if (astObject.related && astObject.related.length > 0) {
+    const subQueries = collectSubQueryTables(astObject.related);
+    const count = subQueries.length;
+    const tableNames = subQueries.join(", ");
+    query += ` (+${count}: ${(0, import_helpers3.ellipsis)(tableNames, 30)})`;
+  }
+  return query;
+};
+var collectSubQueryTables = (related) => {
+  const tables = [];
+  related.forEach((rel) => {
+    if (rel.subquery) {
+      const tableName = rel.subquery.alias || rel.subquery.table;
+      tables.push(tableName);
+      if (rel.subquery.related && rel.subquery.related.length > 0) {
+        tables.push(...collectSubQueryTables(rel.subquery.related));
+      }
+    }
+  });
+  return tables;
+};
+var formatWhere = (where2) => {
+  if (!where2) return "";
+  if (where2.type === "simple") {
+    const column = where2.left?.name || where2.left;
+    const value = where2.right?.value !== void 0 ? where2.right.value : where2.right;
+    const op = where2.op || "=";
+    if (column === "id" && op === "=" && (typeof value === "string" || typeof value === "number")) {
+      return `(${value})`;
+    }
+    if (op === "=") {
+      return `.where(${column}, ${value})`;
+    }
+    return `.where(${column}, ${op}, ${value})`;
+  }
+  if (where2.type === "and" && where2.conditions) {
+    let result = "";
+    where2.conditions.forEach((condition, index) => {
+      if (index === 0) {
+        result += formatWhere(condition);
+      } else {
+        result += `.and(${formatWhere(condition).slice(1)})`;
+      }
     });
-  },
-  __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, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    return result;
+  }
+  if (where2.type === "or" && where2.conditions) {
+    let result = "";
+    where2.conditions.forEach((condition, index) => {
+      if (index === 0) {
+        result += formatWhere(condition);
+      } else {
+        result += `.or(${formatWhere(condition).slice(1)})`;
+      }
     });
-    return to;
-  },
-  __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
-}), mod);
-var index_exports = {};
-__export(index_exports, {
-  run: () => import_run.run,
-  setRunner: () => import_zeroRunner.setRunner
+    return result;
+  }
+  return "";
+};
+
+// src/state.ts
+var import_zero = require("@rocicorp/zero");
+var schema = null;
+var zql = null;
+var authData;
+var errMessage = `Haven't called createZeroClient or createZeroServer yet!`;
+var getZQL = () => {
+  if (!zql) throw new Error(errMessage);
+  return zql;
+};
+var setSchema = (_) => {
+  schema = _;
+  zql = (0, import_zero.createBuilder)(_);
+};
+var getAuthData = () => {
+  return authData || null;
+};
+var setAuthData = (_) => {
+  authData = _;
+};
+
+// src/where.ts
+var import_constants = require("@tamagui/constants");
+var import_helpers4 = require("@take-out/helpers");
+
+// src/helpers/getQueryOrMutatorAuthData.ts
+function getQueryOrMutatorAuthData() {
+  if (isInZeroMutation()) {
+    return mutatorContext().authData;
+  }
+  return getAuthData();
+}
+
+// src/where.ts
+function where(a, b, isServerOnly = false) {
+  const whereFn = b || a;
+  const wrappedWhereFn = ((a2, b2 = getQueryOrMutatorAuthData()) => {
+    if (!import_constants.isServer && isServerOnly) {
+      return a2.and();
+    }
+    const result = whereFn(a2, b2);
+    if (typeof result === "boolean") {
+      if (result) {
+        return a2.cmpLit(0, "=", 0);
+      } else {
+        return a2.cmpLit(1, "=", 0);
+      }
+    }
+    return result;
+  });
+  if (b) {
+    WhereTableNameMap.set(wrappedWhereFn, a);
+  }
+  return wrappedWhereFn;
+}
+var WhereTableNameMap = (0, import_helpers4.globalValue)(
+  `over-zero:where-table-map`,
+  () => /* @__PURE__ */ new WeakMap()
+);
+function getWhereTableName(where2) {
+  return WhereTableNameMap.get(where2);
+}
+
+// src/createPermissions.ts
+function createPermissions({
+  environment,
+  schema: schema2
+}) {
+  function buildPermissionQuery(authData2, eb, permissionWhere, objOrId) {
+    const tableName = getWhereTableName(permissionWhere);
+    if (!tableName) {
+      throw new Error(`Must use PermissionWhere for buildPermissionQuery`);
+    }
+    const tableSchema = schema2.tables[tableName];
+    if (!tableSchema) {
+      throw new Error(`No schema?`);
+    }
+    const primaryKeys = tableSchema.primaryKey;
+    const permissionReturn = permissionWhere(eb, authData2);
+    if (permissionReturn == null) {
+      throw new Error(`No permission defined for ${tableName}`);
+    }
+    if (permissionReturn === true) {
+      return eb.cmpLit(true, "=", true);
+    }
+    if (permissionReturn === false) {
+      return eb.cmpLit(true, "=", false);
+    }
+    const primaryKeyWheres = [];
+    for (const key of primaryKeys) {
+      const value = typeof objOrId === "string" ? objOrId : objOrId[key];
+      primaryKeyWheres.push(eb.cmp(key, value));
+    }
+    return eb.and(permissionReturn, ...primaryKeyWheres);
+  }
+  const can = async (where2, obj) => {
+    if (environment === "server") {
+      const ctx = mutatorContext();
+      const tableName = getWhereTableName(where2);
+      if (!tableName) {
+        throw new Error(`Must use where('table') style where to pass to can()`);
+      }
+      await ensurePermission(ctx.tx, ctx.authData, tableName, where2, obj);
+      setDidRunPermissionCheck(ctx);
+    }
+  };
+  async function ensurePermission(tx, authData2, tableName, where2, obj) {
+    if (authData2?.role === "admin") {
+      return;
+    }
+    const zqlBuilder = getZQL();
+    const queryBase = zqlBuilder[tableName];
+    let query = null;
+    try {
+      query = queryBase.where((eb) => {
+        return buildPermissionQuery(authData2, eb, where2, obj);
+      }).one();
+      (0, import_helpers5.ensure)(await tx.run(query));
+    } catch (err) {
+      const errorTitle = `${tableName} with auth id: ${authData2?.id}`;
+      if (err instanceof import_helpers5.EnsureError) {
+        let msg = `[permission] \u{1F6AB} Not Allowed: ${errorTitle}`;
+        if (process.env.NODE_ENV === "development" && query) {
+          msg += `
+ ${prettyFormatZeroQuery(query)}`;
+        }
+        throw new Error(msg);
+      }
+      throw new Error(`Error running permission ${errorTitle}
+${err}`);
+    }
+  }
+  return {
+    can,
+    buildPermissionQuery
+  };
+}
+
+// src/queryRegistry.ts
+var queryNameRegistry = /* @__PURE__ */ new WeakMap();
+function registerQuery(fn, name) {
+  queryNameRegistry.set(fn, name);
+}
+function getQueryName(fn) {
+  return queryNameRegistry.get(fn);
+}
+
+// src/helpers/batchQuery.ts
+var import_helpers6 = require("@take-out/helpers");
+async function batchQuery(q, mapper, {
+  chunk,
+  pause = 0,
+  stopAfter = 1e5
+} = { chunk: 20 }) {
+  let hasMore = true;
+  let last = null;
+  let iterations = 0;
+  while (hasMore) {
+    let query = q.limit(chunk);
+    if (last) {
+      query = query.start(last);
+    }
+    const results = await query.run({ type: "complete" });
+    await mapper(results);
+    if (results.length < chunk) {
+      hasMore = false;
+    }
+    if (iterations > stopAfter) {
+      console.error(`[batchQuery] \u203C\uFE0F stopping batch, ran ${stopAfter} chunks`);
+      break;
+    }
+    if (pause) {
+      await (0, import_helpers6.sleep)(pause);
+    }
+  }
+}
+
+// src/helpers/createMutators.ts
+var import_constants2 = require("@tamagui/constants");
+var import_helpers7 = require("@take-out/helpers");
+function createMutators({
+  environment,
+  authData: authData2,
+  createServerActions,
+  asyncTasks = [],
+  can,
+  models
+}) {
+  const serverActions = createServerActions?.();
+  const modelMutators = (0, import_helpers7.mapObject)(models, (val) => val.mutate);
+  function withContext(fn) {
+    return async (tx, ...args) => {
+      const mutationContext = {
+        tx,
+        authData: authData2,
+        environment,
+        can,
+        server: environment === "server" ? {
+          actions: serverActions || {},
+          asyncTasks: asyncTasks || {}
+        } : void 0
+      };
+      return await runWithContext(mutationContext, () => {
+        return fn(mutationContext, ...args);
+      });
+    };
+  }
+  function withDevelopmentLogging(name, fn) {
+    if (process.env.NODE_ENV !== "development" && !process.env.IS_TESTING) {
+      return fn;
+    }
+    return async (...args) => {
+      const startTime = performance.now();
+      try {
+        if (import_constants2.isServer) {
+          console.info(`[mutator] ${name} start`);
+        }
+        const result = await fn(...args);
+        const duration = (performance.now() - startTime).toFixed(2);
+        if (import_constants2.isBrowser) {
+          console.groupCollapsed(`[mutator] ${name} completed in ${duration}ms`);
+          console.info("\u2192", args[1]);
+          console.info("\u2190", result);
+          console.trace();
+          console.groupEnd();
+        } else {
+          console.info(`[mutator] ${name} completed in ${duration}ms`);
+        }
+        return result;
+      } catch (error) {
+        const duration = (performance.now() - startTime).toFixed(2);
+        console.groupCollapsed(`[mutator] ${name} failed after ${duration}ms`);
+        console.error("error:", error);
+        console.info("arguments:", JSON.stringify(args[1], null, 2));
+        console.info("stack trace:", new Error().stack);
+        console.groupEnd();
+        throw error;
+      }
+    };
+  }
+  function withTimeoutGuard(name, fn, timeoutMs = import_helpers7.time.ms.minutes(1)) {
+    return async (...args) => {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`[mutator] ${name} timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+      });
+      return Promise.race([fn(...args), timeoutPromise]);
+    };
+  }
+  function decorateMutators(modules) {
+    const result = {};
+    for (const [moduleName, moduleExports] of Object.entries(modules)) {
+      result[moduleName] = {};
+      for (const [name, exportValue] of Object.entries(moduleExports)) {
+        if (typeof exportValue === "function") {
+          const fullName = `${moduleName}.${name}`;
+          result[moduleName][name] = withDevelopmentLogging(
+            fullName,
+            withTimeoutGuard(fullName, withContext(exportValue))
+          );
+        }
+      }
+    }
+    return result;
+  }
+  return decorateMutators(modelMutators);
+}
+
+// src/helpers/ensureLoggedIn.ts
+var import_helpers8 = require("@take-out/helpers");
+var ensureLoggedIn = () => {
+  const { authData: authData2 } = mutatorContext();
+  (0, import_helpers8.ensure)(authData2, "logged in");
+  return authData2;
+};
+
+// src/createZeroClient.tsx
+var import_zero2 = require("@rocicorp/zero");
+var import_react4 = require("@rocicorp/zero/react");
+var import_helpers10 = require("@take-out/helpers");
+var import_react5 = require("react");
+
+// src/createUseQuery.tsx
+var import_react2 = require("@rocicorp/zero/react");
+var import_react3 = require("react");
+
+// src/helpers/useZeroDebug.ts
+var import_helpers9 = require("@take-out/helpers");
+var import_react = require("react");
+var activeQueries = /* @__PURE__ */ new Map();
+var astHistoryByComponent = /* @__PURE__ */ new Map();
+var filterLogs = (table) => false;
+var COLLAPSED = true;
+var AST_CHANGE_THRESHOLD = 4;
+var MAX_AST_HISTORY = 10;
+var useZeroDebug = (query, options, results) => {
+  const astObject = query["_completeAst"]?.() ?? query["ast"];
+  const table = astObject?.table ?? "unknown";
+  const ast = JSON.stringify(astObject, null, 2);
+  const queryDisabled = !options || options?.enabled === false;
+  const enabled = !queryDisabled && filterLogs(table);
+  const stack = new Error().stack;
+  const isPermissionQuery = stack?.includes(`usePermission.ts`);
+  const id = (0, import_react.useId)();
+  const num = activeQueries.get(ast) || 0;
+  const shouldLog = enabled && num === 0;
+  if (enabled) {
+    activeQueries.set(ast, num + 1);
+    if (shouldLog) {
+      if (COLLAPSED) {
+        console.groupCollapsed(
+          `${isPermissionQuery ? `\u{1F46E}\u200D\u2642\uFE0F` : `\u2728`}${prettyFormatZeroQuery(query, "minimal")}`
+        );
+        console.info(id, prettyFormatZeroQuery(query, "full"));
+        console.info("cached result", results);
+        console.trace();
+        console.groupEnd();
+      } else {
+        console.info(`\u2728`, prettyFormatZeroQuery(query, "full"));
+      }
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    const history = astHistoryByComponent.get(id) || { asts: [], changeCount: 0 };
+    const currentAst = ast;
+    const lastAst = history.asts[history.asts.length - 1];
+    if (currentAst !== lastAst) {
+      history.asts.push(currentAst);
+      if (history.asts.length > MAX_AST_HISTORY) {
+        history.asts.shift();
+      }
+      history.changeCount++;
+      astHistoryByComponent.set(id, history);
+      if (history.changeCount > AST_CHANGE_THRESHOLD) {
+        console.warn(
+          `\u26A0\uFE0F AST changed ${history.changeCount} times for component.
+        - id: ${id}
+        - stack: ${(0, import_helpers9.getCurrentComponentStack)("short")}
+        - table: ${table}`,
+          {
+            componentId: id,
+            table,
+            changeCount: history.changeCount,
+            recentAsts: history.asts
+          }
+        );
+      }
+    }
+  }, [id, ast, table, enabled]);
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    return () => {
+      activeQueries.set(ast, activeQueries.get(ast) - 1);
+    };
+  }, [ast, enabled]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      astHistoryByComponent.delete(id);
+    };
+  }, [id]);
+};
+
+// src/resolveQuery.ts
+function resolveQuery({
+  customQueries,
+  fn,
+  params
+}) {
+  const queryName = getQueryName(fn);
+  if (!queryName) {
+    const fnName = fn?.name || "anonymous";
+    throw new Error(
+      `Query function '${fnName}' not registered. Ensure it is exported from a queries file and passed to createZeroClient via groupedQueries.`
+    );
+  }
+  const [namespace, name] = queryName.split(".", 2);
+  const customQuery = customQueries[namespace]?.[name];
+  if (!customQuery) {
+    throw new Error(
+      `CustomQuery '${queryName}' not found. Check that the query is exported and the namespace/name matches.`
+    );
+  }
+  return params !== void 0 ? customQuery(params) : customQuery();
+}
+
+// src/createUseQuery.tsx
+function createUseQuery({
+  DisabledContext,
+  customQueries
+}) {
+  function useQuery(...args) {
+    const disabled = (0, import_react3.use)(DisabledContext);
+    const [fn, paramsOrOptions, optionsArg] = args;
+    const { queryRequest, options } = (0, import_react3.useMemo)(() => {
+      const hasParams = optionsArg !== void 0 || paramsOrOptions && typeof paramsOrOptions === "object" && !("enabled" in paramsOrOptions) && !("ttl" in paramsOrOptions);
+      const params = hasParams ? paramsOrOptions : void 0;
+      const opts = hasParams ? optionsArg : paramsOrOptions;
+      const queryRequest2 = resolveQuery({ customQueries, fn, params });
+      return { queryRequest: queryRequest2, options: opts };
+    }, [fn, paramsOrOptions, optionsArg]);
+    const out = (0, import_react2.useQuery)(queryRequest, options);
+    if (process.env.NODE_ENV === "development") {
+      useZeroDebug(queryRequest, options, out);
+    }
+    if (disabled) {
+      return [null, { type: "unknown" }];
+    }
+    return out;
+  }
+  return useQuery;
+}
+
+// src/zeroRunner.ts
+var runner = null;
+function setRunner(r) {
+  runner = r;
+}
+function getRunner() {
+  if (!runner) {
+    throw new Error(
+      "Zero runner not initialized. Ensure ProvideZero is mounted (client) or createZeroServer is called (server)."
+    );
+  }
+  return runner;
+}
+
+// src/run.ts
+var customQueriesRef = null;
+function setCustomQueries(queries) {
+  customQueriesRef = queries;
+}
+function getCustomQueries() {
+  if (!customQueriesRef) {
+    throw new Error(
+      "Custom queries not initialized. Ensure createZeroClient or createZeroServer has been called."
+    );
+  }
+  return customQueriesRef;
+}
+function run(fnArg, paramsOrOptions, optionsArg) {
+  const hasParams = optionsArg !== void 0 || paramsOrOptions && !("type" in paramsOrOptions);
+  const params = hasParams ? paramsOrOptions : void 0;
+  const options = hasParams ? optionsArg : paramsOrOptions;
+  const customQueries = getCustomQueries();
+  const queryRequest = resolveQuery({ customQueries, fn: fnArg, params });
+  const runner2 = getRunner();
+  return runner2(queryRequest, options);
+}
+
+// src/createZeroClient.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function createZeroClient({
+  schema: schema2,
+  models,
+  groupedQueries
+}) {
+  setSchema(schema2);
+  const wrappedNamespaces = {};
+  for (const [namespace, queries] of Object.entries(groupedQueries)) {
+    wrappedNamespaces[namespace] = {};
+    for (const [name, fn] of Object.entries(queries)) {
+      registerQuery(fn, `${namespace}.${name}`);
+      wrappedNamespaces[namespace][name] = (0, import_zero2.defineQuery)(
+        ({ args }) => fn(args)
+      );
+    }
+  }
+  const customQueries = (0, import_zero2.defineQueries)(wrappedNamespaces);
+  setCustomQueries(customQueries);
+  const DisabledContext = (0, import_react5.createContext)(false);
+  const modelWritePermissions = (0, import_helpers10.mapObject)(models, (val) => val.permissions);
+  let latestZeroInstance = null;
+  const zero = new Proxy({}, {
+    get(_, key) {
+      if (latestZeroInstance === null) {
+        throw new Error(
+          `Zero instance not initialized. Ensure ZeroProvider is mounted before accessing 'zero'.`
+        );
+      }
+      return Reflect.get(latestZeroInstance, key, latestZeroInstance);
+    }
+  });
+  const permissionsHelpers = createPermissions({
+    schema: schema2,
+    environment: "client"
+  });
+  const zeroEvents = (0, import_helpers10.createEmitter)("zero", null);
+  const AuthDataContext = (0, import_react5.createContext)({});
+  const useAuthData = () => (0, import_react5.use)(AuthDataContext);
+  const useQuery = createUseQuery({
+    DisabledContext,
+    customQueries
+  });
+  function usePermission(table, objOrId, enabled = typeof objOrId !== "undefined", debug = false) {
+    const disabled = (0, import_react5.use)(DisabledContext);
+    const authData2 = useAuthData();
+    const permission = modelWritePermissions[table];
+    const query = (() => {
+      let baseQuery = zero.query[table].one();
+      if (disabled || !enabled || !permission) {
+        return baseQuery;
+      }
+      return baseQuery.where((eb) => {
+        return permissionsHelpers.buildPermissionQuery(
+          authData2,
+          eb,
+          permission,
+          objOrId
+        );
+      });
+    })();
+    const [data, status] = (0, import_react4.useQuery)(query, {
+      enabled: Boolean(enabled && permission && authData2 && objOrId)
+    });
+    if (debug) {
+      console.info(
+        `usePermission()`,
+        { data, status, authData: authData2, permission },
+        prettyFormatZeroQuery(query)
+      );
+    }
+    const result = data;
+    const allowed = Boolean(result);
+    if (!objOrId) {
+      return false;
+    }
+    return allowed;
+  }
+  const ProvideZero = ({
+    children,
+    authData: authDataIn,
+    disable,
+    ...props
+  }) => {
+    const authData2 = authDataIn ?? null;
+    const mutators = (0, import_react5.useMemo)(() => {
+      setAuthData(authData2);
+      return createMutators({
+        models,
+        environment: "client",
+        authData: authData2,
+        can: permissionsHelpers.can
+      });
+    }, [authData2]);
+    if (disable) {
+      return children;
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthDataContext.Provider, { value: authData2, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.ZeroProvider, { schema: schema2, kvStore: "mem", mutators, ...props, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SetZeroInstance, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConnectionMonitor, { zeroEvents }),
+      children
+    ] }) });
+  };
+  const SetZeroInstance = () => {
+    const zeroInstance = (0, import_react4.useZero)();
+    if (zeroInstance !== latestZeroInstance) {
+      latestZeroInstance = zeroInstance;
+      setRunner((query, options) => zeroInstance.run(query, options));
+    }
+    return null;
+  };
+  const ConnectionMonitor = (0, import_react5.memo)(
+    ({
+      zeroEvents: zeroEvents2
+    }) => {
+      const state = (0, import_react4.useConnectionState)();
+      const prevState = (0, import_react5.useRef)(state.name);
+      (0, import_react5.useEffect)(() => {
+        if (state.name !== prevState.current) {
+          const reason = "reason" in state ? state.reason : "";
+          prevState.current = state.name;
+          if (state.name === "error" || state.name === "needs-auth") {
+            const message = typeof reason === "string" ? reason : state.name;
+            zeroEvents2.emit({
+              type: "error",
+              message
+            });
+          }
+        }
+      }, [state, zeroEvents2]);
+      return null;
+    }
+  );
+  function preload(fnArg, paramsOrOptions, optionsArg) {
+    const hasParams = optionsArg !== void 0 || paramsOrOptions && !("ttl" in paramsOrOptions);
+    const params = hasParams ? paramsOrOptions : void 0;
+    const options = hasParams ? optionsArg : paramsOrOptions;
+    const queryRequest = resolveQuery({ customQueries, fn: fnArg, params });
+    return zero.preload(queryRequest, options);
+  }
+  return {
+    zeroEvents,
+    ProvideZero,
+    useQuery,
+    usePermission,
+    zero,
+    preload
+  };
+}
+
+// src/mutations.ts
+function mutations(table, permissions, mutations2) {
+  if (permissions) {
+    const tableName = table.schema.name;
+    const createCRUDMutation = (action) => {
+      return async (ctx, obj) => {
+        const runServerPermissionCheck = async () => {
+          if (getDidRunPermissionCheck(ctx)) {
+            return;
+          }
+          if (process.env.VITE_ENVIRONMENT === "ssr") {
+            await ctx.can(permissions, obj);
+          }
+        };
+        if (action !== "insert") {
+          await runServerPermissionCheck();
+        }
+        const existing = mutations2?.[action];
+        if (existing) {
+          await existing(ctx, obj);
+        } else {
+          await ctx.tx.mutate[tableName][action](obj);
+        }
+        if (action === "insert") {
+          await runServerPermissionCheck();
+        }
+      };
+    };
+    const crudMutations = {
+      insert: createCRUDMutation("insert"),
+      update: createCRUDMutation("update"),
+      delete: createCRUDMutation("delete"),
+      upsert: createCRUDMutation("upsert")
+    };
+    return {
+      ...mutations2,
+      // overwrite regular mutations but call them if they are defined by user
+      ...crudMutations
+    };
+  }
+  return table;
+}
+
+// src/serverWhere.ts
+function serverWhere(a, b) {
+  return where(a, b, true);
+}
+
+// src/zql.ts
+var zql2 = new Proxy({}, {
+  get(_target, prop) {
+    const b = getZQL();
+    return b[prop];
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batchQuery,
+  createMutators,
+  createPermissions,
+  createUseQuery,
+  createZeroClient,
+  ensureLoggedIn,
+  getQueryName,
+  getWhereTableName,
+  isInZeroMutation,
+  mutations,
+  mutatorContext,
+  registerQuery,
+  resolveQuery,
+  run,
+  runWithContext,
+  serverWhere,
+  setRunner,
+  where,
+  zql
 });
-module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./createPermissions.cjs"), module.exports);
-__reExport(index_exports, require("./queryRegistry.cjs"), module.exports);
-__reExport(index_exports, require("./helpers/batchQuery.cjs"), module.exports);
-__reExport(index_exports, require("./helpers/createMutators.cjs"), module.exports);
-__reExport(index_exports, require("./helpers/ensureLoggedIn.cjs"), module.exports);
-__reExport(index_exports, require("./helpers/mutatorContext.cjs"), module.exports);
-__reExport(index_exports, require("./createZeroClient.cjs"), module.exports);
-__reExport(index_exports, require("./createUseQuery.cjs"), module.exports);
-__reExport(index_exports, require("./resolveQuery.cjs"), module.exports);
-var import_run = require("./run.cjs"),
-  import_zeroRunner = require("./zeroRunner.cjs");
-__reExport(index_exports, require("./mutations.cjs"), module.exports);
-__reExport(index_exports, require("./where.cjs"), module.exports);
-__reExport(index_exports, require("./serverWhere.cjs"), module.exports);
-__reExport(index_exports, require("./zql.cjs"), module.exports);
+//# sourceMappingURL=index.cjs.map