feat(@sirutils/seql): initialize package and added basic query features

Author: giveerr

bun.lockb

@@ -0,0 +1,26 @@
+language: "typescript"
+type: "library"
+platform: "bun"
+
+tasks:
+  build:
+    command: "bun x builder build src/index.ts -a"
+    deps:
+      - "seql:clean"
+      - "builder:build"
+      - "core:build"
+    inputs:
+      - "src/**/*"
+      - "types/**/*"
+    outputs:
+      - "dist/**"
+  watch:
+    command: "bun x builder build src/index.ts -a -w"
+    deps:
+      - "seql:clean"
+      - "builder:build"
+      - "core:build"
+    local: true
+    inputs:
+      - "src/**/*"
+      - "types/**/*"

packages/seql/moon.yml

@@ -0,0 +1,17 @@
+{
+  "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:*"
+  },
+  "dependencies": {
+    "@sirutils/core": "workspace:*"
+  }
+}

packages/seql/package.json

@@ -0,0 +1,3 @@
+/// <reference types="@sirutils/core" />
+
+import './seql'

packages/seql/src/definitions/index.ts

@@ -0,0 +1,39 @@
+import type { BlobType } from '@sirutils/core'
+
+import type { SeqlTags } from '../tag'
+
+declare global {
+  // biome-ignore lint/style/noNamespace: Redundant
+  namespace Sirutils {
+    interface CustomErrors {
+      seql: SeqlTags
+    }
+
+    // biome-ignore lint/style/noNamespace: Redundant
+    namespace Seql {
+      export type ValueRecord<T = BlobType> = Record<string, T>
+
+      export interface Query<T = BlobType> {
+        $type: symbol
+        text: string
+        values: T[]
+
+        builder: BuildedQuery<T>
+      }
+
+      export interface BuildedQuery<T = BlobType> {
+        $type: symbol
+        values: T[]
+        buildText(nextParamID: number): string
+      }
+
+      export interface AdapterOptions {
+        paramterPattern: (str: string) => string
+      }
+
+      export interface Env {
+        adaptor: 'mysql' | 'postgres'
+      }
+    }
+  }
+}

packages/seql/src/definitions/seql.ts

@@ -0,0 +1,21 @@
+import './definitions'
+
+import { buildAll, 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'
+// 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,
+  ...operations,
+}

packages/seql/src/index.ts

@@ -0,0 +1,3 @@
+export const mysqlAdapter: Sirutils.Seql.AdapterOptions = {
+  paramterPattern: () => '?',
+}

packages/seql/src/internal/adapters/mysql.ts

@@ -0,0 +1,3 @@
+export const postgresAdapter: Sirutils.Seql.AdapterOptions = {
+  paramterPattern: str => `$${str}`,
+}

packages/seql/src/internal/adapters/postgres.ts

@@ -0,0 +1,11 @@
+import { ENV } from './env'
+
+import { mysqlAdapter } from './adapters/mysql'
+import { postgresAdapter } from './adapters/postgres'
+
+export const adaptors = {
+  postgres: postgresAdapter,
+  mysql: mysqlAdapter,
+} as const
+
+export const selectedAdaptor = adaptors[ENV.adaptor]

packages/seql/src/internal/adaptors.ts

@@ -0,0 +1,10 @@
+import { extractEnvs, unwrap } from '@sirutils/core'
+
+export const ENV = unwrap(
+  extractEnvs<Sirutils.Seql.Env>(env => ({
+    adaptor: env.SEQL_ADAPTOR || 'mysql',
+  }))
+)
+
+export const Raw = Symbol('Raw Query')
+export const Generated = Symbol('Generated Query')

packages/seql/src/internal/consts.ts

@@ -0,0 +1,28 @@
+import type { BlobType } from '@sirutils/core'
+
+import { generate, join, raw, toSqlBuilder } from './utils/builder'
+import { mergeLists } from './utils/common'
+
+/**
+ * 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)
+}

packages/seql/src/seql.ts

@@ -0,0 +1,9 @@
+import { tagBuilder } from '@sirutils/core'
+
+const createTag = tagBuilder('@sirutils/seql')
+
+export const seqlTags = {
+  env: createTag('invalid-env'),
+} as const
+
+export type SeqlTags = (typeof seqlTags)[keyof typeof seqlTags]

packages/seql/src/tag.ts

@@ -0,0 +1,91 @@
+import type { BlobType } from '@sirutils/core'
+
+import { ENV } from '../internal/consts'
+import { adaptors } from '../internal/adaptors'
+import { Generated, Raw } from '../internal/consts'
+
+/**
+ * Base builder
+ */
+const builder = <T = BlobType>(
+  values: T[],
+  buildText: (nextParamID: number) => string
+): Sirutils.Seql.BuildedQuery<T> => {
+  return {
+    $type: Raw,
+    values,
+    buildText,
+  }
+}
+
+/**
+ * Check is builder
+ */
+export const isBuilder = (builder: BlobType): builder is Sirutils.Seql.BuildedQuery => {
+  return builder && builder.$type === Raw
+}
+
+/**
+ * Generate the full query
+ */
+export const generate = <T>(builder: Sirutils.Seql.BuildedQuery<T>): Sirutils.Seql.Query<T> => {
+  return {
+    $type: Generated,
+    text: builder.buildText(1),
+    values: builder.values,
+
+    builder,
+  }
+}
+
+/**
+ * Check is generated
+ */
+export const isGenerated = (query: BlobType): query is Sirutils.Seql.Query => {
+  return query && query.$type === Generated
+}
+
+export const join = <T>(
+  builders: Sirutils.Seql.BuildedQuery<T>[],
+  delimiter = ''
+): Sirutils.Seql.BuildedQuery<T> => {
+  return builder(
+    builders.reduce((acc, { values }) => acc.concat(values), [] as T[]),
+    nextParamID => {
+      let paramID = nextParamID
+      const builtText: string[] = []
+
+      for (const builder of builders) {
+        builtText.push(builder.buildText(paramID))
+        paramID += builder.values.length
+      }
+
+      return builtText.join(delimiter)
+    }
+  )
+}
+
+/**
+ * Check if provided value is a BuildedQuery
+ */
+export const toSqlBuilder = <T>(
+  value: Sirutils.Seql.BuildedQuery<T> | T
+): Sirutils.Seql.BuildedQuery<T> => {
+  return isBuilder(value) ? value : safe(value)
+}
+
+/**
+ * Use for query (dangerous). use this function carefully
+ */
+export const raw = (value: string): Sirutils.Seql.BuildedQuery<string> => {
+  return builder([], () => value)
+}
+
+/**
+ * Use for parameters.
+ */
+export const safe = <T>(value: T): Sirutils.Seql.BuildedQuery<T> => {
+  return builder([value], nextParamID =>
+    adaptors[ENV.adaptor].paramterPattern(nextParamID.toString())
+  )
+}

packages/seql/src/utils/builder.ts

@@ -0,0 +1,89 @@
+import type { BlobType } from '@sirutils/core'
+
+import { isGenerated, join } from './builder'
+
+export const escapeIdentifier = (identifier: string) => {
+  let result = identifier
+
+  if (result.charAt(0) === '"' && result.charAt(result.length - 1) === '"') {
+    result = result.slice(1, result.length - 2)
+  }
+  if (result.includes('"')) {
+    throw new Error(`Invalid identifier: ${result}`)
+  }
+  return `"${result}"`
+}
+
+export const filterUndefined = <Value = BlobType>(
+  object: Sirutils.Seql.ValueRecord<Value>
+): Sirutils.Seql.ValueRecord<Value> => {
+  const filteredEntries = Object.entries(object).filter(([_, v]) => v !== undefined)
+
+  return Object.fromEntries(filteredEntries)
+}
+
+export const mergeLists = <T>(list1: readonly T[], list2: readonly T[]): T[] => {
+  const result: T[] = []
+
+  for (let i = 0; i < Math.max(list1.length, list2.length); i++) {
+    const elem1 = list1[i]
+    if (elem1 !== undefined) {
+      result.push(elem1)
+    }
+
+    const elem2 = list2[i]
+    if (elem2 !== undefined) {
+      const generated = (elem2 as BlobType).values
+        .filter((value: BlobType) => isGenerated(value))
+        .map((value: BlobType) => value.builder) as BlobType
+      ;(elem2 as BlobType).values = (elem2 as BlobType).values.filter(
+        (value: BlobType) => !isGenerated(value)
+      )
+
+      if (generated.length > 0) {
+        result.push(join(generated) as T)
+      } else {
+        result.push(elem2)
+      }
+    }
+  }
+
+  return result
+}
+
+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
+}
+
+const objectKeys = (object: object): Set<string> => {
+  return new Set(Object.keys(object))
+}
+
+export const extractKeys = <Value = BlobType>(
+  objects: Sirutils.Seql.ValueRecord<Value>[]
+): 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)
+}