@jigx/core-sdk 1.0.0

package/dist/datasource/sqlite-normalizer.js

@@ -0,0 +1,194 @@
+import SqliteParser from 'node-sql-parser/build/sqlite.js';
+const SqlParserClass = SqliteParser.Parser;
+const SQLITE_OPT = { database: 'SQLite' };
+const TSQL_OPT = { database: 'TransactSQL' };
+const sqlParser = new SqlParserClass();
+function bracketsToBackticks(query) {
+    let result = '';
+    let i = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let inBacktick = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    while (i < query.length) {
+        const char = query[i];
+        const next = i + 1 < query.length ? query[i + 1] : '';
+        if (inLineComment) {
+            result += char;
+            if (char === '\n') {
+                inLineComment = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (inBlockComment) {
+            result += char;
+            if (char === '*' && next === '/') {
+                result += next;
+                inBlockComment = false;
+                i += 2;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        if (inSingleQuote) {
+            result += char;
+            if (char === "'" && next === "'") {
+                result += next;
+                i += 2;
+            }
+            else if (char === "'") {
+                inSingleQuote = false;
+                i += 1;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        if (inDoubleQuote) {
+            result += char;
+            if (char === '"' && next === '"') {
+                result += next;
+                i += 2;
+            }
+            else if (char === '"') {
+                inDoubleQuote = false;
+                i += 1;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        if (inBacktick) {
+            result += char;
+            if (char === '`' && next === '`') {
+                result += next;
+                i += 2;
+            }
+            else if (char === '`') {
+                inBacktick = false;
+                i += 1;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        if (char === '-' && next === '-') {
+            result += char + next;
+            inLineComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            result += char + next;
+            inBlockComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            result += char;
+            inSingleQuote = true;
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            result += char;
+            inDoubleQuote = true;
+            i += 1;
+            continue;
+        }
+        if (char === '`') {
+            result += char;
+            inBacktick = true;
+            i += 1;
+            continue;
+        }
+        if (char === '[') {
+            let inner = '';
+            let j = i + 1;
+            let closed = false;
+            while (j < query.length) {
+                if (query[j] === ']') {
+                    if (j + 1 < query.length && query[j + 1] === ']') {
+                        inner += ']';
+                        j += 2;
+                    }
+                    else {
+                        closed = true;
+                        j += 1;
+                        break;
+                    }
+                }
+                else {
+                    inner += query[j];
+                    j += 1;
+                }
+            }
+            if (closed) {
+                result += '`' + inner + '`';
+                i = j;
+                continue;
+            }
+            result += char;
+            i += 1;
+            continue;
+        }
+        result += char;
+        i += 1;
+    }
+    return result;
+}
+function makeJsonExtractNode(path) {
+    return {
+        type: 'function',
+        name: { name: [{ type: 'default', value: 'json_extract' }] },
+        args: {
+            type: 'expr_list',
+            value: [
+                { type: 'column_ref', table: null, column: 'data', collate: null },
+                { type: 'single_quote_string', value: path },
+            ],
+        },
+        over: null,
+    };
+}
+function expandShorthandInAst(node) {
+    if (node === null || typeof node !== 'object')
+        return node;
+    const obj = node;
+    if (obj.type === 'single_quote_string' &&
+        typeof obj.value === 'string' &&
+        obj.value.startsWith('$.')) {
+        return makeJsonExtractNode(obj.value);
+    }
+    if (obj.type === 'function') {
+        const nameArr = obj.name?.name;
+        if (nameArr?.[0]?.value === 'json_extract')
+            return node;
+    }
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+        result[key] = Array.isArray(val) ? val.map(expandShorthandInAst) : expandShorthandInAst(val);
+    }
+    return result;
+}
+function lowercaseIdentifiers(query) {
+    const parts = query.split(/(\'(?:[^\']|\'\')*\')/g);
+    return parts.map((part, i) => (i % 2 === 0 ? part.toLowerCase() : part)).join('');
+}
+export function normalizeQuery(query) {
+    const preprocessed = bracketsToBackticks(query);
+    const ast = sqlParser.astify(preprocessed, SQLITE_OPT);
+    const transformed = Array.isArray(ast) ? ast.map(expandShorthandInAst) : expandShorthandInAst(ast);
+    return sqlParser.sqlify(transformed, TSQL_OPT);
+}
+export function queriesEquivalent(a, b) {
+    return lowercaseIdentifiers(normalizeQuery(a)) === lowercaseIdentifiers(normalizeQuery(b));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqlite-normalizer.js","sourceRoot":"","sources":["../../src/datasource/sqlite-normalizer.ts"],"names":[],"mappings":"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","sourcesContent":["import { type AST } from 'node-sql-parser'\nimport SqliteParser from 'node-sql-parser/build/sqlite.js'\n\nconst SqlParserClass = SqliteParser.Parser\n\n// Use SQLite grammar for parsing; output with TransactSQL bracket quoting.\n// The SQLite build does not accept [bracket] quoting as input, so we pre-process\n// [foo] → `foo` (backtick), which the SQLite grammar accepts and normalizes to \"foo\".\n// sqlify with TransactSQL opts then re-emits all identifiers as [foo].\nconst SQLITE_OPT = { database: 'SQLite' }\nconst TSQL_OPT = { database: 'TransactSQL' }\nconst sqlParser = new SqlParserClass()\n\n/** Convert [bracket] identifiers to backtick so the SQLite parser accepts them. */\nfunction bracketsToBackticks(query: string): string {\n  let result = ''\n  let i = 0\n\n  let inSingleQuote = false\n  let inDoubleQuote = false\n  let inBacktick = false\n  let inLineComment = false\n  let inBlockComment = false\n\n  while (i < query.length) {\n    const char = query[i]\n    const next = i + 1 < query.length ? query[i + 1] : ''\n\n    // Handle end of line comment\n    if (inLineComment) {\n      result += char\n      if (char === '\\n') {\n        inLineComment = false\n      }\n      i += 1\n      continue\n    }\n\n    // Handle end of block comment\n    if (inBlockComment) {\n      result += char\n      if (char === '*' && next === '/') {\n        result += next\n        inBlockComment = false\n        i += 2\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle single-quoted strings, preserving content verbatim.\n    if (inSingleQuote) {\n      result += char\n      if (char === \"'\" && next === \"'\") {\n        // Escaped single quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === \"'\") {\n        inSingleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle double-quoted identifiers/strings.\n    if (inDoubleQuote) {\n      result += char\n      if (char === '\"' && next === '\"') {\n        // Escaped double quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === '\"') {\n        inDoubleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle backtick-quoted identifiers.\n    if (inBacktick) {\n      result += char\n      if (char === '`' && next === '`') {\n        // Escaped backtick: consume both backticks.\n        result += next\n        i += 2\n      } else if (char === '`') {\n        inBacktick = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // We are not currently inside a string or comment.\n    // Check for start of comments first.\n    if (char === '-' && next === '-') {\n      result += char + next\n      inLineComment = true\n      i += 2\n      continue\n    }\n\n    if (char === '/' && next === '*') {\n      result += char + next\n      inBlockComment = true\n      i += 2\n      continue\n    }\n\n    // Check for start of strings / quoted identifiers.\n    if (char === \"'\") {\n      result += char\n      inSingleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '\"') {\n      result += char\n      inDoubleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '`') {\n      result += char\n      inBacktick = true\n      i += 1\n      continue\n    }\n\n    // Perform [bracket] → `backtick` replacement only outside literals/comments.\n    // Handle ]] as escaped ] inside bracket-quoted identifiers (like '' in strings).\n    if (char === '[') {\n      let inner = ''\n      let j = i + 1\n      let closed = false\n      while (j < query.length) {\n        if (query[j] === ']') {\n          if (j + 1 < query.length && query[j + 1] === ']') {\n            // Escaped ]] → literal ]\n            inner += ']'\n            j += 2\n          } else {\n            // Closing bracket\n            closed = true\n            j += 1\n            break\n          }\n        } else {\n          inner += query[j]\n          j += 1\n        }\n      }\n      if (closed) {\n        result += '`' + inner + '`'\n        i = j\n        continue\n      }\n      // No matching ']' found — treat as a normal character.\n      result += char\n      i += 1\n      continue\n    }\n\n    // Default: copy character as-is.\n    result += char\n    i += 1\n  }\n\n  return result\n}\n\n/** Build a json_extract(data, path) AST function-call node. */\nfunction makeJsonExtractNode(path: string): object {\n  return {\n    type: 'function',\n    name: { name: [{ type: 'default', value: 'json_extract' }] },\n    args: {\n      type: 'expr_list',\n      value: [\n        { type: 'column_ref', table: null, column: 'data', collate: null },\n        { type: 'single_quote_string', value: path },\n      ],\n    },\n    over: null,\n  }\n}\n\n/**\n * Recursively walk an AST node tree, replacing bare `'$.path'` string-literal\n * nodes with json_extract function-call nodes. Existing json_extract calls are\n * left untouched so shorthand is never double-expanded.\n */\nfunction expandShorthandInAst(node: unknown): unknown {\n  if (node === null || typeof node !== 'object') return node\n\n  const obj = node as Record<string, unknown>\n\n  // Bare shorthand: single_quote_string whose value starts with '$.'\n  if (\n    obj.type === 'single_quote_string' &&\n    typeof obj.value === 'string' &&\n    obj.value.startsWith('$.')\n  ) {\n    return makeJsonExtractNode(obj.value)\n  }\n\n  // Skip args of existing json_extract calls — they are already expanded.\n  if (obj.type === 'function') {\n    const nameArr = (obj.name as Record<string, unknown>)?.name as\n      | Array<Record<string, unknown>>\n      | undefined\n    if (nameArr?.[0]?.value === 'json_extract') return node\n  }\n\n  // Recurse into all child properties.\n  const result: Record<string, unknown> = {}\n  for (const [key, val] of Object.entries(obj)) {\n    result[key] = Array.isArray(val) ? val.map(expandShorthandInAst) : expandShorthandInAst(val)\n  }\n  return result\n}\n\n/**\n * Lowercase non-literal content for case-insensitive comparison.\n * Single-quoted string literals are preserved verbatim.\n */\nfunction lowercaseIdentifiers(query: string): string {\n  const parts = query.split(/(\\'(?:[^\\']|\\'\\')*\\')/g)\n  return parts.map((part, i) => (i % 2 === 0 ? part.toLowerCase() : part)).join('')\n}\n\n/**\n * Normalize a SQL query to a canonical, reusable form.\n *\n * Applies the following transformations:\n * 1. Convert `[bracket]` identifiers to backtick for parser input\n * 2. Parse with the SQLite grammar (strips comments, validates structure)\n * 3. Expand `'$.path'` shorthand to `json_extract(data, '$.path')` via AST walk\n * 4. Re-emit with TransactSQL bracket quoting — all identifiers become `[name]`\n *    and SQL keywords are uppercased\n *\n * The result is valid SQL suitable for reuse. Use `queriesEquivalent` for\n * case-insensitive comparison.\n *\n * @param query - SQL query to normalize\n * @returns Canonical form of the query\n */\nexport function normalizeQuery(query: string): string {\n  const preprocessed: string = bracketsToBackticks(query)\n  const ast: AST | AST[] = sqlParser.astify(preprocessed, SQLITE_OPT)\n  const transformed = Array.isArray(ast) ? ast.map(expandShorthandInAst) : expandShorthandInAst(ast)\n  return sqlParser.sqlify(transformed as AST | AST[], TSQL_OPT)\n}\n\n/**\n * Compare two SQL queries for semantic equivalence.\n *\n * Ignores differences in whitespace, keyword case, identifier case, square\n * bracket quoting, and the `'$.path'` json_extract shorthand. String literal\n * values are case-sensitive (`'Active'` ≠ `'active'`).\n *\n * @param a - First SQL query\n * @param b - Second SQL query\n * @returns true if the queries are semantically equivalent\n */\nexport function queriesEquivalent(a: string, b: string): boolean {\n  return lowercaseIdentifiers(normalizeQuery(a)) === lowercaseIdentifiers(normalizeQuery(b))\n}\n"]}

package/dist/datasource/sqlite-validator.d.ts

@@ -0,0 +1,28 @@
+import Database from 'better-sqlite3';
+export interface MultiTableValidationResult {
+    readonly db: Database.Database;
+    readonly tables: Map<string, {
+        readonly safeName: string;
+        readonly normalizedName: string;
+    }>;
+}
+export declare function validateColumnName(name: string): void;
+export declare function validateTableName(name: string): string;
+declare function safeTableName(tableName: string): string;
+export declare const __testOnly__: {
+    readonly safeTableName: typeof safeTableName;
+};
+export declare function replaceParameters(query: string): string;
+export declare function replaceTableName(query: string, originalName: string, safeName: string): string;
+export declare function createValidationDatabase(tableNames: string[], options?: {
+    additionalColumns?: string[];
+}): MultiTableValidationResult;
+export declare function stripSqlComments(query: string): string;
+export declare function validateSelectQuery(db: Database.Database, query: string): Database.Statement;
+export declare function extractColumns(stmt: Database.Statement): string[];
+export declare function validateRequiredColumns(columns: string[], requiredColumns: string[]): {
+    isValid: boolean;
+    missing: string[];
+};
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqlite-validator.d.ts","sourceRoot":"","sources":["../../src/datasource/sqlite-validator.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AAkGrC,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7F;AA8BD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmDrD;AAsCD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0DtD;AAeD,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAQhD;AAMD,eAAO,MAAM,YAAY;;CAEf,CAAA;AASV,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKvD;AAYD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwB9F;AA2BD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE;IACP,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB,GACL,0BAA0B,CA+C5B;AAkBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAwBD,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAgC5F;AAQD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,EAAE,CAEjE;AAkBD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,eAAe,EAAE,MAAM,EAAE,GACxB;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAQA","sourcesContent":["import Database from 'better-sqlite3'\nimport {\n  CommonNameMixedRegex,\n  isSqliteSystemTable,\n  type SystemSqliteTableName,\n} from '../abstract/zod.types.js'\n\n/**\n * SQLite Security Validation Utilities\n *\n * This module leverages SQLite's built-in security features for validation:\n *\n * 1. **SQLite's Hardened Parser** (db.prepare())\n *    - Battle-tested SQL parser used by millions of applications\n *    - Validates query syntax without execution\n *    - Reference: https://sqlite.org/lang.html, https://sqlite.org/security.html\n *\n * 2. **better-sqlite3 Multiple Statement Protection**\n *    - Prepared statements (db.prepare) block multiple SQL statements\n *    - Prevents injection via statement chaining: `'; DROP TABLE users; --`\n *    - Throws RangeError if multiple statements detected\n *\n * 3. **SQLite Bracket-Quoting** ([identifier])\n *    - Safe identifier quoting mechanism built into SQLite\n *    - Protects against reserved keywords and special characters\n *    - Supports escape via ]] for literal ] character\n *\n * 4. **SQLite Expression Limits** (SQLITE_LIMIT_EXPR_DEPTH = 1000)\n *    - Built-in DoS protection against deeply nested expressions\n *    - Reference: https://sqlite.org/limits.html\n *\n * 5. **Prepared Statement Parameter Binding**\n *    - better-sqlite3 automatically escapes bound parameters\n *    - Prevents injection by separating code from data\n *\n * Additional layers: Custom validation (validateTableName, validateColumnName)\n * provides allowlist-based identifier validation before using SQLite features.\n */\n\nconst COLUMN_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ .-]{0,127}$/\nconst COLUMN_FORBIDDEN_CHARS = /['\"`;()\\\\]/\nconst DEFAULT_SCHEMA = 'default'\nconst SCHEMA_SEPARATOR = '/'\nconst MAX_POST_ESCAPE = 80\nconst RESERVED_COLUMNS = new Set(['id', 'data'])\nconst TABLE_TRANSFORMATIONS: Array<[RegExp, string]> = [\n  [/\\//g, '__jx__'],\n  [/-/g, '_jx_'],\n]\nconst BLOCK_COMMENT_REGEX = /\\/\\*[\\s\\S]*?\\*\\//g\nconst LINE_COMMENT_REGEX = /--[^\\n]*/g\n\n/**\n * Matches external package table format: [packageName].[tableName]\n *\n * Example: \"[myPackage].[myTable]\"\n * - Group 1: packageName (characters between first pair of brackets)\n * - Group 2: tableName (characters between second pair of brackets)\n */\nconst EXTERNAL_PACKAGE_TABLE_PATTERN = /^\\[([^\\]]+)\\]\\.\\[([^\\]]+)\\]$/\n\n/**\n * System table schemas from platform database migrations.\n * Source: jigx/packages/datastore/src/database/migrations/solution/\n *\n * These schemas are used to create accurate validation databases for system tables.\n */\nconst SYSTEM_TABLE_SCHEMAS: Record<SystemSqliteTableName, string> = {\n  // Source: 003_sync_status_and_scope.sql.ts\n  _syncScope: `\n    [id]            TEXT NOT NULL PRIMARY KEY,\n    [timestamp]     INTEGER,\n    [state]         TEXT,\n    [notStarted]    INTEGER DEFAULT(0),\n    [syncing]       INTEGER DEFAULT(0),\n    [synced]        INTEGER DEFAULT(0),\n    [failed]        INTEGER DEFAULT(0),\n    [lastStartedAt] INTEGER NULL,\n    [lastFailedAt]  INTEGER NULL,\n    [lastSyncedAt]  INTEGER NULL,\n    [details]       TEXT NULL\n  `,\n  // Source: 001_initial.sql.ts\n  _commandQueue: `\n    [id]         INTEGER NOT NULL PRIMARY KEY,\n    [queue]      TEXT NOT NULL,\n    [type]       TEXT NOT NULL,\n    [payload]    TEXT NULL,\n    [state]      TEXT NULL,\n    [error]      TEXT NULL,\n    [retryCount] INTEGER NULL,\n    [retryAfter] INTEGER NULL\n  `,\n}\n\n/**\n * Return type for createValidationDatabase\n */\nexport interface MultiTableValidationResult {\n  readonly db: Database.Database\n  readonly tables: Map<string, { readonly safeName: string; readonly normalizedName: string }>\n}\n\n/**\n * Validate that a column name is a safe SQL identifier.\n * Prevents SQL injection by ensuring column names follow strict rules.\n *\n * Rules:\n * - Cannot be empty\n * - Must start with a letter (a-z, A-Z) or underscore\n * - Can contain printable ASCII: letters, numbers, underscore, hyphen, period, space\n * - Maximum 128 characters total (1 start character + up to 127 additional characters)\n * - Cannot contain dangerous sequences: --, /*, *\\/\n * - Cannot contain injection characters: quotes, semicolons, parentheses, backslashes\n * - SQL reserved keywords are allowed (will be automatically quoted with brackets)\n *\n * @param name - Column name to validate\n * @throws Error if column name is invalid or potentially dangerous\n *\n * @example\n * ```typescript\n * validateColumnName('user_id')      // ✅ Valid\n * validateColumnName('First Name')   // ✅ Valid (space allowed)\n * validateColumnName('created-at')   // ✅ Valid (hyphen allowed)\n * validateColumnName('user.email')   // ✅ Valid (period allowed)\n * validateColumnName('select')       // ✅ Valid (keyword, will be quoted as [select])\n * validateColumnName('foo--bar')     // ❌ Throws (-- is SQL comment marker)\n * validateColumnName('123abc')       // ❌ Throws (starts with number)\n * validateColumnName('x; DROP')      // ❌ Throws (contains semicolon)\n * ```\n */\nexport function validateColumnName(name: string): void {\n  // Check for non-string values\n  if (typeof name !== 'string') {\n    throw new Error(`Column name must be a string, got: ${typeof name}`)\n  }\n\n  // Check for empty string\n  if (name === '') {\n    throw new Error('Column name must be a non-empty string')\n  }\n\n  // Reject leading/trailing whitespace\n  if (hasOuterWhitespace(name)) {\n    throw new Error(`Invalid column name '${name}': cannot have leading or trailing spaces`)\n  }\n\n  // Block non-ASCII characters (only printable ASCII allowed for security/compatibility)\n\n  if (/[^\\x20-\\x7E]/.test(name)) {\n    throw new Error(`Invalid column name '${name}': only ASCII characters are allowed`)\n  }\n\n  // Validate basic pattern: letter/underscore followed by safe characters, max 128 chars\n  // Allows: letters, digits, underscore, hyphen, period, space\n  if (!COLUMN_NAME_PATTERN.test(name)) {\n    throw new Error(\n      `Invalid column name: must start with letter or underscore, contain only letters/numbers/spaces/hyphens/periods/underscores, max 128 chars`,\n    )\n  }\n\n  // Block SQL comment markers (even though we bracket-quote, defense-in-depth)\n  ensureDoesNotContain(\n    name,\n    '--',\n    `Invalid column name '${name}': cannot contain -- (SQL comment marker)`,\n  )\n  ensureDoesNotContainAny(\n    name,\n    ['/*', '*/'],\n    `Invalid column name '${name}': cannot contain /* or */ (SQL comment markers)`,\n  )\n\n  // Block SQL injection characters\n  if (COLUMN_FORBIDDEN_CHARS.test(name)) {\n    throw new Error(\n      `Invalid column name '${name}': cannot contain quotes (', \", \\`), semicolons, parentheses, or backslashes`,\n    )\n  }\n\n  // Note: SQL reserved keywords (SELECT, WHERE, etc.) pass validation\n  // They are automatically quoted with brackets [keyword] during table creation\n}\n\n/**\n * Validate that a table name is a safe SQL identifier.\n * Prevents SQL injection by ensuring table names follow strict rules.\n * Validated names are used with SQLite's bracket-quoting syntax [name] for safe handling.\n *\n * IMPORTANT: This validates STRUCTURAL/META identifiers (table names), NOT data identifiers.\n * Data row identifiers (RID) use separate validation with 64-char limit for payload data.\n *\n * Validation occurs at TWO stages:\n * 1. PRE-TRANSFORMATION: Input validation (structural correctness)\n * 2. POST-TRANSFORMATION: After escaping (/ → __jx__, - → _jx_) to ensure SQLite compatibility\n *\n * Rules (pre-transformation):\n * - Must start with a letter (a-z, A-Z)\n * - Can contain letters, numbers, underscores, forward slashes, hyphens\n * - Maximum 58 characters (default/ prefix 8 chars + table name 50 chars)\n * - Cannot contain brackets ] which could escape bracket-quoting\n * - Cannot be empty\n *\n * Rules (post-transformation):\n * - Transformed name must not exceed 80 characters\n * - Prevents SQLite identifier overflow after escaping\n *\n * @param name - Table name to validate\n * @returns Safe table name for SQLite (e.g., 'default__jx__expenses', 'foo_jx_bar')\n * @throws Error if table name is invalid or potentially dangerous\n *\n * @example\n * ```typescript\n * const safe = validateTableName('users')           // Returns 'users'\n * const safe = validateTableName('default/orders')  // Returns 'default__jx__orders'\n * const safe = validateTableName('foo-bar')         // Returns 'foo_jx_bar'\n * validateTableName('test] DROP')                   // Throws (bracket escape)\n * validateTableName('123abc')                       // Throws (starts with number)\n * ```\n */\nexport function validateTableName(name: string): string {\n  // Check for empty or non-string values\n  if (!name || typeof name !== 'string') {\n    throw new Error(`Table name must be a non-empty string, got: ${typeof name}`)\n  }\n\n  // Reject bracket characters that could escape SQLite's bracket-quoting\n  // SQLite uses [name] for identifiers, and ] would close the bracket early\n  // Allows us to safely use validated names in CREATE TABLE [${name}] statements\n  if (name.includes(']') || name.includes('[')) {\n    throw new Error(\n      `Invalid table name '${name}': cannot contain brackets [ or ] (bracket escape vulnerability)`,\n    )\n  }\n\n  // Block SQL comment markers (defense-in-depth even with bracket-quoting)\n  ensureDoesNotContain(\n    name,\n    '--',\n    `Invalid table name '${name}': cannot contain -- (SQL comment marker)`,\n  )\n\n  const { tableName, hasSchema } = extractTableName(name)\n\n  // Allow whitelisted system tables (e.g., _syncScope, _commandQueue)\n  if (isSqliteSystemTable(tableName)) {\n    // System tables bypass CommonNameMixedRegex validation but still get transformed\n    const transformedName = safeTableName(name)\n    if (transformedName.length > MAX_POST_ESCAPE) {\n      throw new Error(\n        `Invalid table name '${name}': after transformation becomes '${transformedName}' (${String(transformedName.length)} chars, max ${String(MAX_POST_ESCAPE)})`,\n      )\n    }\n    return transformedName\n  }\n\n  // Validate table name matches CommonNameMixedRegex\n  // (2-50 chars, alphanumeric/hyphens/underscores, starts/ends with letter or number)\n  if (!CommonNameMixedRegex.test(tableName)) {\n    const part = hasSchema ? `table part '${tableName}'` : `name`\n    throw new Error(\n      `Invalid table name '${name}': ${part} must be 2-50 characters, start with a letter, contain only letters/numbers/hyphens/underscores, and end with a letter or number`,\n    )\n  }\n\n  // POST-TRANSFORMATION VALIDATION: Ensure transformed name doesn't exceed limit\n  // Transformation expands characters: / → __jx__ (1 → 5 chars), - → _jx_ (1 → 4 chars)\n  // Example: 'default/foo-bar' (15 chars) → 'default__jx__foo_jx_bar' (23 chars)\n  // Limit accounts for bracket-quoting [name] added during CREATE TABLE\n  // Max: 58 chars (default/ + 50 char table name) + expansion + 2 brackets\n  const transformedName = safeTableName(name)\n  if (transformedName.length > MAX_POST_ESCAPE) {\n    throw new Error(\n      `Invalid table name '${name}': after transformation becomes '${transformedName}' (${String(transformedName.length)} chars, max ${String(MAX_POST_ESCAPE)})`,\n    )\n  }\n\n  return transformedName\n}\n\n/**\n * Transform table name to be SQLite parser-compatible.\n * - '/' -> '__jx__' (e.g., default/expenses)\n * - '-' -> '_jx_' (e.g., foo-bar)\n *\n * Internal transformation function used by validateTableName().\n * External callers should use validateTableName() which validates AND transforms.\n *\n * @param tableName - Original table name (e.g., 'default/expenses', 'foo-bar')\n * @returns Safe table name for SQLite (e.g., 'default__jx__expenses', 'foo_jx_bar')\n *\n * @internal - Access via __testOnly__ export for testing\n */\nfunction safeTableName(tableName: string): string {\n  const needsTransform = TABLE_TRANSFORMATIONS.some(([pattern]) => pattern.test(tableName))\n  if (!needsTransform) return tableName\n\n  return TABLE_TRANSFORMATIONS.reduce(\n    (current, [pattern, replacement]) => current.replace(pattern, replacement),\n    tableName,\n  )\n}\n\n/**\n * Testing-only exports - not part of public API\n * Access internal functions for unit testing transformation logic\n */\nexport const __testOnly__ = {\n  safeTableName,\n} as const\n\n/**\n * Replace query parameters ($param or @param) with '?' placeholders for validation.\n * SQLite's parser requires positional parameters for query preparation.\n *\n * @param query - SQL query with named parameters\n * @returns Query with positional placeholders\n */\nexport function replaceParameters(query: string): string {\n  // SQLite's parser does not support named parameters like $param or @param in the same way as other databases.\n  // To validate the query syntax without providing parameter values, we replace $param and @param with '?'.\n  // This ensures compatibility with SQLite's parser during query validation.\n  return query.replace(/[$@](\\w+)/g, '?')\n}\n\n/**\n * Replace table names in query with safe names for validation.\n *\n * Security: Guards against empty string which would cause regex to match entire query.\n *\n * @param query - Original SQL query\n * @param originalName - Original table name\n * @param safeName - Safe table name\n * @returns Query with replaced table names\n */\nexport function replaceTableName(query: string, originalName: string, safeName: string): string {\n  // Guard against empty inputs which would cause regex issues\n  if (!query || !originalName || !safeName || originalName === safeName) {\n    return query\n  }\n\n  // Check if originalName is already bracketed (e.g., [package].[table])\n  // For these, do a direct replacement without adding more brackets\n  if (originalName.startsWith('[') && originalName.endsWith(']')) {\n    const escapedName = escapeRegExp(originalName)\n    return query.replace(new RegExp(escapedName, 'g'), `[${safeName}]`)\n  }\n\n  // Escape special regex characters in table name\n  const escapedName = escapeRegExp(originalName)\n\n  // Replace unquoted table-name with safe-name (using word boundaries)\n  return (\n    query\n      // Replace [table-name] with [safe-name] (for SQL-escaped names)\n      .replace(new RegExp(`\\\\[${escapedName}\\\\]`, 'g'), `[${safeName}]`)\n      // Replace unquoted table-name with safe-name (using word boundaries)\n      .replace(new RegExp(`\\\\b${escapedName}\\\\b`, 'g'), safeName)\n  )\n}\n\n/**\n * Create in-memory SQLite database with tables for validation.\n * Creates tables with standard Jigx schema (id, data) plus optional additional columns.\n *\n * @param tableNames - Array of table names to create\n * @param options - Schema options\n * @param options.additionalColumns - Additional column names to include (all created as TEXT)\n * @returns Database instance with table info map (caller must close it)\n *\n * @example\n * ```typescript\n * // Single table\n * const { db, tables } = createValidationDatabase(['users'])\n * tables.get('users') // { safeName: 'users', normalizedName: 'users' }\n *\n * // Multiple tables\n * const { db, tables } = createValidationDatabase(['users', 'default/orders'])\n * tables.get('default/orders') // { safeName: 'default__jx__orders', normalizedName: 'default/orders' }\n *\n * // With additional columns\n * const { db, tables } = createValidationDatabase(['items'], {\n *   additionalColumns: ['name', 'value', 'label', 'icon']\n * })\n * ```\n */\nexport function createValidationDatabase(\n  tableNames: string[],\n  options: {\n    additionalColumns?: string[]\n  } = {},\n): MultiTableValidationResult {\n  const db = new Database(':memory:')\n  const { additionalColumns = [] } = options\n  const columns = buildColumnDefinitions(additionalColumns)\n  const tables = new Map<string, { readonly safeName: string; readonly normalizedName: string }>()\n\n  for (const tableName of tableNames) {\n    // Check for external package format: [package].[table]\n    const packageMatch = EXTERNAL_PACKAGE_TABLE_PATTERN.exec(tableName)\n    if (packageMatch) {\n      // External package table - create with package_table format for validation\n      const [, packageName, entityName] = packageMatch\n      const safeName = `${packageName.replace(/-/g, '_')}_${entityName}`\n      // Use the original bracketed format as normalizedName for query replacement\n      const normalizedName = tableName\n\n      db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${columns.join(', ')})`)\n      tables.set(tableName, { safeName, normalizedName })\n      continue\n    }\n\n    const normalizedName = stripWrappingBrackets(tableName)\n\n    // System tables bypass name validation and use platform schemas\n    if (isSqliteSystemTable(normalizedName)) {\n      const safeName = normalizedName // System tables don't need transformation\n      const schema = SYSTEM_TABLE_SCHEMAS[normalizedName]\n      if (!schema) {\n        throw new Error(\n          `System table '${normalizedName}' is whitelisted but missing schema definition. ` +\n            `Add schema to SYSTEM_TABLE_SCHEMAS (source: jigx/packages/datastore/src/database/migrations/solution/)`,\n        )\n      }\n      db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${schema})`)\n      tables.set(tableName, { safeName, normalizedName })\n      continue\n    }\n\n    const safeName = validateTableName(normalizedName)\n\n    db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${columns.join(', ')})`)\n\n    // Store mapping with original table name as key\n    tables.set(tableName, { safeName, normalizedName })\n  }\n\n  return { db, tables }\n}\n\n/**\n * Strip SQL comments from query to prevent comment-based bypasses.\n * Removes both line comments (--) and block comments (slash-star notation).\n *\n * @param query - SQL query with potential comments\n * @returns Query with comments removed\n *\n * @example\n * ```typescript\n * stripSqlComments('/* comment *\\/ SELECT * FROM users')\n * // Returns: ' SELECT * FROM users'\n *\n * stripSqlComments('-- comment\\nSELECT * FROM users')\n * // Returns: '\\nSELECT * FROM users'\n * ```\n */\nexport function stripSqlComments(query: string): string {\n  return query.replace(BLOCK_COMMENT_REGEX, ' ').replace(LINE_COMMENT_REGEX, ' ')\n}\n\n/**\n * Validate SQL SELECT query syntax and return prepared statement.\n * Throws error if query is invalid or not a SELECT.\n *\n * Security: Blocks PRAGMA commands and non-SELECT statements to prevent\n * information disclosure and unauthorized database operations.\n * Strips comments before checking to prevent comment-based bypasses.\n *\n * @param db - SQLite database instance\n * @param query - SQL query to validate\n * @returns Prepared statement\n * @throws Error if query is invalid, not SELECT, or is PRAGMA\n *\n * @example\n * ```typescript\n * validateSelectQuery(db, 'SELECT * FROM users')           // ✅ Allowed\n * validateSelectQuery(db, 'SELECT * FROM users WHERE id=1') // ✅ Allowed\n * validateSelectQuery(db, 'INSERT INTO users ...')          // ❌ Throws\n * validateSelectQuery(db, 'PRAGMA table_info(users)')       // ❌ Throws (info disclosure)\n * validateSelectQuery(db, '/* comment *\\/ PRAGMA ...')      // ❌ Throws (comment stripped first)\n * ```\n */\nexport function validateSelectQuery(db: Database.Database, query: string): Database.Statement {\n  // Trim and normalize whitespace for checking\n  const trimmed = query.trim()\n\n  if (!trimmed) {\n    throw new Error('Query cannot be empty')\n  }\n\n  // Strip comments before checking for PRAGMA to prevent comment-based bypasses\n  // Examples of bypasses: /* comment */ PRAGMA, -- comment\\nPRAGMA\n  const noComments = stripSqlComments(trimmed).trim()\n\n  // Block PRAGMA commands explicitly (they are marked as \"reader\" but expose system info)\n  // PRAGMA can leak database schema, table structure, and configuration\n  // Examples: PRAGMA table_info(), PRAGMA database_list, PRAGMA schema.table_info()\n  const upperQuery = noComments.toUpperCase()\n  if (upperQuery.startsWith('PRAGMA')) {\n    throw new Error('PRAGMA commands are not allowed in datasources')\n  }\n\n  // Validate query syntax without executing - just prepare the statement\n  // Uses SQLite's hardened parser (battle-tested over decades) to validate syntax\n  // This checks SQL syntax without needing parameter values\n  const stmt = db.prepare(query)\n\n  // Ensure it's a SELECT query (reader = true means read-only)\n  // Note: PRAGMA is also marked as reader, hence the explicit check above\n  if (!stmt.reader) {\n    throw new Error('Only SELECT queries are allowed in datasources')\n  }\n\n  return stmt\n}\n\n/**\n * Extract column names from prepared statement.\n *\n * @param stmt - Prepared SQLite statement\n * @returns Array of lowercase column names\n */\nexport function extractColumns(stmt: Database.Statement): string[] {\n  return stmt.columns().map((col) => col.name.toLowerCase())\n}\n\n/**\n * Validate that query returns required columns.\n *\n * @param columns - Column names from query (lowercase)\n * @param requiredColumns - Required column names (lowercase)\n * @returns Object with validation result and missing columns\n *\n * @example\n * ```typescript\n * // Validate dropdown columns\n * const result = validateRequiredColumns(columns, ['value', 'label'])\n *\n * // Validate custom columns\n * const result = validateRequiredColumns(columns, ['id', 'name', 'email'])\n * ```\n */\nexport function validateRequiredColumns(\n  columns: string[],\n  requiredColumns: string[],\n): {\n  isValid: boolean\n  missing: string[]\n} {\n  const columnSet = new Set(columns)\n  const missing = requiredColumns.filter((required) => !columnSet.has(required))\n\n  return {\n    isValid: missing.length === 0,\n    missing,\n  }\n}\n\nfunction hasOuterWhitespace(value: string): boolean {\n  return value.trim() !== value\n}\n\nfunction ensureDoesNotContain(value: string, token: string, errorMessage: string): void {\n  if (value.includes(token)) {\n    throw new Error(errorMessage)\n  }\n}\n\nfunction ensureDoesNotContainAny(value: string, tokens: string[], errorMessage: string): void {\n  if (tokens.some((token) => value.includes(token))) {\n    throw new Error(errorMessage)\n  }\n}\n\nfunction extractTableName(name: string): { tableName: string; hasSchema: boolean } {\n  const parts = name.split(SCHEMA_SEPARATOR)\n\n  if (parts.length === 1) {\n    return { tableName: name, hasSchema: false }\n  }\n\n  if (parts.length === 2) {\n    const [schema, table] = parts\n\n    if (schema !== DEFAULT_SCHEMA) {\n      throw new Error(\n        `Invalid table name '${name}': schema must be '${DEFAULT_SCHEMA}', got '${schema}'`,\n      )\n    }\n\n    return { tableName: table, hasSchema: true }\n  }\n\n  throw new Error(`Invalid table name '${name}': cannot contain multiple '/' separators`)\n}\n\nfunction stripWrappingBrackets(name: string): string {\n  return name.startsWith('[') && name.endsWith(']') ? name.slice(1, -1) : name\n}\n\nfunction buildColumnDefinitions(additionalColumns: string[]): string[] {\n  const uniqueColumns = Array.from(new Set(additionalColumns)).filter(\n    (column) => !RESERVED_COLUMNS.has(column),\n  )\n\n  const validatedColumns = uniqueColumns.map((column) => {\n    validateColumnName(column)\n    return `[${column}] TEXT`\n  })\n\n  return ['id TEXT PRIMARY KEY', 'data TEXT', 'file TEXT', ...validatedColumns]\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n"]}

package/dist/datasource/sqlite-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-validator.d.ts","sourceRoot":"","sources":["../../src/datasource/sqlite-validator.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AAkGrC,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7F;AA8BD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmDrD;AAsCD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0DtD;AAeD,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAQhD;AAMD,eAAO,MAAM,YAAY;;CAEf,CAAA;AASV,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKvD;AAYD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAwB9F;AA2BD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE;IACP,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB,GACL,0BAA0B,CA+C5B;AAkBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAwBD,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAgC5F;AAQD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,EAAE,CAEjE;AAkBD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,eAAe,EAAE,MAAM,EAAE,GACxB;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAQA","sourcesContent":["import Database from 'better-sqlite3'\nimport {\n  CommonNameMixedRegex,\n  isSqliteSystemTable,\n  type SystemSqliteTableName,\n} from '../abstract/zod.types.js'\n\n/**\n * SQLite Security Validation Utilities\n *\n * This module leverages SQLite's built-in security features for validation:\n *\n * 1. **SQLite's Hardened Parser** (db.prepare())\n *    - Battle-tested SQL parser used by millions of applications\n *    - Validates query syntax without execution\n *    - Reference: https://sqlite.org/lang.html, https://sqlite.org/security.html\n *\n * 2. **better-sqlite3 Multiple Statement Protection**\n *    - Prepared statements (db.prepare) block multiple SQL statements\n *    - Prevents injection via statement chaining: `'; DROP TABLE users; --`\n *    - Throws RangeError if multiple statements detected\n *\n * 3. **SQLite Bracket-Quoting** ([identifier])\n *    - Safe identifier quoting mechanism built into SQLite\n *    - Protects against reserved keywords and special characters\n *    - Supports escape via ]] for literal ] character\n *\n * 4. **SQLite Expression Limits** (SQLITE_LIMIT_EXPR_DEPTH = 1000)\n *    - Built-in DoS protection against deeply nested expressions\n *    - Reference: https://sqlite.org/limits.html\n *\n * 5. **Prepared Statement Parameter Binding**\n *    - better-sqlite3 automatically escapes bound parameters\n *    - Prevents injection by separating code from data\n *\n * Additional layers: Custom validation (validateTableName, validateColumnName)\n * provides allowlist-based identifier validation before using SQLite features.\n */\n\nconst COLUMN_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ .-]{0,127}$/\nconst COLUMN_FORBIDDEN_CHARS = /['\"`;()\\\\]/\nconst DEFAULT_SCHEMA = 'default'\nconst SCHEMA_SEPARATOR = '/'\nconst MAX_POST_ESCAPE = 80\nconst RESERVED_COLUMNS = new Set(['id', 'data'])\nconst TABLE_TRANSFORMATIONS: Array<[RegExp, string]> = [\n  [/\\//g, '__jx__'],\n  [/-/g, '_jx_'],\n]\nconst BLOCK_COMMENT_REGEX = /\\/\\*[\\s\\S]*?\\*\\//g\nconst LINE_COMMENT_REGEX = /--[^\\n]*/g\n\n/**\n * Matches external package table format: [packageName].[tableName]\n *\n * Example: \"[myPackage].[myTable]\"\n * - Group 1: packageName (characters between first pair of brackets)\n * - Group 2: tableName (characters between second pair of brackets)\n */\nconst EXTERNAL_PACKAGE_TABLE_PATTERN = /^\\[([^\\]]+)\\]\\.\\[([^\\]]+)\\]$/\n\n/**\n * System table schemas from platform database migrations.\n * Source: jigx/packages/datastore/src/database/migrations/solution/\n *\n * These schemas are used to create accurate validation databases for system tables.\n */\nconst SYSTEM_TABLE_SCHEMAS: Record<SystemSqliteTableName, string> = {\n  // Source: 003_sync_status_and_scope.sql.ts\n  _syncScope: `\n    [id]            TEXT NOT NULL PRIMARY KEY,\n    [timestamp]     INTEGER,\n    [state]         TEXT,\n    [notStarted]    INTEGER DEFAULT(0),\n    [syncing]       INTEGER DEFAULT(0),\n    [synced]        INTEGER DEFAULT(0),\n    [failed]        INTEGER DEFAULT(0),\n    [lastStartedAt] INTEGER NULL,\n    [lastFailedAt]  INTEGER NULL,\n    [lastSyncedAt]  INTEGER NULL,\n    [details]       TEXT NULL\n  `,\n  // Source: 001_initial.sql.ts\n  _commandQueue: `\n    [id]         INTEGER NOT NULL PRIMARY KEY,\n    [queue]      TEXT NOT NULL,\n    [type]       TEXT NOT NULL,\n    [payload]    TEXT NULL,\n    [state]      TEXT NULL,\n    [error]      TEXT NULL,\n    [retryCount] INTEGER NULL,\n    [retryAfter] INTEGER NULL\n  `,\n}\n\n/**\n * Return type for createValidationDatabase\n */\nexport interface MultiTableValidationResult {\n  readonly db: Database.Database\n  readonly tables: Map<string, { readonly safeName: string; readonly normalizedName: string }>\n}\n\n/**\n * Validate that a column name is a safe SQL identifier.\n * Prevents SQL injection by ensuring column names follow strict rules.\n *\n * Rules:\n * - Cannot be empty\n * - Must start with a letter (a-z, A-Z) or underscore\n * - Can contain printable ASCII: letters, numbers, underscore, hyphen, period, space\n * - Maximum 128 characters total (1 start character + up to 127 additional characters)\n * - Cannot contain dangerous sequences: --, /*, *\\/\n * - Cannot contain injection characters: quotes, semicolons, parentheses, backslashes\n * - SQL reserved keywords are allowed (will be automatically quoted with brackets)\n *\n * @param name - Column name to validate\n * @throws Error if column name is invalid or potentially dangerous\n *\n * @example\n * ```typescript\n * validateColumnName('user_id')      // ✅ Valid\n * validateColumnName('First Name')   // ✅ Valid (space allowed)\n * validateColumnName('created-at')   // ✅ Valid (hyphen allowed)\n * validateColumnName('user.email')   // ✅ Valid (period allowed)\n * validateColumnName('select')       // ✅ Valid (keyword, will be quoted as [select])\n * validateColumnName('foo--bar')     // ❌ Throws (-- is SQL comment marker)\n * validateColumnName('123abc')       // ❌ Throws (starts with number)\n * validateColumnName('x; DROP')      // ❌ Throws (contains semicolon)\n * ```\n */\nexport function validateColumnName(name: string): void {\n  // Check for non-string values\n  if (typeof name !== 'string') {\n    throw new Error(`Column name must be a string, got: ${typeof name}`)\n  }\n\n  // Check for empty string\n  if (name === '') {\n    throw new Error('Column name must be a non-empty string')\n  }\n\n  // Reject leading/trailing whitespace\n  if (hasOuterWhitespace(name)) {\n    throw new Error(`Invalid column name '${name}': cannot have leading or trailing spaces`)\n  }\n\n  // Block non-ASCII characters (only printable ASCII allowed for security/compatibility)\n\n  if (/[^\\x20-\\x7E]/.test(name)) {\n    throw new Error(`Invalid column name '${name}': only ASCII characters are allowed`)\n  }\n\n  // Validate basic pattern: letter/underscore followed by safe characters, max 128 chars\n  // Allows: letters, digits, underscore, hyphen, period, space\n  if (!COLUMN_NAME_PATTERN.test(name)) {\n    throw new Error(\n      `Invalid column name: must start with letter or underscore, contain only letters/numbers/spaces/hyphens/periods/underscores, max 128 chars`,\n    )\n  }\n\n  // Block SQL comment markers (even though we bracket-quote, defense-in-depth)\n  ensureDoesNotContain(\n    name,\n    '--',\n    `Invalid column name '${name}': cannot contain -- (SQL comment marker)`,\n  )\n  ensureDoesNotContainAny(\n    name,\n    ['/*', '*/'],\n    `Invalid column name '${name}': cannot contain /* or */ (SQL comment markers)`,\n  )\n\n  // Block SQL injection characters\n  if (COLUMN_FORBIDDEN_CHARS.test(name)) {\n    throw new Error(\n      `Invalid column name '${name}': cannot contain quotes (', \", \\`), semicolons, parentheses, or backslashes`,\n    )\n  }\n\n  // Note: SQL reserved keywords (SELECT, WHERE, etc.) pass validation\n  // They are automatically quoted with brackets [keyword] during table creation\n}\n\n/**\n * Validate that a table name is a safe SQL identifier.\n * Prevents SQL injection by ensuring table names follow strict rules.\n * Validated names are used with SQLite's bracket-quoting syntax [name] for safe handling.\n *\n * IMPORTANT: This validates STRUCTURAL/META identifiers (table names), NOT data identifiers.\n * Data row identifiers (RID) use separate validation with 64-char limit for payload data.\n *\n * Validation occurs at TWO stages:\n * 1. PRE-TRANSFORMATION: Input validation (structural correctness)\n * 2. POST-TRANSFORMATION: After escaping (/ → __jx__, - → _jx_) to ensure SQLite compatibility\n *\n * Rules (pre-transformation):\n * - Must start with a letter (a-z, A-Z)\n * - Can contain letters, numbers, underscores, forward slashes, hyphens\n * - Maximum 58 characters (default/ prefix 8 chars + table name 50 chars)\n * - Cannot contain brackets ] which could escape bracket-quoting\n * - Cannot be empty\n *\n * Rules (post-transformation):\n * - Transformed name must not exceed 80 characters\n * - Prevents SQLite identifier overflow after escaping\n *\n * @param name - Table name to validate\n * @returns Safe table name for SQLite (e.g., 'default__jx__expenses', 'foo_jx_bar')\n * @throws Error if table name is invalid or potentially dangerous\n *\n * @example\n * ```typescript\n * const safe = validateTableName('users')           // Returns 'users'\n * const safe = validateTableName('default/orders')  // Returns 'default__jx__orders'\n * const safe = validateTableName('foo-bar')         // Returns 'foo_jx_bar'\n * validateTableName('test] DROP')                   // Throws (bracket escape)\n * validateTableName('123abc')                       // Throws (starts with number)\n * ```\n */\nexport function validateTableName(name: string): string {\n  // Check for empty or non-string values\n  if (!name || typeof name !== 'string') {\n    throw new Error(`Table name must be a non-empty string, got: ${typeof name}`)\n  }\n\n  // Reject bracket characters that could escape SQLite's bracket-quoting\n  // SQLite uses [name] for identifiers, and ] would close the bracket early\n  // Allows us to safely use validated names in CREATE TABLE [${name}] statements\n  if (name.includes(']') || name.includes('[')) {\n    throw new Error(\n      `Invalid table name '${name}': cannot contain brackets [ or ] (bracket escape vulnerability)`,\n    )\n  }\n\n  // Block SQL comment markers (defense-in-depth even with bracket-quoting)\n  ensureDoesNotContain(\n    name,\n    '--',\n    `Invalid table name '${name}': cannot contain -- (SQL comment marker)`,\n  )\n\n  const { tableName, hasSchema } = extractTableName(name)\n\n  // Allow whitelisted system tables (e.g., _syncScope, _commandQueue)\n  if (isSqliteSystemTable(tableName)) {\n    // System tables bypass CommonNameMixedRegex validation but still get transformed\n    const transformedName = safeTableName(name)\n    if (transformedName.length > MAX_POST_ESCAPE) {\n      throw new Error(\n        `Invalid table name '${name}': after transformation becomes '${transformedName}' (${String(transformedName.length)} chars, max ${String(MAX_POST_ESCAPE)})`,\n      )\n    }\n    return transformedName\n  }\n\n  // Validate table name matches CommonNameMixedRegex\n  // (2-50 chars, alphanumeric/hyphens/underscores, starts/ends with letter or number)\n  if (!CommonNameMixedRegex.test(tableName)) {\n    const part = hasSchema ? `table part '${tableName}'` : `name`\n    throw new Error(\n      `Invalid table name '${name}': ${part} must be 2-50 characters, start with a letter, contain only letters/numbers/hyphens/underscores, and end with a letter or number`,\n    )\n  }\n\n  // POST-TRANSFORMATION VALIDATION: Ensure transformed name doesn't exceed limit\n  // Transformation expands characters: / → __jx__ (1 → 5 chars), - → _jx_ (1 → 4 chars)\n  // Example: 'default/foo-bar' (15 chars) → 'default__jx__foo_jx_bar' (23 chars)\n  // Limit accounts for bracket-quoting [name] added during CREATE TABLE\n  // Max: 58 chars (default/ + 50 char table name) + expansion + 2 brackets\n  const transformedName = safeTableName(name)\n  if (transformedName.length > MAX_POST_ESCAPE) {\n    throw new Error(\n      `Invalid table name '${name}': after transformation becomes '${transformedName}' (${String(transformedName.length)} chars, max ${String(MAX_POST_ESCAPE)})`,\n    )\n  }\n\n  return transformedName\n}\n\n/**\n * Transform table name to be SQLite parser-compatible.\n * - '/' -> '__jx__' (e.g., default/expenses)\n * - '-' -> '_jx_' (e.g., foo-bar)\n *\n * Internal transformation function used by validateTableName().\n * External callers should use validateTableName() which validates AND transforms.\n *\n * @param tableName - Original table name (e.g., 'default/expenses', 'foo-bar')\n * @returns Safe table name for SQLite (e.g., 'default__jx__expenses', 'foo_jx_bar')\n *\n * @internal - Access via __testOnly__ export for testing\n */\nfunction safeTableName(tableName: string): string {\n  const needsTransform = TABLE_TRANSFORMATIONS.some(([pattern]) => pattern.test(tableName))\n  if (!needsTransform) return tableName\n\n  return TABLE_TRANSFORMATIONS.reduce(\n    (current, [pattern, replacement]) => current.replace(pattern, replacement),\n    tableName,\n  )\n}\n\n/**\n * Testing-only exports - not part of public API\n * Access internal functions for unit testing transformation logic\n */\nexport const __testOnly__ = {\n  safeTableName,\n} as const\n\n/**\n * Replace query parameters ($param or @param) with '?' placeholders for validation.\n * SQLite's parser requires positional parameters for query preparation.\n *\n * @param query - SQL query with named parameters\n * @returns Query with positional placeholders\n */\nexport function replaceParameters(query: string): string {\n  // SQLite's parser does not support named parameters like $param or @param in the same way as other databases.\n  // To validate the query syntax without providing parameter values, we replace $param and @param with '?'.\n  // This ensures compatibility with SQLite's parser during query validation.\n  return query.replace(/[$@](\\w+)/g, '?')\n}\n\n/**\n * Replace table names in query with safe names for validation.\n *\n * Security: Guards against empty string which would cause regex to match entire query.\n *\n * @param query - Original SQL query\n * @param originalName - Original table name\n * @param safeName - Safe table name\n * @returns Query with replaced table names\n */\nexport function replaceTableName(query: string, originalName: string, safeName: string): string {\n  // Guard against empty inputs which would cause regex issues\n  if (!query || !originalName || !safeName || originalName === safeName) {\n    return query\n  }\n\n  // Check if originalName is already bracketed (e.g., [package].[table])\n  // For these, do a direct replacement without adding more brackets\n  if (originalName.startsWith('[') && originalName.endsWith(']')) {\n    const escapedName = escapeRegExp(originalName)\n    return query.replace(new RegExp(escapedName, 'g'), `[${safeName}]`)\n  }\n\n  // Escape special regex characters in table name\n  const escapedName = escapeRegExp(originalName)\n\n  // Replace unquoted table-name with safe-name (using word boundaries)\n  return (\n    query\n      // Replace [table-name] with [safe-name] (for SQL-escaped names)\n      .replace(new RegExp(`\\\\[${escapedName}\\\\]`, 'g'), `[${safeName}]`)\n      // Replace unquoted table-name with safe-name (using word boundaries)\n      .replace(new RegExp(`\\\\b${escapedName}\\\\b`, 'g'), safeName)\n  )\n}\n\n/**\n * Create in-memory SQLite database with tables for validation.\n * Creates tables with standard Jigx schema (id, data) plus optional additional columns.\n *\n * @param tableNames - Array of table names to create\n * @param options - Schema options\n * @param options.additionalColumns - Additional column names to include (all created as TEXT)\n * @returns Database instance with table info map (caller must close it)\n *\n * @example\n * ```typescript\n * // Single table\n * const { db, tables } = createValidationDatabase(['users'])\n * tables.get('users') // { safeName: 'users', normalizedName: 'users' }\n *\n * // Multiple tables\n * const { db, tables } = createValidationDatabase(['users', 'default/orders'])\n * tables.get('default/orders') // { safeName: 'default__jx__orders', normalizedName: 'default/orders' }\n *\n * // With additional columns\n * const { db, tables } = createValidationDatabase(['items'], {\n *   additionalColumns: ['name', 'value', 'label', 'icon']\n * })\n * ```\n */\nexport function createValidationDatabase(\n  tableNames: string[],\n  options: {\n    additionalColumns?: string[]\n  } = {},\n): MultiTableValidationResult {\n  const db = new Database(':memory:')\n  const { additionalColumns = [] } = options\n  const columns = buildColumnDefinitions(additionalColumns)\n  const tables = new Map<string, { readonly safeName: string; readonly normalizedName: string }>()\n\n  for (const tableName of tableNames) {\n    // Check for external package format: [package].[table]\n    const packageMatch = EXTERNAL_PACKAGE_TABLE_PATTERN.exec(tableName)\n    if (packageMatch) {\n      // External package table - create with package_table format for validation\n      const [, packageName, entityName] = packageMatch\n      const safeName = `${packageName.replace(/-/g, '_')}_${entityName}`\n      // Use the original bracketed format as normalizedName for query replacement\n      const normalizedName = tableName\n\n      db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${columns.join(', ')})`)\n      tables.set(tableName, { safeName, normalizedName })\n      continue\n    }\n\n    const normalizedName = stripWrappingBrackets(tableName)\n\n    // System tables bypass name validation and use platform schemas\n    if (isSqliteSystemTable(normalizedName)) {\n      const safeName = normalizedName // System tables don't need transformation\n      const schema = SYSTEM_TABLE_SCHEMAS[normalizedName]\n      if (!schema) {\n        throw new Error(\n          `System table '${normalizedName}' is whitelisted but missing schema definition. ` +\n            `Add schema to SYSTEM_TABLE_SCHEMAS (source: jigx/packages/datastore/src/database/migrations/solution/)`,\n        )\n      }\n      db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${schema})`)\n      tables.set(tableName, { safeName, normalizedName })\n      continue\n    }\n\n    const safeName = validateTableName(normalizedName)\n\n    db.exec(`CREATE TABLE IF NOT EXISTS [${safeName}] (${columns.join(', ')})`)\n\n    // Store mapping with original table name as key\n    tables.set(tableName, { safeName, normalizedName })\n  }\n\n  return { db, tables }\n}\n\n/**\n * Strip SQL comments from query to prevent comment-based bypasses.\n * Removes both line comments (--) and block comments (slash-star notation).\n *\n * @param query - SQL query with potential comments\n * @returns Query with comments removed\n *\n * @example\n * ```typescript\n * stripSqlComments('/* comment *\\/ SELECT * FROM users')\n * // Returns: ' SELECT * FROM users'\n *\n * stripSqlComments('-- comment\\nSELECT * FROM users')\n * // Returns: '\\nSELECT * FROM users'\n * ```\n */\nexport function stripSqlComments(query: string): string {\n  return query.replace(BLOCK_COMMENT_REGEX, ' ').replace(LINE_COMMENT_REGEX, ' ')\n}\n\n/**\n * Validate SQL SELECT query syntax and return prepared statement.\n * Throws error if query is invalid or not a SELECT.\n *\n * Security: Blocks PRAGMA commands and non-SELECT statements to prevent\n * information disclosure and unauthorized database operations.\n * Strips comments before checking to prevent comment-based bypasses.\n *\n * @param db - SQLite database instance\n * @param query - SQL query to validate\n * @returns Prepared statement\n * @throws Error if query is invalid, not SELECT, or is PRAGMA\n *\n * @example\n * ```typescript\n * validateSelectQuery(db, 'SELECT * FROM users')           // ✅ Allowed\n * validateSelectQuery(db, 'SELECT * FROM users WHERE id=1') // ✅ Allowed\n * validateSelectQuery(db, 'INSERT INTO users ...')          // ❌ Throws\n * validateSelectQuery(db, 'PRAGMA table_info(users)')       // ❌ Throws (info disclosure)\n * validateSelectQuery(db, '/* comment *\\/ PRAGMA ...')      // ❌ Throws (comment stripped first)\n * ```\n */\nexport function validateSelectQuery(db: Database.Database, query: string): Database.Statement {\n  // Trim and normalize whitespace for checking\n  const trimmed = query.trim()\n\n  if (!trimmed) {\n    throw new Error('Query cannot be empty')\n  }\n\n  // Strip comments before checking for PRAGMA to prevent comment-based bypasses\n  // Examples of bypasses: /* comment */ PRAGMA, -- comment\\nPRAGMA\n  const noComments = stripSqlComments(trimmed).trim()\n\n  // Block PRAGMA commands explicitly (they are marked as \"reader\" but expose system info)\n  // PRAGMA can leak database schema, table structure, and configuration\n  // Examples: PRAGMA table_info(), PRAGMA database_list, PRAGMA schema.table_info()\n  const upperQuery = noComments.toUpperCase()\n  if (upperQuery.startsWith('PRAGMA')) {\n    throw new Error('PRAGMA commands are not allowed in datasources')\n  }\n\n  // Validate query syntax without executing - just prepare the statement\n  // Uses SQLite's hardened parser (battle-tested over decades) to validate syntax\n  // This checks SQL syntax without needing parameter values\n  const stmt = db.prepare(query)\n\n  // Ensure it's a SELECT query (reader = true means read-only)\n  // Note: PRAGMA is also marked as reader, hence the explicit check above\n  if (!stmt.reader) {\n    throw new Error('Only SELECT queries are allowed in datasources')\n  }\n\n  return stmt\n}\n\n/**\n * Extract column names from prepared statement.\n *\n * @param stmt - Prepared SQLite statement\n * @returns Array of lowercase column names\n */\nexport function extractColumns(stmt: Database.Statement): string[] {\n  return stmt.columns().map((col) => col.name.toLowerCase())\n}\n\n/**\n * Validate that query returns required columns.\n *\n * @param columns - Column names from query (lowercase)\n * @param requiredColumns - Required column names (lowercase)\n * @returns Object with validation result and missing columns\n *\n * @example\n * ```typescript\n * // Validate dropdown columns\n * const result = validateRequiredColumns(columns, ['value', 'label'])\n *\n * // Validate custom columns\n * const result = validateRequiredColumns(columns, ['id', 'name', 'email'])\n * ```\n */\nexport function validateRequiredColumns(\n  columns: string[],\n  requiredColumns: string[],\n): {\n  isValid: boolean\n  missing: string[]\n} {\n  const columnSet = new Set(columns)\n  const missing = requiredColumns.filter((required) => !columnSet.has(required))\n\n  return {\n    isValid: missing.length === 0,\n    missing,\n  }\n}\n\nfunction hasOuterWhitespace(value: string): boolean {\n  return value.trim() !== value\n}\n\nfunction ensureDoesNotContain(value: string, token: string, errorMessage: string): void {\n  if (value.includes(token)) {\n    throw new Error(errorMessage)\n  }\n}\n\nfunction ensureDoesNotContainAny(value: string, tokens: string[], errorMessage: string): void {\n  if (tokens.some((token) => value.includes(token))) {\n    throw new Error(errorMessage)\n  }\n}\n\nfunction extractTableName(name: string): { tableName: string; hasSchema: boolean } {\n  const parts = name.split(SCHEMA_SEPARATOR)\n\n  if (parts.length === 1) {\n    return { tableName: name, hasSchema: false }\n  }\n\n  if (parts.length === 2) {\n    const [schema, table] = parts\n\n    if (schema !== DEFAULT_SCHEMA) {\n      throw new Error(\n        `Invalid table name '${name}': schema must be '${DEFAULT_SCHEMA}', got '${schema}'`,\n      )\n    }\n\n    return { tableName: table, hasSchema: true }\n  }\n\n  throw new Error(`Invalid table name '${name}': cannot contain multiple '/' separators`)\n}\n\nfunction stripWrappingBrackets(name: string): string {\n  return name.startsWith('[') && name.endsWith(']') ? name.slice(1, -1) : name\n}\n\nfunction buildColumnDefinitions(additionalColumns: string[]): string[] {\n  const uniqueColumns = Array.from(new Set(additionalColumns)).filter(\n    (column) => !RESERVED_COLUMNS.has(column),\n  )\n\n  const validatedColumns = uniqueColumns.map((column) => {\n    validateColumnName(column)\n    return `[${column}] TEXT`\n  })\n\n  return ['id TEXT PRIMARY KEY', 'data TEXT', 'file TEXT', ...validatedColumns]\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n"]}