forj 0.0.0 → 0.0.1

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/dist/chunk-NVO75XBO.js

@@ -0,0 +1 @@
+import e from"pluralize";var t=["=","!=",">","<",">=","<=","LIKE","IN","NOT IN","IS","IS NOT","BETWEEN"];function r(e,t,r=!0){return!r||e.includes(".")?e:t+"."+e}function s(e){if(null==e||null==e)return"NULL";const t=typeof e;return"number"==t||"bigint"==t?String(e):"boolean"==t?e?"1":"0":e instanceof Date?`'${e.toISOString().slice(0,19).replace("T"," ")}'`:`'${String(e).replace(/'/g,"''")}'`}var n={ZodString:"string",ZodNumber:"number",ZodBoolean:"boolean",ZodObject:"object",ZodArray:"array",ZodDate:"object",ZodNull:"object",ZodUndefined:"undefined",ZodSymbol:"symbol",ZodBigInt:"bigint",ZodFunction:"function"},i=(e,t)=>{const r=e.split(".");for(const e in r){if("object"!=typeof t)return!1;const s=r[e];if("shape"in t&&s in t.shape)t=t.shape[s];else{if(!(s in t))return!1;t=t[s]}}return[r[r.length-1],t]},h=(e,t)=>{const r=i(e,t);return r&&"_def"in r[1]?(e=r[0],t=r[1],((t?._def?.innerType?._def||t?._def)?.typeName||"").split("Zod").pop().toLowerCase()):"unknown"},o=(e,t,r,s=!1)=>{if(!s){const t=i(e,r);if(!t)return t;e=t[0],r=t[1]}if(!("_def"in r))return!1;let h=r?._def||{};"ZodOptional"==r?._def?.typeName&&(h=h?.innerType?._def||{});const u=h?.typeName||"";return!!u&&("ZodUnion"==u&&h?.options?.length?h?.options?.some(r=>o(e,t,r,!0)):"ZodArray"==u?Array.isArray(t):"ZodDate"==u?t instanceof Date:typeof t==n[u])};function u(e,t){if(!t||"string"!=typeof e||!e?.includes("."))return!1;const r=i(e,t);return r&&r?.length}var l=class e{#e;#t;#r=[];#s=[];get clauses(){return this.#r}set clauses(e){this.#r.push(...e)}get args(){return this.#s}set args(e){this.#s.push(...e)}get length(){return this.#r.length}constructor(e,t){this.#e=e,this.#t=t}#n(t,r="AND"){const s=new e(this.#e,this.#t);return t(s),s.length&&(this.#r.push(`${this.length?r+" ":""}(${s.clauses.join(" ")})`),this.#s.push(...s.args)),this}#i(e,t=[],r="AND"){return this.length&&(e=r+" "+e),this.#r.push(e),t?.length&&this.#s.push(...t),this}#h(e,...t){if("function"==typeof t[0])return this.#n(t[0],e);const s=t.length;let[n,i,l]=t;if(2==s&&(l=i,i="="),n=r(String(n),this.#e),this.#t&&!o(n,l,this.#t))throw new Error(`Table column '${String(n)}' of type '${h(n,this.#t)}' is not assignable as type of '${typeof l}'.`);return u(l,this.#t)?this.#i(`${n} ${i} ${l}`,[],e):this.#i(`${n} ${i} ?`,[l],e)}where(...e){return this.#h("AND",...e)}on(...e){return this.where(...e)}orWhere(...e){return this.#h("OR",...e)}orOn(...e){return this.orWhere(...e)}#o(e,t,s,n="AND"){return t?.length?this.#i(r(e,this.#e)+` ${s} (${t.map(()=>"?").join(", ")})`,t,n):this}whereIn(e,t){return this.#o(e,t,"IN")}in(e,t){return this.whereIn(e,t)}whereNotIn(e,t){return this.#o(e,t,"NOT IN")}notIn(e,t){return this.whereNotIn(e,t)}orWhereIn(e,t){return this.#o(e,t,"IN","OR")}orIn(e,t){return this.orWhereIn(e,t)}orWhereNotIn(e,t){return this.#o(e,t,"NOT IN","OR")}orNotIn(e,t){return this.orWhereNotIn(e,t)}#u(e,t,s,n,i="AND"){return this.#i(r(e,this.#e)+` ${n} ? AND ?`,[t,s],i)}whereBetween(e,t,r){return this.#u(e,t,r,"BETWEEN")}between(e,t,r){return this.whereBetween(e,t,r)}orWhereBetween(e,t,r){return this.#u(e,t,r,"BETWEEN","OR")}orBetween(e,t,r){return this.orWhereBetween(e,t,r)}whereNotBetween(e,t,r){return this.#u(e,t,r,"NOT BETWEEN")}notBetween(e,t,r){return this.whereNotBetween(e,t,r)}orWhereNotBetween(e,t,r){return this.#u(e,t,r,"NOT BETWEEN","OR")}orNotBetween(e,t,r){return this.orWhereNotBetween(e,t,r)}#l(e,t="IS",s="AND"){return this.#i(r(e,this.#e)+` ${t} NULL`,[],s)}whereNull(e){return this.#l(e)}onNull(e){return this.whereNull(e)}orWhereNull(e){return this.#l(e,"IS","OR")}orOnNull(e){return this.orWhereNull(e)}whereNotNull(e){return this.#l(e,"IS NOT")}onNotNull(e){return this.whereNotNull(e)}orWhereNotNull(e){return this.#l(e,"IS NOT","OR")}orNotNull(e){return this.orWhereNotNull(e)}},a=class{#e;#t;#a=[];#r;#c=[];#N=[];#w=!1;#g=!1;#f;#p;#d=[];#I;constructor(e,t,r){this.#e=e,this.#t=t,this.#I=r,this.#r=new l(e,t)}async run(){if(!this.#I?.run)throw new Error("No database connection.");return await(this.#I?.run(this))}async first(...e){e?.length&&this.select(...e);const t=await this.run();return t.results?.length?t.results[0]:null}async all(...e){e?.length&&this.select(...e);return(await this.run()).results}select(...e){return this.#a.push(...e.flat(1/0)),this}distinct(){return this.#w=!0,this}#b(e,s,...n){this.#g=!0;const i=(e?e+" ":"")+`JOIN ${s} ON `;if("function"==typeof n[0]){const e=new l(s,this.#t);return n[0](e),this.#d.push(i+e.clauses.join(" ")),this.#r.args=e.args,this}const a=n.length;let[c,N,w,g]=n;if(2==a)w=N,N="=";else if(3!=a||"string"==typeof(f=N)&&t.includes(f))4==a&&(w=r(g,w),N="=");else{if(w=r(w,N),this.#t&&!u(w,this.#t))throw new Error(`Table column '${w}' doesn't exists.`);N="="}var f;const p=r(String(c),String(s));if(this.#t&&!o(p,w,this.#t))throw new Error(`Table column '${p}' of type '${h(p,this.#t)}' is not assignable as type of '${typeof w}'.`);return u(w,this.#t)||(this.#r.args=[w],w="?"),this.#d.push(i+p+` ${N} ${w}`),this}join(e,...t){return this.#b(void 0,e,...t)}innerJoin(e,...t){return this.#b("INNER",e,...t)}leftJoin(e,...t){return this.#b("LEFT",e,...t)}rightJoin(e,...t){return this.#b("RIGHT",e,...t)}crossJoin(e,...t){return this.#b("CROSS",e,...t)}where(...e){return this.#r.where(...e),this}on(...e){return this.where(...e)}orWhere(...e){return this.#r.orWhere(...e),this}orOn(...e){return this.orWhere(...e)}whereIn(e,t){return this.#r.whereIn(e,t),this}in(e,t){return this.whereIn(e,t)}whereNotIn(e,t){return this.#r.whereNotIn(e,t),this}notIn(e,t){return this.whereNotIn(e,t)}orWhereIn(e,t){return this.#r.orWhereIn(e,t),this}orIn(e,t){return this.orWhereIn(e,t)}orWhereNotIn(e,t){return this.#r.orWhereNotIn(e,t),this}orNotIn(e,t){return this.orWhereNotIn(e,t)}whereBetween(e,t,r){return this.#r.whereBetween(e,t,r),this}between(e,t,r){return this.whereBetween(e,t,r)}orWhereBetween(e,t,r){return this.#r.orWhereBetween(e,t,r),this}orBetween(e,t,r){return this.orWhereBetween(e,t,r)}whereNotBetween(e,t,r){return this.#r.whereNotBetween(e,t,r),this}notBetween(e,t,r){return this.whereNotBetween(e,t,r)}orWhereNotBetween(e,t,r){return this.#r.orWhereNotBetween(e,t,r),this}orNotBetween(e,t,r){return this.orWhereNotBetween(e,t,r)}whereNull(e){return this.#r.whereNull(e),this}onNull(e){return this.whereNull(e)}orWhereNull(e){return this.#r.orWhereNull(e),this}orOnNull(e){return this.orWhereNull(e)}whereNotNull(e){return this.#r.whereNotNull(e),this}onNotNull(e){return this.whereNotNull(e)}orWhereNotNull(e){return this.#r.orWhereNotNull(e),this}orNotNull(e){return this.orWhereNotNull(e)}groupBy(...e){return this.#c.push(...e),this}order(e,t="ASC"){return this.#N.push(r(e,this.#e,this.#g)+" "+t.toUpperCase()),this}orderBy(e,t="ASC"){return this.order(e,t)}asc(e){return this.order(e,"ASC")}desc(e){return this.order(e,"DESC")}limit(e){return(e=parseInt(String(e))||0)&&(this.#f=e),this}offset(e){return this.#p=parseInt(String(e))||0,this}#W(e,t){let r=0,n="",i=0;for(let h=e.indexOf("?");-1!==h;h=e.indexOf("?",h+1)){if(r>=t.length)throw new Error(`Missing bind value at position ${r}`);n+=e.slice(i,h),n+=s(t[r++]),i=h+1}if(r<t.length)throw new Error(`Too many bind values: expected ${r}, got ${t.length}`);return n+e.slice(i)}get args(){return this.#r.args}get arguments(){return this.args}get bindings(){return this.args}get query(){let t="";const r=new Set;return this.#a.forEach(t=>{t=function(t,r,s){if(t.toLowerCase().includes(" as "))return t;const n=t.includes(".");if(!s&&!n)return t;const[i,h]=n?t.split("."):[r,t];return`${i}.${h} AS ${e(i,1)}_${h}`}(t,this.#e,this.#g),!r.has(t)&&r.add(t)}),t+=`SELECT ${this.#w?"DISTINCT ":""}${r.size?[...r].join(", "):"*"}`,t+=" FROM "+this.#e,this.#d.length&&(t+=" "+this.#d.join(" ")),this.#r.length&&(t+=" WHERE "+this.#r.clauses.join(" ")),this.#c.length&&(t+=" GROUP BY "+this.#c.join(", ")),this.#N.length&&(t+=" ORDER BY "+this.#N.join(", ")),null!=this.#f&&(t+=" LIMIT "+this.#f),null!=this.#p&&(t+=" OFFSET "+this.#p),t}get sql(){return this.#W(this.query,this.#r.args)}get raw(){return this.sql}};export{a as QueryBuilder};

package/dist/d1.d.ts

@@ -0,0 +1,113 @@
+import { D as DBSchema, P as Pipe, Q as QueryBuilder, W as WhereFn, O as Operator, a as OrderDirection, S as SchemaKeys, R as RunFn } from './index-CwrzXlna.js';
+import { D1Database } from '@cloudflare/workers-types';
+import z from 'zod';
+
+declare abstract class Model$1<TB extends keyof DB, DB> {
+    readonly $DBShape: DB;
+    readonly $TShape: DB[TB];
+    static $table: string;
+    static $schema?: DBSchema;
+    static pipe<S, T>(): Pipe<S, T>;
+    static builder<S, T>(): QueryBuilder<S, T, keyof T>;
+    static select<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, ...columns: C[] | C[][]): QueryBuilder<I["$DBShape"], T, C>;
+    static distinct<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape']>(this: M): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static where<// @ts-ignore
+    M extends typeof Model$1<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$1<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$1<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$1<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$1<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$1<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 whereIn<// @ts-ignore
+    M extends typeof Model$1<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, keyof T>;
+    static in<// @ts-ignore
+    M extends typeof Model$1<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, keyof T>;
+    static whereNotIn<// @ts-ignore
+    M extends typeof Model$1<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, keyof T>;
+    static notIn<// @ts-ignore
+    M extends typeof Model$1<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, keyof T>;
+    static whereBetween<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static between<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static whereNotBetween<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static notBetween<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static whereNull<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static onNull<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static whereNotNull<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static onNotNull<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static order<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, direction?: OrderDirection): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static orderBy<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C, direction?: OrderDirection): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static asc<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static desc<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape'], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static limit<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape']>(this: M, val: number | string): QueryBuilder<I["$DBShape"], T, keyof T>;
+    static offset<// @ts-ignore
+    M extends typeof Model$1<TB, DB>, I extends InstanceType<M>, T extends I['$TShape']>(this: M, val: number | string): QueryBuilder<I["$DBShape"], T, keyof T>;
+}
+
+declare function ModelBuilder<TSchema extends DBSchema, TBase extends SchemaKeys<TSchema>>(schema: TSchema, base: TBase): {
+    new (): {
+        readonly $DBShape: z.TypeOf<TSchema>;
+        readonly $TShape: z.TypeOf<TSchema>[TBase];
+    };
+    $table: string;
+    $schema: TSchema;
+    $db: string | D1Database;
+    pipe<S, T>(): Pipe<S, T>;
+    DB(): D1Database;
+    run<S, T>(db: D1Database): RunFn<S, T>;
+    builder<S, T>(): QueryBuilder<S, T, keyof T>;
+    select<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, ...columns: C[] | C[][]): QueryBuilder<I["$DBShape"], T, C>;
+    distinct<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"]>(this: M): QueryBuilder<I["$DBShape"], T, keyof T>;
+    where<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, fn: WhereFn<T>): QueryBuilder<I["$DBShape"], T, C>;
+    where<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C]): QueryBuilder<I["$DBShape"], T, C>;
+    where<M extends typeof Model$1, 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>;
+    on<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, fn: WhereFn<T>): QueryBuilder<I["$DBShape"], T, C>;
+    on<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C]): QueryBuilder<I["$DBShape"], T, C>;
+    on<M extends typeof Model$1, 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>;
+    whereIn<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C][]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    in<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C][]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    whereNotIn<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C][]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    notIn<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, value: T[C][]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    whereBetween<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    between<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    whereNotBetween<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    notBetween<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, one: T[C], two: T[C]): QueryBuilder<I["$DBShape"], T, keyof T>;
+    whereNull<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    onNull<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    whereNotNull<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    onNotNull<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    order<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, direction?: OrderDirection): QueryBuilder<I["$DBShape"], T, keyof T>;
+    orderBy<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C, direction?: OrderDirection): QueryBuilder<I["$DBShape"], T, keyof T>;
+    asc<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    desc<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"], C extends keyof T>(this: M, column: C): QueryBuilder<I["$DBShape"], T, keyof T>;
+    limit<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"]>(this: M, val: number | string): QueryBuilder<I["$DBShape"], T, keyof T>;
+    offset<M extends typeof Model$1, I extends InstanceType<M>, T extends I["$TShape"]>(this: M, val: number | string): QueryBuilder<I["$DBShape"], T, keyof T>;
+};
+
+declare abstract class Model<TB extends keyof DB, DB> extends Model$1<TB, DB> {
+    static $db: string | D1Database;
+    static pipe<S, T>(): Pipe<S, T>;
+    static DB(): D1Database;
+    static run<S, T>(db: D1Database): RunFn<S, T>;
+}
+
+export { Model, ModelBuilder };

package/dist/d1.js

@@ -0,0 +1 @@
+import{QueryBuilder as t}from"./chunk-NVO75XBO.js";import e from"pluralize";var r=class{static{this.$table=""}static pipe(){throw new Error("Database connection not provided.")}static builder(){const r=this.$table||e(this.name.toLowerCase());return new t(r,this.$schema,this.pipe())}static select(...t){return this.builder().select(...t)}static distinct(){return this.builder().distinct()}static where(...t){return this.builder().where(...t)}static on(...t){return this.builder().where(...t)}static whereIn(t,e){return this.builder().whereIn(t,e)}static in(t,e){return this.builder().whereIn(t,e)}static whereNotIn(t,e){return this.builder().whereNotIn(t,e)}static notIn(t,e){return this.builder().whereNotIn(t,e)}static whereBetween(t,e,r){return this.builder().whereBetween(t,e,r)}static between(t,e,r){return this.builder().whereBetween(t,e,r)}static whereNotBetween(t,e,r){return this.builder().whereNotBetween(t,e,r)}static notBetween(t,e,r){return this.builder().whereNotBetween(t,e,r)}static whereNull(t){return this.builder().whereNull(t)}static onNull(t){return this.builder().whereNull(t)}static whereNotNull(t){return this.builder().whereNotNull(t)}static onNotNull(t){return this.builder().whereNotNull(t)}static order(t,e="ASC"){return this.builder().order(t,e)}static orderBy(t,e="ASC"){return this.builder().order(t,e)}static asc(t){return this.builder().asc(t)}static desc(t){return this.builder().desc(t)}static limit(t){return this.builder().limit(t)}static offset(t){return this.builder().offset(t)}};function i(t,e){return class extends s{static{this.$table=String(e)}static{this.$schema=t}}}var s=class extends r{static{this.$db="DB"}static pipe(){const t=this.DB();return{run:this.run(t)}}static DB(){if("string"==typeof this.$db){if(!(this.$db in process.env))throw new Error(`Database '${this.$db}' instance not provided.`);return process.env[this.$db]}return this.$db}static run(t){return async e=>{let r=t.prepare(e.query);e.args?.length&&(r=r.bind(...e.args));const i=await r.run(),s=i.meta;return{changes:s?.changes,duration:s?.duration,lastId:s?.last_row_id,rowsRead:s?.rows_read,rowsWritten:s?.rows_written,success:i.success,results:i.results}}}};export{s as Model,i as ModelBuilder};

package/dist/index-CwrzXlna.d.ts

@@ -0,0 +1,163 @@
+import z from 'zod';
+
+declare class QueryBuilder<S, T, C extends keyof T = keyof T> implements IJoinBuilder<S>, IClauseBuilder<T> {
+    #private;
+    constructor(table: string, schema?: DBSchema, pipe?: Pipe<S, T, C>);
+    run(): Promise<Result<T, C>>;
+    first<K extends keyof T>(...columns: K[] | K[][]): Promise<null | Item<T, C>>;
+    all<K extends keyof T>(...columns: K[] | K[][]): Promise<Item<T, C>[]>;
+    select<K extends keyof T>(...columns: K[] | K[][]): QueryBuilder<S, T, K>;
+    distinct(): this;
+    join<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    innerJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    leftJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    rightJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    crossJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    where(...args: WhereArgs<T>): this;
+    on(...args: WhereArgs<T>): this;
+    orWhere(...args: WhereArgs<T>): this;
+    orOn(...args: WhereArgs<T>): this;
+    whereIn(column: C, values: T[C][]): this;
+    in(column: C, values: T[C][]): this;
+    whereNotIn(column: C, values: T[C][]): this;
+    notIn(column: C, values: T[C][]): this;
+    orWhereIn(column: C, values: T[C][]): this;
+    orIn(column: C, values: T[C][]): this;
+    orWhereNotIn(column: C, values: T[C][]): this;
+    orNotIn(column: C, values: T[C][]): this;
+    whereBetween(column: C, one: T[C], two: T[C]): this;
+    between(column: C, one: T[C], two: T[C]): this;
+    orWhereBetween(column: C, one: T[C], two: T[C]): this;
+    orBetween(column: C, one: T[C], two: T[C]): this;
+    whereNotBetween(column: C, one: T[C], two: T[C]): this;
+    notBetween(column: C, one: T[C], two: T[C]): this;
+    orWhereNotBetween(column: C, one: T[C], two: T[C]): this;
+    orNotBetween(column: C, one: T[C], two: T[C]): this;
+    whereNull(column: C): this;
+    onNull(column: C): this;
+    orWhereNull(column: C): this;
+    orOnNull(column: C): this;
+    whereNotNull(column: C): this;
+    onNotNull(column: C): this;
+    orWhereNotNull(column: C): this;
+    orNotNull(column: C): this;
+    groupBy(...columns: string[]): this;
+    order(column: C, direction?: OrderDirection): this;
+    orderBy(column: C, direction?: OrderDirection): this;
+    asc(column: C): this;
+    desc(column: C): this;
+    limit(val: number | string): this;
+    offset(val: number | string): this;
+    get args(): Values;
+    get arguments(): Values;
+    get bindings(): Values;
+    get query(): string;
+    get sql(): string;
+    get raw(): string;
+}
+
+type Primitive = null | number | string | boolean;
+type Value = Primitive | undefined;
+type Values = Value[];
+type Operator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'LIKE';
+type OrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc';
+type DBSchema = z.ZodObject<any>;
+type SchemaObject = Record<string, z.ZodTypeAny>;
+type SchemaKeys<TSchema extends DBSchema> = TSchema extends z.ZodObject<infer TShape> ? keyof TShape : TSchema extends SchemaObject ? keyof TSchema : never;
+type RunFn<S, T, C extends keyof T = keyof T> = (qb: QueryBuilder<S, T, C>) => Promise<Result<T, C>>;
+type Pipe<S, T, C extends keyof T = keyof T> = {
+    run: RunFn<S, T, C>;
+};
+type Result<T, C extends keyof T> = {
+    changes: number;
+    duration: number;
+    lastId?: number | string;
+    rowsRead: number;
+    rowsWritten: number;
+    success: boolean;
+    results: Item<T, C>[];
+};
+type Item<B, S extends keyof B, T = Pick<B, S>> = {
+    [K in keyof T]: T[K];
+} & {};
+type WhereFn<T, C extends keyof T = keyof T> = (q: IClauseBuilder<T, C>) => void;
+type WhereArgs<T, C extends keyof T = keyof T> = [WhereFn<T, C>] | [C, T[C]] | [C, Operator, T[C]];
+interface IClauseBuilder<T, C extends keyof T = keyof T> {
+    where(fn: WhereFn<T, C>): this;
+    where(column: C, value: T[C]): this;
+    where(column: C, operator: Operator, value: T[C]): this;
+    where(...args: WhereArgs<T>): this;
+    on(fn: WhereFn<T, C>): this;
+    on(column: C, value: T[C]): this;
+    on(column: C, operator: Operator, value: T[C]): this;
+    on(...args: WhereArgs<T>): this;
+    orWhere(fn: WhereFn<T, C>): this;
+    orWhere(column: C, value: T[C]): this;
+    orWhere(column: C, operator: Operator, value: T[C]): this;
+    orWhere(...args: WhereArgs<T>): this;
+    orOn(fn: WhereFn<T, C>): this;
+    orOn(column: C, value: T[C]): this;
+    orOn(column: C, operator: Operator, value: T[C]): this;
+    orOn(...args: WhereArgs<T>): this;
+    whereIn(column: C, values: T[C][]): this;
+    in(column: C, values: T[C][]): this;
+    whereNotIn(column: C, values: T[C][]): this;
+    notIn(column: C, values: T[C][]): this;
+    orWhereIn(column: C, values: T[C][]): this;
+    orIn(column: C, values: T[C][]): this;
+    orWhereNotIn(column: C, values: T[C][]): this;
+    orNotIn(column: C, values: T[C][]): this;
+    whereBetween(column: C, one: T[C], two: T[C]): this;
+    between(column: C, one: T[C], two: T[C]): this;
+    orWhereBetween(column: C, one: T[C], two: T[C]): this;
+    orBetween(column: C, one: T[C], two: T[C]): this;
+    whereNotBetween(column: C, one: T[C], two: T[C]): this;
+    notBetween(column: C, one: T[C], two: T[C]): this;
+    orWhereNotBetween(column: C, one: T[C], two: T[C]): this;
+    orNotBetween(column: C, one: T[C], two: T[C]): this;
+    whereNull(column: C): this;
+    onNull(column: C): this;
+    orWhereNull(column: C): this;
+    orOnNull(column: C): this;
+    whereNotNull(column: C): this;
+    onNotNull(column: C): this;
+    orWhereNotNull(column: C): this;
+    orNotNull(column: C): this;
+}
+type JoinArgs<S, J extends keyof S> = [
+    WhereFn<S[J]>
+] | [keyof S[J], S[J][keyof S[J]]] | [keyof S[J], Operator, S[J][keyof S[J]]] | [keyof S[J], keyof S, keyof S[keyof S]] | [keyof S[J], Operator, S[J][keyof S[J]]] | [keyof S[J], Operator, keyof S, keyof S[keyof S]];
+interface IJoinBuilder<S> {
+    join<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this;
+    join<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, value: T[C]): this;
+    join<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, operator: Operator, value: T[C]): this;
+    join<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, table2: J2, column2: C2): this;
+    join<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, operator: Operator, table2: J2, column2: C2): this;
+    join<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    innerJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this;
+    innerJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, value: T[C]): this;
+    innerJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, operator: Operator, value: T[C]): this;
+    innerJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, table2: J2, column2: C2): this;
+    innerJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, operator: Operator, table2: J2, column2: C2): this;
+    innerJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    leftJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this;
+    leftJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, value: T[C]): this;
+    leftJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, operator: Operator, value: T[C]): this;
+    leftJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, table2: J2, column2: C2): this;
+    leftJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, operator: Operator, table2: J2, column2: C2): this;
+    leftJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    rightJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this;
+    rightJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, value: T[C]): this;
+    rightJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, operator: Operator, value: T[C]): this;
+    rightJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, table2: J2, column2: C2): this;
+    rightJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, operator: Operator, table2: J2, column2: C2): this;
+    rightJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+    crossJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this;
+    crossJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, value: T[C]): this;
+    crossJoin<J extends keyof S, T extends S[J], C extends keyof T>(table: J, column: C, operator: Operator, value: T[C]): this;
+    crossJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, table2: J2, column2: C2): this;
+    crossJoin<J extends keyof S, T extends S[J], C extends keyof T, J2 extends keyof S, C2 extends keyof S[J2]>(table: J, column: C, operator: Operator, table2: J2, column2: C2): this;
+    crossJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this;
+}
+
+export { type DBSchema as D, type Operator as O, type Pipe as P, QueryBuilder as Q, type RunFn as R, type SchemaKeys as S, type WhereFn as W, type OrderDirection as a };

package/dist/index.ts.d.ts

@@ -0,0 +1,2 @@
+export { Q as QueryBuilder } from './index-CwrzXlna.js';
+import 'zod';

package/dist/index.ts.js

@@ -0,0 +1 @@
+export{QueryBuilder}from"./chunk-NVO75XBO.js";

package/package.json

@@ -1,4 +1,72 @@
 {
-"name": "forj",
-"version": "0.0.0"
+  "name": "forj",
+  "description": "SQLite ORM and Query Builder whitout dependencies",
+  "version": "0.0.1",
+  "type": "module",
+  "files": ["dist"],
+  "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"
+  ]
 }