forj 0.1.6 → 0.1.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],
@@ -13,38 +13,30 @@
     "./dynamodb/types": "./src/dynamodb/types.ts",
     "./migrate": "./src/migrations/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": {
-    "@aws-sdk/client-dynamodb": "3.817.0",
-    "@aws-sdk/lib-dynamodb": "3.817.0",
+    "@aws-sdk/client-dynamodb": "^3.1003.0",
+    "@aws-sdk/lib-dynamodb": "^3.1003.0",
     "pluralize": "^8.0",
-    "t0n": "^0.1",
-    "zod": "^3.19.1"
+    "t0n": "^0.1.12",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@types/node": "^25.1.0",
     "@types/pluralize": "^0.0.33",
     "@cloudflare/workers-types": "^4.20260113.0",
-    "bun-types": "^1.2.13",
+    "bun-types": "^1.3.8",
     "terser": "^5.46.0",
     "tiny-glob": "^0.2",
-    "tsup": "^8.5.1",
+    "tsup": "^8.5.0",
     "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
+  "packageManager": "bun@1.3.10",
   "engines": {
     "node": ">=18.0.0"
   },

package/src/clause-builder.ts

@@ -39,7 +39,7 @@ export default class ClauseBuilder<
     this.#schema = schema
   }
 
-  #nested(fn: WhereFn<T, C>, operator: ClauseOperator = 'AND') {
+  #nested(fn: WhereFn<T>, operator: ClauseOperator = 'AND') {
     const nested = new ClauseBuilder<T, C>(this.#table, this.#schema)
     fn(nested)
 
@@ -80,7 +80,7 @@ export default class ClauseBuilder<
     column = parseColumn(String(column), this.#table)
 
     if (this.#schema && !zSame(column.replace(/"/g, ''), value, this.#schema))
-      throw new Error(`Table column '${String(column)}' of type '${zType(column, this.#schema)}' is not assignable as type of '${typeof value}'.`)
+      throw new Error(`Table column '${String(column.replace(/"/g, ''))}' of type '${zType(column.replace(/"/g, ''), 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
@@ -111,31 +111,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) + ` ${operator} (${values.map(() => '?').join(', ')})`, values, logical)
   }
 
-  whereIn(column: C, values: T[C][]) { // @ts-ignore
+  whereIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'IN')
   }
-  in(column: C, values: T[C][]) {
+  in<K extends keyof T>(column: K, values: T[K][]) {
     return this.whereIn(column, values)
   }
 
-  whereNotIn(column: C, values: T[C][]) { // @ts-ignore
+  whereNotIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'NOT IN')
   }
-  notIn(column: C, values: T[C][]) {
+  notIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.whereNotIn(column, values)
   }
 
-  orWhereIn(column: C, values: T[C][]) { // @ts-ignore
+  orWhereIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'IN', 'OR')
   }
-  orIn(column: C, values: T[C][]) {
+  orIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.orWhereIn(column, values)
   }
 
-  orWhereNotIn(column: C, values: T[C][]) { // @ts-ignore
+  orWhereNotIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'NOT IN', 'OR')
   }
-  orNotIn(column: C, values: T[C][]) {
+  orNotIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.orWhereNotIn(column, values)
   }
 
@@ -149,31 +149,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) + ` ${operator} ? AND ?`, [one, two], logical)
   }
 
-  whereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  whereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'BETWEEN')
   }
-  between(column: C, one: T[C], two: T[C]) {
+  between<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.whereBetween(column, one, two)
   }
 
-  orWhereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  orWhereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'BETWEEN', 'OR')
   }
-  orBetween(column: C, one: T[C], two: T[C]) {
+  orBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.orWhereBetween(column, one, two)
   }
 
-  whereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  whereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'NOT BETWEEN')
   }
-  notBetween(column: C, one: T[C], two: T[C]) {
+  notBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.whereNotBetween(column, one, two)
   }
 
-  orWhereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  orWhereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'NOT BETWEEN', 'OR')
   }
-  orNotBetween(column: C, one: T[C], two: T[C]) {
+  orNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.orWhereNotBetween(column, one, two)
   }
 
@@ -185,31 +185,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) +` ${operator} NULL`, [], logical)
   }
 
-  whereNull(column: C) {
+  whereNull<K extends keyof T>(column: K) {
     return this.#null(column as string)
   }
-  onNull(column: C) {
+  onNull<K extends keyof T>(column: K) {
     return this.whereNull(column)
   }
 
-  orWhereNull(column: C) {
+  orWhereNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS', 'OR')
   }
-  orOnNull(column: C) {
+  orOnNull<K extends keyof T>(column: K) {
     return this.orWhereNull(column)
   }
 
-  whereNotNull(column: C) {
+  whereNotNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS NOT')
   }
-  onNotNull(column: C) {
+  onNotNull<K extends keyof T>(column: K) {
     return this.whereNotNull(column)
   }
 
-  orWhereNotNull(column: C) {
+  orWhereNotNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS NOT', 'OR')
   }
-  orNotNull(column: C) {
+  orNotNull<K extends keyof T>(column: K) {
     return this.orWhereNotNull(column)
   }
 }

package/src/d1/model.ts

@@ -4,22 +4,22 @@ import type {
   // D1Result, D1ExecResult, D1Meta,
 } from './types'
 
-import z from 'zod'
+import type * as z from 'zod'
 import { Envir } from 't0n'
 
 import QueryBuilder from '../query-builder'
 import BModel from '../model'
 import type {
-  DBSchema, SchemaKeys,
+  DBSchema,
   Item,
   Pipe, Result, RunFn,
 } from '../types'
 
 export function Model<
   TSchema extends DBSchema,
-  TBase extends SchemaKeys<TSchema>
+  TBase extends keyof z.infer<TSchema>
 >(schema: TSchema, base: TBase) {
-  type S = z.infer<typeof schema>
+  type S = z.infer<TSchema>
   return class extends BaseModel<TBase, S> {
     static $table = String(base)
     static $schema = schema
@@ -55,8 +55,9 @@ export abstract class BaseModel<TB extends keyof DB, DB> extends BModel<TB, DB>
     ): Promise<Result<T, C>> => {
       let stmt = db.prepare(qb.query)
 
-      if (qb.args?.length)
-        stmt = stmt.bind(...qb.args)
+      const args = qb.args
+      if (args?.length)
+        stmt = stmt.bind(...args)
 
       const resp = await stmt.run<Item<T, C>>()
 

package/src/dynamodb/repository.ts

@@ -1,11 +1,11 @@
-import { z, ZodTypeAny } from 'zod'
+import type * as z from 'zod'
 import { Dynamodb } from './client'
 import { Schema } from './schema'
 import { _model } from './decorators'
 import type { ModelOpts } from './types'
 
 export function Repository<
-  S extends ZodTypeAny,
+  S extends z.ZodTypeAny,
   B extends new (...args: any[]) => any
 >(
   schema: S,

package/src/dynamodb/schema.ts

@@ -1,4 +1,4 @@
-import { z, ZodTypeAny } from 'zod'
+import * as z from 'zod'
 import type { SchemaStructure } from './types'
 
 const m = Symbol('a')
@@ -12,17 +12,26 @@ export function arraySchema(v: any): any {
   return v
 }
 
-export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
+function getArrayItem(schema: z.ZodArray<any>): z.ZodTypeAny {
+  const def: any = schema._def
+  return (def.element ?? def.type ?? def.innerType) as z.ZodTypeAny
+}
+
+export function extractZodKeys(schema: z.ZodTypeAny): SchemaStructure {
   if (schema instanceof z.ZodObject) {
-    return Object.entries(schema.shape).map(([key, value]) => {
-      const inner = unwrap(value as ZodTypeAny)
+    const shape = schema.shape
+
+    return Object.entries(shape).map(([key, value]) => {
+      const inner = unwrap(value as z.ZodTypeAny)
 
       if (inner instanceof z.ZodObject)
         return notEmpty(key, extractZodKeys(inner))
 
       if (inner instanceof z.ZodArray) {
-        const item = unwrap(inner._def.type as ZodTypeAny)
-        return item instanceof z.ZodObject ? notEmpty(key, extractZodKeys(item)) : key
+        const item = unwrap(getArrayItem(inner))
+        return item instanceof z.ZodObject
+          ? notEmpty(key, extractZodKeys(item))
+          : key
       }
 
       return key
@@ -30,7 +39,8 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   }
 
   if (schema instanceof z.ZodArray) {
-    const item = unwrap(schema._def.type as ZodTypeAny)
+    const item = unwrap(getArrayItem(schema))
+
     if (item instanceof z.ZodObject)
       return arraySchema(extractZodKeys(item))
 
@@ -40,24 +50,42 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   return []
 }
 
-export function unwrap(schema: ZodTypeAny): ZodTypeAny {
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable)
-    return unwrap(schema._def.innerType)
+export function unwrap(schema: z.ZodTypeAny): z.ZodTypeAny {
+  while (true) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
+      schema = (schema._def as any).innerType
+      continue
+    }
 
-  if (schema instanceof z.ZodDefault)
-    return unwrap(schema._def.innerType)
+    if (schema instanceof z.ZodDefault) {
+      schema = (schema._def as any).innerType
+      continue
+    }
 
-  // if (schema instanceof z.ZodUnion)
-  //   return unwrap(schema._def.options[0] as ZodTypeAny)
+    if (schema instanceof z.ZodUnion) {
+      const options = (schema._def as any).options as z.ZodTypeAny[]
+      const nonEmpty = options.find(
+        opt => !(opt instanceof z.ZodUndefined) && !(opt instanceof z.ZodNull)
+      )
+      schema = nonEmpty ?? options[0]
+      continue
+    }
 
-  if (schema instanceof z.ZodUnion) {
-    const options = schema._def.options as ZodTypeAny[]
-    const nonEmptyOption = options.find(opt => !(opt instanceof z.ZodUndefined) && !(opt instanceof z.ZodNull))
-    return nonEmptyOption ? unwrap(nonEmptyOption) : options[0]
-  }
+    const def: any = schema._def
+
+    // unwrap transforms / pipes do v4
+    if (def?.schema) {
+      schema = def.schema
+      continue
+    }
 
-  if (schema instanceof z.ZodEffects)
-    return unwrap(schema._def.schema)
+    if (def?.innerType) {
+      schema = def.innerType
+      continue
+    }
+
+    break
+  }
 
   return schema
 }
@@ -67,7 +95,7 @@ function notEmpty(key: string, schema: SchemaStructure): string | Record<string,
 }
 
 export function Schema<
-  T extends ZodTypeAny,
+  T extends z.ZodTypeAny,
   B extends object
 >(
   schema: T,