on-zero 0.16.17 → 0.16.19

package/dist/esm/native-typescript.native.js

@@ -0,0 +1,226 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { parse } from "@babel/parser";
+import { API } from "typescript/unstable/async";
+var _process_env;
+var _GOMAXPROCS;
+(_GOMAXPROCS = (_process_env = process.env).GOMAXPROCS) !== null && _GOMAXPROCS !== void 0 ? _GOMAXPROCS : _process_env.GOMAXPROCS = "2";
+var compiler = null;
+var compilerClose = null;
+var compilerCloseTimer = null;
+var compilerTurn = Promise.resolve();
+async function closeCompiler(session) {
+  try {
+    if (session.paths.size > 0) {
+      var snapshot = await session.api.updateSnapshot({
+        closeFiles: [...session.paths]
+      });
+      await snapshot.dispose();
+    }
+  } finally {
+    await session.api.close();
+  }
+}
+async function acquireCompiler(root, sourcePaths) {
+  var previousTurn = compilerTurn;
+  var releaseTurn = function releaseTurn2() {};
+  compilerTurn = new Promise(function (resolveTurn) {
+    releaseTurn = resolveTurn;
+  });
+  await previousTurn;
+  if (compilerCloseTimer) {
+    clearTimeout(compilerCloseTimer);
+    compilerCloseTimer = null;
+  }
+  if (compilerClose) await compilerClose;
+  if (compiler && compiler.root !== root) {
+    var previous = compiler;
+    compiler = null;
+    await closeCompiler(previous);
+  }
+  compiler !== null && compiler !== void 0 ? compiler : compiler = {
+    api: new API({
+      cwd: root
+    }),
+    paths: /* @__PURE__ */new Set(),
+    root
+  };
+  compiler.api.clearSourceFileCache();
+  var previousPaths = compiler.paths;
+  var nextPaths = new Set(sourcePaths);
+  compiler.paths = nextPaths;
+  if (previousPaths.size > 0) {
+    var closedSnapshot = await compiler.api.updateSnapshot({
+      closeFiles: [...previousPaths],
+      fileChanges: {
+        invalidateAll: true
+      }
+    });
+    await closedSnapshot.dispose();
+    compiler.api.clearSourceFileCache();
+  }
+  var snapshot = await compiler.api.updateSnapshot({
+    openFiles: sourcePaths,
+    fileChanges: {
+      invalidateAll: true
+    }
+  });
+  compiler.api.clearSourceFileCache();
+  return {
+    session: compiler,
+    snapshot,
+    releaseTurn
+  };
+}
+function releaseCompiler(session, releaseTurn) {
+  var _compilerCloseTimer_unref;
+  releaseTurn();
+  compilerCloseTimer = setTimeout(function () {
+    compilerCloseTimer = null;
+    if (compiler !== session) return;
+    compiler = null;
+    compilerClose = closeCompiler(session).finally(function () {
+      compilerClose = null;
+    });
+  }, 25);
+  (_compilerCloseTimer_unref = compilerCloseTimer.unref) === null || _compilerCloseTimer_unref === void 0 ? void 0 : _compilerCloseTimer_unref.call(compilerCloseTimer);
+}
+function collectTypeScriptSourcePaths(roots) {
+  var paths = /* @__PURE__ */new Set();
+  var visited = /* @__PURE__ */new Set();
+  var walk = function walk1(dir) {
+    if (visited.has(dir) || !existsSync(dir)) return;
+    visited.add(dir);
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = readdirSync(dir, {
+          withFileTypes: true
+        })[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var entry = _step2.value;
+        if (entry.name === "node_modules") continue;
+        var path = resolve(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(path);
+        } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+          paths.add(path);
+        }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = roots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var root = _step.value;
+      walk(resolve(root));
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return [...paths].sort();
+}
+async function createNativeTypeScriptProject(root, sourcePaths) {
+  if (sourcePaths.length === 0) {
+    throw new Error(`[on-zero] no TypeScript source files found under ${root}`);
+  }
+  var {
+    session,
+    snapshot,
+    releaseTurn
+  } = await acquireCompiler(root, sourcePaths);
+  var sources = /* @__PURE__ */new Map();
+  var projectsByFile = /* @__PURE__ */new Map();
+  var parseErrors = /* @__PURE__ */new Set();
+  try {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = sourcePaths[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var path = _step.value;
+        var project = await snapshot.getDefaultProjectForFile(path);
+        if (!project) throw new Error(`[on-zero] TypeScript did not open ${path}`);
+        var source = await project.program.getSourceFile(path);
+        if (!source) throw new Error(`[on-zero] TypeScript did not parse ${path}`);
+        sources.set(path, source);
+        projectsByFile.set(path, project);
+        try {
+          parse(readFileSync(path, "utf8"), {
+            plugins: ["jsx", "typescript"],
+            sourceType: "module"
+          });
+        } catch (unused) {
+          parseErrors.add(path);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  } catch (error) {
+    await snapshot.dispose();
+    releaseCompiler(session, releaseTurn);
+    throw error;
+  }
+  var closed = false;
+  return {
+    projectForFile(path2) {
+      var project2 = projectsByFile.get(resolve(path2));
+      if (!project2) throw new Error(`[on-zero] TypeScript project does not contain ${path2}`);
+      return project2;
+    },
+    sourceFile(path2) {
+      var source2 = sources.get(resolve(path2));
+      if (!source2) throw new Error(`[on-zero] TypeScript project does not contain ${path2}`);
+      return source2;
+    },
+    hasParseErrors(path2) {
+      return parseErrors.has(resolve(path2));
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      await snapshot.dispose();
+      releaseCompiler(session, releaseTurn);
+    }
+  };
+}
+export { collectTypeScriptSourcePaths, createNativeTypeScriptProject };
+//# sourceMappingURL=native-typescript.native.js.map

package/dist/esm/native-typescript.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["existsSync","readFileSync","readdirSync","resolve","parse","API","_process_env","_GOMAXPROCS","process","env","GOMAXPROCS","compiler","compilerClose","compilerCloseTimer","compilerTurn","Promise","closeCompiler","session","paths","size","snapshot","api","updateSnapshot","closeFiles","dispose","close","acquireCompiler","root","sourcePaths","previousTurn","releaseTurn","releaseTurn2","resolveTurn","clearTimeout","previous","cwd","Set","clearSourceFileCache","previousPaths","nextPaths","closedSnapshot","fileChanges","invalidateAll","openFiles","releaseCompiler","_compilerCloseTimer_unref","setTimeout","finally","unref","call","collectTypeScriptSourcePaths","roots","visited","walk","walk1","dir","has","add","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_iterator2","withFileTypes","Symbol","iterator","_step2","next","done","entry","value","name","path","isDirectory","isFile","endsWith","err","return","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","_step"],"sources":["../../src/native-typescript.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "on-zero",
-  "version": "0.16.17",
+  "version": "0.16.19",
   "description": "A typed layer over @rocicorp/zero with queries, mutations, and permissions",
   "sideEffects": false,
   "files": [
@@ -101,11 +101,13 @@
     }
   },
   "dependencies": {
+    "@babel/parser": "7.29.7",
     "@rocicorp/logger": "6.2.0",
     "chokidar": "^4.0.3",
     "citty": "^0.1.6",
     "dequal": "^2.0.3",
-    "orez-lite": "0.16.17",
+    "orez-lite": "0.16.19",
+    "typescript": "7.0.2",
     "valibot": "^1.1.0"
   },
   "peerDependencies": {
@@ -136,7 +138,6 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-native": "*",
-    "typescript": "^5.9.3",
     "vitest": "^3.1.1"
   }
 }

package/src/createZeroClient.recovery.test.tsx

@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { createSchema, string, table } from '@rocicorp/zero'
+import { createSchema, string, table, UpdateNeededReasonType } from '@rocicorp/zero'
 import { act, Suspense, useLayoutEffect } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, expect, test, vi } from 'vitest'
@@ -137,6 +137,37 @@ test('remint drops local state and reconstructs a fresh instance in place', asyn
   expect(fakeZero.instances.at(-1)).not.toBe(first)
 })
 
+test('closed headless connection ignores a late update without a recovery error', async () => {
+  const isolated = createZeroClient({
+    schema,
+    models: {},
+    groupedQueries: {},
+    instanceName: 'closed-headless-recovery-test',
+  })
+  const connection = isolated.connectHeadless({
+    cacheURL: 'http://127.0.0.1:7777/zero',
+    userID: 'closed-headless-recovery',
+    kvStore: 'mem',
+    storageKey: 'closed-headless-recovery',
+  })
+  const instance = fakeZero.instances.at(-1)
+  expect(instance).toBeDefined()
+  await connection.close()
+
+  const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+  try {
+    instance?.options.onUpdateNeeded({
+      type: UpdateNeededReasonType.NewClientGroup,
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(consoleError).not.toHaveBeenCalledWith(
+      '[on-zero] recovery could not reload or reconstruct the client'
+    )
+  } finally {
+    consoleError.mockRestore()
+  }
+})
+
 test('provider generation changes with the actual instance during remint', async () => {
   const generationClient = createZeroClient({
     schema,
@@ -431,3 +462,27 @@ test('retire tears down on every sign-out, including inside remint guard window'
   expect(second?.delete).toHaveBeenCalledTimes(1)
   expect(fakeZero.instances.at(-1)).not.toBe(second)
 })
+
+test('headless NewClientGroup recovery reconstructs its client without a provider', async () => {
+  const isolated = createZeroClient({
+    schema,
+    models: {},
+    groupedQueries: {},
+    instanceName: 'headless-recovery-test',
+  })
+  const connection = isolated.connectHeadless({
+    cacheURL: 'http://127.0.0.1:7777/zero',
+    userID: 'headless-recovery',
+  })
+  const first = fakeZero.instances.at(-1)!
+  const countBefore = fakeZero.instances.length
+
+  first.options.onUpdateNeeded({ type: 'NewClientGroup' })
+
+  await vi.waitFor(() => expect(fakeZero.instances).toHaveLength(countBefore + 1))
+  expect(connection.zero).not.toBe(first)
+  expect(await isolated.waitForZero()).toBe(connection.zero)
+  expect(first.close).toHaveBeenCalledOnce()
+
+  await connection.close()
+})

package/src/createZeroClient.tsx

@@ -350,6 +350,8 @@ export function createZeroClientInternal<
     scheduleReload?: (ctx: ScheduleReloadContext) => void
     guardStorage?: RecoveryGuardStorage
     benignLogPatterns?: readonly ZeroLogPattern[]
+    recoverInPlace?: () => Promise<boolean>
+    reload?: () => void | boolean
   }
 
   // build a Zero instance with on-zero's recovery wiring. shared by the
@@ -363,6 +365,8 @@ export function createZeroClientInternal<
     scheduleReload,
     guardStorage,
     benignLogPatterns,
+    recoverInPlace,
+    reload,
   }: ConstructZeroInstanceArgs): ZeroInstance {
     let installedTransport: Pick<HttpPullTransport, 'subscribeLifecycle'> | undefined
     // install before construction so the instance's first connect goes through
@@ -392,7 +396,8 @@ export function createZeroClientInternal<
         ...(benignLogPatterns ?? []),
       ],
       onRecovery: () => mutationLifecycle.fence(),
-      recoverInPlace: () => remint({ dropLocalState: false }),
+      recoverInPlace: recoverInPlace ?? (() => remint({ dropLocalState: false })),
+      reload,
     }
     const recovery = makeZeroRecovery(recoveryDeps)
     const createdInstance = new ZeroClient<Schema, ZeroMutators>({
@@ -1215,28 +1220,62 @@ export function createZeroClientInternal<
     // mutations read auth dynamically through getAuthData(), so this has to be
     // set before the first mutation exactly as the provider sets it in render.
     setAuthData((authData ?? null) as AuthData)
-    const zeroInstance = constructZeroInstance({
-      options,
-      transport,
-      beforeReload,
-      scheduleReload,
-      guardStorage,
-      benignLogPatterns,
-    })
-    publishZeroInstance(zeroInstance)
+    let closed = false
+    let activeInstance: ZeroInstance
+    let unwatch = () => {}
+    const construct = () =>
+      constructZeroInstance({
+        options,
+        transport,
+        beforeReload,
+        scheduleReload,
+        guardStorage,
+        benignLogPatterns,
+        // a headless host has no provider state to bump and no page it owns to
+        // reload. replace the disabled instance directly, then republish the
+        // stable module facade and move the connection watcher with it.
+        recoverInPlace: async () => {
+          // an update can arrive after the host intentionally closed this
+          // connection during preview turnover. there is no live client left
+          // to reconstruct, so recovery is already satisfied.
+          if (closed) return true
+          const outgoing = activeInstance
+          unwatch()
+          clearZeroInstanceReferences(outgoing)
+          mutationLifecycle.fence()
+          try {
+            outgoing.close()
+          } catch {}
+          activeInstance = construct()
+          publishZeroInstance(activeInstance)
+          zeroInstanceVersion?.emit(zeroInstanceVersion.value + 1)
+          unwatch = watchZeroConnection({
+            zeroInstance: activeInstance,
+            auth: options.auth,
+            refreshAuth,
+          })
+          return true
+        },
+        reload: () => false,
+      })
+    activeInstance = construct()
+    publishZeroInstance(activeInstance)
     zeroInstanceVersion?.emit(zeroInstanceVersion.value + 1)
-    const unwatch = watchZeroConnection({
-      zeroInstance,
+    unwatch = watchZeroConnection({
+      zeroInstance: activeInstance,
       auth: options.auth,
       refreshAuth,
     })
     return {
-      zero: zeroInstance,
+      get zero() {
+        return activeInstance
+      },
       close: async () => {
+        closed = true
         unwatch()
-        clearZeroInstanceReferences(zeroInstance)
+        clearZeroInstanceReferences(activeInstance)
         mutationLifecycle.fence()
-        await zeroInstance.close()
+        await activeInstance.close()
       },
     }
   }

package/src/generate-helpers.ts

@@ -820,3 +820,82 @@ ${modelDefs}
 }
 `
 }
+
+export type DrizzleSchemaRelationTable = {
+  key: string
+  properties: readonly string[]
+}
+
+// membership-filtered drizzle input consumed by generated/schema.ts.
+// schemaImportPath is relative to data/generated/.
+export function renderDrizzleSchemaInputModule(options: {
+  schemaImportPath: string
+  tableNames: readonly string[]
+  relationTables: readonly DrizzleSchemaRelationTable[]
+}): string {
+  const tableNames = [...new Set(options.tableNames)].sort()
+  const relationEntries = options.relationTables
+    .filter((table) => table.properties.length > 0)
+    .map((table) => {
+      const body = table.properties.map((property) => `    ${property},`).join('\n')
+      return `  ${table.key}: {\n${body}\n  },`
+    })
+  return [
+    '// auto-generated from the on-zero data layout',
+    `import { defineRelations } from 'drizzle-orm'`,
+    `import * as schema from ${JSON.stringify(options.schemaImportPath)}`,
+    '',
+    `export { ${tableNames.join(', ')} } from ${JSON.stringify(options.schemaImportPath)}`,
+    `export const relations = defineRelations(schema, (r) => ({`,
+    ...relationEntries,
+    `}))`,
+    '',
+  ].join('\n')
+}
+
+// keep the emitted module identical to drizzle-zero-sqlite's
+// generateDrizzleZeroSqliteSchemaFile. that package is the runtime owner;
+// this copy exists so generate-lite can emit the file without importing it.
+export function renderDrizzleZeroSqliteSchemaModule(options: {
+  importPath: string
+  tableNames: readonly string[]
+}): string {
+  const tableNames = [...new Set(options.tableNames)].sort()
+  const typeNames = new Set<string>()
+  const rowAliases = tableNames.map((tableName) => {
+    const typeName = tableName
+      .replace(/(?:^|[^A-Za-z0-9]+)([A-Za-z0-9])/g, (_, character: string) =>
+        character.toUpperCase()
+      )
+      .replace(/^([a-z])/, (character) => character.toUpperCase())
+    if (!/^[$A-Z_a-z][$\w]*$/.test(typeName)) {
+      throw new TypeError(`table name cannot produce a TypeScript alias: ${tableName}`)
+    }
+    if (typeNames.has(typeName)) {
+      throw new TypeError(`table names produce duplicate TypeScript alias: ${typeName}`)
+    }
+    typeNames.add(typeName)
+    return `export type ${typeName} = Row<(typeof schema)['tables'][${JSON.stringify(tableName)}]>`
+  })
+  return [
+    '// auto-generated by drizzle-zero-sqlite',
+    `import { createBuilder, type Row } from '@rocicorp/zero'`,
+    `import { drizzleZeroConfig } from 'drizzle-zero-sqlite'`,
+    `import * as drizzleSchema from ${JSON.stringify(options.importPath)}`,
+    '',
+    `export const schema = drizzleZeroConfig(drizzleSchema, { suppressDefaultsWarning: true })`,
+    '',
+    `export type Schema = typeof schema`,
+    ...rowAliases,
+    '',
+    `export const zql = createBuilder(schema)`,
+    'export const builder = zql',
+    '',
+    `declare module '@rocicorp/zero' {`,
+    '  interface DefaultTypes {',
+    '    schema: Schema',
+    '  }',
+    '}',
+    '',
+  ].join('\n')
+}