@storecraft/database-sqlite 1.0.1 → 1.0.2

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

@@ -1,223 +0,0 @@
-import { sql} from 'kysely'
-import { extract_first_selection } from './con.helpers.json.js';
-
-
-/**
- * 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 pg_stringArrayFrom(expr) {
-  const arg = extract_first_selection(expr, 'agg');
-  return sql`(select coalesce(json_agg(${sql.join([arg])}), '[]') from ${expr} as agg)`
-}
-
-/**
- * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
- *
- * ### Examples
- *
- * <!-- siteExample("select", "Nested array", 110) -->
- *
- * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
- * helpers for fetching nested objects and arrays in a single query. In this example we
- * use the `jsonArrayFrom` helper to fetch person's pets along with the person's id.
- *
- * Please keep in mind that the helpers under the `kysely/helpers` folder, including
- * `jsonArrayFrom`, are not guaranteed to work with third party dialects. In order for
- * them to work, the dialect must automatically parse the `json` data type into
- * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
- * to parse the results.
- *
- * ```ts
- * import { jsonArrayFrom } from 'kysely/helpers/postgres'
- *
- * 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()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select "id", (
- *   select coalesce(json_agg(agg), '[]') 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('kysely').Expression<O>} expr 
- * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O>[]>}
- */
-export function pg_jsonArrayFrom(expr) {
-  return sql`(select coalesce(json_agg(agg), '[]') from ${expr} as agg)`
-}
-
-/**
- * A postgres helper for turning a subquery (or other expression) into a JSON object.
- *
- * The subquery must only return one row.
- *
- * ### Examples
- *
- * <!-- siteExample("select", "Nested object", 120) -->
- *
- * While kysely is not an ORM and it doesn't have the concept of relations, we do provide
- * helpers for fetching nested objects and arrays in a single query. In this example we
- * use the `jsonObjectFrom` helper to fetch person's favorite pet along with the person's id.
- *
- * Please keep in mind that the helpers under the `kysely/helpers` folder, including
- * `jsonObjectFrom`, are not guaranteed to work with 3rd party dialects. In order for
- * them to work, the dialect must automatically parse the `json` data type into
- * javascript JSON values like objects and arrays. Some dialects might simply return
- * the data as a JSON string. In these cases you can use the built in `ParseJSONResultsPlugin`
- * to parse the results.
- *
- * ```ts
- * import { jsonObjectFrom } from 'kysely/helpers/postgres'
- *
- * 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()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select "id", (
- *   select to_json(obj) from (
- *     select "pet"."id" as "pet_id", "pet"."name"
- *     from "pet"
- *     where "pet"."owner_id" = "person"."id"
- *     and "pet"."is_favorite" = $1
- *   ) as obj
- * ) as "favorite_pet"
- * from "person"
- * ```
- * @template O
- * @param {import('kysely').Expression<O>} expr 
- * @returns {import('kysely').RawBuilder<import('kysely').Simplify<O> | null>}
- */
-export function pg_jsonObjectFrom(expr) {
-  return sql`(select to_json(obj) from ${expr} as obj)`
-}
-
-/**
- * The PostgreSQL `json_build_object` function.
- *
- * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
- * While the produced SQL is compatible with all PostgreSQL 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: sql<string>`first_name || ' ' || last_name`
- *     }).as('name')
- *   ])
- *   .execute()
- *
- * result[0].id
- * result[0].name.first
- * result[0].name.last
- * result[0].name.full
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select "id", json_build_object(
- *   'first', first_name,
- *   'last', last_name,
- *   'full', 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 pg_jsonBuildObject(obj) {
-  return sql`json_build_object(${sql.join(
-    Object.keys(obj).flatMap((k) => [sql.lit(k), obj[k]]),
-  )})`
-}

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

@@ -1,263 +0,0 @@
-import { SelectQueryNode, sql} from 'kysely'
-import { extract_first_selection, getJsonObjectArgs } from './con.helpers.json.js';
-
-/**
- * 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',
- *     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 (SQLite):
- *
- * ```sql
- * select "id", (
- *   select coalesce(json_group_array(json_object(
- *     'pet_id', "agg"."pet_id",
- *     'name', "agg"."name"
- *   )), '[]') 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 sqlite_jsonArrayFrom(expr) {
-
-  return sql`(select coalesce(json_group_array(json_object(${sql.join(
-    getSqliteJsonObjectArgs(expr.toOperationNode(), 'agg')
-  )})), '[]') 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 sqlite_stringArrayFrom(expr) {
-  const arg = extract_first_selection(expr, 'agg');
-  return sql`(select coalesce(json_group_array(${sql.join([arg])}), '[]') from ${expr} as agg)`
-}
-
-/**
- * A SQLite 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 SqliteDialect(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', '=', true)
- *     ).as('favorite_pet')
- *   ])
- *   .execute()
- *
- * result[0].id
- * result[0].favorite_pet.pet_id
- * result[0].favorite_pet.name
- * ```
- *
- * The generated SQL (SQLite):
- *
- * ```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 sqlite_jsonObjectFrom(expr) {
-  return sql`(select json_object(${sql.join(
-    getSqliteJsonObjectArgs(expr.toOperationNode(), 'obj'),
-  )}) from ${expr} as obj)`
-}
-
-/**
- * The SQLite `json_object` function.
- *
- * 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',
- *     jsonBuildObject({
- *       first: eb.ref('first_name'),
- *       last: eb.ref('last_name'),
- *       full: sql<string>`first_name || ' ' || last_name`
- *     }).as('name')
- *   ])
- *   .execute()
- *
- * result[0].id
- * result[0].name.first
- * result[0].name.last
- * result[0].name.full
- * ```
- *
- * The generated SQL (SQLite):
- *
- * ```sql
- * select "id", json_object(
- *   'first', first_name,
- *   'last', last_name,
- *   'full', "first_name" || ' ' || "last_name"
- * ) as "name"
- * from "person"
- * ```
- */
-// export function jsonBuildObject<O extends Record<string, Expression<unknown>>>(
-//   obj: O,
-// ): RawBuilder<
-//   Simplify<{
-//     [K in keyof O]: O[K] extends Expression<infer V> ? V : never
-//   }>
-// > {
-//   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 getSqliteJsonObjectArgs(node, table) {
-  try {
-    return getJsonObjectArgs(node, table)
-  } catch {
-    throw new Error(
-      'SQLite jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.',
-    )
-  }
-}

package/src/con.images.js

@@ -1,230 +0,0 @@
-import { func } from '@storecraft/core/v-api'
-import { SQL } from '../index.js'
-import { count_regular, delete_me, delete_search_of, 
-  insert_search_of, regular_upsert_me, where_id_or_handle_table 
-} from './con.shared.js'
-import { sanitize_array } from './utils.funcs.js'
-import { query_to_eb, query_to_sort } from './utils.query.js'
-import { Transaction } from 'kysely'
-import { ID } from '@storecraft/core/v-api/utils.func.js'
-import { 
-  image_url_to_handle, image_url_to_name 
-} from '@storecraft/core/v-api/con.images.logic.js'
-
-/**
- * @typedef {import('@storecraft/core/v-database').db_images} db_col
- */
-export const table_name = 'images'
-
-/**
- * @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_search_of(
-            trx, search_terms, item.id, item.handle, table_name
-          );
-          await regular_upsert_me(trx, table_name, {
-            created_at: item.created_at,
-            updated_at: item.updated_at,
-            id: item.id,
-            handle: item.handle,
-            name: item.name,
-            url: item.url,
-          });
-        }
-      );
-    } catch(e) {
-      console.log(e);
-      return false;
-    }
-    return true;
-  }
-}
-
-
-/**
- * @param {SQL} driver 
- * @returns {db_col["get"]}
- */
-const get = (driver) => {
-  return (id_or_handle, options) => {
-    return driver.client
-    .selectFrom(table_name)
-    .selectAll()
-    .where(where_id_or_handle_table(id_or_handle))
-    .executeTakeFirst();
-  }
-}
-
-
-/**
- * @param {SQL} driver 
- * @returns {db_col["remove"]}
- */
-const remove = (driver) => {
-  return async (id_or_handle) => {
-    const img = await driver.client
-    .selectFrom(table_name)
-    .selectAll()
-    .where(where_id_or_handle_table(id_or_handle))
-    .executeTakeFirst();
-
-    try {
-      await driver.client.transaction().execute(
-        async (trx) => {
-          // remove images -> media
-          await trx
-            .deleteFrom('entity_to_media')
-            .where('value', '=', img.url)
-            .execute();
-          // entities
-          await delete_search_of(trx, id_or_handle);
-          // delete me
-          await delete_me(trx, table_name, id_or_handle);
-        }
-      );
-
-    } catch(e) {
-      console.log(e);
-      return false;
-    }
-    return true;
-  }
-}
-
-/**
- * report media usages
- * @param {SQL} driver 
- * @returns {db_col["report_document_media"]}
- */
-export const report_document_media = (driver) => {
-  /**
-   * @param {Transaction<import('../index.js').Database>} [transaction]
-   */
-  return async (item, transaction) => {
-    if(!(item?.media?.length))
-      return;
-  
-    /**
-     * 
-   * @param {Transaction<import('../index.js').Database>} trx
-     */
-    const doit = async (trx) => {
-      const dates = func.apply_dates({});
-
-      const ms = item.media.map(
-        m => (
-          {
-            handle: image_url_to_handle(m),
-            url: m,
-            name: image_url_to_name(m),
-            id: ID('img'),
-            created_at: dates.created_at,
-            updated_at: dates.updated_at,
-          }
-        )
-      );
-      const handles = ms.map(m => m.handle);
-
-      await trx.deleteFrom(table_name).where(
-        'handle', 'in', handles
-      ).execute();
-      await trx.insertInto(table_name).values(
-        ms
-      ).execute();
-      // search stuff
-      // remove by reporter
-      await trx.deleteFrom('entity_to_search_terms').where(
-        eb => eb.and([
-            eb('reporter', '=', item.id),
-            eb('context', '=', table_name),
-          ]
-        )
-      ).execute();
-      const search = func.union(
-        item['title'], func.to_tokens(item['title'])
-      );
-      if(search.length) {
-        const A = ms.map(m => ({
-            entity_id: m.id,
-            entity_handle: m.handle,
-            context: table_name,
-            reporter: item.id
-          })
-        );
-
-        const B = search.reduce(
-          (p, c) => {
-            p.push(...A.map(a => ({...a, value: c})));
-            return p;
-          }, []
-        );
-      
-        await trx.insertInto('entity_to_search_terms').values(
-          B
-        ).execute();
-      }
-      
-    }
-
-    if(transaction) {
-      await doit(transaction);
-    } else {
-      try {
-        const t = await driver.client
-          .transaction()
-          .execute(doit);
-      } catch(e) {
-        console.log(e);
-      }
-    }
-  }
-}
-
-/**
- * @param {SQL} driver 
- * @returns {db_col["list"]}
- */
-const list = (driver) => {
-  return async (query) => {
-
-    const items = await driver.client
-      .selectFrom(table_name)
-      .selectAll()
-      .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 sanitize_array(items);
-  }
-}
-
-
-/** 
- * @param {SQL} driver
- * @return {db_col}}
- * */
-export const impl = (driver) => {
-
-  return {
-    get: get(driver),
-    upsert: upsert(driver),
-    remove: remove(driver),
-    list: list(driver),
-    report_document_media: report_document_media(driver),
-    count: count_regular(driver, table_name),
-  }
-}