feat(@sirutils/seql): added ability to generate cache keys

Author: giveerr

.gitignore

@@ -139,4 +139,5 @@ lib/
 *.tsbuildinfo
 
 # others
-experiments
+experiments
+.tmp

bun.lockb

@@ -2,12 +2,10 @@
   "name": "@sirutils/seql",
   "version": "0.0.1",
   "type": "module",
-
   "main": "dist/index.js",
   "module": "dist/index.js",
   "files": ["dist", "definitions"],
   "types": "dist/index.d.ts",
-
   "devDependencies": {
     "@sirutils/builder": "workspace:*"
   },

packages/seql/package.json

@@ -13,25 +13,29 @@ declare global {
     namespace Seql {
       export type ValueRecord<T = BlobType> = Record<string, T>
 
-      export interface Query<T = BlobType> {
+      export interface QueryBuilder<T = BlobType> {
         $type: symbol
-        text: string
-        values: T[]
+        entries: [string | null, T, boolean][]
+        cacheKeys: string[]
+        operations: symbol[]
 
-        builder: BuildedQuery<T>
+        buildText(nextParamID: number): string
       }
 
-      export interface BuildedQuery<T = BlobType> {
+      export interface Query<T = BlobType> {
         $type: symbol
+        text: string
         values: T[]
-        buildText(nextParamID: number): string
+
+        builder: Sirutils.Seql.QueryBuilder<T>
       }
 
       export interface AdapterOptions {
         paramterPattern: (str: string) => string
       }
 
       export interface Env {
+        console: 'silent' | 'normal'
         adapter: 'mysql' | 'postgres'
       }
     }

packages/seql/src/definitions/seql.ts

@@ -1,21 +1,20 @@
 import './definitions'
 
-import { buildAll, query } from './seql'
+export * from './tag'
+
+import { query } from './seql'
 
 // biome-ignore lint/style/noNamespaceImport: For re-export as Seql
 import * as builder from './utils/builder'
 // biome-ignore lint/style/noNamespaceImport: For re-export as Seql
-import * as common from './utils/common'
+import * as generater from './utils/generater'
 // biome-ignore lint/style/noNamespaceImport: For re-export as Seql
 import * as operations from './utils/operations'
 
-export * from './tag'
-
 export const Seql = {
   query,
-  buildAll,
 
   ...builder,
-  ...common,
+  ...generater,
   ...operations,
 }

packages/seql/src/index.ts

@@ -3,8 +3,16 @@ import { extractEnvs, unwrap } from '@sirutils/core'
 export const ENV = unwrap(
   extractEnvs<Sirutils.Seql.Env>(env => ({
     adapter: env.SEQL_ADAPTER || 'mysql',
+    console: env.console || 'normal',
   }))
 )
 
-export const Raw = Symbol('Raw Query')
-export const Generated = Symbol('Generated Query')
+export const BUILDER = Symbol('Base Builder')
+export const GENERATED = Symbol('Generated Query')
+
+export const AND = Symbol('AND')
+export const OR = Symbol('OR')
+export const INSERT = Symbol('INSERT')
+export const UPDATE = Symbol('UPDATE')
+
+export const CACHEABLE_OPERATIONS = [AND, OR]

packages/seql/src/internal/consts.ts

@@ -0,0 +1,14 @@
+import { ENV } from './consts'
+
+// TODO: change to planned logger
+
+export const logger = {
+  warn: (...messages: unknown[]) => {
+    if (ENV.console === 'silent') {
+      return
+    }
+
+    // biome-ignore lint/nursery/noConsole: Redundant
+    console.warn(...messages)
+  },
+}

packages/seql/src/internal/logger.ts

@@ -0,0 +1,45 @@
+import type { BlobType } from '@sirutils/core'
+
+export const isObject = (value: BlobType): value is object =>
+  typeof value === 'object' && !Array.isArray(value) && value !== null && !(value instanceof Date)
+
+export const unique = (data: BlobType[]) => [...new Set(data)]
+
+const objectKeys = (object: object): Set<string> => {
+  return new Set(Object.keys(object))
+}
+
+const areSetsEqual = <T>(set1: Set<T>, set2: Set<T>): boolean => {
+  const difference = new Set(set1)
+  for (const elem of set2) {
+    if (difference.has(elem)) {
+      difference.delete(elem)
+    } else {
+      return false
+    }
+  }
+
+  return difference.size === 0
+}
+
+export const filterUndefined = <T extends Sirutils.Seql.ValueRecord>(object: T): T => {
+  return Object.fromEntries(Object.entries(object).filter(([_, v]) => v !== undefined)) as T
+}
+
+export const extractKeys = <T extends Sirutils.Seql.ValueRecord>(objects: T[]): string[] => {
+  if (objects.length === 0) {
+    throw new Error('Cannot call extractKeys on empty list')
+  }
+
+  // biome-ignore lint/style/noNonNullAssertion: <explanation>
+  const keys = objectKeys(objects[0]!)
+
+  for (const o of objects) {
+    const oKeys = objectKeys(o)
+    if (!areSetsEqual(keys, oKeys)) {
+      throw new Error(`Objects have different keys: ${JSON.stringify(objects)}`)
+    }
+  }
+
+  return Array.from(keys)
+}

packages/seql/src/internal/utils.ts

@@ -1,28 +1,11 @@
 import type { BlobType } from '@sirutils/core'
 
-import { generate, join, raw, toSqlBuilder } from './utils/builder'
-import { mergeLists } from './utils/common'
+import { buildAll } from './utils/builder'
+import { generate } from './utils/generater'
 
 /**
  * Use this for creating queries
  */
-export const query = (texts: TemplateStringsArray, ...values: BlobType[]): Sirutils.Seql.Query => {
-  const result = generate(buildAll(texts, ...values))
-
-  return result
-}
-
-/**
- * Internal template string tag that builds all props.
- */
-export const buildAll = (
-  texts: TemplateStringsArray,
-  ...values: BlobType[]
-): Sirutils.Seql.BuildedQuery => {
-  const textSqlBuilders = texts.map(raw)
-  const valueSqlBuilders = values.map(toSqlBuilder)
-
-  const sqlBuilders = mergeLists(textSqlBuilders, valueSqlBuilders)
-
-  return join(sqlBuilders)
+export const query = (texts: TemplateStringsArray, ...values: BlobType[]) => {
+  return generate(buildAll(texts, ...values))
 }

packages/seql/src/seql.ts

@@ -4,6 +4,7 @@ const createTag = tagBuilder('@sirutils/seql')
 
 export const seqlTags = {
   env: createTag('invalid-env'),
+  cacheEvicted: createTag('cache-evicted'),
 } as const
 
 export type SeqlTags = (typeof seqlTags)[keyof typeof seqlTags]