@storecraft/database-sqlite 1.0.1 → 1.0.2

package/src/con.helpers.json.js

@@ -1,231 +0,0 @@
-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.d.ts').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.d.ts').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.d.ts').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

@@ -1,233 +0,0 @@
-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`,`,
-  )}}')`
-}

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

@@ -1,239 +0,0 @@
-import { SelectQueryNode, sql } from "kysely"
-import { extract_first_selection, getJsonObjectArgs } from "./con.helpers.json.js"
-
-/**
- * A MySQL helper for aggregating a subquery into a JSON array.
- *
- * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
- * may not parse the nested JSON into arrays. In these cases you can use the built in
- * `ParseJSONResultsPlugin` to parse the results.
- *
- * ### 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
- * ```
- *
- * The generated SQL (MySQL):
- *
- * ```sql
- * select `id`, (
- *   select cast(coalesce(json_arrayagg(json_object(
- *     'pet_id', `agg`.`pet_id`,
- *     'name', `agg`.`name`
- *   )), '[]') as json) from (
- *     select `pet`.`id` as `pet_id`, `pet`.`name`
- *     from `pet`
- *     where `pet`.`owner_id` = `person`.`id`
- *     order by `pet`.`name`
- *   ) as `agg`
- * ) as `pets`
- * from `person`
- * ```
- * 
- * @template O
- * @param {import("./con.helpers.json.js").SelectQueryBuilderExpression<O>} expr 
- * @returns {import("kysely").RawBuilder<import("kysely").Simplify<O>[]>}
- */
-export function mysql_jsonArrayFrom(expr) {
-  return sql`(select cast(coalesce(json_arrayagg(json_object(${sql.join(
-    getMysqlJsonObjectArgs(expr.toOperationNode(), 'agg'),
-  )})), '[]') as json) from ${expr} as agg)`
-}
-
-/**
- * A SQLite 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 SqliteDialect(config),
- *   plugins: [new ParseJSONResultsPlugin()]
- * })
- * ```
- *
- * ### 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', ....]
- * ```
- *
- * The generated SQL (SQLite):
- *
- * ```sql
- * select "id", (
- *   select coalesce(json_group_array("agg"."name"), '[]') from (
- *     select "pet"."name"
- *     from "pet"
- *     where "pet"."owner_id" = "person"."id"
- *     order by "pet"."name"
- *   ) as "agg"
- * ) as "pets"
- * from "person"
- * ```
- * @template O
- * @param {import('./con.helpers.json.js').SelectQueryBuilderExpression<O>} expr 
- * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O>[]>}
- */
-export function mysql_stringArrayFrom(expr) {
-  const arg = extract_first_selection(expr, 'agg');
-  return sql`(select cast(coalesce(json_arrayagg(${sql.join([arg])}), '[]') as json) from ${expr} as agg)`
-}
-
-
-/**
- * A MySQL helper for turning a subquery into a JSON object.
- *
- * The subquery must only return one row.
- *
- * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
- * may not parse the nested JSON into objects. In these cases you can use the built in
- * `ParseJSONResultsPlugin` to parse the results.
- *
- * ### 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
- * ```
- *
- * The generated SQL (MySQL):
- *
- * ```sql
- * select `id`, (
- *   select json_object(
- *     'pet_id', `obj`.`pet_id`,
- *     'name', `obj`.`name`
- *   ) from (
- *     select `pet`.`id` as `pet_id`, `pet`.`name`
- *     from `pet`
- *     where `pet`.`owner_id` = `person`.`id`
- *     and `pet`.`is_favorite` = ?
- *   ) as obj
- * ) as `favorite_pet`
- * from `person`
- * ```
- * 
- * @template O
- * @param {import("./con.helpers.json.js").SelectQueryBuilderExpression<O>} expr 
- * @returns {import("kysely").RawBuilder<import("kysely").Simplify<O> | null>}
- */
-export function mysql_jsonObjectFrom(expr) {
-  return sql`(select json_object(${sql.join(
-    getMysqlJsonObjectArgs(expr.toOperationNode(), 'obj'),
-  )}) from ${expr} as obj)`
-}
-
-/**
- * The MySQL `json_object` function.
- *
- * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
- * While the produced SQL is compatible with all MySQL databases, some 3rd party dialects
- * may not parse the nested JSON into objects. In these cases you can use the built in
- * `ParseJSONResultsPlugin` to parse the results.
- *
- * ### 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()
- *
- * result[0].id
- * result[0].name.first
- * result[0].name.last
- * result[0].name.full
- * ```
- *
- * The generated SQL (MySQL):
- *
- * ```sql
- * select "id", json_object(
- *   '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 mysql_jsonBuildObject(obj) {
-  return sql`json_object(${sql.join(
-    Object.keys(obj).flatMap((k) => [sql.lit(k), obj[k]]),
-  )})`
-}
-
-/**
- * 
- * @param {SelectQueryNode} node 
- * @param {string} table 
- * @returns {import("kysely").Expression<unknown>[]}
- */
-function getMysqlJsonObjectArgs(node, table) {
-  try {
-    return getJsonObjectArgs(node, table)
-  } catch {
-    throw new Error(
-      'MySQL jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.',
-    )
-  }
-}