forj 0.0.1 → 0.0.2

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
-  "files": ["dist"],
+  "main": "src/index.ts",
+  "files": ["src"],
   "exports": {
+    ".": "./src/index.ts",
+    "./d1": "./src/d1/index.ts"
+  },
+  "-exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
@@ -17,7 +22,7 @@
   "scripts": {
     "bench": "tsx tests/benchmark/*.bench.ts",
     "build": "tsup",
-    "prepublishOnly": "bun run build"
+    "-prepublishOnly": "bun run build"
   },
   "dependencies": {
     "@cloudflare/workers-types": "^4.20260113.0",

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,79 @@
+import type {
+  D1Database,
+  D1PreparedStatement,
+  D1Result, D1ExecResult, D1Meta,
+} from '@cloudflare/workers-types'
+
+import z from 'zod'
+
+import { QueryBuilder } from '../query-builder'
+import { default as BaseModel } from '../model'
+import type {
+  DBSchema, SchemaKeys,
+  Item,
+  Pipe, Result, RunFn,
+} from '../types'
+
+export function ModelBuilder<
+  TSchema extends DBSchema,
+  TBase extends SchemaKeys<TSchema>
+>(schema: TSchema, base: TBase) {
+  type S = z.infer<typeof schema>
+  return class extends Model<TBase, S> {
+    static $table = String(base)
+    static $schema = schema
+  }
+}
+
+export default ModelBuilder
+
+export abstract class Model<TB extends keyof DB, DB> extends BaseModel<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 (!(this.$db in process.env))
+        throw new Error(`Database '${this.$db}' instance not provided.`)
+
+      // @ts-ignore
+      return process.env[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/index.ts

@@ -0,0 +1 @@
+export * from './query-builder'

package/src/model.ts

@@ -0,0 +1,258 @@
+import pluralize from 'pluralize'
+import { QueryBuilder } from './query-builder'
+import type {
+  Operator, OrderDirection,
+  WhereFn, WhereArgs,
+  DBSchema, Pipe,
+} from './types'
+
+export default abstract class Model<TB extends keyof DB, DB> {
+  // Property only for the compiler (does not exist at runtime)
+  readonly $DBShape!: DB
+  readonly $TShape!: DB[TB]
+
+  static $table: string = ''
+  static $schema?: DBSchema
+
+  static pipe<S, T>(): Pipe<S, T> {
+    throw new Error(`Database connection not provided.`) // improv this message
+  }
+
+  static builder<S, T>() {
+    const table = this.$table || pluralize(this.name.toLowerCase())
+
+    return new QueryBuilder<S, T>(table, this.$schema, this.pipe<S, T>())
+  }
+
+  static select< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, ...columns: C[] | C[][]) {
+    return this.builder<I['$DBShape'], T>().select(...columns)
+  }
+
+  static distinct< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M) {
+    return this.builder<I['$DBShape'], T>().distinct()
+  }
+
+  static where< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T, C>
+  static where< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  static where< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  static where< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M, ...args: WhereArgs<T>) {
+    return this.builder<I['$DBShape'], T>().where(...args)
+  }
+
+  static on< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T, C>
+  static on< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  static on< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  static on< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M, ...args: WhereArgs<T>) {
+    return this.builder<I['$DBShape'], T>().where(...args)
+  }
+
+  static whereIn< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C][]) {
+    return this.builder<I['$DBShape'], T>().whereIn(column, value)
+  }
+
+  static in< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C][]) {
+    return this.builder<I['$DBShape'], T>().whereIn(column, value)
+  }
+
+  static whereNotIn< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C][]) {
+    return this.builder<I['$DBShape'], T>().whereNotIn(column, value)
+  }
+
+  static notIn< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, value: T[C][]) {
+    return this.builder<I['$DBShape'], T>().whereNotIn(column, value)
+  }
+
+  static whereBetween< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, one: T[C], two: T[C]) {
+    return this.builder<I['$DBShape'], T>().whereBetween(column, one, two)
+  }
+
+  static between< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, one: T[C], two: T[C]) {
+    return this.builder<I['$DBShape'], T>().whereBetween(column, one, two)
+  }
+
+  static whereNotBetween< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, one: T[C], two: T[C]) {
+    return this.builder<I['$DBShape'], T>().whereNotBetween(column, one, two)
+  }
+
+  static notBetween< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, one: T[C], two: T[C]) {
+    return this.builder<I['$DBShape'], T>().whereNotBetween(column, one, two)
+  }
+
+  static whereNull< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().whereNull(column)
+  }
+
+  static onNull< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().whereNull(column)
+  }
+
+  static whereNotNull< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().whereNotNull(column)
+  }
+
+  static onNotNull< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().whereNotNull(column)
+  }
+
+  // TODO: groupBy(...columns: string[])
+
+  static order< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, direction: OrderDirection = 'ASC') {
+    return this.builder<I['$DBShape'], T>().order(column, direction)
+  }
+
+  static orderBy< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C, direction: OrderDirection = 'ASC') {
+    return this.builder<I['$DBShape'], T>().order(column, direction)
+  }
+
+  static asc< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().asc(column)
+  }
+
+  static desc< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+    C extends keyof T
+  >(this: M, column: C) {
+    return this.builder<I['$DBShape'], T>().desc(column)
+  }
+
+  static limit< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M, val: number | string) {
+    return this.builder<I['$DBShape'], T>().limit(val)
+  }
+
+  static offset< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M, val: number | string) {
+    return this.builder<I['$DBShape'], T>().offset(val)
+  }
+
+}