@storecraft/database-sqlite 1.0.1

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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,263 @@
+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

@@ -0,0 +1,230 @@
+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),
+  }
+}