@storecraft/database-sql-base 1.0.0

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 '../driver.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),
+  }
+}

package/src/con.notifications.js

@@ -0,0 +1,149 @@
+import { SQL } from '../driver.js'
+import { count_regular, delete_me, delete_search_of, 
+  insert_search_of, regular_upsert_me, where_id_or_handle_table, 
+  with_search } from './con.shared.js'
+import { sanitize_array } from './utils.funcs.js'
+import { query_to_eb, query_to_sort } from './utils.query.js'
+
+/**
+ * @typedef {import('@storecraft/core/v-database').db_notifications} db_col
+ */
+export const table_name = 'notifications'
+
+/**
+ * @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, [...item.search, ...search_terms], 
+            item.id, item.id, table_name
+            );
+          await regular_upsert_me(trx, table_name, {
+            created_at: item.created_at,
+            updated_at: item.updated_at,
+            message: item.message,
+            author: item.author,
+            id: item.id,
+            actions: JSON.stringify(item.actions)
+          });
+        }
+      );
+    } catch(e) {
+      console.log(e);
+      return false;
+    }
+    return true;
+  }
+}
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["upsertBulk"]}
+ */
+const upsertBulk = (driver) => {
+  return async (items, search_terms) => {
+    const results = [];
+    // for (const it of items)
+    for(let ix = 0; ix < items.length; ix++)
+      results.push(await upsert(driver)(
+        items[ix], search_terms?.[ix])
+        );
+
+    return results.every(b => b);
+  }
+}
+
+/**
+ * @param {SQL} driver 
+ * @returns {db_col["get"]}
+ */
+const get = (driver) => {
+  return (id_or_handle, options) => {
+    return driver.client
+    .selectFrom(table_name)
+    .selectAll()
+    .select(eb => [
+      with_search(eb, eb.ref('notifications.id'), driver.dialectType),
+    ]
+    .filter(Boolean))
+    .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) => {
+    try {
+      await driver.client.transaction().execute(
+        async (trx) => {
+          // 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;
+  }
+}
+
+
+/**
+ * @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_search(eb, eb.ref('notifications.id'), driver.dialectType),
+      ].filter(Boolean))
+      .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),
+    upsertBulk: upsertBulk(driver),
+    remove: remove(driver),
+    list: list(driver),
+    count: count_regular(driver, table_name),
+  }
+}