orez 0.2.27 → 0.2.30

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

@@ -1,427 +0,0 @@
-/**
- * sqlite-mode tests - mode resolution, shim generation, and mode transitions
- */
-
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import {
-  applySqliteMode,
-  backupOriginal,
-  cleanupShim,
-  getShimMode,
-  hasBackup,
-  restoreOriginal,
-} from './apply-mode.js'
-import { resolveSqliteMode, resolveSqliteModeConfig } from './resolve-mode.js'
-import { generateCjsShim, generateEsmShim } from './shim-template.js'
-import { BACKUP_MARKER, JOURNAL_MODE } from './types.js'
-
-describe('sqlite mode types', () => {
-  it('journal_mode is wal2 for both modes (required by zero-cache)', () => {
-    expect(JOURNAL_MODE.native).toBe('wal2')
-    expect(JOURNAL_MODE.wasm).toBe('wal2')
-  })
-})
-
-describe('sqlite mode resolution', () => {
-  it('resolves native mode when disableWasmSqlite is true', () => {
-    expect(resolveSqliteMode(true, false)).toBe('native')
-  })
-
-  it('resolves wasm mode when forceWasmSqlite is true', () => {
-    expect(resolveSqliteMode(false, true)).toBe('wasm')
-  })
-
-  it('auto-detects mode based on native binary availability', () => {
-    // when neither flag is set, mode depends on whether native binary exists
-    const mode = resolveSqliteMode(false, false)
-    expect(['wasm', 'native']).toContain(mode)
-  })
-
-  it('returns config with mode for native', () => {
-    const config = resolveSqliteModeConfig(true, false)
-    expect(config).not.toBeNull()
-    expect(config?.mode).toBe('native')
-  })
-})
-
-describe('shim template generation', () => {
-  it('generates cjs shim with correct journal_mode for wasm', () => {
-    const shim = generateCjsShim({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-    })
-    expect(shim).toContain("db.pragma('journal_mode = wal2')")
-    expect(shim).toContain('// mode: wasm')
-    expect(shim).toContain('orez sqlite shim')
-  })
-
-  it('generates cjs shim with correct journal_mode for native', () => {
-    const shim = generateCjsShim({
-      mode: 'native',
-      bedrockPath: '/path/to/bedrock',
-    })
-    expect(shim).toContain("db.pragma('journal_mode = wal2')")
-    expect(shim).toContain('// mode: native')
-  })
-
-  it('generates esm shim with correct journal_mode for wasm', () => {
-    const shim = generateEsmShim({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-    })
-    expect(shim).toContain("db.pragma('journal_mode = wal2')")
-    expect(shim).toContain('// mode: wasm')
-  })
-
-  it('includes common pragmas in both shim types', () => {
-    const cjs = generateCjsShim({ mode: 'wasm', bedrockPath: '/path' })
-    const esm = generateEsmShim({ mode: 'wasm', bedrockPath: '/path' })
-
-    for (const shim of [cjs, esm]) {
-      expect(shim).toContain("db.pragma('busy_timeout = 30000')")
-      expect(shim).toContain("db.pragma('synchronous = off')")
-    }
-  })
-
-  it('includes api polyfills in generated shims', () => {
-    const shim = generateCjsShim({ mode: 'wasm', bedrockPath: '/path' })
-
-    expect(shim).toContain('Database.prototype.unsafeMode')
-    expect(shim).toContain('Database.prototype.defaultSafeIntegers')
-    expect(shim).toContain('Database.prototype.serialize')
-    expect(shim).toContain('Database.prototype.backup')
-    expect(shim).toContain('SP.scanStatus')
-    expect(shim).toContain('SP.scanStatusV2')
-    expect(shim).toContain('SQLITE_SCANSTAT_NLOOP')
-  })
-
-  it('includes pragma wrapper to skip optimize', () => {
-    const shim = generateCjsShim({ mode: 'wasm', bedrockPath: '/path' })
-    expect(shim).toContain("str.trim().toLowerCase().startsWith('optimize')")
-  })
-
-  it('includes tracing when enabled', () => {
-    const withTracing = generateCjsShim({
-      mode: 'wasm',
-      bedrockPath: '/path',
-      includeTracing: true,
-    })
-    const withoutTracing = generateCjsShim({
-      mode: 'wasm',
-      bedrockPath: '/path',
-      includeTracing: false,
-    })
-
-    expect(withTracing).toContain('_zero.changeLog')
-    expect(withoutTracing).not.toContain('_zero.changeLog')
-  })
-})
-
-describe('shim backup/restore lifecycle', () => {
-  let testDir: string
-  let mockPackageDir: string
-  let mockIndexPath: string
-
-  const originalContent = `'use strict';
-// original @rocicorp/zero-sqlite3 content
-module.exports = require('better-sqlite3');
-`
-
-  beforeEach(() => {
-    testDir = join(
-      tmpdir(),
-      `orez-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    )
-    mockPackageDir = join(testDir, 'node_modules', '@rocicorp', 'zero-sqlite3', 'lib')
-    mkdirSync(mockPackageDir, { recursive: true })
-    mockIndexPath = join(mockPackageDir, 'index.js')
-
-    // create mock package.json
-    writeFileSync(
-      join(testDir, 'node_modules', '@rocicorp', 'zero-sqlite3', 'package.json'),
-      JSON.stringify({ name: '@rocicorp/zero-sqlite3', main: 'lib/index.js' })
-    )
-
-    // create original index.js
-    writeFileSync(mockIndexPath, originalContent)
-  })
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true })
-  })
-
-  it('backups original file before shimming', () => {
-    expect(hasBackup(mockIndexPath)).toBe(false)
-    expect(backupOriginal(mockIndexPath)).toBe(true)
-    expect(hasBackup(mockIndexPath)).toBe(true)
-
-    const backupContent = readFileSync(mockIndexPath + BACKUP_MARKER, 'utf-8')
-    expect(backupContent).toBe(originalContent)
-  })
-
-  it('does not re-backup if backup already exists', () => {
-    backupOriginal(mockIndexPath)
-    const backupPath = mockIndexPath + BACKUP_MARKER
-
-    // modify original (simulate shim)
-    writeFileSync(mockIndexPath, 'shimmed content')
-
-    // backup should not overwrite existing backup
-    expect(backupOriginal(mockIndexPath)).toBe(true)
-    expect(readFileSync(backupPath, 'utf-8')).toBe(originalContent)
-  })
-
-  it('restores original from backup', () => {
-    backupOriginal(mockIndexPath)
-    writeFileSync(mockIndexPath, 'shimmed content')
-
-    expect(restoreOriginal(mockIndexPath)).toBe(true)
-    expect(readFileSync(mockIndexPath, 'utf-8')).toBe(originalContent)
-    expect(hasBackup(mockIndexPath)).toBe(false)
-  })
-
-  it('returns false when no backup to restore', () => {
-    expect(restoreOriginal(mockIndexPath)).toBe(false)
-  })
-
-  it('getShimMode returns null for unshimmed file', () => {
-    expect(getShimMode(mockIndexPath)).toBeNull()
-  })
-
-  it('getShimMode returns mode for shimmed file', () => {
-    const shimContent = generateCjsShim({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-    })
-    writeFileSync(mockIndexPath, shimContent)
-
-    expect(getShimMode(mockIndexPath)).toBe('wasm')
-  })
-
-  it('cleanupShim restores original if backup exists', () => {
-    backupOriginal(mockIndexPath)
-    writeFileSync(mockIndexPath, 'shimmed')
-
-    cleanupShim(
-      join(testDir, 'node_modules', '@rocicorp', 'zero-sqlite3', 'lib', 'index.js')
-    )
-
-    expect(readFileSync(mockIndexPath, 'utf-8')).toBe(originalContent)
-  })
-})
-
-describe('mode transitions', () => {
-  let testDir: string
-  let mockPackageDir: string
-  let mockIndexPath: string
-
-  const originalContent = `'use strict';
-// original @rocicorp/zero-sqlite3
-module.exports = require('better-sqlite3');
-`
-
-  beforeEach(() => {
-    testDir = join(
-      tmpdir(),
-      `orez-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    )
-    mockPackageDir = join(testDir, 'node_modules', '@rocicorp', 'zero-sqlite3', 'lib')
-    mkdirSync(mockPackageDir, { recursive: true })
-    mockIndexPath = join(mockPackageDir, 'index.js')
-
-    writeFileSync(
-      join(testDir, 'node_modules', '@rocicorp', 'zero-sqlite3', 'package.json'),
-      JSON.stringify({ name: '@rocicorp/zero-sqlite3', main: 'lib/index.js' })
-    )
-    writeFileSync(mockIndexPath, originalContent)
-  })
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true })
-  })
-
-  it('native -> wasm -> native preserves original', () => {
-    // start in native mode (no shim)
-    expect(getShimMode(mockIndexPath)).toBeNull()
-
-    // switch to wasm mode
-    const wasmResult = applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(wasmResult.success).toBe(true)
-    expect(getShimMode(mockIndexPath)).toBe('wasm')
-    expect(hasBackup(mockIndexPath)).toBe(true)
-
-    // switch back to native mode
-    const nativeResult = applySqliteMode({
-      mode: 'native',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(nativeResult.success).toBe(true)
-    expect(getShimMode(mockIndexPath)).toBeNull()
-    expect(readFileSync(mockIndexPath, 'utf-8')).toBe(originalContent)
-    expect(hasBackup(mockIndexPath)).toBe(false)
-  })
-
-  it('wasm -> native -> wasm works correctly', () => {
-    // start in wasm mode
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(getShimMode(mockIndexPath)).toBe('wasm')
-    const wasmContent = readFileSync(mockIndexPath, 'utf-8')
-
-    // switch to native
-    applySqliteMode({
-      mode: 'native',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(getShimMode(mockIndexPath)).toBeNull()
-
-    // switch back to wasm
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(getShimMode(mockIndexPath)).toBe('wasm')
-
-    // shim should have same journal_mode
-    const newWasmContent = readFileSync(mockIndexPath, 'utf-8')
-    expect(newWasmContent).toContain('journal_mode = wal2')
-  })
-
-  it('multiple wasm applies are idempotent', () => {
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    const firstShim = readFileSync(mockIndexPath, 'utf-8')
-
-    // apply again
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    const secondShim = readFileSync(mockIndexPath, 'utf-8')
-
-    expect(firstShim).toBe(secondShim)
-    expect(hasBackup(mockIndexPath)).toBe(true)
-  })
-
-  it('does not backup shimmed content', () => {
-    // apply wasm shim
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-
-    // manually delete backup to simulate corruption
-    const backupPath = mockIndexPath + BACKUP_MARKER
-    rmSync(backupPath)
-
-    // try to backup again - should fail because file is shimmed
-    expect(backupOriginal(mockIndexPath)).toBe(false)
-  })
-
-  it('wasm re-apply is idempotent even without backup', () => {
-    // apply wasm shim first
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-
-    // delete backup to simulate corruption
-    const backupPath = mockIndexPath + BACKUP_MARKER
-    rmSync(backupPath)
-
-    // re-applying same wasm mode should succeed (idempotent)
-    const result = applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('wasm shim fails on unshimmed file if backup cannot be created', () => {
-    // manually write a shimmed file without backup (simulates external corruption)
-    const shimContent = generateCjsShim({ mode: 'native', bedrockPath: '/path' })
-    writeFileSync(mockIndexPath, shimContent)
-
-    // try to apply wasm shim - should fail because file is shimmed but no backup
-    const result = applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(result.success).toBe(false)
-    expect(result.error).toContain('no backup')
-  })
-
-  it('native mode fails if shimmed with no backup', () => {
-    // apply wasm shim first
-    applySqliteMode({
-      mode: 'wasm',
-      bedrockPath: '/path/to/bedrock',
-      zeroSqlitePath: mockIndexPath,
-    })
-
-    // delete backup to simulate corruption
-    const backupPath = mockIndexPath + BACKUP_MARKER
-    rmSync(backupPath)
-
-    // try to restore native - should fail
-    const result = applySqliteMode({
-      mode: 'native',
-      zeroSqlitePath: mockIndexPath,
-    })
-    expect(result.success).toBe(false)
-    expect(result.error).toContain('no backup')
-  })
-})
-
-describe('shim contract tests', () => {
-  it('wasm shim sets journal_mode = wal2', () => {
-    const shim = generateCjsShim({ mode: 'wasm', bedrockPath: '/path' })
-    expect(shim).toContain("db.pragma('journal_mode = wal2')")
-  })
-
-  it('native shim sets journal_mode = wal2', () => {
-    const shim = generateCjsShim({ mode: 'native', bedrockPath: '/path' })
-    expect(shim).toContain("db.pragma('journal_mode = wal2')")
-  })
-
-  it('both modes set busy_timeout and synchronous', () => {
-    for (const mode of ['wasm', 'native'] as const) {
-      const shim = generateCjsShim({ mode, bedrockPath: '/path' })
-      expect(shim).toContain("db.pragma('busy_timeout = 30000')")
-      expect(shim).toContain("db.pragma('synchronous = off')")
-    }
-  })
-
-  it('shim exports Database and SqliteError', () => {
-    const shim = generateCjsShim({ mode: 'wasm', bedrockPath: '/path' })
-    expect(shim).toContain('module.exports = Database')
-    expect(shim).toContain('module.exports.SqliteError = SqliteError')
-  })
-
-  it('esm shim exports default and named SqliteError', () => {
-    const shim = generateEsmShim({ mode: 'wasm', bedrockPath: '/path' })
-    expect(shim).toContain('export default Database')
-    expect(shim).toContain('export { SqliteError }')
-  })
-})

package/src/sqlite-mode/types.ts

@@ -1,30 +0,0 @@
-/**
- * sqlite mode types and constants
- */
-
-export type SqliteMode = 'native' | 'wasm'
-
-export interface SqliteModeConfig {
-  mode: SqliteMode
-  // path to bedrock-sqlite for wasm mode
-  bedrockPath?: string
-  // path to @rocicorp/zero-sqlite3 package
-  zeroSqlitePath?: string
-}
-
-// journal mode - zero-cache requires wal2 for replica sync (BEGIN CONCURRENT)
-// both modes use wal2 now - bedrock-sqlite wasm should support it
-export const JOURNAL_MODE: Record<SqliteMode, string> = {
-  native: 'wal2',
-  wasm: 'wal2',
-}
-
-// common pragmas shared by both modes
-// synchronous=off skips fsync — safe for a dev tool, big perf win
-export const COMMON_PRAGMAS = {
-  busy_timeout: '30000',
-  synchronous: 'off',
-}
-
-// backup file marker for identifying orez-shimmed packages
-export const BACKUP_MARKER = '.orez-backup'

package/src/vite-plugin.ts

@@ -1,67 +0,0 @@
-import { startZeroLite } from './index.js'
-
-import type { Hook, ZeroLiteConfig } from './config.js'
-import type { Server } from 'node:http'
-import type { Plugin } from 'vite'
-
-export interface OrezPluginOptions extends Partial<
-  Omit<ZeroLiteConfig, 'onDbReady' | 'onHealthy'>
-> {
-  s3?: boolean
-  s3Port?: number
-  // lifecycle hooks - callback functions (preferred for vite) or shell commands
-  onDbReady?: Hook
-  onHealthy?: Hook
-}
-
-export function orezPlugin(options?: OrezPluginOptions): Plugin {
-  let stop: (() => Promise<void>) | null = null
-  let s3Server: Server | null = null
-  let adminServer: Server | null = null
-
-  return {
-    name: 'orez',
-
-    async configureServer(server) {
-      const result = await startZeroLite(options)
-      stop = result.stop
-
-      // start admin dashboard if adminPort is configured
-      if (result.config.adminPort > 0 && result.logStore) {
-        const { startAdminServer } = await import('./admin/server.js')
-        adminServer = await startAdminServer({
-          port: result.config.adminPort,
-          logStore: result.logStore,
-          httpLog: result.httpLog,
-          config: result.config,
-          zeroEnv: result.zeroEnv || {},
-          actions: {
-            restartZero: result.restartZero,
-            stopZero: result.stopZero,
-            resetZero: result.resetZero,
-            resetZeroFull: result.resetZeroFull,
-          },
-          startTime: Date.now(),
-          db: result.instances,
-        })
-      }
-
-      if (options?.s3) {
-        const { startS3Local } = await import('./s3-local.js')
-        s3Server = await startS3Local({
-          port: options.s3Port || 9200,
-          dataDir: result.config.dataDir,
-        })
-      }
-
-      server.httpServer?.on('close', async () => {
-        adminServer?.close()
-        s3Server?.close()
-        if (stop) {
-          await stop()
-          stop = null
-        }
-      })
-    },
-  }
-}