on-zero 0.4.22 → 0.4.24

package/dist/cjs/instanceRegistry.native.js

@@ -0,0 +1,111 @@
+"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 instanceRegistry_exports = {};
+__export(instanceRegistry_exports, {
+  getInstanceForNamespace: () => getInstanceForNamespace,
+  getInstanceForQueryFn: () => getInstanceForQueryFn,
+  registerClientInstance: () => registerClientInstance
+});
+module.exports = __toCommonJS(instanceRegistry_exports);
+var import_helpers = require("@take-out/helpers");
+var import_queryRegistry = require("./queryRegistry.native.js");
+var getInstancesByNamespace = function () {
+  return (0, import_helpers.globalValue)("on-zero:instances-by-namespace", function () {
+    return /* @__PURE__ */new Map();
+  });
+};
+function registerClientInstance(param) {
+  var {
+    name,
+    namespaces,
+    customQueries
+  } = param;
+  var instancesByNamespace = getInstancesByNamespace();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = instancesByNamespace[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [namespace, owner] = _step.value;
+      if (owner.name === name) {
+        instancesByNamespace.delete(namespace);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var instance = {
+    name,
+    customQueries,
+    runner: null
+  };
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = namespaces[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var namespace1 = _step1.value;
+      var existing = instancesByNamespace.get(namespace1);
+      if (existing) {
+        throw new Error(`[on-zero] namespace '${namespace1}' is already claimed by zero client instance '${existing.name}' (while creating instance '${name}'). Each query/mutator namespace must belong to exactly one createZeroClient instance.`);
+      }
+      instancesByNamespace.set(namespace1, instance);
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  return instance;
+}
+function getInstanceForNamespace(namespace) {
+  return getInstancesByNamespace().get(namespace);
+}
+function getInstanceForQueryFn(fn) {
+  var queryName = (0, import_queryRegistry.getQueryName)(fn);
+  if (!queryName) return void 0;
+  return getInstanceForNamespace(queryName.split(".", 1)[0]);
+}
+//# sourceMappingURL=instanceRegistry.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","instanceRegistry_exports","__export","getInstanceForNamespace","getInstanceForQueryFn","registerClientInstance","module","exports","import_helpers","require","import_queryRegistry","getInstancesByNamespace","globalValue","Map","param","name","namespaces","customQueries","instancesByNamespace","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Symbol","iterator","_step","next","done","namespace","owner","delete","err","return","instance","runner"],"sources":["../../src/instanceRegistry.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,wBAAA;AAAAC,QAAA,CAAAD,wBAAA;EAAAE,uBAAA,EAAAA,CAAA,KAAAA,uBAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAAA,qBAAA;EAAAC,sBAAA,EAAAA,CAAA,KAAAA;AAAA;AASAC,MAAA,CAAAC,OAAA,GAAAX,YAA4B,CAAAK,wBAAA;AAE5B,IAAAO,cAAA,GAAAC,OAA6B;AAa7B,IAAAC,oBAAM,GAAAD,OAA0B,4BAC9B;AAAA,IACEE,uBAAA,YAAAA,CAAA;EACA,OAAM,IAAAH,cAAA,CAAII,WAAI;IAChB,0BAAAC,GAAA;EAEK;AAAgC;AACrC,SACAR,uBAAAS,KAAA;EACA;IAAAC,IAAA;IAAAC,UAAA;IAAAC;EAAA,IAAAH,KAAA;EACF,IAIuBI,oBAAA,GAAAP,uBAAA;EACrB,IAAAQ,yBAA6B;IAAAC,iBAAwB;IAAAC,cAAA;EAGrD;IACE,KAAI,IAAAC,SAAM,GAASJ,oBAAM,CAAAK,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;MACvB,KAAAS,SAAA,EAAAC,KAAqB,IAAAJ,KAAO,CAAAzB,KAAA;MAC9B,IAAA6B,KAAA,CAAAd,IAAA,KAAAA,IAAA;QACFG,oBAAA,CAAAY,MAAA,CAAAF,SAAA;MAEA;IAEA;EACE,SAAMG,GAAA;IACNX,iBAAc;IACZC,cAAU,GAAAU,GAAA;EAAA,UACR;IACmC,IACrC;MACF,KAAAZ,yBAAA,IAAAG,SAAA,CAAAU,MAAA;QACAV,SAAA,CAAAU,MAAA,CAAqB;MACvB;IAEA,UAAO;MACT,IAAAZ,iBAAA;QAEO,MAASC,cAAA;MAGd;IACF;EAEO;EACL,IAAAY,QAAM;IACNlB,IAAK;IACLE,aAAO;IACTiB,MAAA","ignoreList":[]}

package/dist/cjs/multiInstance.test.cjs

@@ -0,0 +1,322 @@
+var import_zero = require("@rocicorp/zero");
+var import_helpers = require("@take-out/helpers");
+var import_vitest = require("vitest");
+var import_combineZeroClients = require("./combineZeroClients.cjs");
+var import_createZeroClient = require("./createZeroClient.cjs");
+var import_instanceRegistry = require("./instanceRegistry.cjs");
+var import_queryRegistry = require("./queryRegistry.cjs");
+var import_run = require("./run.cjs");
+var import_zeroRunner = require("./zeroRunner.cjs");
+const userTable = (0, import_zero.table)("user").columns({
+  id: (0, import_zero.string)(),
+  name: (0, import_zero.string)()
+}).primaryKey("id");
+const taskTable = (0, import_zero.table)("task").columns({
+  id: (0, import_zero.string)(),
+  title: (0, import_zero.string)()
+}).primaryKey("id");
+const schema = (0, import_zero.createSchema)({
+  tables: [userTable, taskTable]
+});
+const makeQueryFn = () => args => args;
+function makeClient(instanceName, namespace) {
+  const byId = makeQueryFn();
+  return {
+    byId,
+    client: (0, import_createZeroClient.createZeroClient)({
+      schema,
+      models: {},
+      groupedQueries: {
+        [namespace]: {
+          byId
+        }
+      },
+      instanceName
+    })
+  };
+}
+function fakeClient(name, namespaces, zeroStub) {
+  (0, import_instanceRegistry.registerClientInstance)({
+    name,
+    namespaces,
+    // boundary stub: dispatch tests never resolve queries through it
+    customQueries: {}
+  });
+  return {
+    instanceName: name,
+    useQuery: import_vitest.vi.fn(() => `${name}-useQuery`),
+    useQueryDirect: import_vitest.vi.fn(() => `${name}-useQueryDirect`),
+    usePermission: import_vitest.vi.fn(() => `${name}-usePermission`),
+    usePermissionDirect: import_vitest.vi.fn(() => `${name}-usePermissionDirect`),
+    zero: zeroStub,
+    preload: import_vitest.vi.fn(() => `${name}-preload`),
+    getQuery: import_vitest.vi.fn(() => `${name}-getQuery`),
+    zeroEvents: (0, import_helpers.createEmitter)(`zero:test-${name}`, null),
+    ControlQueries: ({
+      children
+    }) => children
+  };
+}
+(0, import_vitest.describe)("multi-instance namespace dispatch", () => {
+  (0, import_vitest.test)("run() dispatches named queries to the owning instance runner", async () => {
+    const control = makeClient("run-control", "runUser");
+    const project = makeClient("run-project", "runTask");
+    const controlRunner = import_vitest.vi.fn(async (..._args) => ({
+      from: "control"
+    }));
+    const projectRunner = import_vitest.vi.fn(async (..._args) => ({
+      from: "project"
+    }));
+    (0, import_instanceRegistry.getInstanceForNamespace)("runUser").runner = controlRunner;
+    (0, import_instanceRegistry.getInstanceForNamespace)("runTask").runner = projectRunner;
+    const ambientRunner = import_vitest.vi.fn(async (..._args) => ({
+      from: "ambient"
+    }));
+    (0, import_zeroRunner.setRunner)(ambientRunner);
+    await (0, import_vitest.expect)((0, import_run.run)(control.byId, {
+      id: "1"
+    })).resolves.toEqual({
+      from: "control"
+    });
+    await (0, import_vitest.expect)((0, import_run.run)(project.byId, {
+      id: "2"
+    })).resolves.toEqual({
+      from: "project"
+    });
+    (0, import_vitest.expect)(ambientRunner).not.toHaveBeenCalled();
+    const request = controlRunner.mock.calls[0][0];
+    (0, import_vitest.expect)(request.query.queryName).toBe("runUser.byId");
+  });
+  (0, import_vitest.test)("a claimed namespace with an unmounted instance uses the ambient runner (server path)", async () => {
+    const {
+      byId
+    } = makeClient("srv-instance", "srvThing");
+    const ambient = import_vitest.vi.fn(async (..._args) => ({
+      from: "ambient"
+    }));
+    (0, import_zeroRunner.setRunner)(ambient);
+    await (0, import_vitest.expect)((0, import_run.run)(byId, {
+      id: "1"
+    })).resolves.toEqual({
+      from: "ambient"
+    });
+    (0, import_vitest.expect)(ambient).toHaveBeenCalledTimes(1);
+  });
+  (0, import_vitest.test)("duplicate namespace claim throws at create time", () => {
+    makeClient("dup-a", "dupNs");
+    (0, import_vitest.expect)(() => makeClient("dup-b", "dupNs")).toThrow(/already claimed/);
+  });
+  (0, import_vitest.test)("re-creating an instance under the same name re-claims without throwing (hmr)", () => {
+    makeClient("hmr", "hmrNs");
+    (0, import_vitest.expect)(() => makeClient("hmr", "hmrNs")).not.toThrow();
+    (0, import_vitest.expect)((0, import_instanceRegistry.getInstanceForNamespace)("hmrNs")?.name).toBe("hmr");
+  });
+  (0, import_vitest.test)("model namespaces are claimed too", () => {
+    const models = {
+      mdlThing: {
+        mutate: {
+          insert: async () => {}
+        }
+      }
+    };
+    (0, import_createZeroClient.createZeroClient)({
+      schema,
+      models,
+      groupedQueries: {},
+      instanceName: "mdl-a"
+    });
+    (0, import_vitest.expect)((0, import_instanceRegistry.getInstanceForNamespace)("mdlThing")?.name).toBe("mdl-a");
+    (0, import_vitest.expect)(() => (0, import_createZeroClient.createZeroClient)({
+      schema,
+      models,
+      groupedQueries: {},
+      instanceName: "mdl-b"
+    })).toThrow(/already claimed/);
+  });
+});
+(0, import_vitest.describe)("multi-instance isolation", () => {
+  (0, import_vitest.test)("each instance has an isolated zeroEvents emitter", () => {
+    const {
+      client: a
+    } = makeClient("emit-a", "emitA");
+    const {
+      client: b
+    } = makeClient("emit-b", "emitB");
+    (0, import_vitest.expect)(a.zeroEvents).not.toBe(b.zeroEvents);
+    (0, import_vitest.expect)(a.zeroEvents.options?.name).toBe("zero:emit-a");
+    (0, import_vitest.expect)(b.zeroEvents.options?.name).toBe("zero:emit-b");
+    const seenByB = [];
+    b.zeroEvents.listen(event => seenByB.push(event));
+    a.zeroEvents.emit({
+      type: "error",
+      message: "a-only"
+    });
+    (0, import_vitest.expect)(seenByB).toEqual([]);
+    (0, import_vitest.expect)(a.zeroEvents.value).toEqual({
+      type: "error",
+      message: "a-only"
+    });
+    (0, import_vitest.expect)(b.zeroEvents.value).toBe(null);
+  });
+  (0, import_vitest.test)("the default instance keeps the legacy emitter name", () => {
+    const {
+      client
+    } = makeClient("default", "defaultNs");
+    (0, import_vitest.expect)(client.zeroEvents.options?.name).toBe("zero");
+  });
+  (0, import_vitest.test)("each instance has its own unmounted zero proxy", () => {
+    const {
+      client: a
+    } = makeClient("proxy-a", "proxyA");
+    const {
+      client: b
+    } = makeClient("proxy-b", "proxyB");
+    (0, import_vitest.expect)(a.zero === b.zero).toBe(false);
+    (0, import_vitest.expect)(() => a.zero.clientID).toThrow(/not initialized/);
+    (0, import_vitest.expect)(() => b.zero.clientID).toThrow(/not initialized/);
+  });
+});
+(0, import_vitest.describe)("combineZeroClients facade", () => {
+  (0, import_vitest.test)("zero.mutate dispatches by model namespace, rest forwards to primary", () => {
+    const insertSpy = import_vitest.vi.fn();
+    const updateSpy = import_vitest.vi.fn();
+    const control = fakeClient("fz-control", ["fzUser"], {
+      mutate: {
+        fzUser: {
+          insert: insertSpy
+        }
+      },
+      userID: "primary-user"
+    });
+    const project = fakeClient("fz-project", ["fzTask"], {
+      mutate: {
+        fzTask: {
+          update: updateSpy
+        }
+      },
+      userID: "project-user"
+    });
+    const combined = (0, import_combineZeroClients.combineZeroClients)(control, project);
+    const zero = combined.zero;
+    zero.mutate.fzUser.insert({
+      id: "1"
+    });
+    zero.mutate.fzTask.update({
+      id: "2"
+    });
+    (0, import_vitest.expect)(insertSpy).toHaveBeenCalledWith({
+      id: "1"
+    });
+    (0, import_vitest.expect)(updateSpy).toHaveBeenCalledWith({
+      id: "2"
+    });
+    (0, import_vitest.expect)(zero.userID).toBe("primary-user");
+    (0, import_vitest.expect)(zero.mutate.unknownNs).toBe(void 0);
+  });
+  (0, import_vitest.test)("useQuery/preload/getQuery/usePermission dispatch by namespace", () => {
+    const control = fakeClient("fq-control", ["fqUser"], {});
+    const project = fakeClient("fq-project", ["fqTask"], {});
+    const userQuery = makeQueryFn();
+    const taskQuery = makeQueryFn();
+    (0, import_queryRegistry.registerQuery)(userQuery, "fqUser.byId");
+    (0, import_queryRegistry.registerQuery)(taskQuery, "fqTask.byId");
+    const combined = (0, import_combineZeroClients.combineZeroClients)(control, project);
+    const useQuery = combined.useQuery;
+    const preload = combined.preload;
+    const getQuery = combined.getQuery;
+    const usePermission = combined.usePermission;
+    useQuery(userQuery, {
+      id: "1"
+    });
+    (0, import_vitest.expect)(control.useQueryDirect).toHaveBeenCalledWith(userQuery, {
+      id: "1"
+    });
+    (0, import_vitest.expect)(control.useQuery).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(project.useQuery).not.toHaveBeenCalled();
+    useQuery(taskQuery, {
+      id: "2"
+    });
+    (0, import_vitest.expect)(project.useQuery).toHaveBeenCalledWith(taskQuery, {
+      id: "2"
+    });
+    (0, import_vitest.expect)(project.useQueryDirect).not.toHaveBeenCalled();
+    preload(taskQuery, {
+      id: "3"
+    });
+    (0, import_vitest.expect)(project.preload).toHaveBeenCalledWith(taskQuery, {
+      id: "3"
+    });
+    (0, import_vitest.expect)(control.preload).not.toHaveBeenCalled();
+    getQuery(userQuery, {
+      id: "4"
+    });
+    (0, import_vitest.expect)(control.getQuery).toHaveBeenCalledWith(userQuery, {
+      id: "4"
+    });
+    (0, import_vitest.expect)(project.getQuery).not.toHaveBeenCalled();
+    const anonymous = makeQueryFn();
+    useQuery(anonymous, {
+      id: "5"
+    });
+    (0, import_vitest.expect)(control.useQueryDirect).toHaveBeenCalledWith(anonymous, {
+      id: "5"
+    });
+    usePermission("fqTask", "row-1");
+    (0, import_vitest.expect)(project.usePermission).toHaveBeenCalledWith("fqTask", "row-1");
+    (0, import_vitest.expect)(project.usePermissionDirect).not.toHaveBeenCalled();
+    usePermission("fqUser", "row-2");
+    (0, import_vitest.expect)(control.usePermissionDirect).toHaveBeenCalledWith("fqUser", "row-2");
+    (0, import_vitest.expect)(control.usePermission).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.test)("the inner option overrides which client uses the context path", () => {
+    const a = fakeClient("inner-a", ["innerA"], {});
+    const b = fakeClient("inner-b", ["innerB"], {});
+    const aQuery = makeQueryFn();
+    const bQuery = makeQueryFn();
+    (0, import_queryRegistry.registerQuery)(aQuery, "innerA.byId");
+    (0, import_queryRegistry.registerQuery)(bQuery, "innerB.byId");
+    const combined = (0, import_combineZeroClients.combineZeroClients)(a, b, {
+      inner: "inner-a"
+    });
+    const useQuery = combined.useQuery;
+    useQuery(aQuery, {
+      id: "1"
+    });
+    (0, import_vitest.expect)(a.useQuery).toHaveBeenCalledWith(aQuery, {
+      id: "1"
+    });
+    (0, import_vitest.expect)(a.useQueryDirect).not.toHaveBeenCalled();
+    useQuery(bQuery, {
+      id: "2"
+    });
+    (0, import_vitest.expect)(b.useQueryDirect).toHaveBeenCalledWith(bQuery, {
+      id: "2"
+    });
+    (0, import_vitest.expect)(b.useQuery).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(() => (0, import_combineZeroClients.combineZeroClients)(a, b, {
+      inner: "nope"
+    })).toThrow(/not one of the passed clients/);
+  });
+  (0, import_vitest.test)("combined zeroEvents relays every instance", () => {
+    const {
+      client: a
+    } = makeClient("relay-a", "relayA");
+    const {
+      client: b
+    } = makeClient("relay-b", "relayB");
+    const combined = (0, import_combineZeroClients.combineZeroClients)(a, b);
+    const seen = [];
+    combined.zeroEvents.listen(event => seen.push(event));
+    a.zeroEvents.emit({
+      type: "error",
+      message: "from-a"
+    });
+    b.zeroEvents.emit({
+      type: "error",
+      message: "from-b"
+    });
+    (0, import_vitest.expect)(seen.map(event => event?.message)).toEqual(["from-a", "from-b"]);
+    (0, import_vitest.expect)(a.zeroEvents.value?.message).toBe("from-a");
+    (0, import_vitest.expect)(b.zeroEvents.value?.message).toBe("from-b");
+  });
+});