on-zero 0.4.23 → 0.4.24

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");
+  });
+});