@storecraft/database-sqlite 1.0.1

package/src/kysely.sanitize.plugin.js

@@ -0,0 +1,40 @@
+import { sanitize } from './utils.funcs.js';
+
+/**
+ * @description This `kysely` plugin will process query
+ * results and will do the following:
+ * - sanitize `undefined` and `null` values
+ * - `active` keys will be transformed to `boolean`
+ * 
+ * 
+ * @typedef {import('kysely').KyselyPlugin} KyselyPlugin
+ * 
+ * 
+ * @implements {KyselyPlugin}
+ */
+export class SanitizePlugin {
+
+  /**
+   * 
+   * @param {import('kysely').PluginTransformQueryArgs} args 
+   * 
+   * 
+   * @returns {import('kysely').RootOperationNode}
+   */
+  transformQuery(args) {
+    return args.node;
+  }
+
+  /**
+   * 
+   * @param {import('kysely').PluginTransformResultArgs} args 
+   * 
+   * 
+   * @returns {Promise<import('kysely').QueryResult<import('kysely').UnknownRow>>}
+   */
+  transformResult(args){
+    sanitize(args.result.rows);
+
+    return Promise.resolve(args.result);
+  }
+}

package/src/utils.funcs.js

@@ -0,0 +1,77 @@
+export const isDef = v => v!==undefined && v!==null;
+export const isUndef = v => !isDef(v);
+
+/**
+ * 
+ * @param  {...any} keys 
+ * @returns 
+ */
+export const delete_keys = (...keys) => {
+
+  /**
+   * @template T
+   * @param {T} o
+   * @returns {T}
+   */
+  return (o) => {
+    keys.forEach(k => {o?.[k] && delete o[k]} )
+    return o
+  }
+}
+
+/**
+ * Sanitize null/undefined valued keys
+ * 
+ * 
+ * @template {Record<string, any>} T
+ * 
+ * 
+ * @param {T} o 
+ */
+export const sanitize = o => {
+  for (const key in o) {
+    const value = o[key];
+
+    if(!isDef(value)) {
+      delete o[key];
+      continue;
+    }
+    if(key==='active') {
+      o[key] = Boolean(value);
+    }
+    else if(key==='price') {
+      o[key] = parseFloat(value);
+    }
+    else if(key==='compare_at_price') {
+      o[key] = parseFloat(value);
+    }
+    else if(typeof value === 'object') {
+      sanitize(o[key])
+    }
+  }
+
+  return o;
+}
+
+
+/**
+ * Sanitize the document before sending to client
+ * 
+ * @template T
+ * 
+ * @param {T[]} arr 
+ */
+export const sanitize_array = arr => {
+  for(const p of arr) {
+    sanitize(p);
+  }
+  return arr;
+}
+
+/**
+ * 
+ * @param {string} v 
+ */
+export const isID = v => {
+  return v.includes('_');
+}

package/src/utils.query.js

@@ -0,0 +1,195 @@
+/**
+ * @typedef {import("../index.js").Database} Database
+ */
+
+import { parse } from "@storecraft/core/v-ql";
+
+/**
+ * Convert an API Query cursor into mongo dialect, also sanitize.
+ * 
+ * 1. (a1, a2) >  (b1, b2) ==> (a1 > b1) || (a1=b1 & a2>b2)
+ * 2. (a1, a2) >= (b1, b2) ==> (a1 > b1) || (a1=b1 & a2>=b2)
+ * 3. (a1, a2, a3) >  (b1, b2, b3) ==> (a1 > b1) || (a1=b1 & a2>b2) || (a1=b1 & a2=b2 & a3>b3)
+ * 4. (a1, a2, a3) >= (b1, b2, b3) ==> (a1 > b1) || (a1=b1 & a2>b2) || (a1=b1 & a2=b2 & a3>=b3)
+ * 
+ * @param {import("kysely").ExpressionBuilder<Database>} eb 
+ * @param {import("@storecraft/core/v-api").Cursor} c 
+ * @param {'>' | '>=' | '<' | '<='} relation 
+ * @param {(x: [k: string, v: any]) => [k: string, v: any]} transformer Your chance to change key and value
+ */
+export const query_cursor_to_eb = (eb, c, relation, transformer=(x)=>x) => {
+
+  let rel_key_1; // relation in last conjunction term in [0, n-1] disjunctions
+  let rel_key_2; // relation in last conjunction term in last disjunction
+
+  if (relation==='>' || relation==='>=') {
+    rel_key_1 = rel_key_2 = '>';
+    if(relation==='>=')
+      rel_key_2='>=';
+  }
+  else if (relation==='<' || relation==='<=') {
+    rel_key_1 = rel_key_2 = '<';
+    if(relation==='<=')
+      rel_key_2='<=';
+  } else return undefined;
+
+  
+  const disjunctions = [];
+  // each disjunction clause
+  for (let ix = 0; ix < c.length; ix++) {
+    const is_last_disjunction = ix==c.length-1;
+    const conjunctions = [];
+    // each conjunction clause up until the last term (not inclusive)
+    for (let jx = 0; jx < ix; jx++) {
+      // the a_n=b_n
+      const r = transformer(c[jx]);
+      
+      // conjunctions.push({ [r[0]] : r[1] });
+      conjunctions.push(eb(r[0], '=', r[1]));
+    }
+
+    // Last conjunction term
+    const relation_key = is_last_disjunction ? rel_key_2 : rel_key_1;
+    const r = transformer(c[ix]);
+    // conjunctions.push({ [r[0]] : { [relation_key]: r[1] } });
+    conjunctions.push(eb(r[0], relation_key, r[1]));
+    // Add to disjunctions list
+    // disjunctions.push({ $and: conjunctions });
+    disjunctions.push(eb.and(conjunctions));
+  }
+
+  if(disjunctions.length==0)
+    return undefined;
+
+  // const result = {
+  //   $or: disjunctions
+  // };
+
+  return eb.or(disjunctions);
+
+  // return result;
+}
+
+
+/**
+ * @param {import("kysely").ExpressionBuilder<Database>} eb 
+ * @param {import("@storecraft/core/v-ql").VQL.Node} node 
+ * @param {keyof Database} table_name 
+ */
+export const query_vql_node_to_eb = (eb, node, table_name) => {
+  if(node.op==='LEAF') {
+    // console.log('value', node.value)
+    return eb
+    .exists(
+      eb => eb
+      .selectFrom('entity_to_search_terms')
+      .select('id')
+      .where(
+        eb => eb.and(
+          [
+            eb.or(
+              [
+                eb(`entity_to_search_terms.entity_id`, '=', eb.ref(`${table_name}.id`)),
+                eb(`entity_to_search_terms.entity_handle`, '=', eb.ref(`${table_name}.handle`)),
+              ]
+            ),
+            eb(`entity_to_search_terms.value`, 'like', node.value.toLowerCase())
+          ]
+        )
+      )
+    )
+  }
+
+  let conjunctions = [];
+  for(let arg of node?.args) {
+    conjunctions.push(query_vql_node_to_eb(eb, arg, table_name));
+  }
+
+  switch (node.op) {
+    case '&':
+      return eb.and(conjunctions)
+    case '|':
+      return eb.or(conjunctions)
+    case '!':
+      return eb.not(conjunctions[0])
+    default:
+      throw new Error('VQL-failed')
+  }
+
+}
+
+/**
+ * @param {import("kysely").ExpressionBuilder<Database>} eb 
+ * @param {import("@storecraft/core/v-ql").VQL.Node} root 
+ * @param {keyof Database} table_name 
+ */
+export const query_vql_to_eb = (eb, root, table_name) => {
+  return root ? query_vql_node_to_eb(eb, root, table_name) : undefined;
+}
+
+
+/**
+ * Convert an API Query into mongo dialect, also sanitize.
+ * 
+ * 
+ * @param {import("kysely").ExpressionBuilder<Database>} eb 
+ * @param {import("@storecraft/core/v-api").ApiQuery} q 
+ * @param {keyof Database} table_name 
+ * 
+ */
+export const query_to_eb = (eb, q={}, table_name) => {
+  const clauses = [];
+
+  const sort_sign = q.order === 'asc' ? 1 : -1;
+  const asc = sort_sign==1;
+
+  // compute index clauses
+  if(q.startAt) {
+    clauses.push(query_cursor_to_eb(eb, q.startAt, asc ? '>=' : '<='));
+  } else if(q.startAfter) {
+    clauses.push(query_cursor_to_eb(eb, q.startAfter, asc ? '>' : '<'));
+  }
+
+  if(q.endAt) {
+    clauses.push(query_cursor_to_eb(eb, q.endAt, asc ? '<=' : '>='));
+  } else if(q.endBefore) {
+    clauses.push(query_cursor_to_eb(eb, q.endBefore, asc ? '<' : '>'));
+  }
+
+  // compute VQL clauses 
+  try {
+    if(q.vql && !q.vqlParsed) {
+      q.vqlParsed = parse(q.vql)
+    }
+  } catch(e) {}
+
+  const vql_clause = query_vql_to_eb(eb, q.vqlParsed, table_name)
+  vql_clause && clauses.push(vql_clause);
+
+  return eb.and(clauses);
+}
+
+const SIGN = {
+  '1': 'asc',
+  '-1': 'desc'
+}
+
+/**
+ * Convert an API Query into mongo dialect, also sanitize.
+ * 
+ * @param {import("@storecraft/core/v-api").ApiQuery} q 
+ */
+export const query_to_sort = (q={}) => {
+  // const sort_sign = q.order === 'asc' ? 'asc' : 'desc';
+  // `reverse_sign=-1` means we need to reverse because of `limitToLast`
+  const reverse_sign = (q.limitToLast && !q.limit) ? -1 : 1;
+  const asc = q.order === 'asc';
+  const sort_sign = (asc ? 1 : -1) * reverse_sign;
+
+  // compute sort fields and order
+  const sort = (q.sortBy?.length ? q.sortBy :  ['updated_at', 'id']).map(
+    s => `${s} ${SIGN[sort_sign]}`
+  )
+  
+  return sort;
+}

package/tests/query.cursor.test.js

@@ -0,0 +1,389 @@
+// import { test } from 'uvu';
+// import * as assert from 'uvu/assert';
+// import { query_cursor_to_mongo } from '../src/utils.query.js'
+
+// test('(a1, a2, a3)', async () => {
+//   const t_1 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$gt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": "b2"
+//           },
+//           {
+//             "a3": {
+//               "$gte": "b3"
+//             }
+//           }
+//         ]
+//       }
+//     ]
+//   };
+
+//   const t_2 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$gt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": "b2"
+//           },
+//           {
+//             "a3": {
+//               "$gt": "b3"
+//             }
+//           }
+//         ]
+//       }
+//     ]
+//   };
+
+//   const t_3 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$lt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": "b2"
+//           },
+//           {
+//             "a3": {
+//               "$lte": "b3"
+//             }
+//           }
+//         ]
+//       }
+//     ]
+//   };
+
+//   const t_4 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$lt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": "b2"
+//           },
+//           {
+//             "a3": {
+//               "$lt": "b3"
+//             }
+//           }
+//         ]
+//       }
+//     ]
+//   };
+
+//   /** @type {import('@storecraft/core').Cursor[]} */
+//   const cursor = [
+//     ['a1', 'b1'],
+//     ['a2', 'b2'],
+//     ['a3', 'b3'],
+//   ];
+
+//   const rel_1 = query_cursor_to_mongo(cursor, '>=');
+//   const rel_2 = query_cursor_to_mongo(cursor, '>');
+//   const rel_3 = query_cursor_to_mongo(cursor, '<=');
+//   const rel_4 = query_cursor_to_mongo(cursor, '<');
+
+//   assert.equal(rel_1, t_1);
+//   assert.equal(rel_2, t_2);
+//   assert.equal(rel_3, t_3);
+//   assert.equal(rel_4, t_4);
+
+// });
+
+
+// test('(a1, a2)', async () => {
+//   const t_1 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$gte": "b2"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_2 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$gt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_3 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$lte": "b2"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_4 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//       {
+//         "$and": [
+//           {
+//             "a1": "b1"
+//           },
+//           {
+//             "a2": {
+//               "$lt": "b2"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   /** @type {import('@storecraft/core').Cursor[]} */
+//   const cursor = [
+//     ['a1', 'b1'],
+//     ['a2', 'b2'],
+//   ];
+
+//   const rel_1 = query_cursor_to_mongo(cursor, '>=');
+//   const rel_2 = query_cursor_to_mongo(cursor, '>');
+//   const rel_3 = query_cursor_to_mongo(cursor, '<=');
+//   const rel_4 = query_cursor_to_mongo(cursor, '<');
+  
+//   assert.equal(rel_1, t_1);
+//   assert.equal(rel_2, t_2);
+//   assert.equal(rel_3, t_3);
+//   assert.equal(rel_4, t_4);
+// });
+
+
+
+// test('(a1)', async () => {
+//   const t_1 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gte": "b1"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_2 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$gt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_3 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lte": "b1"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   const t_4 = {
+//     "$or": [
+//       {
+//         "$and": [
+//           {
+//             "a1": {
+//               "$lt": "b1"
+//             }
+//           }
+//         ]
+//       },
+//     ]
+//   };
+
+//   /** @type {import('@storecraft/core').Cursor[]} */
+//   const cursor = [
+//     ['a1', 'b1'],
+//   ];
+
+//   const rel_1 = query_cursor_to_mongo(cursor, '>=');
+//   const rel_2 = query_cursor_to_mongo(cursor, '>');
+//   const rel_3 = query_cursor_to_mongo(cursor, '<=');
+//   const rel_4 = query_cursor_to_mongo(cursor, '<');
+  
+//   assert.equal(rel_1, t_1);
+//   assert.equal(rel_2, t_2);
+//   assert.equal(rel_3, t_3);
+//   assert.equal(rel_4, t_4);
+// });
+
+
+
+// test.run();