forj 0.0.1 → 0.0.3

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
-  "files": ["dist"],
+  "main": "src/index.ts",
+  "files": ["src"],
   "exports": {
+    ".": "./src/index.ts",
+    "./d1": "./src/d1/index.ts",
+    "./d1/types": "./src/d1/types.ts"
+  },
+  "-exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
@@ -17,15 +23,18 @@
   "scripts": {
     "bench": "tsx tests/benchmark/*.bench.ts",
     "build": "tsup",
-    "prepublishOnly": "bun run build"
+    "-prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@cloudflare/workers-types": "^4.20260113.0",
+    "@aws-sdk/client-dynamodb": "3.817.0",
+    "@aws-sdk/lib-dynamodb": "3.817.0",
     "pluralize": "^8.0",
+    "t0n": "^0.1",
     "zod": "^3.19.1"
   },
   "devDependencies": {
     "@types/pluralize": "^0.0.33",
+    "@cloudflare/workers-types": "^4.20260113.0",
     "bun-types": "^1.2.13",
     "terser": "^5.46.0",
     "tiny-glob": "^0.2",

package/src/clause-builder.ts

@@ -0,0 +1,216 @@
+import { parseColumn, isJoinCompare, zSame, zType } from './utils'
+import type {
+  IClauseBuilder,
+  ClauseOperator,
+  Value, Values,
+  WhereFn, WhereArgs,
+  DBSchema,
+} from './types'
+
+export default class ClauseBuilder<
+  T,
+  C extends keyof T = keyof T
+> implements IClauseBuilder<T> {
+  #table: string
+  #schema?: DBSchema
+  #clauses: string[] = []
+  #args: Values = []
+
+  get clauses() {
+    return this.#clauses
+  }
+  set clauses(clauses: string[]) {
+    this.#clauses.push(...clauses)
+  }
+
+  get args() {
+    return this.#args
+  }
+  set args(args: Values) {
+    this.#args.push(...args)
+  }
+
+  get length() {
+    return this.#clauses.length
+  }
+
+  constructor(table: string, schema?: DBSchema) {
+    this.#table = table
+    this.#schema = schema
+  }
+
+  #nested(fn: WhereFn<T, C>, operator: ClauseOperator = 'AND') {
+    const nested = new ClauseBuilder<T, C>(this.#table, this.#schema)
+    fn(nested)
+
+    if (nested.length) {
+      this.#clauses.push(`${this.length ? operator +' ' : ''}(${nested.clauses.join(' ')})`)
+      this.#args.push(...nested.args)
+    }
+
+    return this
+  }
+
+  #clause(sql: string, values: Values = [], bool: ClauseOperator = 'AND') {
+    if (this.length) sql = bool +' '+ sql
+    this.#clauses.push(sql)
+
+    if (values?.length) // TODO: https://developers.cloudflare.com/d1/worker-api/#type-conversion
+      this.#args.push(...values)
+
+    return this
+  }
+
+  #where(
+    logical: ClauseOperator,
+    ...args: WhereArgs<T>
+  ) {
+    if (typeof args[0] == 'function')
+      return this.#nested(args[0], logical)
+
+    const length = args.length
+    let [column, operator, value] = args
+
+    if (length == 2) { // @ts-ignore
+      value = operator
+      operator = '='
+    }
+
+    // @ts-ignore
+    column = parseColumn(String(column), this.#table)
+
+    if (this.#schema && !zSame(column, value, this.#schema)) {
+      throw new Error(`Table column '${String(column)}' of type '${zType(column, this.#schema)}' is not assignable as type of '${typeof value}'.`)
+    }
+
+    return isJoinCompare(value, this.#schema) // @ts-ignore
+      ? this.#clause(`${column} ${operator} ${value}`, [], logical) // @ts-ignore
+      : this.#clause(`${column} ${operator} ?`, [value], logical)
+  }
+
+  where(...args: WhereArgs<T>) {
+    return this.#where('AND', ...args)
+  }
+  on(...args: WhereArgs<T>) {
+    return this.where(...args)
+  }
+
+  orWhere(...args: WhereArgs<T>) {
+    return this.#where('OR', ...args)
+  }
+  orOn(...args: WhereArgs<T>) {
+    return this.orWhere(...args)
+  }
+
+  #in(
+    column: string,
+    values: Values,
+    operator: 'IN' | 'NOT IN',
+    logical: ClauseOperator = 'AND'
+  ) {
+    if (!values?.length) return this
+    return this.#clause(parseColumn(column, this.#table) + ` ${operator} (${values.map(() => '?').join(', ')})`, values, logical)
+  }
+
+  whereIn(column: C, values: T[C][]) { // @ts-ignore
+    return this.#in(column, values, 'IN')
+  }
+  in(column: C, values: T[C][]) {
+    return this.whereIn(column, values)
+  }
+
+  whereNotIn(column: C, values: T[C][]) { // @ts-ignore
+    return this.#in(column, values, 'NOT IN')
+  }
+  notIn(column: C, values: T[C][]) {
+    return this.whereNotIn(column, values)
+  }
+
+  orWhereIn(column: C, values: T[C][]) { // @ts-ignore
+    return this.#in(column, values, 'IN', 'OR')
+  }
+  orIn(column: C, values: T[C][]) {
+    return this.orWhereIn(column, values)
+  }
+
+  orWhereNotIn(column: C, values: T[C][]) { // @ts-ignore
+    return this.#in(column, values, 'NOT IN', 'OR')
+  }
+  orNotIn(column: C, values: T[C][]) {
+    return this.orWhereNotIn(column, values)
+  }
+
+  #between(
+    column: string,
+    one: Value,
+    two: Value,
+    operator: 'BETWEEN' | 'NOT BETWEEN',
+    logical: ClauseOperator = 'AND'
+  ) {
+    return this.#clause(parseColumn(column, this.#table) + ` ${operator} ? AND ?`, [one, two], logical)
+  }
+
+  whereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+    return this.#between(column, one, two, 'BETWEEN')
+  }
+  between(column: C, one: T[C], two: T[C]) {
+    return this.whereBetween(column, one, two)
+  }
+
+  orWhereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+    return this.#between(column, one, two, 'BETWEEN', 'OR')
+  }
+  orBetween(column: C, one: T[C], two: T[C]) {
+    return this.orWhereBetween(column, one, two)
+  }
+
+  whereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+    return this.#between(column, one, two, 'NOT BETWEEN')
+  }
+  notBetween(column: C, one: T[C], two: T[C]) {
+    return this.whereNotBetween(column, one, two)
+  }
+
+  orWhereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+    return this.#between(column, one, two, 'NOT BETWEEN', 'OR')
+  }
+  orNotBetween(column: C, one: T[C], two: T[C]) {
+    return this.orWhereNotBetween(column, one, two)
+  }
+
+  #null(
+    column: string,
+    operator: 'IS' | 'IS NOT' = 'IS',
+    logical: ClauseOperator = 'AND'
+  ) {
+    return this.#clause(parseColumn(column, this.#table) +` ${operator} NULL`, [], logical)
+  }
+
+  whereNull(column: C) {
+    return this.#null(column as string)
+  }
+  onNull(column: C) {
+    return this.whereNull(column)
+  }
+
+  orWhereNull(column: C) {
+    return this.#null(column as string, 'IS', 'OR')
+  }
+  orOnNull(column: C) {
+    return this.orWhereNull(column)
+  }
+
+  whereNotNull(column: C) {
+    return this.#null(column as string, 'IS NOT')
+  }
+  onNotNull(column: C) {
+    return this.whereNotNull(column)
+  }
+
+  orWhereNotNull(column: C) {
+    return this.#null(column as string, 'IS NOT', 'OR')
+  }
+  orNotNull(column: C) {
+    return this.orWhereNotNull(column)
+  }
+}

package/src/d1/index.ts

@@ -0,0 +1,4 @@
+
+// export * from './migration'
+// export * from './seeder'
+export * from './model'

package/src/d1/model.ts

@@ -0,0 +1,78 @@
+import type {
+  D1Database,
+  // D1PreparedStatement,
+  // D1Result, D1ExecResult, D1Meta,
+} from './types'
+
+import z from 'zod'
+import { Envir } from 't0n'
+
+import QueryBuilder from '../query-builder'
+import BModel from '../model'
+import type {
+  DBSchema, SchemaKeys,
+  Item,
+  Pipe, Result, RunFn,
+} from '../types'
+
+export function Model<
+  TSchema extends DBSchema,
+  TBase extends SchemaKeys<TSchema>
+>(schema: TSchema, base: TBase) {
+  type S = z.infer<typeof schema>
+  return class extends BaseModel<TBase, S> {
+    static $table = String(base)
+    static $schema = schema
+  }
+}
+
+export abstract class BaseModel<TB extends keyof DB, DB> extends BModel<TB, DB> {
+  static $db: string | D1Database = 'DB'
+
+  static pipe<S, T>(): Pipe<S, T> {
+    const db = this.DB()
+
+    return {
+      run: this.run<S, T>(db)
+    }
+  }
+
+  static DB() {
+    if (typeof this.$db == 'string') { // TODO: improv compatibility without nodejs_compat
+      if (!Envir.has(this.$db))
+        throw new Error(`Database '${this.$db}' instance not provided.`)
+
+      // @ts-ignore
+      return Envir.get(this.$db) as D1Database
+    }
+
+    return this.$db
+  }
+
+  static run<S, T>(db: D1Database): RunFn<S, T> {
+    return async <S, T, C extends keyof T = keyof T>(
+      qb: QueryBuilder<S, T, C>
+    ): Promise<Result<T, C>> => {
+      let stmt = db.prepare(qb.query)
+
+      if (qb.args?.length)
+        stmt = stmt.bind(...qb.args)
+
+      const resp = await stmt.run<Item<T, C>>()
+
+      const meta = resp.meta as any
+
+      return {
+        changes: meta?.changes,
+        duration: meta?.duration,
+        lastId: meta?.last_row_id,
+        // served_by: meta?.served_by,
+        rowsRead: meta?.rows_read,
+        rowsWritten: meta?.rows_written,
+        // meta: resp.meta,
+        success: resp.success,
+        results: resp.results,
+      }
+    }
+  }
+}

package/src/d1/types.ts

@@ -0,0 +1,7 @@
+export type {
+  D1Database,
+  D1PreparedStatement,
+  D1Result, D1ExecResult, D1Meta,
+} from '@cloudflare/workers-types'
+
+export * from '../types'

package/src/dynamodb/client.ts

@@ -0,0 +1,125 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
+import {
+  DynamoDBDocumentClient,
+
+  BatchGetCommand,
+  BatchWriteCommand,
+
+  DeleteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  UpdateCommand,
+
+  ScanCommandInput,
+  QueryCommandInput,
+  UpdateCommandInput,
+
+  BatchGetCommandInput,
+  BatchWriteCommandInput,
+} from '@aws-sdk/lib-dynamodb'
+import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb'
+import AbstractModel from './model'
+import { Keys, KeySchema } from './types'
+
+const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
+  region: process.env.AWS_REGION || 'us-east-1',
+  endpoint: process.env.AWS_ENDPOINT_URL || undefined,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'DUMMYIDEXAMPLE',
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'DUMMYEXAMPLEKEY',
+  },
+} : {})
+
+export const DocumentClient = DynamoDBDocumentClient.from(client)
+
+export class Dynamodb {
+  static model<T extends object>(cls: new (...args: any[]) => T) {
+    return new AbstractModel<T>(cls)
+  }
+
+  static raw() {
+    return RawClient
+  }
+}
+
+export class RawClient {
+  static async get(TableName: string, key: Keys | Record<string, string>, sk?: string) {
+    return DocumentClient.send(new GetCommand({ TableName, Key: this.key(key, sk) }))
+  }
+
+  static async scan(TableName: string, filters: Omit<ScanCommandInput, 'TableName'>) {
+    return DocumentClient.send(new ScanCommand({ ...filters, TableName }))
+  }
+
+  static async query(TableName: string, filters: Omit<QueryCommandInput, 'TableName'>) {
+    return DocumentClient.send(new QueryCommand({ ...filters, TableName }))
+  }
+
+  static async put(TableName: string, Item: Record<string, NativeAttributeValue>) {
+    return DocumentClient.send(new PutCommand({ TableName, Item }))
+  }
+
+  static async update(
+    TableName: string,
+    filters: Omit<UpdateCommandInput, 'TableName' | 'Key'>,
+    key: Keys | Record<string, string>,
+    sk?: string
+  ) {
+    return DocumentClient.send(new UpdateCommand({
+      ...filters, TableName, Key: this.key(key, sk),
+    }))
+  }
+
+  static async delete(TableName: string, key: Keys | Record<string, string>, sk?: string) {
+    return DocumentClient.send(new DeleteCommand({ TableName, Key: this.key(key, sk) }))
+  }
+
+  static async batchGet(batch: BatchGetCommandInput) {
+    return DocumentClient.send(new BatchGetCommand(batch))
+  }
+
+  static async batchWrite(batch: BatchWriteCommandInput) {
+    return DocumentClient.send(new BatchWriteCommand(batch))
+  }
+
+  static key(
+    key: Keys | Record<string, string>,
+    sk?: string,
+    schema?: KeySchema,
+    defaultSK?: string,
+  ) {
+    let pk: string
+    let skValue: string | undefined
+
+    if (Array.isArray(key)) {
+      pk = key[0]
+      skValue = key[1] ?? sk
+    } else if (typeof key == 'object' && key != null) {
+      return key
+    } else {
+      pk = key
+      skValue = sk
+    }
+
+    if (!schema) {
+      const keys = {PK: pk}
+      // @ts-ignore
+      if (skValue) keys.SK = skValue
+      return keys
+    }
+
+    const keys = { [schema.PK]: pk }
+
+    if (schema?.SK) {
+      if (skValue) {
+        keys[schema.SK] = skValue
+      } else if (defaultSK) {
+        keys[schema.SK] = defaultSK
+      }
+    }
+
+    return keys
+  }
+}

package/src/dynamodb/compact.ts

@@ -0,0 +1,205 @@
+import { getLength } from 't0n'
+import { isArraySchema } from './schema'
+import type { SchemaStructure } from './types'
+
+export default class Compact {
+  static #typeRegex: RegExp
+  static #reverseTypeRegex: RegExp
+  static #reverseTypeMap: Record<string, string>
+  static #typeMap: Record<string, string> = {
+    // Boolean
+    'true': 'T',
+    'false': 'F',
+    // Null
+    'null': 'N',
+    // Array
+    '[]': 'A',
+    '["0"]': 'A0',
+    '["1"]': 'A1',
+    '["false"]': 'A2',
+    '["true"]': 'A3',
+    // Object
+    '{}': 'O',
+    // String
+    '""': 'S',
+    '"0"': 'S0',
+    '"1"': 'S1',
+    '"false"': 'S2',
+    '"true"': 'S3',
+  }
+
+  static {
+    const keys = []
+    const values = []
+    const reverseTypeMap: Record<string, string> = {}
+    for (const key in this.#typeMap) {
+      const val = this.#typeMap[key]
+      const k = key.replace(/"/g, "'")
+      keys.push(k)
+      values.push(val)
+
+      reverseTypeMap[val] = k
+      this.#typeMap[k] = val
+    }
+
+    this.#reverseTypeMap = reverseTypeMap
+    this.#typeRegex = this.#mapRegex(keys)
+    this.#reverseTypeRegex = this.#mapRegex(values)
+  }
+
+  static encode(obj: any, schema: SchemaStructure): string {
+    const seen: any[] = []
+
+    return this.#pack(
+      JSON.stringify(this.zip(obj, schema, seen))
+        .replace(/"\^(\d+)"/g, '^$1')
+        .replace(/"/g, '~TDQ~')
+        .replace(/'/g, '"')
+        .replace(/~TDQ~/g, "'")
+        .replace(/\\'/g, "^'")
+    )
+  }
+
+  static smartDecode<T = any>(val: any, schema: SchemaStructure): T {
+    if (!val) return val as T
+
+    if (Array.isArray(val)) // @ts-ignore
+      return val.map((i: {v: string}) => this.decode<T>(i?.V, schema)).filter(Boolean) as T
+
+    return val?.V ? this.decode<T>(val.V, schema) : val
+  }
+
+  static decode<T = any>(val: string, schema: SchemaStructure): T {
+    if (!val || typeof val != 'string') return val as T
+
+    return this.withSchema(this.unzip(JSON.parse(
+      this.#unpack(val)
+        .replace(/"/g, '~TSQ~')
+        .replace(/'/g, '"')
+        .replace(/~TSQ~/g, "'")
+        .replace(/\^"/g, '\\"')
+        .replace(/(?<=[,{\[]|^)(\^\d+)(?=[,\]}[]|$)/g, '"$1"')
+    )), schema) as T
+  }
+
+  static zip(obj: any, schema: SchemaStructure, seen: any[]): any[] {
+    if (Array.isArray(obj))
+      return obj?.length ? obj.map(item => this.zip(item, schema, seen)) : []
+
+    if (this.#cantZip(obj)) return obj
+
+    return schema.map(key => {
+      if (typeof key == 'string')
+        return this.memo(obj[key], seen)
+
+      const mainKey = Object.keys(key)[0]
+      const subKeys = key[mainKey]
+      const val = obj[mainKey]
+
+      if (Array.isArray(val))
+        return val.map(item => this.zip(item, subKeys, seen))
+
+      return this.zip(val, subKeys, seen)
+    })
+  }
+
+  static unzip(val: any, seen: any[] = []): any[] {
+    if (Array.isArray(val))
+      return val?.length ? val.map(item => this.unzip(item, seen)) : []
+
+    const type = typeof val
+    const length = getLength(val, type)
+
+    if (this.#cantZip(val, type, length)) return val
+
+    if (type == 'object') {
+      for (const key in val)
+        val[key] = this.unzip(val[key], seen)
+
+      return val
+    }
+
+    if (type == 'string' && val.startsWith('^')) {
+      const item = seen[parseInt(val.slice(1), 10)]
+      return item ? item : val
+    }
+
+    seen.push(val)
+    return val
+  }
+
+  static withSchema(value: any[], keys: any[], deep = false): any {
+    if (!value || !Array.isArray(value))
+      return value
+
+    if (!deep && isArraySchema(keys))
+      return value?.length ? value.map(v => this.withSchema(v, keys, true)) : []
+
+    return Object.fromEntries(
+      keys.map((key, index) => this.entry(key, value[index])).filter(Boolean)
+    )
+  }
+
+  static entry(key: any, value: any): any {
+    if (!key) return undefined
+
+    if (typeof key == 'string')
+      return [key, value == null ? null : value]
+
+    const mainKey = Object.keys(key)[0]
+    const subKeys = key[mainKey]
+
+    if (Array.isArray(value)) {
+      if (value.length < 1)
+        return [mainKey, []]
+
+      return Array.isArray(value[0])
+        ? [mainKey, value.map(v => this.withSchema(v, subKeys))]
+        : [mainKey, this.withSchema(value, subKeys)]
+    }
+
+    return [mainKey, value == null ? null : value]
+  }
+
+  static memo(val: any, seen: any[]): any {
+    if (Array.isArray(val))
+      return val.map(item => this.memo(item, seen))
+
+    const type = typeof val
+    if (type == 'object' && val != null) {
+      for (const key in val)
+        val[key] = this.memo(val[key], seen)
+
+      return val
+    }
+
+    const length = getLength(val, type)
+    if (this.#cantZip(val, type, length)) return val
+
+    const index = seen.indexOf(val)
+    if (index != -1)
+      return `^${index}`
+
+    seen.push(val)
+    return val
+  }
+
+  static #mapRegex(keys: string[]) {
+    keys = keys.sort((a, b) => b.length - a.length).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    return new RegExp(`(?<![^\\s,\\[\\{:])(${keys.join('|')})(?![^\\s,\\]\\}:])`, 'g')
+  }
+
+  static #pack(val: string): string {
+    return val.replace(this.#typeRegex, match => this.#typeMap[match])
+  }
+
+  static #unpack(val: string): string {
+    return val.replace(this.#reverseTypeRegex, match => this.#reverseTypeMap[match])
+  }
+
+  static #cantZip(val: any, type: string = '', length: number = 0) {
+    if (!val || [null, true, false, 'true', 'false'].includes(val)) return true
+
+    return !type && !length ? false : type != 'object' && length < 2
+  }
+}