@storecraft/database-sql-base 1.0.0

package/migrations.sqlite/00000_init_tables.js

@@ -0,0 +1,357 @@
+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', 'text', (col) =>
+      col.primaryKey()
+    )
+    .addColumn('handle', 'text', (col) => col.unique())
+    .addColumn('created_at', 'text')
+    .addColumn('updated_at', 'text')
+    .addColumn('attributes', 'json')
+    .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', 'text', col => col.notNull())
+    .addColumn('entity_handle', 'text')
+    .addColumn('value', 'text')
+    .addColumn('reporter', 'text')
+    .addColumn('context', 'text')
+}
+
+/**
+ * 
+ * @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 
+ * @param {keyof Database} table_name 
+ * @param {boolean} [include_id=true] 
+ * @param {boolean} [include_handle=true] 
+ */
+const create_base_indexes = async (db, table_name, include_id=true, include_handle=true) => {
+  if(include_id) {
+    await db.schema.createIndex(`index_${table_name}_id_updated_at_asc`)
+            .on(table_name)
+            .columns(['id', 'updated_at asc'])
+            .execute();
+    await db.schema.createIndex(`index_${table_name}_id_updated_at_desc`)
+            .on(table_name)
+            .columns(['id', 'updated_at desc'])
+            .execute();
+  }
+
+  if(include_handle) {
+    await db.schema.createIndex(`index_${table_name}_handle_updated_at_asc`)
+            .on(table_name)
+            .columns(['handle', 'updated_at asc'])
+            .execute();
+    await db.schema.createIndex(`index_${table_name}_handle_updated_at_desc`)
+            .on(table_name)
+            .columns(['handle', 'updated_at desc'])
+            .execute();
+  }
+}
+
+
+/**
+ * @param {Kysely<Database>} db 
+ * @param {keyof Pick<Database, 'entity_to_media' | 
+ * 'entity_to_search_terms' | 'entity_to_tags_projections' | 
+ * 'products_to_collections' | 'products_to_discounts' | 
+ * 'products_to_variants' | 'products_to_related_products' | 'storefronts_to_other'>} table_name 
+ */
+const create_entity_table_indexes = async (db, table_name) => {
+  await db.schema.createIndex(`index_${table_name}_entity_id`)
+           .on(table_name)
+           .column('entity_id')
+           .execute();
+  await db.schema.createIndex(`index_${table_name}_entity_handle`)
+           .on(table_name)
+           .column('entity_handle')
+           .execute();
+  await db.schema.createIndex(`index_${table_name}_value`)
+           .on(table_name)
+           .column('value')
+           .execute();
+  await db.schema.createIndex(`index_${table_name}_reporter`)
+           .on(table_name)
+           .column('reporter')
+           .execute();
+  await db.schema.createIndex(`index_${table_name}_context`)
+           .on(table_name)
+           .column('context')
+           .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', 'text', (col) => col.unique())
+      .addColumn('password', 'text')
+      .addColumn('roles', 'json')
+      .addColumn('confirmed_mail', 'integer');
+    await tb.execute();
+    await create_base_indexes(db, 'auth_users');
+  }
+
+  { // tags
+    let tb = create_safe_table(db, 'tags');
+    tb = add_base_columns(tb);
+    tb = tb.addColumn('values', 'json');
+    await tb.execute();
+    await create_base_indexes(db, 'tags');
+  }
+
+  { // templates
+    let tb = create_safe_table(db, 'templates');
+    tb = add_base_columns(tb);
+    tb = tb.addColumn('title', 'text');
+    tb = tb.addColumn('template_html', 'text');
+    tb = tb.addColumn('template_text', 'text');
+    tb = tb.addColumn('reference_example_input', 'json');
+    await tb.execute();
+    await create_base_indexes(db, 'templates');
+  }
+
+  { // collections
+    let tb = create_safe_table(db, 'collections');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('published', 'text')
+    await tb.execute();
+    await create_base_indexes(db, 'collections');
+  }
+
+  { // 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('isbn', 'text', (col) => col.unique())
+      .addColumn('compare_at_price', 'numeric')
+      .addColumn('qty', 'integer')
+      .addColumn('variants_options', 'json')
+      .addColumn('parent_handle', 'text')
+      .addColumn('parent_id', 'text')
+      .addColumn('variant_hint', 'json')
+    await tb.execute();
+    await create_base_indexes(db, 'products');
+  }
+
+  { // products_to_collections
+    await create_entity_to_value_table(db, 'products_to_collections').execute();
+    await create_entity_table_indexes(db, 'products_to_collections');
+  }
+
+  { // products_to_discounts
+    await create_entity_to_value_table(db, 'products_to_discounts').execute();
+    await create_entity_table_indexes(db, 'products_to_discounts');
+  }
+  
+  { // products_to_variants
+    await create_entity_to_value_table(db, 'products_to_variants').execute();
+    await create_entity_table_indexes(db, 'products_to_variants');
+  }
+
+  { // products_to_related_products
+    await create_entity_to_value_table(db, 'products_to_related_products').execute();
+    await create_entity_table_indexes(db, 'products_to_related_products');
+  }
+
+  { // 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();
+    await create_base_indexes(db, 'shipping_methods');
+  }
+
+  { // posts
+    let tb = create_safe_table(db, 'posts');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('title', 'text')
+      .addColumn('text', 'text')
+    await tb.execute();
+    await create_base_indexes(db, 'posts');
+  }
+
+  { // customers
+    let tb = create_safe_table(db, 'customers');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('email', 'text', (col) => col.unique())
+      .addColumn('auth_id', 'text', (col) => col.unique())
+      .addColumn('firstname', 'text')
+      .addColumn('lastname', 'text')
+      .addColumn('phone_number', 'text')
+      .addColumn('address', 'json')
+    await tb.execute();
+    await create_base_indexes(db, 'customers');
+  }
+
+  { // orders
+    let tb = create_safe_table(db, 'orders');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('contact', 'json')
+      .addColumn('address', 'json')
+      .addColumn('line_items', 'json')
+      .addColumn('notes', 'text')
+      .addColumn('shipping_method', 'json')
+      .addColumn('status', 'json')
+      .addColumn('pricing', 'json')
+      .addColumn('validation', 'json')
+      .addColumn('payment_gateway', 'json')
+      .addColumn('coupons', 'json')
+      .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();
+    await create_base_indexes(db, 'orders');
+  }
+
+  { // 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();
+    await create_base_indexes(db, 'storefronts');
+  }
+
+  { // storefronts_to_other
+    await create_entity_to_value_table(db, 'storefronts_to_other').execute();
+    await create_entity_table_indexes(db, 'storefronts_to_other');
+  }
+
+  { // notifications
+    let tb = create_safe_table(db, 'notifications');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('message', 'text')
+      .addColumn('author', 'text')
+      .addColumn('actions', 'json')
+      // .addColumn('search', 'json')
+    await tb.execute();
+    await create_base_indexes(db, 'notifications', true, false);
+  } 
+
+  { // images
+    let tb = create_safe_table(db, 'images');
+    tb = add_base_columns(tb);
+    tb = tb
+      .addColumn('name', 'text')
+      .addColumn('url', 'text')
+    await tb.execute();
+    await create_base_indexes(db, 'images');
+  } 
+
+  { // 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', 'json')
+      .addColumn('_application_id', 'integer')
+      .addColumn('_discount_type_id', 'integer')
+    await tb.execute();
+    await create_base_indexes(db, 'discounts');
+  } 
+
+  { // entity_to_tags_projections
+    await create_entity_to_value_table(db, 'entity_to_tags_projections').execute();
+    await create_entity_table_indexes(db, 'entity_to_tags_projections');
+  }
+
+  { // entity_to_search_terms
+    await create_entity_to_value_table(db, 'entity_to_search_terms').execute();
+    await create_entity_table_indexes(db, 'entity_to_search_terms');
+  }
+
+  { // entity_to_media
+    await create_entity_to_value_table(db, 'entity_to_media').execute();
+    await create_entity_table_indexes(db, 'entity_to_media');
+  }
+
+}
+
+/**
+ * 
+ * @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'),
+  ]);
+}

package/migrations.sqlite/00001_seed_email_templates.js

@@ -0,0 +1 @@
+export * from '../migrations.shared/00001_seed_email_templates.js'

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@storecraft/database-sql-base",
+  "version": "1.0.0",
+  "description": "Official SQL Database driver for storecraft",
+  "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-sql-base"
+  },
+  "keywords": [
+    "commerce",
+    "dashboard",
+    "code",
+    "storecraft"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "types": "./types.public.d.ts",
+  "scripts": {
+    "test": "uvu -c",
+    "database-sql-base:test:sqlite": "node ./tests/runner.sqlite-local.test.js",
+    "database-sql-base:test:postgres": "node ./tests/runner.postgres-local.test.js",
+    "database-sql-base:test:mysql": "node ./tests/runner.mysql-local.test.js",
+    "database-sql-base:publish": "npm publish --access public"
+  },
+  "dependencies": {
+    "@storecraft/core": "^1.0.0",
+    "kysely": "^0.27.2"
+  },
+  "devDependencies": {
+    "@storecraft/platform-node": "^1.0.0",
+    "@storecraft/test-runner": "^1.0.0",
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/node": "^20.11.0",
+    "@types/pg": "^8.11.2",
+    "better-sqlite3": "^9.4.3",
+    "dotenv": "^16.3.1",
+    "mysql2": "^3.9.2",
+    "pg": "^8.11.3",
+    "tarn": "^3.0.2",
+    "tedious": "^18.1.0",
+    "uvu": "^0.5.6"
+  }
+}

package/src/con.auth_users.js

@@ -0,0 +1,159 @@
+import { SQL } from '../driver.js'
+import { sanitize_array } from './utils.funcs.js'
+import { count_regular, delete_me, insert_search_of, insert_tags_of, regular_upsert_me, 
+  where_id_or_handle_table, 
+  with_media, 
+  with_tags} from './con.shared.js'
+import { query_to_eb, query_to_sort } from './utils.query.js';
+
+/**
+ * @typedef {import('@storecraft/core/v-database').db_auth_users} db_col
+ */
+
+export const table_name = 'auth_users';
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["upsert"]}
+ */
+const upsert = (driver) => {
+  return async (item, search_terms=[]) => {
+    const c = driver.client;
+    try {
+      const t = await c.transaction().execute(
+        async (trx) => {
+
+          await insert_tags_of(trx, item.tags, item.id, item.email, table_name);
+          await insert_search_of(trx, search_terms, item.id, item.email, table_name);
+
+          return await regular_upsert_me(trx, table_name, {
+            confirmed_mail: item.confirmed_mail ? 1 : 0,
+            email: item.email,
+            handle: item.email,
+            password: item.password,
+            created_at: item.created_at,
+            updated_at: item.updated_at,
+            id: item.id,
+            roles: JSON.stringify(item.roles),
+          });
+        }
+      );
+      return t.numInsertedOrUpdatedRows>0;
+    } catch(e) {
+      console.log(e);
+      return false;
+    }
+    return true;
+  }
+}
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["get"]}
+ */
+const get = (driver) => {
+  return (id_or_email, options) => {
+    return driver.client
+      .selectFrom(table_name)
+      .selectAll()
+      .where(where_id_or_handle_table(id_or_email))
+      .executeTakeFirst();
+  }
+}
+
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["getByEmail"]}
+ */
+const getByEmail = (driver) => {
+  return (email) => {
+    return driver.client
+      .selectFrom('auth_users')
+      .selectAll().where('email', '=', email)
+      .executeTakeFirst();
+  }
+}
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["remove"]}
+ */
+const remove = (driver) => {
+  return async (id_or_email) => {
+    try {
+      await driver.client.transaction().execute(
+        async (trx) => {
+            
+          // entities
+          // delete me
+          await delete_me(trx, table_name, id_or_email);
+        }
+      );
+    } catch(e) {
+      console.log(e);
+      return false;
+    }
+    return true;
+  }
+}
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["removeByEmail"]}
+ */
+const removeByEmail = (driver) => {
+  return async (email) => {
+    const r = await driver.client
+      .deleteFrom('auth_users')
+      .where('email', '=', email)
+      .executeTakeFirst();
+    return r.numDeletedRows>0;
+  }
+}
+
+/**
+ * @param {SQL} driver 
+ * 
+ * 
+ * @returns {db_col["list"]}
+ */
+const list = (driver) => {
+  return async (query) => {
+
+    const items = await driver.client.selectFrom(table_name)
+      .selectAll()
+      .select(eb => [
+        with_tags(eb, eb.ref('auth_users.id'), driver.dialectType),
+        with_media(eb, eb.ref('auth_users.id'), driver.dialectType),
+      ])
+      .where(
+        (eb) => {
+          return query_to_eb(eb, query, table_name);
+        }
+      )
+      .orderBy(query_to_sort(query))
+      .limit(query.limitToLast ?? query.limit ?? 10)
+      .execute();
+
+    if(query.limitToLast) items.reverse();
+
+    return items;
+  }
+}
+
+/** 
+ * @param {SQL} driver
+ * @return {db_col}}
+ * */
+export const impl = (driver) => {
+
+  return {
+    get: get(driver),
+    getByEmail: getByEmail(driver),
+    upsert: upsert(driver),
+    remove: remove(driver),
+    removeByEmail: removeByEmail(driver),
+    list: list(driver),
+    count: count_regular(driver, table_name),
+  }
+}