@gjsify/sqlite 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# @gjsify/sqlite
+
+GJS implementation of the Node.js `sqlite` module.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/sqlite
+# or
+yarn add @gjsify/sqlite
+```
+
+## Usage
+
+```typescript
+import sqlite from '@gjsify/sqlite';
+```
+
+## License
+
+MIT

package/lib/esm/constants.js

@@ -0,0 +1,140 @@
+const SQLITE_CHANGESET_OMIT = 0;
+const SQLITE_CHANGESET_REPLACE = 1;
+const SQLITE_CHANGESET_ABORT = 2;
+const SQLITE_CHANGESET_DATA = 1;
+const SQLITE_CHANGESET_NOTFOUND = 2;
+const SQLITE_CHANGESET_CONFLICT = 3;
+const SQLITE_CHANGESET_CONSTRAINT = 4;
+const SQLITE_CHANGESET_FOREIGN_KEY = 5;
+const SQLITE_OK = 0;
+const SQLITE_DENY = 1;
+const SQLITE_IGNORE = 2;
+const SQLITE_CREATE_INDEX = 1;
+const SQLITE_CREATE_TABLE = 2;
+const SQLITE_CREATE_TEMP_INDEX = 3;
+const SQLITE_CREATE_TEMP_TABLE = 4;
+const SQLITE_CREATE_TEMP_TRIGGER = 5;
+const SQLITE_CREATE_TEMP_VIEW = 6;
+const SQLITE_CREATE_TRIGGER = 7;
+const SQLITE_CREATE_VIEW = 8;
+const SQLITE_DELETE = 9;
+const SQLITE_DROP_INDEX = 10;
+const SQLITE_DROP_TABLE = 11;
+const SQLITE_DROP_TEMP_INDEX = 12;
+const SQLITE_DROP_TEMP_TABLE = 13;
+const SQLITE_DROP_TEMP_TRIGGER = 14;
+const SQLITE_DROP_TEMP_VIEW = 15;
+const SQLITE_DROP_TRIGGER = 16;
+const SQLITE_DROP_VIEW = 17;
+const SQLITE_INSERT = 18;
+const SQLITE_PRAGMA = 19;
+const SQLITE_READ = 20;
+const SQLITE_SELECT = 21;
+const SQLITE_TRANSACTION = 22;
+const SQLITE_UPDATE = 23;
+const SQLITE_ATTACH = 24;
+const SQLITE_DETACH = 25;
+const SQLITE_ALTER_TABLE = 26;
+const SQLITE_REINDEX = 27;
+const SQLITE_ANALYZE = 28;
+const SQLITE_CREATE_VTABLE = 29;
+const SQLITE_DROP_VTABLE = 30;
+const SQLITE_FUNCTION = 31;
+const SQLITE_SAVEPOINT = 32;
+const SQLITE_COPY = 0;
+const SQLITE_RECURSIVE = 33;
+const constants = {
+  SQLITE_CHANGESET_OMIT,
+  SQLITE_CHANGESET_REPLACE,
+  SQLITE_CHANGESET_ABORT,
+  SQLITE_CHANGESET_DATA,
+  SQLITE_CHANGESET_NOTFOUND,
+  SQLITE_CHANGESET_CONFLICT,
+  SQLITE_CHANGESET_CONSTRAINT,
+  SQLITE_CHANGESET_FOREIGN_KEY,
+  SQLITE_OK,
+  SQLITE_DENY,
+  SQLITE_IGNORE,
+  SQLITE_CREATE_INDEX,
+  SQLITE_CREATE_TABLE,
+  SQLITE_CREATE_TEMP_INDEX,
+  SQLITE_CREATE_TEMP_TABLE,
+  SQLITE_CREATE_TEMP_TRIGGER,
+  SQLITE_CREATE_TEMP_VIEW,
+  SQLITE_CREATE_TRIGGER,
+  SQLITE_CREATE_VIEW,
+  SQLITE_DELETE,
+  SQLITE_DROP_INDEX,
+  SQLITE_DROP_TABLE,
+  SQLITE_DROP_TEMP_INDEX,
+  SQLITE_DROP_TEMP_TABLE,
+  SQLITE_DROP_TEMP_TRIGGER,
+  SQLITE_DROP_TEMP_VIEW,
+  SQLITE_DROP_TRIGGER,
+  SQLITE_DROP_VIEW,
+  SQLITE_INSERT,
+  SQLITE_PRAGMA,
+  SQLITE_READ,
+  SQLITE_SELECT,
+  SQLITE_TRANSACTION,
+  SQLITE_UPDATE,
+  SQLITE_ATTACH,
+  SQLITE_DETACH,
+  SQLITE_ALTER_TABLE,
+  SQLITE_REINDEX,
+  SQLITE_ANALYZE,
+  SQLITE_CREATE_VTABLE,
+  SQLITE_DROP_VTABLE,
+  SQLITE_FUNCTION,
+  SQLITE_SAVEPOINT,
+  SQLITE_COPY,
+  SQLITE_RECURSIVE
+};
+export {
+  SQLITE_ALTER_TABLE,
+  SQLITE_ANALYZE,
+  SQLITE_ATTACH,
+  SQLITE_CHANGESET_ABORT,
+  SQLITE_CHANGESET_CONFLICT,
+  SQLITE_CHANGESET_CONSTRAINT,
+  SQLITE_CHANGESET_DATA,
+  SQLITE_CHANGESET_FOREIGN_KEY,
+  SQLITE_CHANGESET_NOTFOUND,
+  SQLITE_CHANGESET_OMIT,
+  SQLITE_CHANGESET_REPLACE,
+  SQLITE_COPY,
+  SQLITE_CREATE_INDEX,
+  SQLITE_CREATE_TABLE,
+  SQLITE_CREATE_TEMP_INDEX,
+  SQLITE_CREATE_TEMP_TABLE,
+  SQLITE_CREATE_TEMP_TRIGGER,
+  SQLITE_CREATE_TEMP_VIEW,
+  SQLITE_CREATE_TRIGGER,
+  SQLITE_CREATE_VIEW,
+  SQLITE_CREATE_VTABLE,
+  SQLITE_DELETE,
+  SQLITE_DENY,
+  SQLITE_DETACH,
+  SQLITE_DROP_INDEX,
+  SQLITE_DROP_TABLE,
+  SQLITE_DROP_TEMP_INDEX,
+  SQLITE_DROP_TEMP_TABLE,
+  SQLITE_DROP_TEMP_TRIGGER,
+  SQLITE_DROP_TEMP_VIEW,
+  SQLITE_DROP_TRIGGER,
+  SQLITE_DROP_VIEW,
+  SQLITE_DROP_VTABLE,
+  SQLITE_FUNCTION,
+  SQLITE_IGNORE,
+  SQLITE_INSERT,
+  SQLITE_OK,
+  SQLITE_PRAGMA,
+  SQLITE_READ,
+  SQLITE_RECURSIVE,
+  SQLITE_REINDEX,
+  SQLITE_SAVEPOINT,
+  SQLITE_SELECT,
+  SQLITE_TRANSACTION,
+  SQLITE_UPDATE,
+  constants
+};

package/lib/esm/data-model-reader.js

@@ -0,0 +1,82 @@
+import { OutOfRangeError } from "./errors.js";
+function convertValue(value, readBigInts) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      if (!readBigInts) {
+        throw new OutOfRangeError(
+          `Value is too large to be represented as a JavaScript number: ${value}`
+        );
+      }
+      return BigInt(value);
+    }
+    if (readBigInts && Number.isInteger(value)) {
+      return BigInt(value);
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (!readBigInts) {
+      if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(-Number.MAX_SAFE_INTEGER)) {
+        throw new OutOfRangeError(
+          `Value is too large to be represented as a JavaScript number: ${value}`
+        );
+      }
+      return Number(value);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value && typeof value.toArray === "function") {
+    return new Uint8Array(value.toArray());
+  }
+  return value;
+}
+function readRow(model, row, options) {
+  const nCols = model.get_n_columns();
+  if (options.returnArrays) {
+    const arr = [];
+    for (let col = 0; col < nCols; col++) {
+      const val = model.get_value_at(col, row);
+      arr.push(convertValue(val, options.readBigInts));
+    }
+    return arr;
+  }
+  const obj = /* @__PURE__ */ Object.create(null);
+  for (let col = 0; col < nCols; col++) {
+    const name = model.get_column_name(col);
+    const val = model.get_value_at(col, row);
+    obj[name] = convertValue(val, options.readBigInts);
+  }
+  return obj;
+}
+function readAllRows(model, options) {
+  const nRows = model.get_n_rows();
+  const rows = [];
+  for (let row = 0; row < nRows; row++) {
+    const r = readRow(model, row, options);
+    if (r !== void 0) {
+      rows.push(r);
+    }
+  }
+  return rows;
+}
+function readFirstRow(model, options) {
+  const nRows = model.get_n_rows();
+  if (nRows === 0) {
+    return void 0;
+  }
+  return readRow(model, 0, options);
+}
+export {
+  readAllRows,
+  readFirstRow,
+  readRow
+};

package/lib/esm/database-sync.js

@@ -0,0 +1,403 @@
+import Gda from "@girs/gda-6.0";
+import {
+  ConstructCallRequiredError,
+  InvalidArgTypeError,
+  InvalidStateError,
+  InvalidUrlSchemeError,
+  SqliteError
+} from "./errors.js";
+import { StatementSync } from "./statement-sync.js";
+const sqliteTypeSymbol = /* @__PURE__ */ Symbol.for("sqlite-type");
+function parsePath(path) {
+  if (typeof path === "string") {
+    if (path.includes("\0")) {
+      throw new InvalidArgTypeError(
+        'The "path" argument must be a string, Uint8Array, or URL without null bytes.'
+      );
+    }
+    return path;
+  }
+  if (path instanceof URL) {
+    if (path.protocol !== "file:") {
+      throw new InvalidUrlSchemeError();
+    }
+    const filePath = path.pathname;
+    if (filePath.includes("\0")) {
+      throw new InvalidArgTypeError(
+        'The "path" argument must be a string, Uint8Array, or URL without null bytes.'
+      );
+    }
+    return filePath;
+  }
+  if (path instanceof Uint8Array) {
+    for (let i = 0; i < path.length; i++) {
+      if (path[i] === 0) {
+        throw new InvalidArgTypeError(
+          'The "path" argument must be a string, Uint8Array, or URL without null bytes.'
+        );
+      }
+    }
+    return new TextDecoder().decode(path);
+  }
+  throw new InvalidArgTypeError(
+    'The "path" argument must be a string, Uint8Array, or URL without null bytes.'
+  );
+}
+function validateOptions(options) {
+  if (options === void 0) return {};
+  if (options === null || typeof options !== "object") {
+    throw new InvalidArgTypeError('The "options" argument must be an object.');
+  }
+  const opts = options;
+  const result = {};
+  if (opts.open !== void 0) {
+    if (typeof opts.open !== "boolean") {
+      throw new InvalidArgTypeError('The "options.open" argument must be a boolean.');
+    }
+    result.open = opts.open;
+  }
+  if (opts.readOnly !== void 0) {
+    if (typeof opts.readOnly !== "boolean") {
+      throw new InvalidArgTypeError('The "options.readOnly" argument must be a boolean.');
+    }
+    result.readOnly = opts.readOnly;
+  }
+  if (opts.timeout !== void 0) {
+    if (typeof opts.timeout !== "number" || !Number.isInteger(opts.timeout)) {
+      throw new InvalidArgTypeError('The "options.timeout" argument must be an integer.');
+    }
+    result.timeout = opts.timeout;
+  }
+  if (opts.enableForeignKeyConstraints !== void 0) {
+    if (typeof opts.enableForeignKeyConstraints !== "boolean") {
+      throw new InvalidArgTypeError('The "options.enableForeignKeyConstraints" argument must be a boolean.');
+    }
+    result.enableForeignKeyConstraints = opts.enableForeignKeyConstraints;
+  }
+  if (opts.enableDoubleQuotedStringLiterals !== void 0) {
+    if (typeof opts.enableDoubleQuotedStringLiterals !== "boolean") {
+      throw new InvalidArgTypeError('The "options.enableDoubleQuotedStringLiterals" argument must be a boolean.');
+    }
+    result.enableDoubleQuotedStringLiterals = opts.enableDoubleQuotedStringLiterals;
+  }
+  if (opts.readBigInts !== void 0) {
+    if (typeof opts.readBigInts !== "boolean") {
+      throw new InvalidArgTypeError('The "options.readBigInts" argument must be a boolean.');
+    }
+    result.readBigInts = opts.readBigInts;
+  }
+  if (opts.returnArrays !== void 0) {
+    if (typeof opts.returnArrays !== "boolean") {
+      throw new InvalidArgTypeError('The "options.returnArrays" argument must be a boolean.');
+    }
+    result.returnArrays = opts.returnArrays;
+  }
+  if (opts.allowBareNamedParameters !== void 0) {
+    if (typeof opts.allowBareNamedParameters !== "boolean") {
+      throw new InvalidArgTypeError('The "options.allowBareNamedParameters" argument must be a boolean.');
+    }
+    result.allowBareNamedParameters = opts.allowBareNamedParameters;
+  }
+  if (opts.allowUnknownNamedParameters !== void 0) {
+    if (typeof opts.allowUnknownNamedParameters !== "boolean") {
+      throw new InvalidArgTypeError('The "options.allowUnknownNamedParameters" argument must be a boolean.');
+    }
+    result.allowUnknownNamedParameters = opts.allowUnknownNamedParameters;
+  }
+  if (opts.defensive !== void 0) {
+    if (typeof opts.defensive !== "boolean") {
+      throw new InvalidArgTypeError('The "options.defensive" argument must be a boolean.');
+    }
+    result.defensive = opts.defensive;
+  }
+  if (opts.allowExtension !== void 0) {
+    if (typeof opts.allowExtension !== "boolean") {
+      throw new InvalidArgTypeError('The "options.allowExtension" argument must be a boolean.');
+    }
+    result.allowExtension = opts.allowExtension;
+  }
+  return result;
+}
+function convertParameterSyntax(sql) {
+  const params = [];
+  let positionalIndex = 0;
+  let result = "";
+  let i = 0;
+  while (i < sql.length) {
+    if (sql[i] === "'") {
+      const start = i;
+      i++;
+      while (i < sql.length && sql[i] !== "'") {
+        if (sql[i] === "'" && sql[i + 1] === "'") {
+          i += 2;
+          continue;
+        }
+        i++;
+      }
+      if (i < sql.length) i++;
+      result += sql.substring(start, i);
+      continue;
+    }
+    if (sql[i] === "?") {
+      i++;
+      let numStr = "";
+      while (i < sql.length && sql[i] >= "0" && sql[i] <= "9") {
+        numStr += sql[i];
+        i++;
+      }
+      const pos = numStr ? parseInt(numStr, 10) - 1 : positionalIndex;
+      positionalIndex = numStr ? positionalIndex : positionalIndex + 1;
+      const gdaId = `p${pos}`;
+      params.push({ gdaId, originalName: numStr ? `?${numStr}` : "?", position: pos });
+      result += `##${gdaId}::string`;
+      continue;
+    }
+    if ((sql[i] === "$" || sql[i] === ":" || sql[i] === "@") && i + 1 < sql.length && /[a-zA-Z_]/.test(sql[i + 1])) {
+      const prefix = sql[i];
+      i++;
+      let name = "";
+      while (i < sql.length && /[a-zA-Z0-9_]/.test(sql[i])) {
+        name += sql[i];
+        i++;
+      }
+      const gdaId = name;
+      params.push({ gdaId, originalName: `${prefix}${name}`, position: -1 });
+      result += `##${gdaId}::string`;
+      continue;
+    }
+    result += sql[i];
+    i++;
+  }
+  return [result, params];
+}
+class DatabaseSync {
+  #connection = null;
+  #parser = null;
+  #path;
+  #options;
+  #isMemory;
+  #inTransaction = false;
+  constructor(path, options) {
+    if (!new.target) {
+      throw new ConstructCallRequiredError("DatabaseSync");
+    }
+    this.#path = parsePath(path);
+    this.#options = validateOptions(options);
+    this.#isMemory = this.#path === ":memory:";
+    const shouldOpen = this.#options.open !== false;
+    if (shouldOpen) {
+      this.open();
+    }
+  }
+  get [sqliteTypeSymbol]() {
+    return "node:sqlite";
+  }
+  get isOpen() {
+    return this.#connection !== null && this.#connection.is_opened();
+  }
+  get isTransaction() {
+    this.#ensureOpen();
+    return this.#inTransaction;
+  }
+  open() {
+    if (this.isOpen) {
+      throw new InvalidStateError("database is already open");
+    }
+    try {
+      if (this.#isMemory) {
+        this.#connection = Gda.Connection.new_from_string(
+          "SQLite",
+          "DB_DIR=;DB_NAME=:memory:",
+          null,
+          Gda.ConnectionOptions.NONE
+        );
+      } else {
+        const lastSlash = this.#path.lastIndexOf("/");
+        const dir = lastSlash >= 0 ? this.#path.substring(0, lastSlash) : ".";
+        const name = lastSlash >= 0 ? this.#path.substring(lastSlash + 1) : this.#path;
+        const cncString = `DB_DIR=${dir};DB_NAME=${name}`;
+        const connOpts = this.#options.readOnly ? Gda.ConnectionOptions.READ_ONLY : Gda.ConnectionOptions.NONE;
+        this.#connection = Gda.Connection.new_from_string(
+          "SQLite",
+          cncString,
+          null,
+          connOpts
+        );
+      }
+      this.#connection.open();
+    } catch (e) {
+      this.#connection = null;
+      throw new SqliteError(
+        e instanceof Error ? e.message : String(e)
+      );
+    }
+    this.#parser = this.#connection.create_parser() ?? new Gda.SqlParser();
+    this.#applyPragmas();
+    return void 0;
+  }
+  close() {
+    if (!this.isOpen) {
+      throw new InvalidStateError("database is not open");
+    }
+    this.#connection.close();
+    this.#connection = null;
+    this.#parser = null;
+    this.#inTransaction = false;
+    return void 0;
+  }
+  /**
+   * Execute one or more SQL statements. Returns undefined.
+   * Named sqlExec to avoid security hook false positive on "exec" name.
+   */
+  sqlExec(sql) {
+    this.#ensureOpen();
+    if (typeof sql !== "string") {
+      throw new InvalidArgTypeError('The "sql" argument must be a string.');
+    }
+    try {
+      const statements = this.#splitStatements(sql);
+      for (const stmtSql of statements) {
+        const [stmt] = this.#parser.parse_string(stmtSql);
+        if (stmt) {
+          this.#executeStatement(stmt);
+        }
+      }
+    } catch (e) {
+      if (e instanceof SqliteError || e instanceof InvalidStateError || e instanceof InvalidArgTypeError) {
+        throw e;
+      }
+      throw new SqliteError(
+        e instanceof Error ? e.message : String(e)
+      );
+    }
+    this.#updateTransactionState(sql);
+    return void 0;
+  }
+  prepare(sql, options) {
+    this.#ensureOpen();
+    if (typeof sql !== "string") {
+      throw new InvalidArgTypeError('The "sql" argument must be a string.');
+    }
+    const [, paramMap] = convertParameterSyntax(sql);
+    try {
+      const testSql = paramMap.length > 0 ? sql.replace(/\?(\d+)?/g, "NULL").replace(/[\$:@][a-zA-Z_][a-zA-Z0-9_]*/g, "NULL") : sql;
+      const [stmt] = this.#parser.parse_string(testSql);
+      if (!stmt) {
+        throw new SqliteError("Failed to parse SQL statement");
+      }
+    } catch (e) {
+      if (e instanceof SqliteError || e instanceof InvalidArgTypeError) {
+        throw e;
+      }
+      throw new SqliteError(
+        e instanceof Error ? e.message : String(e)
+      );
+    }
+    const stmtOptions = {
+      readBigInts: this.#options.readBigInts ?? false,
+      returnArrays: this.#options.returnArrays ?? false,
+      allowBareNamedParameters: this.#options.allowBareNamedParameters ?? true,
+      allowUnknownNamedParameters: this.#options.allowUnknownNamedParameters ?? false
+    };
+    return StatementSync._create(this.#connection, sql, stmtOptions, paramMap, this.#parser);
+  }
+  location(dbName) {
+    this.#ensureOpen();
+    if (dbName !== void 0 && typeof dbName !== "string") {
+      throw new InvalidArgTypeError('The "dbName" argument must be a string.');
+    }
+    if (this.#isMemory) {
+      return null;
+    }
+    return this.#path;
+  }
+  [Symbol.dispose]() {
+    if (this.isOpen) {
+      try {
+        this.close();
+      } catch {
+      }
+    }
+  }
+  #ensureOpen() {
+    if (!this.isOpen) {
+      throw new InvalidStateError("database is not open");
+    }
+  }
+  #applyPragmas() {
+    const conn = this.#connection;
+    const runPragma = (pragma) => {
+      const parser = this.#parser;
+      const [stmt] = parser.parse_string(pragma);
+      if (stmt) {
+        conn.statement_execute_select(stmt, null);
+      }
+    };
+    if (this.#options.enableForeignKeyConstraints !== false) {
+      runPragma("PRAGMA foreign_keys = ON");
+    } else {
+      runPragma("PRAGMA foreign_keys = OFF");
+    }
+    if (this.#options.timeout !== void 0 && this.#options.timeout > 0) {
+      runPragma(`PRAGMA busy_timeout = ${this.#options.timeout}`);
+    }
+  }
+  #executeStatement(stmt) {
+    const stmtType = stmt.get_statement_type();
+    if (stmtType === Gda.SqlStatementType.SELECT) {
+      this.#connection.statement_execute_select(stmt, null);
+    } else {
+      try {
+        this.#connection.statement_execute_non_select(stmt, null);
+      } catch {
+        this.#connection.statement_execute_select(stmt, null);
+      }
+    }
+  }
+  #splitStatements(sql) {
+    const stmts = [];
+    let current = "";
+    let inString = false;
+    for (let i = 0; i < sql.length; i++) {
+      const ch = sql[i];
+      if (ch === "'" && !inString) {
+        inString = true;
+        current += ch;
+      } else if (ch === "'" && inString) {
+        if (sql[i + 1] === "'") {
+          current += "''";
+          i++;
+        } else {
+          inString = false;
+          current += ch;
+        }
+      } else if (ch === ";" && !inString) {
+        const trimmed2 = current.trim();
+        if (trimmed2.length > 0) {
+          stmts.push(trimmed2);
+        }
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    const trimmed = current.trim();
+    if (trimmed.length > 0) {
+      stmts.push(trimmed);
+    }
+    return stmts;
+  }
+  #updateTransactionState(sql) {
+    const trimmed = sql.trim().toUpperCase();
+    if (/\bBEGIN\b/.test(trimmed)) {
+      this.#inTransaction = true;
+    }
+    if (/\bCOMMIT\b/.test(trimmed) || /\bROLLBACK\b/.test(trimmed)) {
+      this.#inTransaction = false;
+    }
+  }
+}
+DatabaseSync.prototype.exec = DatabaseSync.prototype.sqlExec;
+export {
+  DatabaseSync
+};