@storecraft/database-sql-base 1.0.0

package/src/con.discounts.utils.js

@@ -0,0 +1,180 @@
+import { enums } from "@storecraft/core/v-api";
+
+/** @param {import("@storecraft/core/v-api").DiscountType} d */
+const is_order_discount = d => {
+  return (d.info.details.meta.id===enums.DiscountMetaEnum.order.id);
+}
+
+/** @param {import("@storecraft/core/v-api").DiscountType} d */
+const is_automatic_discount = d => {
+  return (d.application.id===enums.DiscountApplicationEnum.Auto.id);
+}
+
+const extract_abs_number = v => {
+  return v && !isNaN(v) && v!==Infinity && Math.abs(v);
+}
+/**
+ * @typedef {import("../index.js").Database} Database
+ * @param {import("kysely").ExpressionBuilder<Database, 'products'>} eb 
+ * @param {keyof Pick<Database, 'entity_to_tags_projections' | 'products_to_collections'>} table 
+ * @param {import("kysely").BinaryOperator} op 
+ * @param {string[]} value 
+ */
+const eb_in = (eb, table, op, value) => {
+  return eb.exists(
+    eb => eb
+      .selectFrom(table)
+      .select('id')
+      .where(
+        eb => eb.and([
+          eb.or(
+            [
+              eb(`${table}.entity_id`, '=', eb.ref('products.id')),
+              eb(`${table}.entity_handle`, '=', eb.ref('products.handle')),
+            ]
+          ),
+          eb(`${table}.value`, op, value)
+        ])
+      )
+  )
+}
+
+/**
+ * create a mongodb conjunctions clauses from discount, intended
+ * for filtering.
+ * @param {import("kysely").ExpressionBuilder<Database, 'products'>} eb 
+ * @param {import("@storecraft/core/v-api").DiscountType} d 
+ */
+export const discount_to_conjunctions = (eb, d) => {
+  // discount has to be product discount + automatic + active + has filters
+  const is_good = (
+    !is_order_discount(d) && is_automatic_discount(d) && 
+    d.active && d?.info?.filters?.length
+  );
+
+  if(!is_good) return [];
+
+  const conjunctions = [];
+  const filters = d.info.filters;
+
+  for(const filter of filters) {
+    const op = filter.meta.op;
+
+    switch (op) {
+      case enums.FilterMetaEnum.p_all.op:
+        // do nothing
+        break;
+      case enums.FilterMetaEnum.p_in_products.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_in_products} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+
+          conjunctions.push(
+            eb(
+              'products.handle', 'in', 
+              cast.map(item => item.handle).filter(Boolean)
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_not_in_products.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_not_in_products} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+
+          conjunctions.push(
+            eb(
+              'products.handle', 'not in', 
+              cast.map(item => item.handle).filter(Boolean)
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_in_tags.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_in_tags} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+          
+          conjunctions.push(
+            eb_in(
+              eb, 'entity_to_tags_projections', 'in', 
+              cast
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_not_in_tags.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_not_in_tags} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+
+          conjunctions.push(
+            eb.not(
+              eb_in(
+                eb, 'entity_to_tags_projections', 'in', 
+                cast
+              )
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_in_collections.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_in_collections} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+
+          // PROBLEM: we only have ids, but use handles in the filters
+          conjunctions.push(
+            eb_in(
+              eb, 'products_to_collections', 'in', 
+              cast.map(c => c.id)
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_not_in_collections.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_not_in_collections} */
+          const cast = Array.isArray(filter?.value) ? filter.value : [];
+
+          conjunctions.push(
+            eb.not(
+              eb_in(
+                eb, 'products_to_collections', 'in', 
+                cast.map(c => c.id)
+              )
+            )
+          );
+        }
+        break;
+      case enums.FilterMetaEnum.p_in_price_range.op:
+        {
+          /** @type {import("@storecraft/core/v-api").FilterValue_p_in_price_range} */
+          const cast = {
+            from: 0,
+            to: Number.POSITIVE_INFINITY,
+            ...(filter?.value ?? {}),
+          };
+
+          const from = extract_abs_number(cast.from);
+          const to = extract_abs_number(cast.to);
+
+          const conj = { price: { $and: [] } };
+
+          if(from) 
+            conjunctions.push(eb('price', '>=', from));
+
+          if(to) 
+            conjunctions.push(eb('price', '<', to));
+
+        }
+        break;
+    
+      default:
+        break;
+    }
+  }
+
+  return conjunctions;
+}
+

package/src/con.helpers.json.js

@@ -0,0 +1,231 @@
+import {
+  AliasNode, ColumnNode, ExpressionWrapper, IdentifierNode, 
+  ReferenceNode, SelectQueryNode, TableNode, ValueNode } from 'kysely'
+import { sqlite_jsonArrayFrom, sqlite_jsonObjectFrom, 
+  sqlite_stringArrayFrom } from './con.helpers.json.sqlite.js'
+import { pg_jsonArrayFrom, pg_jsonObjectFrom, 
+  pg_stringArrayFrom } from './con.helpers.json.postgres.js'
+import { mysql_jsonArrayFrom, mysql_jsonObjectFrom, 
+  mysql_stringArrayFrom } from './con.helpers.json.mysql.js'
+import { mssql_jsonArrayFrom, mssql_jsonObjectFrom, 
+  mssql_stringArrayFrom } from './con.helpers.json.mssql.js'
+
+  
+/**
+ * @template O
+ * @typedef {Object} _SelectQueryBuilderExpression
+ * @property {boolean} isSelectQueryBuilder
+ * @property {() => SelectQueryNode} toOperationNode
+ */
+
+/**
+ * @template O
+ * @typedef {import('kysely').AliasableExpression<O> & _SelectQueryBuilderExpression<O>} SelectQueryBuilderExpression
+ * @property {boolean} isSelectQueryBuilder
+ * @property {(): SelectQueryNode} toOperationNode
+ */
+
+
+/**
+ * 
+ * @param {SelectQueryNode} node 
+ * @param {string} table 
+ * @returns {import('kysely').Expression<unknown>[] }
+ */
+export function getJsonObjectArgs(node, table) {
+  /** @type {import('kysely').Expression<unknown>[] } */
+  const args = []
+
+  for (const { selection: s } of node.selections ?? []) {
+    
+    if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
+      args.push(
+        colName(s.column.column.name),
+        colRef(table, s.column.column.name),
+      )
+    } else if (ColumnNode.is(s)) {
+      args.push(colName(s.column.name), colRef(table, s.column.name))
+    } else if (AliasNode.is(s) && IdentifierNode.is(s.alias)) {
+      args.push(colName(s.alias.name), colRef(table, s.alias.name))
+    } else {
+      throw new Error(`can't extract column names from the select query node`)
+    }
+  }
+
+  return args
+}
+
+/**
+ * 
+ * @param {string} col 
+ * @returns {import('kysely').Expression<unknown> }
+ */
+function colName(col) {
+  return new ExpressionWrapper(ValueNode.createImmediate(col))
+}
+
+/**
+ * 
+ * @param {string} table 
+ * @param {string} col 
+ * @returns {import('kysely').Expression<unknown> }
+ */
+function colRef(table, col) {
+  return new ExpressionWrapper(
+    ReferenceNode.create(ColumnNode.create(col), TableNode.create(table)),
+  )
+}
+
+/**
+ * @template O
+ * @param {SelectQueryBuilderExpression<O>} expr 
+ * @param {string} table 
+ * @returns {import('kysely').Expression<unknown>}
+ */
+export const extract_first_selection = (expr, table) => {
+  /** @type {any} */
+  let s_ = expr.toOperationNode();
+  /** @type {SelectQueryNode} */
+  const s__ = s_;
+  const s = s__.selections[0].selection;
+  /** @type {import('kysely').Expression<unknown>} */
+  let arg;
+  if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
+    // console.log('arg ', s)
+    arg = colRef(table, s.column.column.name);
+  } else if (ColumnNode.is(s)) {
+    arg = colRef(table, s.column.name);
+    // console.log('arg ', 2)
+  } else if (AliasNode.is(s) && IdentifierNode.is(s.alias)) {
+    arg = colRef(table, s.alias.name);
+    // console.log('arg ', 3)
+  } else {
+    throw new Error(`can't extract column names from the select query node`)
+  } 
+  return arg;
+}
+
+/**
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ * 
+ * @template O
+ * @param {import('./con.helpers.json.js').SelectQueryBuilderExpression<O>} expr 
+ * @param {import('../types.public.js').SqlDialectType} sql_type 
+ * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O>[]>}
+ */
+export function jsonArrayFrom(expr, sql_type) {
+  switch(sql_type) {
+    case 'SQLITE':
+      return sqlite_jsonArrayFrom(expr);
+    case 'POSTGRES':
+      return pg_jsonArrayFrom(expr);
+    case 'MYSQL':
+      return mysql_jsonArrayFrom(expr);
+    case 'MSSQL':
+      return mssql_jsonArrayFrom(expr);
+    default:
+      throw new Error(`sql_type=${sql_type} NOT SUPPORTED !`);
+  }  
+}
+
+
+/**
+ * A SQLite helper for aggregating a subquery into a JSON array.
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     stringArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select('pet.name')
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].pets = ['name1', 'name2', ....]
+ * ```
+ * @template O
+ * @param {import('./con.helpers.json.js').SelectQueryBuilderExpression<O>} expr 
+ * @param {import('../types.public.js').SqlDialectType} sql_type 
+ * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O>[]>}
+ */
+export function stringArrayFrom(expr, sql_type) {
+  switch(sql_type) {
+    case 'SQLITE':
+      return sqlite_stringArrayFrom(expr);
+    case 'POSTGRES':
+      return pg_stringArrayFrom(expr);
+    case 'MYSQL':
+      return mysql_stringArrayFrom(expr);
+    case 'MSSQL':
+      return mssql_stringArrayFrom(expr);
+    default:
+      throw new Error(`sql_type=${sql_type} NOT SUPPORTED !`);
+  }  
+}
+
+/**
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *   
+ * @template O
+ * @param {import('./con.helpers.json.js').SelectQueryBuilderExpression<O>} expr 
+ * @param {import('../types.public.js').SqlDialectType} sql_type 
+ * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O> | null>}
+ */
+export function jsonObjectFrom(expr, sql_type) {
+  switch(sql_type) {
+    case 'SQLITE':
+      return sqlite_jsonObjectFrom(expr);
+    case 'POSTGRES':
+      return pg_jsonObjectFrom(expr);
+    case 'MYSQL':
+      return mysql_jsonObjectFrom(expr);
+    case 'MSSQL':
+      return mssql_jsonObjectFrom(expr);
+    default:
+      throw new Error(`sql_type=${sql_type} NOT SUPPORTED !`);
+  }
+}

package/src/con.helpers.json.mssql.js

@@ -0,0 +1,233 @@
+import { sql } from "kysely"
+
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .modifyEnd(sql`offset 0 rows`)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset 0 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ * 
+ * @template O
+ * @param {import("kysely").Expression<O>} expr 
+ * @returns {import("kysely").RawBuilder<import("kysely").Simplify<O>[]>}
+ */
+export function mssql_jsonArrayFrom(expr) {
+  return sql`coalesce((select * from ${expr} as agg for json path, include_null_values), '[]')`
+}
+
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .modifyEnd(sql`offset 0 rows`)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset 0 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ * 
+ * @template O
+ * @param {import("kysely").Expression<O>} expr 
+ * @returns {import("kysely").RawBuilder<import("kysely").Simplify<O>[]>}
+ */
+export function mssql_stringArrayFrom(expr) {
+  return sql`coalesce((select * from ${expr} as agg for json path, include_null_values), '[]')`
+}
+
+
+/**
+ * An MS SQL Server helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', 1)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = @1
+ *   ) as "agg" for json path, include_null_values, without_array_wrapper
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ * 
+ * @template O
+ * @param {import("kysely").Expression<O>} expr 
+ * @returns {import("kysely").RawBuilder<import("kysely").Simplify<O> | null>}
+ */
+export function mssql_jsonObjectFrom(expr) {
+  return sql`(select * from ${expr} as agg for json path, include_null_values, without_array_wrapper)`
+}
+
+/**
+ * The MS SQL Server `json_query` function, single argument variant.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", json_query(
+ *   '{"first":"'+"first_name"+',"last":"'+"last_name"+',"full":"'+concat("first_name", ' ', "last_name")+'"}'
+ * ) as "name"
+ * from "person"
+ * ```
+ * 
+ * @template {Record<string, import("kysely").Expression<unknown>>} O
+ * @param {O} obj 
+ * @returns {import("kysely").RawBuilder<import("kysely").Simplify<{[K in keyof O]: O[K] extends Expression<infer V> ? V : never}>>}
+ */
+export function mssql_jsonBuildObject(obj) {
+  return sql`json_query('{${sql.join(
+    Object.keys(obj).map((k) => sql`"${sql.raw(k)}":"'+${obj[k]}+'"`),
+    sql`,`,
+  )}}')`
+}