forj 0.0.0 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present, ZUNQ.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,17 +1,24 @@
-### Verify if name exists:
+# `forj`
+
+SQLite ORM and Query Builder whitout dependencies.
+
+## Install
+
+To install the package, run:
 
 ```bash
-npm view PACKAGE_NAME
+# bun
+bun i forj
 ```
 
-or
+## Tests
+
+To perform the tests, run:
 
 ```bash
-bun info PACKAGE_NAME
+bun test
 ```
 
-### Publish package
+## License
 
-```bash
-bun publish
-```
+This package is licensed under the [MIT license](https://github.com/attla/forj/blob/main/LICENSE) © [Zunq](https://zunq.com)

package/package.json

@@ -1,4 +1,77 @@
 {
-"name": "forj",
-"version": "0.0.0"
+  "name": "forj",
+  "description": "SQLite ORM and Query Builder whitout dependencies",
+  "version": "0.0.2",
+  "type": "module",
+  "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"
+    },
+    "./d1": {
+      "import": "./dist/d1.js",
+      "types": "./dist/d1.d.ts"
+    }
+  },
+  "scripts": {
+    "bench": "tsx tests/benchmark/*.bench.ts",
+    "build": "tsup",
+    "-prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@cloudflare/workers-types": "^4.20260113.0",
+    "pluralize": "^8.0",
+    "zod": "^3.19.1"
+  },
+  "devDependencies": {
+    "@types/pluralize": "^0.0.33",
+    "bun-types": "^1.2.13",
+    "terser": "^5.46.0",
+    "tiny-glob": "^0.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "author": "Zunq <open-source@zunq.com>",
+  "license": "MIT",
+  "homepage": "https://zunq.dev",
+  "repository": "git://github.com/attla/forj",
+  "bugs": "https://github.com/attla/forj/issues",
+  "keywords": [
+    "forj",
+    "attla",
+    "resources",
+    "support",
+    "sqlite",
+    "orm",
+    "query",
+    "builder",
+    "query builder",
+    "query-builder",
+    "db",
+    "database",
+    "sql",
+    "mysql",
+    "postgres",
+    "postgresql",
+    "typescript",
+    "aws",
+    "lambda",
+    "llrt",
+    "deno",
+    "bun",
+    "nodejs"
+  ]
 }

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)
+  }
+
+}