@lix-js/sdk 0.0.1

package/node_modules/sqlite-wasm-kysely/dist/util/sqliteWasmBinary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteWasmBinary.js","sourceRoot":"","sources":["../../src/util/sqliteWasmBinary.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,SAAS,mBAAmB,CAAC,MAAc;IACzC,IAAI,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,KAAK,GAAG,IAAI,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAChD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7C,KAAK,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC;AAED,MAAM,gBAAgB,GACpB,sgtsCAAsgtsC,CAAC;AAEzgtsC,MAAM,CAAC,MAAM,UAAU,GAAG,mBAAmB,CAAC,gBAAgB,CAAC,CAAC"}

package/node_modules/sqlite-wasm-kysely/package.json

@@ -0,0 +1,34 @@
+{
+  "private": true,
+  "name": "sqlite-wasm-kysely",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && vitest run",
+    "test:watch": "vitest",
+    "format": "prettier . --write"
+  },
+  "dependencies": {
+    "@eliaspourquoi/sqlite-node-wasm": "^3.46.0-build2"
+  },
+  "devDependencies": {
+    "@vitest/browser": "^1.6.0",
+    "kysely": "^0.27.4",
+    "prettier": "^3.3.2",
+    "typescript": "^5.5.3",
+    "vite": "^5.3.3",
+    "vitest": "^1.6.0",
+    "webdriverio": "^8.39.1"
+  },
+  "peerDependencies": {
+    "kysely": "*"
+  }
+}

package/node_modules/sqlite-wasm-kysely/src/dialect.ts

@@ -0,0 +1,15 @@
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import { SqliteWasmDriver } from "./kysely/SqliteWasmDriver.js";
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+
+export const createDialect = (args: { database: Database }) => {
+  return {
+    createAdapter: () => new SqliteAdapter(),
+    createDriver: () =>
+      new SqliteWasmDriver({
+        database: args.database,
+      }),
+    createIntrospector: (db: any) => new SqliteIntrospector(db),
+    createQueryCompiler: () => new SqliteQueryCompiler(),
+  };
+};

package/node_modules/sqlite-wasm-kysely/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./util/index.js";
+export { createDialect } from "./dialect.js";

package/node_modules/sqlite-wasm-kysely/src/kysely/ConnectionMutex.ts

@@ -0,0 +1,23 @@
+export class ConnectionMutex {
+  #promise?: Promise<void>;
+  #resolve?: () => void;
+
+  async lock(): Promise<void> {
+    while (this.#promise) {
+      await this.#promise;
+    }
+
+    this.#promise = new Promise((resolve) => {
+      this.#resolve = resolve;
+    });
+  }
+
+  unlock(): void {
+    const resolve = this.#resolve;
+
+    this.#promise = undefined;
+    this.#resolve = undefined;
+
+    resolve?.();
+  }
+}

package/node_modules/sqlite-wasm-kysely/src/kysely/SqliteWasmConnection.ts

@@ -0,0 +1,57 @@
+import { CompiledQuery, DatabaseConnection, QueryResult } from "kysely";
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+import { sqliteModule } from "./sqliteModule.js";
+
+export class SqliteWasmConnection implements DatabaseConnection {
+  readonly #db: Database;
+
+  constructor(db: Database) {
+    this.#db = db;
+  }
+
+  executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
+    const { sql, parameters } = compiledQuery;
+
+    const statementData = {
+      rows: [],
+      columns: [],
+    };
+
+    // we cant know what kind of query we are dealing with at that state - unless we switch to perpared statments
+    // for now we collect all information required
+    // save the changes before (total changes seems to be fast and worth the twoe extra round trips inspiration from https://github.com/WiseLibs/better-sqlite3/blob/254b8e93d78b1b03c9a2c777f4d304a0ea1530c6/src/objects/statement.lzz#L159)
+    const totalChangesBefore = this.#db.changes(true);
+
+    // execute the statement
+    const rows = this.#db.exec({
+      sql: sql,
+      bind: parameters as any,
+      returnValue: "resultRows",
+      rowMode: "object",
+      columnNames: statementData.columns,
+    });
+
+    const lastInsertId = sqliteModule?.capi.sqlite3_last_insert_rowid(this.#db);
+
+    // check if we had changes in the db at all - if so - collect the number of changes
+    const changes =
+      totalChangesBefore === this.#db.changes(true) ? 0 : this.#db.changes();
+
+    // console.log('sql: ' + sql);
+    // console.log('result: ', rows);
+    // We don't have knowledge about rather its update/delete/or select - so we return the results
+    // @ts-expect-error - TODO for @martin-lysk - typescript complains
+    return Promise.resolve({
+      numAffectedRows: changes,
+      insertId: lastInsertId,
+
+      // queries with result
+      rows: rows as O[],
+    });
+  }
+
+  // eslint-disable-next-line require-yield
+  async *streamQuery() {
+    throw new Error("not supported for wasm driver yet");
+  }
+}

package/node_modules/sqlite-wasm-kysely/src/kysely/SqliteWasmDialectConfig.ts

@@ -0,0 +1,19 @@
+import { DatabaseConnection } from "kysely";
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+
+export interface SqliteWasmDialectConfig {
+  /**
+   * An sqlite Database instance or a function that returns one.
+   *
+   * If a function is provided, it's called once when the first query is executed.
+   *
+   * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+   */
+  database: Database | (() => Promise<Database>);
+  /**
+   * Called once when the first query is executed.
+   *
+   * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
+   */
+  onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+}

package/node_modules/sqlite-wasm-kysely/src/kysely/SqliteWasmDriver.ts

@@ -0,0 +1,58 @@
+import { CompiledQuery, DatabaseConnection, Driver } from "kysely";
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+import { SqliteWasmDialectConfig } from "./SqliteWasmDialectConfig.js";
+import { ConnectionMutex } from "./ConnectionMutex.js";
+import { SqliteWasmConnection } from "./SqliteWasmConnection.js";
+
+export class SqliteWasmDriver implements Driver {
+  readonly #config: SqliteWasmDialectConfig;
+  readonly #connectionMutex = new ConnectionMutex();
+
+  #db?: Database;
+  #connection?: DatabaseConnection;
+
+  constructor(config: SqliteWasmDialectConfig) {
+    // this.#config = freeze({ ...config })
+    this.#config = { ...config };
+  }
+
+  async init(): Promise<void> {
+    this.#db =
+      typeof this.#config.database === "function"
+        ? await this.#config.database()
+        : this.#config.database;
+
+    this.#connection = new SqliteWasmConnection(this.#db);
+
+    if (this.#config.onCreateConnection) {
+      await this.#config.onCreateConnection(this.#connection);
+    }
+  }
+
+  async acquireConnection(): Promise<DatabaseConnection> {
+    // SQLite only has one single connection. We use a mutex here to wait
+    // until the single connection has been released.
+    await this.#connectionMutex.lock();
+    return this.#connection!;
+  }
+
+  async beginTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("begin"));
+  }
+
+  async commitTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("commit"));
+  }
+
+  async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("rollback"));
+  }
+
+  async releaseConnection(): Promise<void> {
+    this.#connectionMutex.unlock();
+  }
+
+  async destroy(): Promise<void> {
+    this.#db?.close();
+  }
+}

package/node_modules/sqlite-wasm-kysely/src/kysely/index.ts

@@ -0,0 +1,4 @@
+export { SqliteWasmConnection } from "./SqliteWasmConnection.js";
+export type { SqliteWasmDialectConfig } from "./SqliteWasmDialectConfig.js";
+export { SqliteWasmDriver } from "./SqliteWasmDriver.js";
+export { ConnectionMutex } from "./ConnectionMutex.js";

package/node_modules/sqlite-wasm-kysely/src/kysely/sqliteModule.ts

@@ -0,0 +1,7 @@
+import { Sqlite3Static } from "@eliaspourquoi/sqlite-node-wasm";
+
+export let sqliteModule: Sqlite3Static;
+
+export function setSqliteModule(module: Sqlite3Static) {
+  sqliteModule = module;
+}

package/node_modules/sqlite-wasm-kysely/src/util/contentFromDatabase.ts

@@ -0,0 +1,13 @@
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+import { sqliteModule } from "../kysely/sqliteModule.js";
+
+/**
+ * Exports the content of a database as a Uint8Array.
+ *
+ * @example
+ *   const db = createInMemoryDatabase({ readOnly: false });
+ *   const content = contentFromDatabase(db);
+ */
+export const contentFromDatabase = (db: Database): Uint8Array => {
+  return sqliteModule.capi.sqlite3_js_db_export(db);
+};

package/node_modules/sqlite-wasm-kysely/src/util/createInMemoryDatabase.ts

@@ -0,0 +1,30 @@
+import sqlite3InitModule from "@eliaspourquoi/sqlite-node-wasm";
+import { setSqliteModule, sqliteModule } from "../kysely/sqliteModule.js";
+import { wasmBinary } from "./sqliteWasmBinary.js";
+
+export const createInMemoryDatabase = async ({
+  readOnly = false,
+}: {
+  readOnly?: boolean;
+}) => {
+  if (!sqliteModule) {
+    await initSqlite();
+  }
+  const flags = [
+    readOnly ? "r" : "cw", // read and write
+    "", // non verbose
+  ].join("");
+
+  return new sqliteModule.oo1.DB(":memory:", flags);
+};
+
+async function initSqlite() {
+  setSqliteModule(
+    await sqlite3InitModule({
+      // @ts-expect-error
+      wasmBinary: wasmBinary,
+      // https://github.com/opral/inlang-sdk/issues/170#issuecomment-2334768193
+      locateFile: () => "sqlite3.wasm",
+    }),
+  );
+}

package/node_modules/sqlite-wasm-kysely/src/util/importDatabase.ts

@@ -0,0 +1,34 @@
+import { sqliteModule } from "../kysely/sqliteModule.js";
+import { Database } from "@eliaspourquoi/sqlite-node-wasm";
+
+export const importDatabase = ({
+  db,
+  content,
+  schema = "main",
+  readOnly = false,
+}: {
+  db: Database;
+  content: Uint8Array;
+  schema?: string;
+  readOnly?: boolean;
+}) => {
+  const deserializeFlag = readOnly
+    ? sqliteModule.capi.SQLITE_DESERIALIZE_READONLY
+    : sqliteModule.capi.SQLITE_DESERIALIZE_FREEONCLOSE |
+      sqliteModule.capi.SQLITE_DESERIALIZE_RESIZEABLE;
+
+  const contentPointer = sqliteModule.wasm.allocFromTypedArray(content);
+  const deserializeReturnCode = sqliteModule.capi.sqlite3_deserialize(
+    db.pointer!,
+    schema,
+    contentPointer,
+    content.byteLength, // db size
+    content.byteLength, // content size
+    deserializeFlag,
+  );
+
+  // check if the deserialization was successfull
+  db.checkRc(deserializeReturnCode);
+
+  return db;
+};

package/node_modules/sqlite-wasm-kysely/src/util/index.ts

@@ -0,0 +1,5 @@
+export { contentFromDatabase } from "./contentFromDatabase.js";
+export { createInMemoryDatabase } from "./createInMemoryDatabase.js";
+export { importDatabase } from "./importDatabase.js";
+export type { Database as SqliteDatabase } from "@eliaspourquoi/sqlite-node-wasm";
+export { loadDatabaseInMemory } from "./loadDatabaseInMemory.js";

package/node_modules/sqlite-wasm-kysely/src/util/loadDatabaseInMemory.ts

@@ -0,0 +1,13 @@
+import { createInMemoryDatabase } from "./createInMemoryDatabase.js";
+import { importDatabase } from "./importDatabase.js";
+
+export async function loadDatabaseInMemory(data: ArrayBuffer) {
+  const database = await createInMemoryDatabase({
+    readOnly: false,
+  });
+  importDatabase({
+    db: database,
+    content: new Uint8Array(data),
+  });
+  return database;
+}