@storecraft/database-turso 1.0.0

package/README.md

@@ -0,0 +1,70 @@
+# Storecraft Turso (libsql) Database support
+
+<div style="text-align:center">
+  <img src='https://storecraft.app/storecraft-color.svg' 
+       width='90%'' />
+</div><hr/><br/>
+
+Official `Turso` / `libSql` driver for `StoreCraft` on any platforms.
+
+```bash
+npm i @storecraft/database-cloudflare-d1
+```
+
+## Setup
+
+- First, login to your [turso](https://turso.tech) account.
+- Create a database.
+- Create an API Key.
+
+
+## usage
+
+```js
+import 'dotenv/config';
+import http from "node:http";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+import { App } from '@storecraft/core'
+import { NodePlatform } from '@storecraft/platforms/node';
+import { Turso } from '@storecraft/database-turso'
+import { migrateToLatest } from '@storecraft/database-turso/migrate.js'
+import { NodeLocalStorage } from '@storecraft/storage-local/node'
+
+const app = new App(
+  {
+    auth_admins_emails: ['admin@sc.com'],
+    auth_secret_access_token: 'auth_secret_access_token',
+    auth_secret_refresh_token: 'auth_secret_refresh_token'
+  }
+)
+.withPlatform(new NodePlatform())
+.withDatabase(
+  new Turso(
+    { 
+      prefers_batch_over_transactions: true,
+      libsqlConfig: {
+        url: process.env.TURSO_URL,
+        authToken: process.env.TURSO_API_TOKEN,
+      }
+    }
+  )
+)
+.withStorage(new NodeLocalStorage(join(homedir(), 'tomer')))
+
+await app.init();
+await migrateToLatest(app.db, false);
+ 
+const server = http.createServer(app.handler).listen(
+  8000,
+  () => {
+    console.log(`Server is running on http://localhost:8000`);
+  }
+); 
+
+```
+
+```text
+Author: Tomer Shalev <tomer.shalev@gmail.com>
+```

package/driver.js

@@ -0,0 +1,33 @@
+import { App } from '@storecraft/core';
+import { SQL } from '@storecraft/database-sql-base';
+import { LibsqlDialect } from './kysely.turso.dialect.js';
+
+/**
+ * @param {any} b 
+ * @param {string} msg 
+ */
+const assert = (b, msg) => {
+  if(!Boolean(b)) throw new Error(msg);
+}
+
+
+/**
+ * @extends {SQL}
+ */
+export class Turso extends SQL {
+
+  /**
+   * 
+   * @param {import('./types.public.d.ts').Config} [config] config 
+   */
+  constructor(config) {
+    super(
+      {
+        dialect_type: 'SQLITE',
+        dialect: new LibsqlDialect(config),
+      }
+    );
+
+  }
+
+}

package/index.js

@@ -0,0 +1,4 @@
+export * from './driver.js';
+
+
+

package/kysely.turso.dialect.js

@@ -0,0 +1,246 @@
+import * as libsql from "@libsql/client";
+import * as kysely from "kysely";
+
+/**
+ * @typedef {import('kysely').Driver} Driver
+ * @typedef {import('kysely').Dialect} Dialect
+ * @typedef {import('kysely').DatabaseConnection} DatabaseConnection
+ * @typedef {import('./types.public.d.ts').Config} Config
+ */
+
+/**
+ * 
+ * @implements {Dialect}
+ */
+export class LibsqlDialect {
+  /** @type {Config} */    
+  #config;
+
+  /**
+   * 
+   * @param {Config} config 
+   */
+  constructor(config) {
+    this.#config = config;
+  }
+
+  createAdapter() { return new kysely.SqliteAdapter(); }
+  createQueryCompiler() { return new kysely.SqliteQueryCompiler(); }
+  createDriver() {
+
+    if (this.#config?.libsqlConfig?.url===undefined) {
+      throw new Error(
+        "Please specify either `client` or `url` in the LibsqlDialect config"
+      );
+    }
+
+    return new LibsqlDriver(
+      libsql.createClient(this.#config.libsqlConfig), 
+      this.#config
+    );
+  }
+
+  /** @type {Dialect["createIntrospector"]} */
+  createIntrospector(db) {
+    return new kysely.SqliteIntrospector(db);
+  }
+
+}
+
+/**
+ * 
+ * @implements {Driver}
+ */
+export class LibsqlDriver {
+  /** @type {libsql.Client} */
+  client;
+
+  /**
+   * @param {libsql.Client} client 
+   * @param {Config} config 
+   */
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+
+  async init() {}
+
+  async acquireConnection() {
+    return new LibsqlConnection(this.client, this.config);
+  }
+
+  /**
+   * 
+   * @param {LibsqlConnection} connection 
+   * @param {kysely.TransactionSettings} settings 
+   */
+  async beginTransaction(connection, settings) {
+    await connection.beginTransaction();
+  }
+
+  /**
+   * 
+   * @param {LibsqlConnection} connection 
+   */
+  async commitTransaction(connection) {
+    await connection.commitTransaction();
+  }
+
+  /**
+   * 
+   * @param {LibsqlConnection} connection 
+   */
+  async rollbackTransaction(connection) {
+    await connection.rollbackTransaction();
+  }
+
+  /**
+   * 
+   * @param {LibsqlConnection} _conn 
+   */
+  async releaseConnection(_conn) {}
+
+  async destroy() {
+    this.client.close();
+  }
+}
+
+/**
+ * @implements {DatabaseConnection}
+ */
+export class LibsqlConnection {
+  /** @type {libsql.Client} */
+  client;
+  /** @type {Config} */
+  config;
+  isBatch = false;
+  /** @type {kysely.CompiledQuery[]} */
+  batch = []
+
+  /** @type {libsql.Transaction} */
+  #transaction;
+
+  /**
+   * 
+   * @param {libsql.Client} client 
+   * @param {Config} config 
+   */
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+
+  /**
+   * @param {kysely.CompiledQuery[]} compiledQueries 
+   * 
+   * @returns {Promise<import('kysely').QueryResult<import("@libsql/client").Row>>}
+   */
+  async #internal_executeQuery(compiledQueries) {
+    const target = this.#transaction ?? this.client;
+
+    const stmts = compiledQueries.map(
+      cq => (
+        {
+          sql: cq.sql,
+          args: (/** @type {import("@libsql/client").InArgs} */ (cq.parameters)),
+        }
+      )
+    );
+
+    const results = await target.batch(
+      stmts  
+    );
+
+    // console.log('q', JSON.stringify({sql, params}, null, 2))
+    console.log('stmts', JSON.stringify(stmts, null, 2))
+    console.log('result', JSON.stringify(results, null, 2))
+
+    const last_result = results?.at(-1);
+
+    return {
+      insertId: last_result?.lastInsertRowid,
+      rows: last_result?.rows ?? [],
+      numAffectedRows: BigInt(last_result?.rowsAffected ?? 0),
+      // @ts-ignore deprecated in kysely >= 0.23, keep for backward compatibility.
+      numUpdatedOrDeletedRows: last_result?.rowsAffected,
+    };
+
+  } 
+
+  /**
+   * 
+   * @param {kysely.CompiledQuery} compiledQuery 
+   * 
+   * @returns {Promise<import('kysely').QueryResult>}
+   */
+  async executeQuery(compiledQuery) {
+    console.log('this.isBatch', this.isBatch)
+    if(this.isBatch) {
+      this.batch.push(compiledQuery);
+      return Promise.resolve(
+        {
+          rows: []
+        }
+      )
+    } else {
+      return this.#internal_executeQuery([compiledQuery]);
+    }
+  }
+
+  async beginTransaction() {
+    if(this.config.prefers_batch_over_transactions) {
+      this.isBatch = true;
+      this.batch = [];
+      return;
+    }
+
+    if (this.#transaction) {
+      throw new Error("Transaction already in progress");
+    }
+    this.#transaction = await this.client.transaction();
+  }
+
+  async commitTransaction() {
+    console.log('commitTransaction')
+    if(this.isBatch) {
+      // console.trace()
+      await this.#internal_executeQuery(this.batch);
+      this.isBatch = false;
+      this.batch = [];
+      return;
+    }
+
+    if (!this.#transaction) {
+      throw new Error("No transaction to commit");
+    }
+    await this.#transaction.commit();
+    this.#transaction = undefined;
+  }
+
+  async rollbackTransaction() {
+    if(this.isBatch) {
+      this.isBatch = false;
+      this.batch = [];
+      return;
+    }
+
+    if (!this.#transaction) {
+      throw new Error("No transaction to rollback");
+    }
+    await this.#transaction.rollback();
+    this.#transaction = undefined;
+  }
+  /**
+   * @template R result type
+   * 
+   * @param {kysely.CompiledQuery} compiledQuery 
+   * @param {number} chunkSize 
+   * 
+   * @returns {AsyncIterableIterator<import('kysely').QueryResult<R>>}
+   */
+  async *streamQuery(compiledQuery, chunkSize) {
+    throw new Error("Libsql Driver does not support streaming yet");
+  }
+
+}

package/kysely.turso.utils.js

@@ -0,0 +1,33 @@
+
+/**
+ * 
+ * @param {string} stmt 
+ * @param {any[] | Record<string, any>} params 
+ */
+export const prepare_and_bind = (stmt='', params=[]) => {
+  const params_object = Array.isArray(params) ? 
+      params.reduce((a, v, idx) => ({ ...a, [idx+1]: v}), {}) : 
+      params; 
+
+  let current = 0;
+  let result = ''
+  let index_run = 1;
+  for (let m of stmt.matchAll(/\?[0-9]*/g)) {
+    result += stmt.slice(current, m.index);
+  
+    const match_string = m[0];
+    let index_access = match_string.length > 1 ? 
+          Number(match_string.slice(1)) : 
+          index_run;
+  
+    result += "'" + params_object[index_access] + "'";
+  
+    current = m.index + m[0].length;
+    index_run+=1;
+  }
+  
+  result += stmt.slice(current);
+
+  return result;
+}
+

package/migrate.js

@@ -0,0 +1,5 @@
+export { migrateToLatest } from '@storecraft/database-sql-base/migrate.js';
+
+
+
+

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@storecraft/database-turso",
+  "version": "1.0.0",
+  "description": "`Storecraft` database driver for `Turso` (cloud sqlite)",
+  "license": "MIT",
+  "author": "Tomer Shalev (https://github.com/store-craft)",
+  "homepage": "https://github.com/store-craft/storecraft",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/store-craft/storecraft.git",
+    "directory": "packages/database-turso"
+  },
+  "keywords": [
+    "commerce",
+    "dashboard",
+    "code",
+    "storecraft"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "types": "./types.public.d.ts",
+  "scripts": {
+    "database-turso:test": "node ./tests/runner.test.js",
+    "database-turso:publish": "npm publish --access public"
+  },
+  "peerDependencies": {
+    "kysely": "*"
+  },
+  "dependencies": {
+    "@libsql/client": "^0.9.0",
+    "@storecraft/core": "^1.0.0",
+    "@storecraft/database-sql-base": "^1.0.0"
+  },
+  "devDependencies": {
+    "@storecraft/test-runner": "^1.0.0",
+    "@types/node": "^20.11.0",
+    "dotenv": "^16.3.1",
+    "uvu": "^0.5.6"
+  }
+}

package/tests/runner.test.js

@@ -0,0 +1,47 @@
+import { App } from '@storecraft/core';
+import { NodePlatform } from '@storecraft/platforms/node';
+import  { api_index } from '@storecraft/test-runner'
+import { Turso } from '../index.js';
+import { migrateToLatest } from '../migrate.js';
+
+export const create_app = async () => {
+
+  const app = new App(
+    {
+      auth_admins_emails: ['admin@sc.com'],
+      auth_secret_access_token: 'auth_secret_access_token',
+      auth_secret_refresh_token: 'auth_secret_refresh_token'
+    }
+  )
+  .withPlatform(new NodePlatform())
+  .withDatabase(
+    new Turso(
+      { 
+        prefers_batch_over_transactions: true,
+        libsqlConfig: {
+          url: process.env.TURSO_URL,
+          authToken: process.env.TURSO_API_TOKEN,
+        }
+      }
+    )
+  )
+
+  return app.init();
+}
+
+async function test() {
+  const app = await create_app();
+
+  await migrateToLatest(app.db, false);
+
+  Object.entries(api_index).slice(0, -1).forEach(
+    ([name, runner]) => {
+      runner.create(app).run();
+    }
+  );
+  const last_test = Object.values(api_index).at(-1).create(app);
+  last_test.after(async ()=>{app.db.disconnect()});
+  last_test.run();
+}
+
+test();

package/tests/sandbox.js

@@ -0,0 +1,33 @@
+import 'dotenv/config';
+import { App } from '@storecraft/core';
+import { Turso } from '@storecraft/database-turso';
+import { migrateToLatest } from '@storecraft/database-turso/migrate.js';
+import { NodePlatform } from '@storecraft/platforms/node';
+
+export const test = async () => {
+  const app = new App(
+    {
+      auth_admins_emails: ['admin@sc.com'],
+      auth_secret_access_token: 'auth_secret_access_token',
+      auth_secret_refresh_token: 'auth_secret_refresh_token'
+    }
+  )
+  .withPlatform(new NodePlatform())
+  .withDatabase(
+    new Turso(
+      { 
+        prefers_batch_over_transactions: true,
+        libsqlConfig: {
+          url: process.env.TURSO_URL,
+          authToken: process.env.TURSO_API_TOKEN,
+        }
+      }
+    )
+  );
+  
+  await app.init();
+  await migrateToLatest(app.db, false);
+
+}
+
+test();

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": [
+    "*", 
+    "src/*", 
+    "tests/*.js",
+    "d1/*"
+  ]
+}

package/types.public.d.ts

@@ -0,0 +1,16 @@
+import type { Config as LibSqlConfig } from '@libsql/client'
+export { Turso } from './index.js';
+
+export type Config = {
+
+  /**
+   * @description Official `libsql` config
+   */
+  libsqlConfig: LibSqlConfig
+
+  /**
+   * @description if `true`, transactions are converted into a non-interactive batch,
+   * use with caution and prefer this when transactions are non-interactive
+   */
+  prefers_batch_over_transactions?: boolean;
+}