@storecraft/database-planetscale 1.0.0

package/README.md

@@ -0,0 +1,68 @@
+# Storecraft Planetscale (cloud mysql) Database support
+
+<div style="text-align:center">
+  <img src='https://storecraft.app/storecraft-color.svg' 
+       width='90%'' />
+</div><hr/><br/>
+
+Official `Planetscale` (cloud MySql) driver for `StoreCraft` on any platforms.
+
+```bash
+npm i @storecraft/database-neon
+```
+
+## Setup
+
+- First, login to your [planetscale](https://planetscale.com/) account.
+- Create a database.
+- Copy the `connection string`.
+
+
+## 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 { PlanetScale } from '@storecraft/database-planetscale'
+import { migrateToLatest } from '@storecraft/database-planetscale/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 PlanetScale(
+    { 
+      url: process.env.PLANETSCALE_CONNECTION_URL,
+      useSharedConnection: true
+    }
+  )
+)
+.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/index.js

@@ -0,0 +1,34 @@
+import { SQL } from '@storecraft/database-sql-base';
+import { PlanetScaleDialect } from './kysely.planet.dialect.js';
+
+
+/**
+ * @param {any} b 
+ * @param {string} msg 
+ */
+const assert = (b, msg) => {
+  if(!Boolean(b)) throw new Error(msg);
+}
+
+
+/**
+ * 
+ * @extends {SQL}
+ */
+export class PlanetScale extends SQL {
+
+  /**
+   * 
+   * @param {import('./types.public.d.ts').PlanetScaleDialectConfig} [config] config 
+   */
+  constructor(config) {
+    super(
+      {
+        dialect_type: 'MYSQL',
+        dialect: new PlanetScaleDialect(config),
+      }
+    );
+
+  }
+
+}

package/jsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "checkJs": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": [
+    "*", 
+    "src/*", 
+    "tests/*.js",
+    "d1/*"
+  ]
+}

package/kysely.planet.dialect.js

@@ -0,0 +1,209 @@
+import {connect, Connection} from '@planetscale/database'
+import {
+  CompiledQuery,
+  Kysely,
+  MysqlAdapter,
+  MysqlIntrospector,
+  MysqlQueryCompiler,
+} from 'kysely'
+
+/**
+ * @typedef {import('kysely').Dialect} Dialect
+ * @typedef {import('kysely').Driver} Driver
+ * @typedef {import('kysely').DatabaseConnection} DatabaseConnection
+ * @typedef {import('kysely').DatabaseIntrospector} DatabaseIntrospector
+ * @typedef {import('./types.public.d.ts').PlanetScaleDialectConfig} PlanetScaleDialectConfig
+ */
+
+/**
+ * PlanetScale dialect that uses the [PlanetScale Serverless Driver for JavaScript][0].
+ * The constructor takes an instance of {@link Config} from `@planetscale/database`.
+ *
+ * ```typescript
+ * new PlanetScaleDialect({
+ *   host: '<host>',
+ *   username: '<username>',
+ *   password: '<password>',
+ * })
+ *
+ * // or with a connection URL
+ *
+ * new PlanetScaleDialect({
+ *   url: process.env.DATABASE_URL ?? 'mysql://<username>:<password>@<host>/<database>'
+ * })
+ * ```
+ *
+ * See the [`@planetscale/database` documentation][1] for more information.
+ *
+ * [0]: https://github.com/planetscale/database-js
+ * [1]: https://github.com/planetscale/database-js#readme
+ * 
+ * @implements {Dialect}
+ */
+export class PlanetScaleDialect {
+
+  /**
+   * @param {PlanetScaleDialectConfig} config 
+   */
+  constructor(config) {
+    this.config = config
+  }
+
+  createAdapter() { return new MysqlAdapter() }
+  createDriver() { return new PlanetScaleDriver(this.config) }
+  createQueryCompiler() { return new MysqlQueryCompiler() }
+  /** @type {Dialect["createIntrospector"]} */
+  createIntrospector(db) { return new MysqlIntrospector(db) }
+}
+
+/**
+ * @implements {Driver}
+ */
+class PlanetScaleDriver {
+
+  /**
+   * @param {PlanetScaleDialectConfig} config 
+   */
+  constructor(config) {
+    this.config = config
+  }
+
+  async init() {}
+
+  async acquireConnection(){
+    return new PlanetScaleConnection(this.config)
+  }
+
+  /**
+   * @param {PlanetScaleConnection} conn 
+   */
+  async beginTransaction(conn) {
+    return await conn.beginTransaction()
+  }
+
+  /**
+   * @param {PlanetScaleConnection} conn 
+   */
+  async commitTransaction(conn) {
+    return await conn.commitTransaction()
+  }
+
+  /**
+   * @param {PlanetScaleConnection} conn 
+   */
+  async rollbackTransaction(conn) {
+    return await conn.rollbackTransaction()
+  }
+
+  /**
+   * @param {PlanetScaleConnection} _conn 
+   */
+  async releaseConnection(_conn) {}
+
+  async destroy() {}
+}
+
+
+/** @type {WeakMap<PlanetScaleDialectConfig, Connection>} */
+const sharedConnections = new WeakMap()
+
+
+/**
+ * @implements {DatabaseConnection}
+ */
+class PlanetScaleConnection {
+  /** @type {Connection} */
+  #conn;
+  /** @type {PlanetScaleConnection} */
+  #transactionClient; 
+
+  /**
+   * 
+   * @param {PlanetScaleDialectConfig} config 
+   * @param {boolean} [isForTransaction=false] 
+   */
+  constructor(config, isForTransaction = false) {
+    this.config = config;
+
+    const useSharedConnection = config.useSharedConnection && !isForTransaction;
+    const sharedConnection = useSharedConnection ? sharedConnections.get(config) : undefined;
+
+    this.#conn = sharedConnection ?? connect({...config});
+
+    if (useSharedConnection) 
+      sharedConnections.set(config, this.#conn);
+  }
+
+  /**
+   * @template R result type
+   * 
+   * @param {CompiledQuery} compiledQuery 
+   * 
+   * @returns {Promise<import('kysely').QueryResult<R>>}
+   */
+  async executeQuery(compiledQuery) {
+    if (this.#transactionClient) 
+      return this.#transactionClient.executeQuery(compiledQuery);
+
+    // If no custom formatter is provided, format dates as DB date strings
+    const parameters = compiledQuery.parameters;
+    const results = await this.#conn.execute(
+      compiledQuery.sql, parameters
+    );
+
+    // @planetscale/database versions older than 1.3.0 return errors directly, rather than throwing
+    if (( /** @type {any} */ (results))?.error) {
+      throw ( /** @type {any} */ (results))?.error;
+    }
+
+    const numAffectedRows = (results.rowsAffected == null) ? 
+        undefined : BigInt(results.rowsAffected);
+    const insertId = (results.insertId !== null && results.insertId.toString() !== '0') ? 
+        BigInt(results.insertId) : undefined;
+
+    return {
+      insertId,
+      rows: ( /** @type {R[]} */ (results.rows)),
+      // @ts-ignore replaces `QueryResult.numUpdatedOrDeletedRows` in kysely > 0.22
+      // following https://github.com/koskimas/kysely/pull/188
+      numAffectedRows,
+      // deprecated in kysely > 0.22, keep for backward compatibility.
+      numUpdatedOrDeletedRows: numAffectedRows,
+    }
+  }
+
+  async beginTransaction() {
+    this.#transactionClient = this.#transactionClient ?? new PlanetScaleConnection(this.config, true);
+    await this.#transactionClient.#conn.execute('BEGIN');
+  }
+
+  async commitTransaction() {
+    if (!this.#transactionClient) throw new Error('No transaction to commit')
+    try {
+      await this.#transactionClient.#conn.execute('COMMIT')
+    } finally {
+      this.#transactionClient = undefined
+    }
+  }
+
+  async rollbackTransaction() {
+    if (!this.#transactionClient) throw new Error('No transaction to rollback')
+    try {
+      await this.#transactionClient.#conn.execute('ROLLBACK')
+    } finally {
+      this.#transactionClient = undefined
+    }
+  }
+
+  /**
+   * @template R result type
+   * 
+   * @param {CompiledQuery} _compiledQuery 
+   * @param {number} _chunkSize 
+   * 
+   * @returns {AsyncIterableIterator<import('kysely').QueryResult<R>>}
+   */
+  async *streamQuery(_compiledQuery, _chunkSize) {
+    throw new Error('PlanetScale Serverless Driver does not support streaming')
+  }
+}

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-planetscale",
+  "version": "1.0.0",
+  "description": "`Storecraft` database driver for `PlanetScale` (cloud mysql)",
+  "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-planetscale"
+  },
+  "keywords": [
+    "commerce",
+    "dashboard",
+    "code",
+    "storecraft"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "types": "./types.public.d.ts",
+  "scripts": {
+    "database-planetscale:test": "node ./tests/runner.test.js",
+    "database-planetscale:publish": "npm publish --access public"
+  },
+  "peerDependencies": {
+    "kysely": "*"
+  },
+  "dependencies": {
+    "@planetscale/database": "^1.18.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,44 @@
+import { App } from '@storecraft/core';
+import { NodePlatform } from '@storecraft/platforms/node';
+import  { api_index } from '@storecraft/test-runner'
+import { PlanetScale } from '@storecraft/database-planetscale';
+import { migrateToLatest } from '@storecraft/database-planetscale/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 PlanetScale(
+      { 
+        url: process.env.PLANETSCALE_CONNECTION_URL,
+        useSharedConnection: true
+      }
+    )
+  )
+  
+  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/types.public.d.ts

@@ -0,0 +1,18 @@
+import type { Config } from '@planetscale/database'
+
+export { PlanetScale } from './index.js'
+
+/**
+ * @description Config for the PlanetScale dialect. It extends {@link Config} from `@planetscale/database`,
+ * so you can pass any of those options to the constructor.
+ *
+ * @see https://github.com/planetscale/database-js#usage
+ */
+export interface PlanetScaleDialectConfig extends Config {
+  /**
+   * Use a single `@planetscale/database` connection for all non-transaction queries.
+   *
+   * @default false
+   */
+  useSharedConnection?: boolean
+}