orez 0.2.26 → 0.2.29

package/src/sqlite-mode/apply-mode.ts

@@ -1,224 +0,0 @@
-/**
- * apply sqlite mode - handles shim installation with backup/restore lifecycle
- *
- * this module manages the in-place patching of @rocicorp/zero-sqlite3 with proper
- * backup/restore to prevent mode contamination when switching between wasm and native.
- */
-
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { generateCjsShim } from './shim-template.js'
-import { BACKUP_MARKER, type SqliteMode, type SqliteModeConfig } from './types.js'
-
-interface ApplyResult {
-  success: boolean
-  shimPath?: string
-  error?: string
-}
-
-/**
- * find the index.js file to shim in @rocicorp/zero-sqlite3
- */
-function findZeroSqliteIndex(zeroSqlitePath: string): string | null {
-  // find package root (contains package.json)
-  let dir = zeroSqlitePath
-  while (dir && !existsSync(resolve(dir, 'package.json'))) {
-    const parent = resolve(dir, '..')
-    if (parent === dir) break
-    dir = parent
-  }
-
-  // try lib/index.js first, then root index.js
-  const libIndex = resolve(dir, 'lib', 'index.js')
-  if (existsSync(libIndex)) return libIndex
-
-  const rootIndex = resolve(dir, 'index.js')
-  if (existsSync(rootIndex)) return rootIndex
-
-  return null
-}
-
-/**
- * get backup path for an index file
- */
-function getBackupPath(indexPath: string): string {
-  return indexPath + BACKUP_MARKER
-}
-
-/**
- * check if a file is already shimmed by orez
- */
-function isOrezShimmed(indexPath: string): boolean {
-  if (!existsSync(indexPath)) return false
-  const content = readFileSync(indexPath, 'utf-8')
-  return content.includes('orez sqlite shim')
-}
-
-/**
- * check what mode an existing shim is configured for
- */
-export function getShimMode(indexPath: string): SqliteMode | null {
-  if (!existsSync(indexPath)) return null
-  const content = readFileSync(indexPath, 'utf-8')
-  if (!content.includes('orez sqlite shim')) return null
-
-  // extract mode from comment: "// mode: wasm, journal_mode: delete"
-  const match = content.match(/\/\/ mode: (native|wasm),/)
-  return match ? (match[1] as SqliteMode) : null
-}
-
-/**
- * backup the original @rocicorp/zero-sqlite3 index.js
- * only backs up if not already backed up and not already shimmed
- */
-export function backupOriginal(indexPath: string): boolean {
-  const backupPath = getBackupPath(indexPath)
-
-  // already have a backup
-  if (existsSync(backupPath)) return true
-
-  // don't backup if file is already shimmed (would backup the shim)
-  if (isOrezShimmed(indexPath)) {
-    return false
-  }
-
-  if (!existsSync(indexPath)) return false
-
-  const content = readFileSync(indexPath, 'utf-8')
-  writeFileSync(backupPath, content)
-  return true
-}
-
-/**
- * restore the original @rocicorp/zero-sqlite3 from backup
- */
-export function restoreOriginal(indexPath: string): boolean {
-  const backupPath = getBackupPath(indexPath)
-
-  if (!existsSync(backupPath)) {
-    // no backup to restore from
-    return false
-  }
-
-  const content = readFileSync(backupPath, 'utf-8')
-  writeFileSync(indexPath, content)
-  rmSync(backupPath)
-  return true
-}
-
-/**
- * check if backup exists
- */
-export function hasBackup(indexPath: string): boolean {
-  return existsSync(getBackupPath(indexPath))
-}
-
-/**
- * apply wasm mode shim to @rocicorp/zero-sqlite3
- * backs up original first, writes shim in place
- */
-export function applyWasmShim(config: SqliteModeConfig): ApplyResult {
-  if (config.mode !== 'wasm') {
-    return { success: false, error: 'applyWasmShim called with non-wasm mode' }
-  }
-
-  if (!config.zeroSqlitePath) {
-    return { success: false, error: '@rocicorp/zero-sqlite3 not found' }
-  }
-
-  if (!config.bedrockPath) {
-    return { success: false, error: 'bedrock-sqlite not found' }
-  }
-
-  const indexPath = findZeroSqliteIndex(config.zeroSqlitePath)
-  if (!indexPath) {
-    return { success: false, error: 'could not find @rocicorp/zero-sqlite3 index.js' }
-  }
-
-  // check if already shimmed for wasm mode
-  const existingMode = getShimMode(indexPath)
-  if (existingMode === 'wasm') {
-    return { success: true, shimPath: indexPath }
-  }
-
-  // backup original before shimming - must succeed
-  const backedUp = backupOriginal(indexPath)
-  if (!backedUp && !hasBackup(indexPath)) {
-    // file is shimmed (possibly by another mode) but no backup exists
-    // cannot safely proceed - would lose ability to restore
-    return {
-      success: false,
-      error:
-        'cannot apply wasm shim: file is already shimmed with no backup. reinstall @rocicorp/zero-sqlite3',
-    }
-  }
-
-  // generate and write shim
-  const shimCode = generateCjsShim({
-    mode: 'wasm',
-    bedrockPath: config.bedrockPath,
-    includeTracing: false,
-  })
-
-  writeFileSync(indexPath, shimCode)
-
-  return { success: true, shimPath: indexPath }
-}
-
-/**
- * restore native mode by removing shim and restoring original
- */
-export function restoreNativeMode(zeroSqlitePath: string): ApplyResult {
-  const indexPath = findZeroSqliteIndex(zeroSqlitePath)
-  if (!indexPath) {
-    return { success: false, error: 'could not find @rocicorp/zero-sqlite3 index.js' }
-  }
-
-  // check if currently shimmed
-  if (!isOrezShimmed(indexPath)) {
-    // not shimmed, nothing to do
-    return { success: true }
-  }
-
-  // restore from backup
-  if (restoreOriginal(indexPath)) {
-    return { success: true }
-  }
-
-  // no backup available - this is a problem
-  return {
-    success: false,
-    error:
-      'cannot restore native mode: no backup found. reinstall @rocicorp/zero-sqlite3',
-  }
-}
-
-/**
- * apply sqlite mode - main entry point
- * handles both installing wasm shim and restoring to native
- */
-export function applySqliteMode(config: SqliteModeConfig): ApplyResult {
-  if (config.mode === 'native') {
-    // for native mode, restore original if shimmed
-    if (config.zeroSqlitePath) {
-      return restoreNativeMode(config.zeroSqlitePath)
-    }
-    return { success: true }
-  }
-
-  return applyWasmShim(config)
-}
-
-/**
- * cleanup any shim artifacts - used during shutdown or cleanup
- */
-export function cleanupShim(zeroSqlitePath: string | undefined): void {
-  if (!zeroSqlitePath) return
-
-  const indexPath = findZeroSqliteIndex(zeroSqlitePath)
-  if (!indexPath) return
-
-  // restore original if we have a backup
-  restoreOriginal(indexPath)
-}

package/src/sqlite-mode/index.ts

@@ -1,15 +0,0 @@
-/**
- * sqlite-mode module - unified sqlite mode handling for orez
- *
- * this module provides:
- * - type definitions for sqlite modes
- * - mode resolution from config
- * - shim generation (single source of truth)
- * - safe mode application with backup/restore
- */
-
-export * from './types.js'
-export * from './resolve-mode.js'
-export * from './apply-mode.js'
-export * from './shim-template.js'
-export * from './native-binary.js'

package/src/sqlite-mode/native-binary.ts

@@ -1,89 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-
-import { resolvePackage } from './package-resolve.js'
-
-const NATIVE_BINARY_RELATIVE_PATHS = ['build/Release/better_sqlite3.node']
-
-export interface NativeBinaryCheckResult {
-  packageEntryPath: string
-  packageRoot: string
-  expectedPaths: string[]
-  existingPaths: string[]
-  found: boolean
-}
-
-function findPackageRoot(entryPath: string): string {
-  if (!entryPath) return ''
-
-  let dir = dirname(entryPath)
-  for (let i = 0; i < 12; i++) {
-    const pkgJson = resolve(dir, 'package.json')
-    if (existsSync(pkgJson)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgJson, 'utf-8'))
-        if (pkg?.name === '@rocicorp/zero-sqlite3') {
-          return dir
-        }
-      } catch {
-        // ignore malformed package.json and continue searching upward
-      }
-    }
-
-    const parent = dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-
-  return ''
-}
-
-export function inspectNativeSqliteBinary(): NativeBinaryCheckResult {
-  const packageEntryPath = resolvePackage('@rocicorp/zero-sqlite3')
-  const packageRoot = findPackageRoot(packageEntryPath)
-  const expectedPaths = packageRoot
-    ? NATIVE_BINARY_RELATIVE_PATHS.map((relativePath) =>
-        resolve(packageRoot, relativePath)
-      )
-    : []
-  const existingPaths = expectedPaths.filter((filePath) => existsSync(filePath))
-
-  return {
-    packageEntryPath,
-    packageRoot,
-    expectedPaths,
-    existingPaths,
-    found: existingPaths.length > 0,
-  }
-}
-
-export function hasMissingNativeBinarySignature(message: string): boolean {
-  const text = message.toLowerCase()
-  return (
-    text.includes('better_sqlite3.node') ||
-    (text.includes('could not locate the bindings file') &&
-      text.includes('zero-sqlite3')) ||
-    (text.includes('err_dlopen_failed') && text.includes('better_sqlite3')) ||
-    (text.includes('no native build was found') && text.includes('sqlite'))
-  )
-}
-
-export function formatNativeBootstrapInstructions(
-  result: NativeBinaryCheckResult
-): string {
-  const expectedList =
-    result.expectedPaths.length > 0
-      ? result.expectedPaths.map((filePath) => `  - ${filePath}`).join('\n')
-      : '  - <unable to resolve @rocicorp/zero-sqlite3 package root>'
-
-  return [
-    'native sqlite binary is missing.',
-    `resolved package entry: ${result.packageEntryPath || '<not resolved>'}`,
-    'expected native binary path(s):',
-    expectedList,
-    'fix:',
-    '  bun i @rocicorp/zero-sqlite3',
-    '  bun run native:bootstrap',
-    'manual emergency fallback (not automated): copy a known-good better_sqlite3.node into build/Release and re-run native:bootstrap.',
-  ].join('\n')
-}

package/src/sqlite-mode/package-resolve.ts

@@ -1,17 +0,0 @@
-import { createRequire } from 'node:module'
-
-/**
- * resolve a package entry path
- * import.meta.resolve doesn't work in vitest, so we fall back to require.resolve
- */
-export function resolvePackage(pkg: string): string {
-  try {
-    const resolved = import.meta.resolve(pkg)
-    if (resolved) return resolved.replace('file://', '')
-  } catch {}
-  try {
-    const require = createRequire(import.meta.url)
-    return require.resolve(pkg)
-  } catch {}
-  return ''
-}

package/src/sqlite-mode/resolve-mode.ts

@@ -1,80 +0,0 @@
-/**
- * mode resolution - canonical place to determine sqlite mode from config/env
- *
- * priority:
- * 1. explicit --disable-wasm-sqlite flag → native (requires compiled binary)
- * 2. explicit --force-wasm-sqlite flag → wasm
- * 3. native binary exists → native (auto-detect, faster)
- * 4. fallback → wasm (works everywhere)
- */
-
-import { inspectNativeSqliteBinary } from './native-binary.js'
-import { resolvePackage } from './package-resolve.js'
-
-import type { SqliteMode, SqliteModeConfig } from './types.js'
-export { resolvePackage } from './package-resolve.js'
-
-/**
- * resolve sqlite mode from config
- * single source of truth for mode selection
- *
- * auto-detects native if binary exists (faster), otherwise wasm.
- *
- * @param disableWasmSqlite - explicit flag to force native mode
- * @param forceWasmSqlite - explicit flag to force wasm mode
- */
-export function resolveSqliteMode(
-  disableWasmSqlite: boolean,
-  forceWasmSqlite: boolean = false
-): SqliteMode {
-  // explicit native request
-  if (disableWasmSqlite) return 'native'
-
-  // explicit wasm request
-  if (forceWasmSqlite) return 'wasm'
-
-  // auto-detect: use native if binary is compiled
-  const nativeCheck = inspectNativeSqliteBinary()
-  if (nativeCheck.found) return 'native'
-
-  // fallback to wasm
-  return 'wasm'
-}
-
-/**
- * resolve full sqlite mode config including paths
- * returns null if required packages aren't installed
- */
-export function resolveSqliteModeConfig(
-  disableWasmSqlite: boolean,
-  forceWasmSqlite: boolean = false
-): SqliteModeConfig | null {
-  const mode = resolveSqliteMode(disableWasmSqlite, forceWasmSqlite)
-  const zeroSqlitePath = resolvePackage('@rocicorp/zero-sqlite3') || undefined
-
-  // native mode needs zero-sqlite3 path
-  if (mode === 'native') {
-    return { mode, zeroSqlitePath }
-  }
-
-  // wasm mode only needs bedrock-sqlite - we write a shim
-  // directly into node_modules/@rocicorp/zero-sqlite3
-  const bedrockPath = resolvePackage('bedrock-sqlite')
-
-  if (!bedrockPath) {
-    return null // bedrock-sqlite not installed
-  }
-
-  return {
-    mode,
-    bedrockPath,
-    zeroSqlitePath, // optional - may not exist if using shim
-  }
-}
-
-/**
- * get mode display string for logging
- */
-export function getModeDisplayString(mode: SqliteMode): string {
-  return mode
-}

package/src/sqlite-mode/shim-template.ts

@@ -1,159 +0,0 @@
-/**
- * shim template generator - single source of truth for both cjs and esm shims.
- * generates the shim code that wraps bedrock-sqlite to be compatible with
- * @rocicorp/zero-sqlite3 (better-sqlite3 api).
- */
-
-import { COMMON_PRAGMAS, JOURNAL_MODE, type SqliteMode } from './types.js'
-
-export interface ShimOptions {
-  mode: SqliteMode
-  bedrockPath: string
-  // include debug tracing for changeLog/replicationState writes
-  includeTracing?: boolean
-}
-
-/**
- * generate the core shim code (shared between cjs and esm)
- * this is the constructor wrapper and api polyfills
- */
-function generateShimCore(opts: ShimOptions): string {
-  const journalMode = JOURNAL_MODE[opts.mode]
-  const { busy_timeout, synchronous } = COMMON_PRAGMAS
-
-  return `
-var OrigDatabase = mod.Database;
-var SqliteError = mod.SqliteError;
-
-function Database() {
-  var db = new OrigDatabase(...arguments);
-  try {
-    db.pragma('journal_mode = ${journalMode}');
-    db.pragma('synchronous = ${synchronous}');
-    db.pragma('temp_store = memory');
-    db.pragma('busy_timeout = ${busy_timeout}');
-  } catch(e) {}
-  return db;
-}
-
-Database.prototype = OrigDatabase.prototype;
-Database.prototype.constructor = Database;
-Object.keys(OrigDatabase).forEach(function(k) { Database[k] = OrigDatabase[k]; });
-
-// api polyfills for better-sqlite3 compatibility
-Database.prototype.unsafeMode = function() { return this; };
-if (!Database.prototype.defaultSafeIntegers) {
-  Database.prototype.defaultSafeIntegers = function() { return this; };
-}
-if (!Database.prototype.serialize) {
-  Database.prototype.serialize = function() { throw new Error('not supported in wasm'); };
-}
-if (!Database.prototype.backup) {
-  Database.prototype.backup = function() { throw new Error('not supported in wasm'); };
-}
-
-// wrap pragma to skip optimize (can corrupt wasm vfs) and swallow sqlite errors
-var origPragma = OrigDatabase.prototype.pragma;
-Database.prototype.pragma = function(str, opts) {
-  if (str && str.trim().toLowerCase().startsWith('optimize')) return [];
-  try { return origPragma.call(this, str, opts); }
-  catch(e) { if (e && (e.code === 'SQLITE_CORRUPT' || e.code === 'SQLITE_IOERR')) return []; throw e; }
-};
-
-// wrap close to swallow wasm errors during shutdown
-var origClose = OrigDatabase.prototype.close;
-Database.prototype.close = function() {
-  try { return origClose.call(this); }
-  catch(e) { console.error('[orez-shim] close error (swallowed):', e?.message || e); }
-};
-
-// statement prototype polyfills
-var tmpDb = new OrigDatabase(':memory:');
-var tmpStmt = tmpDb.prepare('SELECT 1');
-var SP = Object.getPrototypeOf(tmpStmt);
-if (!SP.safeIntegers) SP.safeIntegers = function() { return this; };
-SP.scanStatus = function() { return undefined; };
-SP.scanStatusV2 = function() { return []; };
-SP.scanStatusReset = function() {};
-tmpDb.close();
-
-// scanstat constants for query planner compatibility
-Database.SQLITE_SCANSTAT_NLOOP = 0;
-Database.SQLITE_SCANSTAT_NVISIT = 1;
-Database.SQLITE_SCANSTAT_EST = 2;
-Database.SQLITE_SCANSTAT_NAME = 3;
-Database.SQLITE_SCANSTAT_EXPLAIN = 4;
-Database.SQLITE_SCANSTAT_SELECTID = 5;
-Database.SQLITE_SCANSTAT_PARENTID = 6;
-Database.SQLITE_SCANSTAT_NCYCLE = 7;
-Database.SQLITE_SCANSTAT_COMPLEX = 8;
-`.trim()
-}
-
-/**
- * generate debug tracing code for run() method
- */
-function generateTracing(): string {
-  return `
-// trace writes to _zero.changeLog and _zero.replicationState for debugging
-var origRun = OrigDatabase.prototype.run;
-Database.prototype.run = function(sql) {
-  var args = Array.prototype.slice.call(arguments, 1);
-  if (typeof sql === 'string') {
-    if (sql.includes('_zero.changeLog')) {
-      console.info('[orez-shim] changeLog write:', sql.slice(0, 120), args.length ? JSON.stringify(args[0]).slice(0, 80) : '');
-    }
-    if (sql.includes('_zero.replicationState') && (sql.includes('UPDATE') || sql.includes('INSERT'))) {
-      console.info('[orez-shim] replicationState update:', sql.slice(0, 120), args.length ? JSON.stringify(args[0]).slice(0, 80) : '');
-    }
-  }
-  return origRun.apply(this, arguments);
-};
-`.trim()
-}
-
-/**
- * generate commonjs shim for in-place patching of @rocicorp/zero-sqlite3
- */
-export function generateCjsShim(opts: ShimOptions): string {
-  const core = generateShimCore(opts)
-  const tracing = opts.includeTracing ? '\n' + generateTracing() : ''
-
-  return `'use strict';
-// orez sqlite shim - wraps bedrock-sqlite for zero-cache compatibility
-// mode: ${opts.mode}, journal_mode: ${JOURNAL_MODE[opts.mode]}
-var mod = require('${opts.bedrockPath}');
-${core}
-${tracing}
-module.exports = Database;
-module.exports.SqliteError = SqliteError;
-`
-}
-
-/**
- * generate esm shim for loader hooks
- */
-export function generateEsmShim(opts: ShimOptions): string {
-  const core = generateShimCore(opts)
-  const tracing = opts.includeTracing ? '\n' + generateTracing() : ''
-
-  return `// orez sqlite shim - wraps bedrock-sqlite for zero-cache compatibility
-// mode: ${opts.mode}, journal_mode: ${JOURNAL_MODE[opts.mode]}
-
-// catch uncaught exceptions from bedrock-sqlite wasm clearly
-process.on('uncaughtException', (err) => {
-  console.error('[orez-shim] UNCAUGHT EXCEPTION:', err?.message || err);
-  console.error('[orez-shim] code:', err?.code, 'name:', err?.name);
-  console.error('[orez-shim] stack:', err?.stack?.split('\\n').slice(0, 5).join('\\n'));
-  process.exit(1);
-});
-
-import { createRequire } from 'node:module';
-const require = createRequire('${opts.bedrockPath}');
-var mod = require('${opts.bedrockPath}');
-${core}
-${tracing}
-export default Database;
-export { SqliteError };
-`
-}