jazz-tools 2.0.0-alpha.21 → 2.0.0-alpha.22

package/dist/runtime/napi.integration.test.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { beforeAll, describe, expect, it, vi } from "vitest";
 import { serializeRuntimeSchema } from "../drivers/schema-wire.js";
 import { translateQuery } from "./query-adapter.js";
+import { loadCompiledSchema } from "../schema-loader.js";
 import { pushSchemaCatalogue, startLocalJazzServer } from "../testing/local-jazz-server.js";
 import { createNapiRuntime, loadNapiModule } from "./testing/napi-runtime-test-utils.js";
 const JWT_KID = "napi-test-kid";
@@ -29,86 +30,13 @@ const TIMESTAMP_SCHEMA = {
         ],
     },
 };
-const TODO_SERVER_WASM_SCHEMA = {
-    projects: {
-        columns: [{ name: "name", column_type: { type: "Text" }, nullable: false }],
-    },
-    todos: {
-        columns: [
-            { name: "title", column_type: { type: "Text" }, nullable: false },
-            { name: "done", column_type: { type: "Boolean" }, nullable: false },
-            { name: "description", column_type: { type: "Text" }, nullable: true },
-            {
-                name: "parent",
-                column_type: { type: "Uuid" },
-                nullable: true,
-                references: "todos",
-            },
-            {
-                name: "project",
-                column_type: { type: "Uuid" },
-                nullable: true,
-                references: "projects",
-            },
-            { name: "owner_id", column_type: { type: "Text" }, nullable: false },
-        ],
-        policies: {
-            select: {
-                using: {
-                    type: "Cmp",
-                    column: "owner_id",
-                    op: "Eq",
-                    value: {
-                        type: "SessionRef",
-                        path: ["user_id"],
-                    },
-                },
-            },
-            insert: {
-                with_check: {
-                    type: "Cmp",
-                    column: "owner_id",
-                    op: "Eq",
-                    value: {
-                        type: "SessionRef",
-                        path: ["user_id"],
-                    },
-                },
-            },
-            update: {
-                using: {
-                    type: "Cmp",
-                    column: "owner_id",
-                    op: "Eq",
-                    value: {
-                        type: "SessionRef",
-                        path: ["user_id"],
-                    },
-                },
-                with_check: {
-                    type: "Cmp",
-                    column: "owner_id",
-                    op: "Eq",
-                    value: {
-                        type: "SessionRef",
-                        path: ["user_id"],
-                    },
-                },
-            },
-            delete: {
-                using: {
-                    type: "Cmp",
-                    column: "owner_id",
-                    op: "Eq",
-                    value: {
-                        type: "SessionRef",
-                        path: ["user_id"],
-                    },
-                },
-            },
-        },
-    },
-};
+let todoServerWasmSchemaPromise = null;
+async function loadTodoServerWasmSchema() {
+    if (!todoServerWasmSchemaPromise) {
+        todoServerWasmSchemaPromise = loadCompiledSchema(TODO_SERVER_SCHEMA_DIR).then((compiled) => compiled.wasmSchema);
+    }
+    return await todoServerWasmSchemaPromise;
+}
 const simpleTodosTable = {
     _table: "todos",
     _schema: TEST_SCHEMA,
@@ -135,30 +63,34 @@ const timestampProjectsTable = {
     _rowType: undefined,
     _initType: undefined,
 };
-const policyTodosTable = {
-    _table: "todos",
-    _schema: TODO_SERVER_WASM_SCHEMA,
-    _rowType: undefined,
-    _initType: undefined,
-};
-const allPolicyTodosQuery = {
-    _table: "todos",
-    _schema: TODO_SERVER_WASM_SCHEMA,
-    _rowType: undefined,
-    _build() {
-        return JSON.stringify({
-            table: "todos",
-            conditions: [],
-            includes: {},
-            orderBy: [],
-            offset: 0,
-        });
-    },
-};
-function policyTodoByIdQuery(id) {
+function makePolicyTodosTable(schema) {
+    return {
+        _table: "todos",
+        _schema: schema,
+        _rowType: undefined,
+        _initType: undefined,
+    };
+}
+function makeAllPolicyTodosQuery(schema) {
+    return {
+        _table: "todos",
+        _schema: schema,
+        _rowType: undefined,
+        _build() {
+            return JSON.stringify({
+                table: "todos",
+                conditions: [],
+                includes: {},
+                orderBy: [],
+                offset: 0,
+            });
+        },
+    };
+}
+function makePolicyTodoByIdQuery(schema, id) {
     return {
         _table: "todos",
-        _schema: TODO_SERVER_WASM_SCHEMA,
+        _schema: schema,
         _rowType: undefined,
         _build() {
             return JSON.stringify({
@@ -172,7 +104,7 @@ function policyTodoByIdQuery(id) {
     };
 }
 const BASIC_SCHEMA_DIR = fileURLToPath(new URL("../testing/fixtures/basic", import.meta.url));
-const TODO_SERVER_SCHEMA_DIR = fileURLToPath(new URL("../../../../examples/todo-server-ts/schema", import.meta.url));
+const TODO_SERVER_SCHEMA_DIR = fileURLToPath(new URL("../../../../examples/todo-server-ts", import.meta.url));
 beforeAll(async () => {
     await loadNapiModule();
 });
@@ -463,19 +395,19 @@ describe("NAPI integration", () => {
         const updatedOversizedTitle = "y".repeat(45_000);
         const queryJson = translateQuery(allTodosQuery._build(), TEST_SCHEMA);
         try {
-            const insertedRow = runtime.insert("todos", [
-                { type: "Text", value: oversizedTitle },
-                { type: "Boolean", value: false },
-            ]);
+            const insertedRow = runtime.insert("todos", {
+                title: { type: "Text", value: oversizedTitle },
+                done: { type: "Boolean", value: false },
+            });
             let rows = await runtime.query(queryJson);
             expect(rows).toHaveLength(1);
             expect(rows[0]).toMatchObject({ id: insertedRow.id });
             expect(rows[0]?.values[0]).toEqual({ type: "Text", value: oversizedTitle });
             expect(rows[0]?.values[1]).toEqual({ type: "Boolean", value: false });
-            const secondRow = runtime.insert("todos", [
-                { type: "Text", value: "kept title" },
-                { type: "Boolean", value: false },
-            ]);
+            const secondRow = runtime.insert("todos", {
+                title: { type: "Text", value: "kept title" },
+                done: { type: "Boolean", value: false },
+            });
             runtime.update(secondRow.id, {
                 title: { type: "Text", value: updatedOversizedTitle },
             });
@@ -543,10 +475,10 @@ describe("NAPI integration", () => {
                 call[1][1] === clientId &&
                 hasPayloadKind(call[1][2], "QuerySettled"))).toBe(true);
         }, { timeout: 15_000 });
-        const insertedRow = runtime.insert("todos", [
-            { type: "Text", value: "client-synced-item" },
-            { type: "Boolean", value: false },
-        ]);
+        const insertedRow = runtime.insert("todos", {
+            title: { type: "Text", value: "client-synced-item" },
+            done: { type: "Boolean", value: false },
+        });
         await vi.waitFor(() => {
             expect(rawCalls.some((call) => isNestedOutboxCall(call) &&
                 call[1][0] === "client" &&
@@ -564,6 +496,7 @@ describe("NAPI integration", () => {
             context = createJazzContext({
                 appId: `napi-backend-sync-${randomUUID()}`,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: captureServer.baseUrl,
                 backendSecret: "napi-backend-secret",
@@ -604,6 +537,7 @@ describe("NAPI integration", () => {
             context = createJazzContext({
                 appId: `napi-backend-reconnect-${randomUUID()}`,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: captureServer.baseUrl,
                 backendSecret: "napi-backend-secret",
@@ -657,9 +591,12 @@ describe("NAPI integration", () => {
                 env: "test",
                 userBranch: "main",
             });
+            const todoServerSchema = await loadTodoServerWasmSchema();
+            const policyTodosTable = makePolicyTodosTable(todoServerSchema);
             context = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 backendSecret,
@@ -667,6 +604,7 @@ describe("NAPI integration", () => {
                 userBranch: "main",
                 tier: "worker",
             });
+            await settleAsyncSyncWork();
             const backendDb = context.asBackend();
             const aliceDb = context.forSession({
                 user_id: "alice",
@@ -676,32 +614,38 @@ describe("NAPI integration", () => {
                 title: "session-created-item",
                 done: false,
                 description: "created via forSession",
-                owner_id: "alice",
+                ownerId: "alice",
             }, { tier: "edge" }), 10_000, "session insert timed out");
             await vi.waitFor(async () => {
-                expect(await withTimeout(backendDb.one(policyTodoByIdQuery(createdTodo.id), { tier: "edge" }), 10_000, "backend session read timed out")).toMatchObject({
+                expect(await withTimeout(backendDb.one(makePolicyTodoByIdQuery(todoServerSchema, createdTodo.id), {
+                    tier: "edge",
+                }), 10_000, "backend session read timed out")).toMatchObject({
                     id: createdTodo.id,
                     title: "session-created-item",
                     done: false,
-                    owner_id: "alice",
+                    ownerId: "alice",
                 });
             }, { timeout: 20_000 });
             await expect(aliceDb.insertDurable(policyTodosTable, {
                 title: "session-policy-denied",
                 done: false,
                 description: "",
-                owner_id: "bob",
+                ownerId: "bob",
             }, { tier: "edge" })).rejects.toThrow();
             await withTimeout(aliceDb.updateDurable(policyTodosTable, createdTodo.id, { done: true }, { tier: "edge" }), 10_000, "session update timed out");
             await vi.waitFor(async () => {
-                expect(await withTimeout(backendDb.one(policyTodoByIdQuery(createdTodo.id), { tier: "edge" }), 10_000, "backend session update read timed out")).toMatchObject({
+                expect(await withTimeout(backendDb.one(makePolicyTodoByIdQuery(todoServerSchema, createdTodo.id), {
+                    tier: "edge",
+                }), 10_000, "backend session update read timed out")).toMatchObject({
                     id: createdTodo.id,
                     done: true,
                 });
             }, { timeout: 20_000 });
             await withTimeout(aliceDb.deleteDurable(policyTodosTable, createdTodo.id, { tier: "edge" }), 10_000, "session delete timed out");
             await vi.waitFor(async () => {
-                expect(await withTimeout(backendDb.one(policyTodoByIdQuery(createdTodo.id), { tier: "edge" }), 10_000, "backend session delete read timed out")).toBeNull();
+                expect(await withTimeout(backendDb.one(makePolicyTodoByIdQuery(todoServerSchema, createdTodo.id), {
+                    tier: "edge",
+                }), 10_000, "backend session delete read timed out")).toBeNull();
             }, { timeout: 20_000 });
         }
         finally {
@@ -734,9 +678,13 @@ describe("NAPI integration", () => {
                 env: "test",
                 userBranch: "main",
             });
+            const todoServerSchema = await loadTodoServerWasmSchema();
+            const policyTodosTable = makePolicyTodosTable(todoServerSchema);
+            const allPolicyTodosQuery = makeAllPolicyTodosQuery(todoServerSchema);
             context = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 backendSecret,
@@ -757,14 +705,14 @@ describe("NAPI integration", () => {
                 title: "request-created-item",
                 done: false,
                 description: "created via forRequest",
-                owner_id: "request-user",
+                ownerId: "request-user",
             }, { tier: "edge" }), 10_000, "request insert timed out");
             await vi.waitFor(async () => {
                 expect(await withTimeout(requestDb.all(allPolicyTodosQuery, { tier: "edge" }), 10_000, "request-scoped read timed out")).toEqual([
                     expect.objectContaining({
                         id: createdTodo.id,
                         title: "request-created-item",
-                        owner_id: "request-user",
+                        ownerId: "request-user",
                     }),
                 ]);
             }, { timeout: 20_000 });
@@ -772,13 +720,15 @@ describe("NAPI integration", () => {
                 title: "request-policy-denied",
                 done: false,
                 description: "",
-                owner_id: "someone-else",
+                ownerId: "someone-else",
             }, { tier: "edge" })).rejects.toThrow();
             await vi.waitFor(async () => {
-                expect(await withTimeout(backendDb.one(policyTodoByIdQuery(createdTodo.id), { tier: "edge" }), 10_000, "backend request read timed out")).toMatchObject({
+                expect(await withTimeout(backendDb.one(makePolicyTodoByIdQuery(todoServerSchema, createdTodo.id), {
+                    tier: "edge",
+                }), 10_000, "backend request read timed out")).toMatchObject({
                     id: createdTodo.id,
                     title: "request-created-item",
-                    owner_id: "request-user",
+                    ownerId: "request-user",
                 });
             }, { timeout: 20_000 });
         }
@@ -818,9 +768,13 @@ describe("NAPI integration", () => {
                 env: "test",
                 userBranch: "main",
             });
+            const todoServerSchema = await loadTodoServerWasmSchema();
+            const policyTodosTable = makePolicyTodosTable(todoServerSchema);
+            const allPolicyTodosQuery = makeAllPolicyTodosQuery(todoServerSchema);
             bobContext = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 jwtToken: signJwt({ sub: "bob", claims: {} }, JWT_SECRET),
@@ -830,7 +784,8 @@ describe("NAPI integration", () => {
             });
             carolContext = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 jwtToken: signJwt({ sub: "carol", claims: {} }, JWT_SECRET),
@@ -840,7 +795,8 @@ describe("NAPI integration", () => {
             });
             aliceContext = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 jwtToken: signJwt({ sub: "alice", claims: {} }, JWT_SECRET),
@@ -850,7 +806,8 @@ describe("NAPI integration", () => {
             });
             readerContext = createJazzContext({
                 appId,
-                app: { wasmSchema: TODO_SERVER_WASM_SCHEMA },
+                app: { wasmSchema: todoServerSchema },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 backendSecret,
@@ -858,6 +815,7 @@ describe("NAPI integration", () => {
                 userBranch: "main",
                 tier: "worker",
             });
+            await settleAsyncSyncWork();
             const bobWriter = bobContext.db();
             const carolWriter = carolContext.db();
             const aliceWriter = aliceContext.db();
@@ -865,19 +823,19 @@ describe("NAPI integration", () => {
                 title: "bob-item",
                 done: false,
                 description: "",
-                owner_id: "bob",
+                ownerId: "bob",
             }, { tier: "edge" }), 10_000, "bob writer create timed out");
             await withTimeout(carolWriter.insertDurable(policyTodosTable, {
                 title: "carol-item",
                 done: false,
                 description: "",
-                owner_id: "carol",
+                ownerId: "carol",
             }, { tier: "edge" }), 10_000, "carol writer create timed out");
             await withTimeout(aliceWriter.insertDurable(policyTodosTable, {
                 title: "alice-item",
                 done: false,
                 description: "",
-                owner_id: "alice",
+                ownerId: "alice",
             }, { tier: "edge" }), 10_000, "alice writer create timed out");
             const readerBackend = readerContext.asBackend();
             const aliceSessionDb = readerContext.forSession({
@@ -941,6 +899,7 @@ describe("NAPI integration", () => {
             writerContext = createJazzContext({
                 appId,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 backendSecret,
@@ -948,10 +907,12 @@ describe("NAPI integration", () => {
             readerContext = createJazzContext({
                 appId,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "memory" },
                 serverUrl: server.url,
                 backendSecret,
             });
+            await settleAsyncSyncWork();
             const writer = writerContext.asBackend();
             const reader = readerContext.asBackend();
             await waitForQueryRows(reader, allTodosQuery, (rows) => rows.length === 0);
@@ -975,7 +936,20 @@ describe("NAPI integration", () => {
             const updatedRow = rowsAfterUpdate.find((row) => row.id === rowId);
             expect(updatedRow?.done).toBe(true);
             await writer.deleteDurable(simpleTodosTable, rowId, { tier: "edge" });
-            await waitForQueryRows(reader, allTodosQuery, (rows) => !rows.some((row) => row.id === rowId));
+            await settleAsyncSyncWork();
+            await waitForQueryRows(writer, allTodosQuery, (rows) => !rows.some((row) => row.id === rowId));
+            await readerContext.shutdown();
+            readerContext = createJazzContext({
+                appId,
+                app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
+                driver: { type: "memory" },
+                serverUrl: server.url,
+                backendSecret,
+            });
+            await settleAsyncSyncWork();
+            const refreshedReader = readerContext.asBackend();
+            await waitForQueryRows(refreshedReader, allTodosQuery, (rows) => !rows.some((row) => row.id === rowId));
         }
         finally {
             if (writerContext) {
@@ -999,6 +973,7 @@ describe("NAPI integration", () => {
             writerContext = createJazzContext({
                 appId,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "persistent", dataPath },
             });
             const writer = writerContext.db();
@@ -1014,6 +989,7 @@ describe("NAPI integration", () => {
             reopenedContext = createJazzContext({
                 appId,
                 app: { wasmSchema: TEST_SCHEMA },
+                permissions: {},
                 driver: { type: "persistent", dataPath },
             });
             const reopened = reopenedContext.db();
@@ -1045,6 +1021,7 @@ describe("NAPI integration", () => {
             context = createJazzContext({
                 appId: randomUUID(),
                 app: { wasmSchema: TIMESTAMP_SCHEMA },
+                permissions: {},
                 driver: { type: "persistent", dataPath },
             });
             await expect(context.db().insertDurable(timestampProjectsTable, {