@storecraft/database-sql-base 1.0.0

package/README.md

@@ -0,0 +1,126 @@
+# Storecraft `SQL` driver
+
+Official `SQL` driver for `StoreCraft` with the dialects abstracted with `Kysely` or your own drivers.
+
+## 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/platform-node'
+import { MongoDB } from '@storecraft/database-mongodb-node'
+import { NodeLocalStorage } from '@storecraft/storage-node-local'
+
+let app = new App(
+  new NodePlatform(),
+  new MongoDB({ db_name: 'prod', url: '<MONGO-URL>'}),
+  new NodeLocalStorage(join(homedir(), 'tomer'))
+);
+
+await app.init();
+ 
+const server = http.createServer(app.handler).listen(
+  8000,
+  () => {
+    console.log(`Server is running on http://localhost:8000`);
+  }
+); 
+
+```
+
+## Testing Locally
+
+### **SQLite**
+1. Simply `runner.sqlite-local.test.js`
+```bash
+npm run test:sqlite
+```
+
+### **Postgres**
+1. First setup a `postgres` server
+```bash
+docker pull postgres
+docker run --name some-postgres -e POSTGRES_USER=admin -e POSTGRES_PASSWORD=admin \
+          -e PGDATA=/var/lib/postgresql/data/pgdata \
+	        -v $(pwd):/var/lib/postgresql/data \
+          -p 5432:5432 -d postgres
+```
+
+2. create Environment
+create `.env` file with
+```bash
+POSTGRES_USER='user'
+POSTGRES_PASSWORD='password'
+POSTGRES_PORT=5432
+POSTGRES_HOST='localhost'
+```
+
+3. Run `runner.postgres-local.test.js`
+```bash
+npm run test:postgres
+```
+
+### **MySQL**
+1. First setup a `mysql` server
+```zsh
+docker pull mysql
+docker run --name mysql \
+           -v $(pwd):/etc/mysql/conf.d \
+           -v /my/own/datadir:/var/lib/mysql \
+           -e MYSQL_ROOT_PASSWORD=admin -e MYSQL_ROOT_HOST=localhost \
+           -e MYSQL_DATABASE=main -e MYSQL_USER=admin -e MYSQL_PASSWORD=admin \
+           -p 8080:3306 -d mysql
+```
+
+2. create Environment
+create `.env` file with
+```bash
+MYSQL_USER='root'
+MYSQL_ROOT_PASSWORD='password'
+MYSQL_PORT=8080
+MYSQL_HOST='localhost'
+```
+
+3. Run `runner.mysql-local.test.js`
+```bash
+npm run test:mysql
+```
+
+### **MSSQL** (Currently NOT SUPPORTED, waiting for votes on that one)
+Work in progress, i will probably not continue with this.
+
+1. First setup a `mysql` server
+```zsh
+docker pull mcr.microsoft.com/mssql/server
+# use this For OSX with M1 chips
+docker pull mcr.microsoft.com/azure-sql-edge:latest
+docker run --name some-mssql \
+           -e ACCEPT_EULA=Y -e MSSQL_SA_PASSWORD='Abcd1234!?' \
+           -v $(pwd):/var/opt/mssql \
+           -p 1433:1433 \
+           -d mcr.microsoft.com/azure-sql-edge:latest
+
+```
+
+2. create Environment
+create `.env` file with
+```bash
+MYSQL_USER='root'
+MYSQL_ROOT_PASSWORD='password'
+MYSQL_PORT=8080
+MYSQL_HOST='localhost'
+```
+
+3. Run `runner.mysql-local.test.js`
+```bash
+npm run test:mysql
+```
+
+
+```text
+Author: Tomer Shalev <tomer.shalev@gmail.com>
+```

package/TODO.md

@@ -0,0 +1,2 @@
+- seacrh terms (vql)
+  - TODO: test it

package/db-strategy.md

@@ -0,0 +1,3 @@
+# SQL data modeling strategy
+
+TODO

package/driver.js

@@ -0,0 +1,190 @@
+import { App } from '@storecraft/core';
+import { impl as auth_users } from './src/con.auth_users.js';
+import { impl as collections } from './src/con.collections.js';
+import { impl as customers } from './src/con.customers.js';
+import { impl as discounts } from './src/con.discounts.js';
+import { impl as images } from './src/con.images.js';
+import { impl as notifications } from './src/con.notifications.js';
+import { impl as orders } from './src/con.orders.js';
+import { impl as posts } from './src/con.posts.js';
+import { impl as products } from './src/con.products.js';
+import { impl as shipping } from './src/con.shipping.js';
+import { impl as storefronts } from './src/con.storefronts.js';
+import { impl as tags } from './src/con.tags.js';
+import { impl as templates } from './src/con.templates.js';
+import { impl as search } from './src/con.search.js';
+import { Kysely, ParseJSONResultsPlugin } from 'kysely'
+import { SanitizePlugin } from './src/kysely.sanitize.plugin.js';
+
+
+/**
+ * @param {any} b 
+ * @param {string} msg 
+ */
+const assert = (b, msg) => {
+  if(!Boolean(b)) throw new Error(msg);
+}
+
+/**
+ * @typedef {import('./types.public.js').Config} Config
+ * @typedef {import('./types.sql.tables.js').Database} Database
+ * @typedef {import('kysely').Dialect} Dialect
+ * @typedef {import('@storecraft/core/v-database').db_driver} db_driver
+*/
+
+/**
+ * @implements {db_driver}
+ */
+export class SQL {
+
+  /** @type {boolean} */ 
+  #_is_ready;
+
+  /** @type {App<any, any, any>} */ 
+  #_app;
+
+  /** @type {Config} */ 
+  #_config;
+
+  /** @type {Kysely<Database>} */ 
+  #_client;
+  
+  /** @type {db_driver["resources"]} */ 
+  #_resources;
+
+  /**
+   * 
+   * @param {Config} [config] config 
+   */
+  constructor(config) {
+    this.#_is_ready = false;
+    this.#_config = config;
+
+    assert(
+      this.#_config.dialect, 
+      'No Dialect found !'
+    );
+
+    assert(
+      this.#_config.dialect_type, 
+      'No Dialect Type specified !'
+    );
+
+    this.#_client = new Kysely(
+      {
+        dialect: this.#_config.dialect, 
+        plugins: [
+          new ParseJSONResultsPlugin(),
+          new SanitizePlugin()
+        ]
+      }
+    );
+  }
+
+  throwIfNotReady() {
+    assert(
+      this.isReady,
+      'Database not ready !!! you need to `.init()` it'
+    );
+  }
+
+  /**
+   * 
+   * @param {boolean} [destroy_db_upon_completion=false] 
+   */
+  async migrateToLatest(destroy_db_upon_completion=false) {
+    this.throwIfNotReady();
+
+    const { migrateToLatest } = await import('./migrate.js');
+
+    await migrateToLatest(this, destroy_db_upon_completion);
+  };
+
+  /**
+   * 
+   * @param {App<any, any, any>} app 
+   * 
+   * 
+   * @returns {Promise<this>}
+   */
+  async init(app) {
+    if(this.isReady)
+      return this;
+
+    this.#_app = app;
+    
+    this.#_resources = {
+      auth_users: auth_users(this),
+      collections: collections(this),
+      customers: customers(this),
+      discounts: discounts(this),
+      images: images(this),
+      notifications: notifications(this),
+      orders: orders(this),
+      posts: posts(this),
+      products: products(this),
+      storefronts: storefronts(this),
+      tags: tags(this),
+      shipping_methods: shipping(this),
+      templates: templates(this),
+      search: search(this),
+    }
+    
+    this.#_is_ready = true; 
+
+    return this;
+  }
+
+  async disconnect() {
+    await this.client.destroy();
+    return true;
+  }
+
+  /**
+   * `database` resources
+   */
+  get resources () {
+    return this.#_resources;
+  }
+  
+  get name () { 
+    return 'main'; 
+  }
+
+  get app() { 
+    return this.#_app; 
+  }
+
+  get client() { 
+    return this.#_client; 
+  }
+
+  get config() { 
+    return this.#_config; 
+  }
+
+  get isReady() { 
+    return this.#_is_ready; 
+  }
+
+  get dialectType() { 
+    return this.#_config.dialect_type; 
+  }
+
+  get isSqlite() { 
+    return this.dialectType==='SQLITE'; 
+  }
+
+  get isPostgres() { 
+    return this.dialectType==='POSTGRES'; 
+  }
+
+  get isMysql() { 
+    return this.dialectType==='MYSQL'; 
+  }
+
+  get isMssql() { 
+    return this.dialectType==='MSSQL'; 
+  }
+
+}

package/index.js

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

package/migrate.js

@@ -0,0 +1,66 @@
+import { fileURLToPath } from "node:url";
+import * as path from 'path'
+import { promises as fs } from 'fs'
+import {
+  Migrator,
+  FileMigrationProvider,
+} from 'kysely'
+import { SQL } from "./index.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const current = {
+  driver: undefined
+}
+
+/**
+ * 
+ * @param {SQL} db_driver 
+ * @param {boolean} [destroy_db_upon_completion=true] 
+ */
+export async function migrateToLatest(db_driver, destroy_db_upon_completion=true) {
+  if(!db_driver?.client)
+    throw new Error('No Kysely client found !!!');
+
+  console.log('Resolving migrations')
+
+  let db = db_driver.client;
+
+  current.driver = db_driver;
+
+  const migrator = new Migrator({
+    db,
+    provider: new FileMigrationProvider({
+      fs,
+      path,
+      migrationFolder: path.join(
+        __dirname, 
+        `migrations.${db_driver.dialectType.toLowerCase()}`
+      ),
+    }),
+  })
+
+  const { error, results } = await migrator.migrateToLatest();
+
+  results?.forEach((it) => {
+    if (it.status === 'Success') {
+      console.log(
+        `migration "${it.migrationName}" was executed successfully`
+        );
+    } else if (it.status === 'Error') {
+      console.error(
+        `failed to execute migration "${it.migrationName}"`
+        );
+    }
+  })
+
+  if (error) {
+    console.error('failed to migrate')
+    console.error(error)
+    process.exit(1)
+  }
+
+  if(destroy_db_upon_completion)
+    await db.destroy()
+}

package/migrations.mssql/00000_init_tables.js

@@ -0,0 +1,268 @@
+import { CreateTableBuilder, Kysely } from 'kysely'
+
+/**
+ * @typedef {import('../types.sql.tables.js').Database} Database
+ */
+
+/**
+ * @template {string} TB
+ * @template {string} B
+ * @param {CreateTableBuilder<TB, B>} tb 
+ */
+const add_base_columns = tb => {
+  return tb
+    .addColumn('id', 'VARCHAR(256)', (col) =>
+      col.primaryKey()
+    )
+    .addColumn('handle', 'VARCHAR(256)', (col) => col.unique())
+    .addColumn('created_at', 'text')
+    .addColumn('updated_at', 'text')
+    .addColumn('attributes', 'VARCHAR(MAX)')
+    .addColumn('description', 'text')
+    .addColumn('active', 'integer')
+}
+
+/**
+ * @param {Kysely<Database>} db
+ * @param {keyof Database} table_name
+ */
+const create_entity_to_value_table = (db, table_name) => {
+
+  return db.schema
+    .createTable(table_name)
+    .addColumn('id', 'integer', 
+        (col) => col.autoIncrement().primaryKey()
+    )
+    .addColumn('entity_id', 'VARCHAR(256)', col => col.notNull())
+    .addColumn('entity_handle', 'VARCHAR(256)')
+    .addColumn('value', 'VARCHAR(256)')
+    .addColumn('reporter', 'VARCHAR(256)')
+    .addColumn('context', 'VARCHAR(256)')
+}
+
+/**
+ * 
+ * @param {Kysely<Database>} db 
+ * @param {keyof Database} table_name 
+ */
+const create_safe_table = (db, table_name) => {
+  return db.schema.createTable(table_name);
+}
+
+/**
+ * 
+ * @param {Kysely<Database>} db 
+ * @param {keyof Database} table_name 
+ */
+const drop_safe_table = (db, table_name) => {
+  return db.schema.dropTable(table_name).execute();
+}
+
+/**
+ * 
+ * @param {Kysely<Database>} db 
+ */
+export async function up(db) {
+  { // auth_users
+    let tb = create_safe_table(db, 'auth_users');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('email', 'VARCHAR(256)', (col) => col.unique())
+      .addColumn('password', 'text')
+      .addColumn('roles', 'VARCHAR(MAX)')
+      .addColumn('confirmed_mail', 'integer');
+    await tb.execute();
+  }
+
+  { // tags
+    let tb = create_safe_table(db, 'tags');
+    tb = add_base_columns(tb);
+    tb = tb.addColumn('values', 'VARCHAR(MAX)');
+    await tb.execute();
+  }
+
+  { // collections
+    let tb = create_safe_table(db, 'collections');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('published', 'text')
+    await tb.execute();
+  }
+
+  { // products
+    let tb = create_safe_table(db, 'products');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('video', 'text')
+      .addColumn('price', 'numeric')
+      .addColumn('compare_at_price', 'numeric')
+      .addColumn('qty', 'integer')
+      .addColumn('variants_options', 'VARCHAR(MAX)')
+      .addColumn('parent_handle', 'text')
+      .addColumn('parent_id', 'text')
+      .addColumn('variant_hint', 'VARCHAR(MAX)')
+    await tb.execute();
+  }
+
+  { // products_to_collections
+    let tb = create_entity_to_value_table(db, 'products_to_collections')
+    await tb.execute();
+  }
+
+  { // products_to_discounts
+    let tb = create_entity_to_value_table(db, 'products_to_discounts')
+    await tb.execute();
+  }
+  
+  { // products_to_variants
+    let tb = create_entity_to_value_table(db, 'products_to_variants')
+    await tb.execute();
+  }
+
+  { // shipping_methods
+    let tb = create_safe_table(db, 'shipping_methods');
+    tb = add_base_columns(tb);
+    tb = tb.addColumn('title', 'text')
+      .addColumn('price', 'numeric')
+    await tb.execute();
+  }
+
+  { // posts
+    let tb = create_safe_table(db, 'posts');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('text', 'text')
+    await tb.execute();
+  }
+
+  { // customers
+    let tb = create_safe_table(db, 'customers');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('email', 'VARCHAR(256)', (col) => col.unique())
+      .addColumn('auth_id', 'VARCHAR(256)', (col) => col.unique())
+      .addColumn('firstname', 'text')
+      .addColumn('lastname', 'text')
+      .addColumn('phone_number', 'text')
+      .addColumn('address', 'VARCHAR(MAX)')
+    await tb.execute();
+  }
+
+  { // orders
+    let tb = create_safe_table(db, 'orders');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('contact', 'VARCHAR(MAX)')
+      .addColumn('address', 'VARCHAR(MAX)')
+      .addColumn('line_items', 'VARCHAR(MAX)')
+      .addColumn('notes', 'text')
+      .addColumn('shipping_method', 'VARCHAR(MAX)')
+      .addColumn('status', 'VARCHAR(MAX)')
+      .addColumn('pricing', 'VARCHAR(MAX)')
+      .addColumn('validation', 'VARCHAR(MAX)')
+      .addColumn('payment_gateway', 'VARCHAR(MAX)')
+      .addColumn('coupons', 'VARCHAR(MAX)')
+      .addColumn('_customer_id', 'text')
+      .addColumn('_customer_email', 'text')
+      .addColumn('_status_payment_id', 'integer')
+      .addColumn('_status_checkout_id', 'integer')
+      .addColumn('_status_fulfillment_id', 'integer')
+    
+    await tb.execute();
+  }
+
+  { // storefronts
+    let tb = create_safe_table(db, 'storefronts');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('video', 'text')
+      .addColumn('published', 'text')
+    await tb.execute();
+  }
+
+  { // storefronts_to_other
+    let tb = create_entity_to_value_table(db, 'storefronts_to_other')
+    await tb.execute();
+  }
+
+  { // notifications
+    let tb = create_safe_table(db, 'notifications');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('message', 'text')
+      .addColumn('author', 'text')
+      .addColumn('actions', 'VARCHAR(MAX)')
+    await tb.execute();
+  } 
+
+  { // images
+    let tb = create_safe_table(db, 'images');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('name', 'text')
+      .addColumn('url', 'text')
+    await tb.execute();
+  } 
+
+  { // discounts
+    let tb = create_safe_table(db, 'discounts');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('published', 'text')
+      .addColumn('priority', 'integer')
+      .addColumn('info', 'json')
+      .addColumn('application', 'VARCHAR(MAX)')
+      .addColumn('_application_id', 'integer')
+      .addColumn('_discount_type_id', 'integer')
+    await tb.execute();
+  } 
+
+  { // entity_to_tags_projections
+    let tb = create_entity_to_value_table(db, 'entity_to_tags_projections')
+    await tb.execute();
+  }
+
+  { // entity_to_search_terms
+    let tb = create_entity_to_value_table(db, 'entity_to_search_terms')
+    await tb.execute();
+  }
+
+  { // entity_to_media
+    let tb = create_entity_to_value_table(db, 'entity_to_media')
+    await tb.execute();
+  }
+
+}
+
+/**
+ * 
+ * @param {Kysely<Database>} db 
+ */
+export async function down(db) {
+  await Promise.all([
+    drop_safe_table(db, 'auth_users'),
+    drop_safe_table(db, 'tags'),
+    drop_safe_table(db, 'collections'),
+    drop_safe_table(db, 'customers'),
+    drop_safe_table(db, 'discounts'),
+    drop_safe_table(db, 'images'),
+    drop_safe_table(db, 'notifications'),
+    drop_safe_table(db, 'orders'),
+    drop_safe_table(db, 'posts'),
+    drop_safe_table(db, 'shipping_methods'),
+    drop_safe_table(db, 'products'),
+    drop_safe_table(db, 'products_to_collections'),
+    drop_safe_table(db, 'products_to_discounts'),
+    drop_safe_table(db, 'products_to_variants'),
+    drop_safe_table(db, 'storefronts'),
+    drop_safe_table(db, 'storefronts_to_other'),
+    drop_safe_table(db, 'entity_to_media'),
+    drop_safe_table(db, 'entity_to_search_terms'),
+    drop_safe_table(db, 'entity_to_tags_projections'),
+  ]);
+}