@xnetjs/sqlite 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,207 @@
+import { S as SQLValue } from './types-C_aHfRDF.js';
+export { R as RunResult, a as SQLRow, b as SQLiteConfig, c as SchemaVersion } from './types-C_aHfRDF.js';
+import { S as SQLiteAdapter } from './adapter-I7yAV6iu.js';
+export { P as PreparedStatement } from './adapter-I7yAV6iu.js';
+export { a as SCHEMA_DDL, b as SCHEMA_DDL_CORE, c as SCHEMA_DDL_FTS, d as SCHEMA_MIGRATIONS, S as SCHEMA_VERSION, g as getMigrationSQL } from './schema-CjkXTqxn.js';
+export { BrowserSupport, checkBrowserSupport, showUnsupportedBrowserMessage } from './browser-support.js';
+
+/**
+ * @xnetjs/sqlite - SQL query building helpers
+ */
+/**
+ * Build a parameterized INSERT statement.
+ */
+declare function buildInsert(table: string, columns: string[], options?: {
+    orReplace?: boolean;
+    orIgnore?: boolean;
+}): {
+    sql: string;
+    placeholders: string;
+};
+/**
+ * Build a parameterized UPDATE statement.
+ */
+declare function buildUpdate(table: string, columns: string[], whereColumns: string[]): string;
+/**
+ * Build a parameterized SELECT statement with optional filters.
+ */
+declare function buildSelect(table: string, columns?: string[], options?: {
+    where?: string[];
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+}): string;
+/**
+ * Escape a string for use in LIKE patterns.
+ */
+declare function escapeLike(value: string): string;
+/**
+ * Build a batch INSERT statement for multiple rows.
+ */
+declare function buildBatchInsert(table: string, columns: string[], rowCount: number): string;
+
+/**
+ * @xnetjs/sqlite - Full-Text Search (FTS5) helpers
+ *
+ * These functions manage the FTS5 index for searchable node content.
+ * FTS5 is not supported by sql.js, so these functions are no-ops
+ * when using MemorySQLiteAdapter.
+ */
+
+interface FTSSearchResult {
+    nodeId: string;
+    rank: number;
+    snippet?: string;
+}
+interface FTSSearchOptions {
+    /** Maximum number of results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Include snippets in results */
+    includeSnippets?: boolean;
+    /** Highlight markers for snippets */
+    highlightMarkers?: {
+        start: string;
+        end: string;
+    };
+}
+/**
+ * Update the FTS index for a node.
+ * Call this when a node's title or content changes.
+ *
+ * @param db - SQLite adapter
+ * @param nodeId - ID of the node
+ * @param title - Node title (can be null)
+ * @param content - Searchable content (can be null)
+ */
+declare function updateNodeFTS(db: SQLiteAdapter, nodeId: string, title: string | null, content: string | null): Promise<void>;
+/**
+ * Delete a node from the FTS index.
+ *
+ * @param db - SQLite adapter
+ * @param nodeId - ID of the node to remove
+ */
+declare function deleteNodeFTS(db: SQLiteAdapter, nodeId: string): Promise<void>;
+/**
+ * Search nodes using FTS5.
+ *
+ * @param db - SQLite adapter
+ * @param query - FTS5 match query (e.g., "hello world", "title:project")
+ * @param options - Search options
+ * @returns Array of matching node IDs with rank
+ */
+declare function searchNodes(db: SQLiteAdapter, query: string, options?: FTSSearchOptions): Promise<FTSSearchResult[]>;
+/**
+ * Rebuild the entire FTS index from node data.
+ * Use this after data imports or to fix index corruption.
+ *
+ * @param db - SQLite adapter
+ * @param getNodeContent - Function to get title and content for a node
+ */
+declare function rebuildFTS(db: SQLiteAdapter, getNodeContent: (nodeId: string) => Promise<{
+    title: string | null;
+    content: string | null;
+}>): Promise<number>;
+/**
+ * Optimize the FTS index.
+ * Call this periodically or after large batch operations.
+ */
+declare function optimizeFTS(db: SQLiteAdapter): Promise<void>;
+/**
+ * Extract searchable text from TipTap JSON content.
+ */
+declare function extractTextFromTipTap(node: TipTapNode): string;
+/**
+ * Extract searchable text from node properties.
+ * Handles common property types (string, TipTap JSON).
+ */
+declare function extractSearchableContent(properties: Record<string, unknown>): string | null;
+interface TipTapNode {
+    type: string;
+    content?: TipTapNode[];
+    text?: string;
+}
+
+/**
+ * @xnetjs/sqlite - Database diagnostics and analysis utilities
+ *
+ * These functions help debug performance issues, analyze query plans,
+ * and inspect database state.
+ */
+
+interface IndexInfo {
+    name: string;
+    tableName: string;
+    unique: boolean;
+    columns: string[];
+    partial: boolean;
+}
+interface TableStats {
+    name: string;
+    rowCount: number;
+    pageCount: number;
+    unusedBytes: number;
+}
+interface QueryPlanStep {
+    id: number;
+    parent: number;
+    detail: string;
+}
+interface DatabaseStats {
+    pageSize: number;
+    pageCount: number;
+    freePageCount: number;
+    schemaVersion: number;
+    walMode: boolean;
+    foreignKeys: boolean;
+}
+/**
+ * Get information about all indexes in the database.
+ */
+declare function getIndexInfo(db: SQLiteAdapter): Promise<IndexInfo[]>;
+/**
+ * Check which indexes are being used for a query.
+ */
+declare function analyzeQuery(db: SQLiteAdapter, sql: string, params?: SQLValue[]): Promise<{
+    plan: QueryPlanStep[];
+    usedIndexes: string[];
+    fullTableScan: boolean;
+}>;
+/**
+ * Get statistics about a table.
+ */
+declare function analyzeTable(db: SQLiteAdapter, tableName: string): Promise<TableStats>;
+/**
+ * Get statistics about all tables.
+ */
+declare function getAllTableStats(db: SQLiteAdapter): Promise<TableStats[]>;
+/**
+ * Get overall database statistics.
+ */
+declare function getDatabaseStats(db: SQLiteAdapter): Promise<DatabaseStats>;
+/**
+ * Run ANALYZE to update query planner statistics.
+ */
+declare function runAnalyze(db: SQLiteAdapter, tableName?: string): Promise<void>;
+/**
+ * Check database integrity.
+ */
+declare function checkIntegrity(db: SQLiteAdapter): Promise<{
+    ok: boolean;
+    errors: string[];
+}>;
+/**
+ * Get the full EXPLAIN output for a query (bytecode).
+ */
+declare function explainQuery(db: SQLiteAdapter, sql: string, params?: SQLValue[]): Promise<string[]>;
+/**
+ * Time a query and return the result with timing info.
+ */
+declare function timeQuery<T>(db: SQLiteAdapter, sql: string, params?: SQLValue[]): Promise<{
+    result: T[];
+    durationMs: number;
+    rowCount: number;
+}>;
+
+export { type DatabaseStats, type FTSSearchOptions, type FTSSearchResult, type IndexInfo, type QueryPlanStep, SQLValue, SQLiteAdapter, type TableStats, analyzeQuery, analyzeTable, buildBatchInsert, buildInsert, buildSelect, buildUpdate, checkIntegrity, deleteNodeFTS, escapeLike, explainQuery, extractSearchableContent, extractTextFromTipTap, getAllTableStats, getDatabaseStats, getIndexInfo, optimizeFTS, rebuildFTS, runAnalyze, searchNodes, timeQuery, updateNodeFTS };

package/dist/index.js

@@ -0,0 +1,353 @@
+import {
+  SCHEMA_DDL,
+  SCHEMA_DDL_CORE,
+  SCHEMA_DDL_FTS,
+  SCHEMA_MIGRATIONS,
+  SCHEMA_VERSION,
+  getMigrationSQL
+} from "./chunk-HIREU5S5.js";
+import {
+  checkBrowserSupport,
+  showUnsupportedBrowserMessage
+} from "./chunk-ZRR5D2OD.js";
+
+// src/query-builder.ts
+function buildInsert(table, columns, options) {
+  const placeholders = columns.map(() => "?").join(", ");
+  const columnList = columns.join(", ");
+  let prefix = "INSERT";
+  if (options?.orReplace) prefix = "INSERT OR REPLACE";
+  if (options?.orIgnore) prefix = "INSERT OR IGNORE";
+  return {
+    sql: `${prefix} INTO ${table} (${columnList}) VALUES (${placeholders})`,
+    placeholders
+  };
+}
+function buildUpdate(table, columns, whereColumns) {
+  const setClause = columns.map((c) => `${c} = ?`).join(", ");
+  const whereClause = whereColumns.map((c) => `${c} = ?`).join(" AND ");
+  return `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
+}
+function buildSelect(table, columns = ["*"], options) {
+  let sql = `SELECT ${columns.join(", ")} FROM ${table}`;
+  if (options?.where && options.where.length > 0) {
+    sql += ` WHERE ${options.where.map((c) => `${c} = ?`).join(" AND ")}`;
+  }
+  if (options?.orderBy) {
+    sql += ` ORDER BY ${options.orderBy}`;
+  }
+  if (options?.limit !== void 0) {
+    sql += ` LIMIT ${options.limit}`;
+  }
+  if (options?.offset !== void 0) {
+    sql += ` OFFSET ${options.offset}`;
+  }
+  return sql;
+}
+function escapeLike(value) {
+  return value.replace(/[%_\\]/g, "\\$&");
+}
+function buildBatchInsert(table, columns, rowCount) {
+  const placeholders = columns.map(() => "?").join(", ");
+  const valuesList = Array(rowCount).fill(`(${placeholders})`).join(", ");
+  const columnList = columns.join(", ");
+  return `INSERT INTO ${table} (${columnList}) VALUES ${valuesList}`;
+}
+
+// src/fts.ts
+async function updateNodeFTS(db, nodeId, title, content) {
+  const hasFTS = await checkFTSSupport(db);
+  if (!hasFTS) return;
+  await db.run("DELETE FROM nodes_fts WHERE node_id = ?", [nodeId]);
+  if (title || content) {
+    await db.run("INSERT INTO nodes_fts (node_id, title, content) VALUES (?, ?, ?)", [
+      nodeId,
+      title ?? "",
+      content ?? ""
+    ]);
+  }
+}
+async function deleteNodeFTS(db, nodeId) {
+  const hasFTS = await checkFTSSupport(db);
+  if (!hasFTS) return;
+  await db.run("DELETE FROM nodes_fts WHERE node_id = ?", [nodeId]);
+}
+async function searchNodes(db, query, options = {}) {
+  const hasFTS = await checkFTSSupport(db);
+  if (!hasFTS) return [];
+  const { limit = 50, offset = 0, includeSnippets = false, highlightMarkers } = options;
+  const escapedQuery = escapeFTSQuery(query);
+  if (!escapedQuery) return [];
+  let sql;
+  if (includeSnippets) {
+    const startMark = highlightMarkers?.start ?? "<mark>";
+    const endMark = highlightMarkers?.end ?? "</mark>";
+    sql = `
+      SELECT 
+        node_id,
+        rank,
+        snippet(nodes_fts, 2, '${startMark}', '${endMark}', '...', 32) as snippet
+      FROM nodes_fts
+      WHERE nodes_fts MATCH ?
+      ORDER BY rank
+      LIMIT ? OFFSET ?
+    `;
+  } else {
+    sql = `
+      SELECT node_id, rank
+      FROM nodes_fts
+      WHERE nodes_fts MATCH ?
+      ORDER BY rank
+      LIMIT ? OFFSET ?
+    `;
+  }
+  const rows = await db.query(sql, [escapedQuery, limit, offset]);
+  return rows.map((row) => ({
+    nodeId: row.node_id,
+    rank: row.rank,
+    snippet: row.snippet ?? void 0
+  }));
+}
+async function rebuildFTS(db, getNodeContent) {
+  const hasFTS = await checkFTSSupport(db);
+  if (!hasFTS) return 0;
+  const nodes = await db.query("SELECT id FROM nodes WHERE deleted_at IS NULL");
+  await db.run("DELETE FROM nodes_fts");
+  let indexed = 0;
+  const batchSize = 100;
+  for (let i = 0; i < nodes.length; i += batchSize) {
+    const batch = nodes.slice(i, i + batchSize);
+    await db.transaction(async () => {
+      for (const node of batch) {
+        const { title, content } = await getNodeContent(node.id);
+        if (title || content) {
+          await db.run("INSERT INTO nodes_fts (node_id, title, content) VALUES (?, ?, ?)", [
+            node.id,
+            title ?? "",
+            content ?? ""
+          ]);
+          indexed++;
+        }
+      }
+    });
+  }
+  return indexed;
+}
+async function optimizeFTS(db) {
+  const hasFTS = await checkFTSSupport(db);
+  if (!hasFTS) return;
+  await db.run("INSERT INTO nodes_fts(nodes_fts) VALUES('optimize')");
+}
+function extractTextFromTipTap(node) {
+  const parts = [];
+  if (node.text) {
+    parts.push(node.text);
+  }
+  if (node.content) {
+    for (const child of node.content) {
+      parts.push(extractTextFromTipTap(child));
+    }
+  }
+  return parts.join(" ").trim();
+}
+function extractSearchableContent(properties) {
+  const parts = [];
+  const content = properties.content;
+  if (content) {
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (typeof content === "object" && "type" in content) {
+      parts.push(extractTextFromTipTap(content));
+    }
+  }
+  const description = properties.description;
+  if (typeof description === "string") {
+    parts.push(description);
+  }
+  const body = properties.body;
+  if (typeof body === "string") {
+    parts.push(body);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+var ftsSupport = /* @__PURE__ */ new WeakMap();
+async function checkFTSSupport(db) {
+  if (ftsSupport.has(db)) {
+    return ftsSupport.get(db);
+  }
+  try {
+    const result = await db.queryOne(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='nodes_fts'"
+    );
+    const supported = result !== null;
+    ftsSupport.set(db, supported);
+    return supported;
+  } catch {
+    ftsSupport.set(db, false);
+    return false;
+  }
+}
+function escapeFTSQuery(query) {
+  query = query.trim();
+  if (!query) return "";
+  query = query.replace(/"/g, '""');
+  if (/[*():^~-]/.test(query)) {
+    return `"${query}"`;
+  }
+  return query;
+}
+
+// src/diagnostics.ts
+async function getIndexInfo(db) {
+  const indexes = await db.query(
+    "SELECT name, tbl_name, sql FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%'"
+  );
+  const result = [];
+  for (const idx of indexes) {
+    const columns = await db.query(`PRAGMA index_info('${idx.name}')`);
+    result.push({
+      name: idx.name,
+      tableName: idx.tbl_name,
+      unique: idx.sql?.includes("UNIQUE") ?? false,
+      columns: columns.map((c) => c.name),
+      partial: idx.sql?.includes("WHERE") ?? false
+    });
+  }
+  return result;
+}
+async function analyzeQuery(db, sql, params) {
+  const plan = await db.query(`EXPLAIN QUERY PLAN ${sql}`, params);
+  const steps = plan.map((row) => ({
+    id: row.id,
+    parent: row.parent,
+    detail: row.detail
+  }));
+  const usedIndexes = [];
+  let fullTableScan = false;
+  for (const step of steps) {
+    const detail = step.detail.toUpperCase();
+    const indexMatch = step.detail.match(/USING (?:COVERING )?INDEX (\w+)/i);
+    if (indexMatch) {
+      usedIndexes.push(indexMatch[1]);
+    }
+    if (detail.includes("SCAN TABLE") && !detail.includes("USING")) {
+      fullTableScan = true;
+    }
+  }
+  return { plan: steps, usedIndexes, fullTableScan };
+}
+async function analyzeTable(db, tableName) {
+  const countResult = await db.queryOne(`SELECT COUNT(*) as count FROM ${tableName}`);
+  const rowCount = countResult?.count ?? 0;
+  let pageCount = 0;
+  let unusedBytes = 0;
+  try {
+    const pages = await db.query(`SELECT pageno, unused FROM dbstat WHERE name = ?`, [
+      tableName
+    ]);
+    pageCount = pages.length;
+    unusedBytes = pages.reduce((sum, p) => sum + p.unused, 0);
+  } catch {
+  }
+  return {
+    name: tableName,
+    rowCount,
+    pageCount,
+    unusedBytes
+  };
+}
+async function getAllTableStats(db) {
+  const tables = await db.query(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+  );
+  const stats = [];
+  for (const table of tables) {
+    stats.push(await analyzeTable(db, table.name));
+  }
+  return stats.sort((a, b) => b.rowCount - a.rowCount);
+}
+async function getDatabaseStats(db) {
+  const [pageSize, pageCount, freePageCount, schemaVersion, walMode, foreignKeys] = await Promise.all([
+    db.queryOne("PRAGMA page_size"),
+    db.queryOne("PRAGMA page_count"),
+    db.queryOne("PRAGMA freelist_count"),
+    db.queryOne("PRAGMA schema_version"),
+    db.queryOne("PRAGMA journal_mode"),
+    db.queryOne("PRAGMA foreign_keys")
+  ]);
+  return {
+    pageSize: Number(pageSize?.page_size ?? 4096),
+    pageCount: Number(pageCount?.page_count ?? 0),
+    freePageCount: Number(freePageCount?.freelist_count ?? 0),
+    schemaVersion: Number(schemaVersion?.schema_version ?? 0),
+    walMode: String(walMode?.journal_mode ?? "").toLowerCase() === "wal",
+    foreignKeys: Boolean(foreignKeys?.foreign_keys)
+  };
+}
+async function runAnalyze(db, tableName) {
+  if (tableName) {
+    await db.exec(`ANALYZE ${tableName}`);
+  } else {
+    await db.exec("ANALYZE");
+  }
+}
+async function checkIntegrity(db) {
+  const results = await db.query("PRAGMA integrity_check(100)");
+  const errors = [];
+  for (const row of results) {
+    if (row.integrity_check !== "ok") {
+      errors.push(row.integrity_check);
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+async function explainQuery(db, sql, params) {
+  const rows = await db.query(`EXPLAIN ${sql}`, params);
+  return rows.map(
+    (row) => `${row.opcode.padEnd(15)} ${String(row.p1).padStart(4)} ${String(row.p2).padStart(4)} ${String(row.p3).padStart(4)} ${row.p4 || ""}`
+  );
+}
+async function timeQuery(db, sql, params) {
+  const start = performance.now();
+  const result = await db.query(sql, params);
+  const durationMs = performance.now() - start;
+  return {
+    result,
+    durationMs,
+    rowCount: result.length
+  };
+}
+export {
+  SCHEMA_DDL,
+  SCHEMA_DDL_CORE,
+  SCHEMA_DDL_FTS,
+  SCHEMA_MIGRATIONS,
+  SCHEMA_VERSION,
+  analyzeQuery,
+  analyzeTable,
+  buildBatchInsert,
+  buildInsert,
+  buildSelect,
+  buildUpdate,
+  checkBrowserSupport,
+  checkIntegrity,
+  deleteNodeFTS,
+  escapeLike,
+  explainQuery,
+  extractSearchableContent,
+  extractTextFromTipTap,
+  getAllTableStats,
+  getDatabaseStats,
+  getIndexInfo,
+  getMigrationSQL,
+  optimizeFTS,
+  rebuildFTS,
+  runAnalyze,
+  searchNodes,
+  showUnsupportedBrowserMessage,
+  timeQuery,
+  updateNodeFTS
+};

package/dist/schema-CjkXTqxn.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @xnetjs/sqlite - Unified SQLite schema for xNet
+ */
+/**
+ * Current schema version.
+ * Increment this when making schema changes.
+ */
+declare const SCHEMA_VERSION = 1;
+/**
+ * Core SQLite schema for xNet (without FTS5).
+ * This schema works on all platforms including sql.js.
+ */
+declare const SCHEMA_DDL_CORE = "\n-- ============================================\n-- Schema Version Tracking\n-- ============================================\n\nCREATE TABLE IF NOT EXISTS _schema_version (\n    version INTEGER PRIMARY KEY,\n    applied_at INTEGER NOT NULL\n);\n\n-- ============================================\n-- Core Tables\n-- ============================================\n\n-- All nodes (Pages, Databases, Rows, Comments, etc.)\nCREATE TABLE IF NOT EXISTS nodes (\n    id TEXT PRIMARY KEY,\n    schema_id TEXT NOT NULL,\n    created_at INTEGER NOT NULL,\n    updated_at INTEGER NOT NULL,\n    created_by TEXT NOT NULL,\n    deleted_at INTEGER\n);\n\n-- Node properties (LWW per-property)\nCREATE TABLE IF NOT EXISTS node_properties (\n    node_id TEXT NOT NULL,\n    property_key TEXT NOT NULL,\n    value BLOB,\n    lamport_time INTEGER NOT NULL,\n    updated_by TEXT NOT NULL,\n    updated_at INTEGER NOT NULL,\n\n    PRIMARY KEY (node_id, property_key),\n    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE\n);\n\n-- Change log (event sourcing)\nCREATE TABLE IF NOT EXISTS changes (\n    hash TEXT PRIMARY KEY,\n    node_id TEXT NOT NULL,\n    payload BLOB NOT NULL,\n    lamport_time INTEGER NOT NULL,\n    lamport_peer TEXT NOT NULL,\n    wall_time INTEGER NOT NULL,\n    author TEXT NOT NULL,\n    parent_hash TEXT,\n    batch_id TEXT,\n    signature BLOB NOT NULL,\n\n    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE\n);\n\n-- Y.Doc binary state (for nodes with collaborative content)\nCREATE TABLE IF NOT EXISTS yjs_state (\n    node_id TEXT PRIMARY KEY,\n    state BLOB NOT NULL,\n    updated_at INTEGER NOT NULL,\n\n    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE\n);\n\n-- Y.Doc incremental updates (for sync)\nCREATE TABLE IF NOT EXISTS yjs_updates (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    node_id TEXT NOT NULL,\n    update_data BLOB NOT NULL,\n    timestamp INTEGER NOT NULL,\n    origin TEXT,\n\n    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE\n);\n\n-- Yjs snapshots (for document time travel)\nCREATE TABLE IF NOT EXISTS yjs_snapshots (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    node_id TEXT NOT NULL,\n    timestamp INTEGER NOT NULL,\n    snapshot BLOB NOT NULL,\n    doc_state BLOB NOT NULL,\n    byte_size INTEGER NOT NULL,\n\n    FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE\n);\n\n-- Blobs (content-addressed)\nCREATE TABLE IF NOT EXISTS blobs (\n    cid TEXT PRIMARY KEY,\n    data BLOB NOT NULL,\n    mime_type TEXT,\n    size INTEGER NOT NULL,\n    created_at INTEGER NOT NULL,\n    reference_count INTEGER DEFAULT 1\n);\n\n-- Documents (for @xnetjs/storage compatibility)\nCREATE TABLE IF NOT EXISTS documents (\n    id TEXT PRIMARY KEY,\n    content BLOB NOT NULL,\n    metadata TEXT NOT NULL,\n    version INTEGER NOT NULL DEFAULT 1\n);\n\n-- Signed updates (for @xnetjs/storage compatibility)\nCREATE TABLE IF NOT EXISTS updates (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    doc_id TEXT NOT NULL,\n    update_hash TEXT NOT NULL,\n    update_data TEXT NOT NULL,\n    created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n    UNIQUE(doc_id, update_hash)\n);\n\n-- Snapshots (for @xnetjs/storage compatibility)\nCREATE TABLE IF NOT EXISTS snapshots (\n    doc_id TEXT PRIMARY KEY,\n    snapshot_data TEXT NOT NULL,\n    created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000)\n);\n\n-- Sync metadata\nCREATE TABLE IF NOT EXISTS sync_state (\n    key TEXT PRIMARY KEY,\n    value TEXT NOT NULL\n);\n\n-- ============================================\n-- Indexes\n-- ============================================\n\nCREATE INDEX IF NOT EXISTS idx_nodes_schema ON nodes(schema_id);\nCREATE INDEX IF NOT EXISTS idx_nodes_updated ON nodes(updated_at);\nCREATE INDEX IF NOT EXISTS idx_nodes_created_by ON nodes(created_by);\nCREATE INDEX IF NOT EXISTS idx_nodes_deleted ON nodes(deleted_at);\n\nCREATE INDEX IF NOT EXISTS idx_properties_node ON node_properties(node_id);\nCREATE INDEX IF NOT EXISTS idx_properties_lamport ON node_properties(lamport_time);\n\nCREATE INDEX IF NOT EXISTS idx_changes_node ON changes(node_id);\nCREATE INDEX IF NOT EXISTS idx_changes_lamport ON changes(lamport_time);\nCREATE INDEX IF NOT EXISTS idx_changes_wall_time ON changes(wall_time);\nCREATE INDEX IF NOT EXISTS idx_changes_batch ON changes(batch_id);\n\nCREATE INDEX IF NOT EXISTS idx_yjs_state_updated ON yjs_state(updated_at);\nCREATE INDEX IF NOT EXISTS idx_yjs_updates_node ON yjs_updates(node_id);\nCREATE INDEX IF NOT EXISTS idx_yjs_snapshots_node ON yjs_snapshots(node_id);\nCREATE INDEX IF NOT EXISTS idx_yjs_snapshots_timestamp ON yjs_snapshots(node_id, timestamp);\n\nCREATE INDEX IF NOT EXISTS idx_updates_doc ON updates(doc_id);\nCREATE INDEX IF NOT EXISTS idx_updates_created ON updates(created_at);\n";
+/**
+ * FTS5 schema for full-text search.
+ * This is applied separately because sql.js doesn't support FTS5.
+ */
+declare const SCHEMA_DDL_FTS = "\n-- ============================================\n-- Full-Text Search (FTS5)\n-- ============================================\n\n-- FTS index for searchable node content\nCREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(\n    node_id,\n    title,\n    content,\n    tokenize='porter unicode61'\n);\n\n-- Triggers to keep FTS in sync will be managed by application layer\n-- since the searchable content is derived from node properties\n";
+/**
+ * Unified SQLite schema for xNet.
+ * This schema is shared across all platforms (with FTS5).
+ * Use SCHEMA_DDL_CORE for platforms without FTS5 support (sql.js).
+ */
+declare const SCHEMA_DDL: string;
+/**
+ * Schema for future versions (migrations).
+ * Each key is the version number, value is the upgrade SQL.
+ */
+declare const SCHEMA_MIGRATIONS: Record<number, string>;
+/**
+ * Get the SQL to upgrade from one version to another.
+ */
+declare function getMigrationSQL(fromVersion: number, toVersion: number): string;
+
+export { SCHEMA_VERSION as S, SCHEMA_DDL as a, SCHEMA_DDL_CORE as b, SCHEMA_DDL_FTS as c, SCHEMA_MIGRATIONS as d, getMigrationSQL as g };

package/dist/types-C_aHfRDF.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @xnetjs/sqlite - Type definitions for unified SQLite adapter
+ */
+/**
+ * SQL parameter types that can be bound to statements.
+ */
+type SQLValue = string | number | bigint | Uint8Array | null;
+/**
+ * Row type for query results.
+ */
+type SQLRow = Record<string, SQLValue>;
+/**
+ * Result of a mutation query (INSERT, UPDATE, DELETE).
+ */
+interface RunResult {
+    /** Number of rows affected by the query */
+    changes: number;
+    /** Last inserted row ID (for INSERT with AUTOINCREMENT) */
+    lastInsertRowid: bigint;
+}
+/**
+ * Configuration options for SQLite database.
+ */
+interface SQLiteConfig {
+    /** Database file path or name */
+    path: string;
+    /** Enable WAL mode (default: true) */
+    walMode?: boolean;
+    /** Enable foreign keys (default: true) */
+    foreignKeys?: boolean;
+    /** Busy timeout in milliseconds (default: 5000) */
+    busyTimeout?: number;
+}
+/**
+ * Schema version information.
+ */
+interface SchemaVersion {
+    version: number;
+    appliedAt: number;
+}
+
+export type { RunResult as R, SQLValue as S, SQLRow as a, SQLiteConfig as b, SchemaVersion as c };