forj 0.1.7 → 0.1.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],
@@ -13,38 +13,31 @@
     "./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",
+    "pathe": "^2.0",
     "pluralize": "^8.0",
-    "t0n": "^0.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.3.8",
     "terser": "^5.46.0",
     "tiny-glob": "^0.2",
-    "tsup": "^8.5.1",
+    "tsup": "^8.5.0",
     "tsx": "^4.19.4",
     "typescript": "^5.9.3"
   },
+  "packageManager": "bun@1.3.10",
   "engines": {
     "node": ">=18.0.0"
   },
@@ -89,4 +82,4 @@
     "bun",
     "nodejs"
   ]
-}
+}

package/src/d1/model.ts

@@ -4,7 +4,7 @@ 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'

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,17 @@ export function arraySchema(v: any): any {
   return v
 }
 
-function getArrayItem(schema: z.ZodArray<any>): ZodTypeAny {
+function getArrayItem(schema: z.ZodArray<any>): z.ZodTypeAny {
   const def: any = schema._def
-  return (def.element ?? def.type ?? def.innerType) as ZodTypeAny
+  return (def.element ?? def.type ?? def.innerType) as z.ZodTypeAny
 }
 
-export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
+export function extractZodKeys(schema: z.ZodTypeAny): SchemaStructure {
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape
 
     return Object.entries(shape).map(([key, value]) => {
-      const inner = unwrap(value as ZodTypeAny)
+      const inner = unwrap(value as z.ZodTypeAny)
 
       if (inner instanceof z.ZodObject)
         return notEmpty(key, extractZodKeys(inner))
@@ -50,7 +50,7 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   return []
 }
 
-export function unwrap(schema: ZodTypeAny): ZodTypeAny {
+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
@@ -63,7 +63,7 @@ export function unwrap(schema: ZodTypeAny): ZodTypeAny {
     }
 
     if (schema instanceof z.ZodUnion) {
-      const options = (schema._def as any).options as ZodTypeAny[]
+      const options = (schema._def as any).options as z.ZodTypeAny[]
       const nonEmpty = options.find(
         opt => !(opt instanceof z.ZodUndefined) && !(opt instanceof z.ZodNull)
       )
@@ -95,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,

package/src/migrations/builder.ts

@@ -3,7 +3,11 @@ import { sqlName, tableSlug } from '../utils'
 import type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from './types'
 
 export default class SchemaBuilder {
-  static create(blueprint: Blueprint, exist: boolean = false): string {
+  static create(
+    blueprint: Blueprint,
+    exist: boolean = false,
+    rowId: boolean = true
+  ): string {
     const table = sqlName(blueprint.table)
     const columns = blueprint.columns
     const indexes = blueprint.indexes
@@ -19,7 +23,9 @@ export default class SchemaBuilder {
       ...foreignKeyDefinitions
     ].filter(Boolean)
 
-    return `CREATE TABLE ${exist ? 'IF NOT EXISTS ' : ''}${table} (\n  ${allDefinitions.join(',\n  ')}\n);`
+    return `CREATE TABLE ${exist ? 'IF NOT EXISTS ' : ''}${table} (\n  ${allDefinitions.join(',\n  ')}\n)${
+      rowId ? '' : ' WITHOUT ROWID'
+    };`
   }
 
   static alter(blueprint: Blueprint): string[] {

package/src/migrations/migrator.ts

@@ -1,11 +1,12 @@
 import glob from 'tiny-glob'
 import { mkdirSync, existsSync, writeFileSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { Datte, IMPORT } from 't0n'
+import { dirname, join } from 'pathe'
+import { Datte, Envir, IMPORT } from 't0n'
 import { Schema } from './schema'
 import { MigrationInfo, MigrationClass, Queue } from './types'
 
-const __root = resolve(dirname(new URL(import.meta.url).pathname), '../../../..')
+export const _forj = join(dirname(new URL(import.meta.url).pathname), '..')
+export const _root = Envir.get('npm_config_local_prefix') || Envir.get('PWD') || join(_forj, '../../../')
 
 export class Migrator {
   static #input: string
@@ -24,17 +25,17 @@ export class Migrator {
   }
 
   static dir(dir?: string) {
-    this.#input = join(__root, 'migrations', dir || '')
+    this.#input = join(_root, 'migrations', dir || '')
     this.#output = join(this.#input, 'sql')
     return this
   }
 
   static inputDir(dir: string) {
-    this.#input = join(__root, dir)
+    this.#input = join(_root, dir)
     return this
   }
   static outputDir(dir: string) {
-    this.#output = join(__root, dir)
+    this.#output = join(_root, dir)
     return this
   }
 
@@ -88,7 +89,7 @@ export class Migrator {
     if (!match) return null
     const [, year, month, day, hour, minute, second, slugName] = match
 
-    const input = join(__root, fileName)
+    const input = join(_root, fileName)
     const output = join(this.#output, name +'.sql')
     const mod = await IMPORT(input)
     const handler = mod.default as MigrationClass

package/src/migrations/schema.ts

@@ -47,8 +47,8 @@ export class Schema {
     return blueprint
   }
 
-  static create(table: string, fn: BlueprintFn, exist: boolean = false) {
-    this.#addStatement(Builder.create(this.#blueprint(table, fn), exist))
+  static create(table: string, fn: BlueprintFn, exist: boolean = false, rowId: boolean = true) {
+    this.#addStatement(Builder.create(this.#blueprint(table, fn), exist, rowId))
   }
 
   static createIfNotExists(table: string, fn: BlueprintFn) {
@@ -66,7 +66,15 @@ export class Schema {
     this.#addStatement(Builder.create(this.#blueprint(table, fn as BlueprintFn, (table: Blueprint) => {
       columns.forEach(column => table.foreignId(column))
       table.primary(table.columns.map(c => c.name))
-    })).slice(0, -1) + ' WITHOUT ROWID;')
+    }), false, false))
+  }
+
+  static createWithoutRowId(table: string, fn: BlueprintFn, exist: boolean = false) {
+    this.create(table, fn, false, false)
+  }
+
+  static createIfNotExistsWithoutRowId(table: string, fn: BlueprintFn) {
+    this.create(table, fn, true, false)
   }
 
   static table(table: string, fn: BlueprintFn) {

package/src/types.ts

@@ -1,5 +1,6 @@
-import z from 'zod'
-import QueryBuilder from './query-builder'
+import type * as z from 'zod'
+import type zm from 'zod/mini'
+import type QueryBuilder from './query-builder'
 import { types } from './utils'
 
 export type text = string
@@ -28,17 +29,45 @@ export type OrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc'
 
 export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'CROSS'
 
-export type DBSchema = z.ZodObject<z.ZodRawShape>
+// type ZodRawShapeCompat = Record<string, z.ZodTypeAny>
 
-export type SchemaObject = z.ZodRawShape
+// export type DBSchema = z.ZodObject<ZodRawShapeCompat>
+
+// export type SchemaObject = ZodRawShapeCompat
+
+// export type SchemaKeys<TSchema extends DBSchema | SchemaObject> =
+//   TSchema extends z.ZodObject<infer TShape extends ZodRawShapeCompat>
+//     ? keyof TShape
+//     : TSchema extends ZodRawShapeCompat
+//       ? keyof TSchema
+//       : never
+
+
+export type DBSchema = z.ZodTypeAny | zm.ZodMiniObject
+
+export type SchemaObject = Record<string, z.ZodTypeAny>
 
 export type SchemaKeys<TSchema extends DBSchema | SchemaObject> =
-  TSchema extends z.ZodObject<infer TShape extends z.ZodRawShape>
+  TSchema extends { shape: infer TShape }
     ? keyof TShape
-    : TSchema extends z.ZodRawShape
+    : TSchema extends SchemaObject
       ? keyof TSchema
       : never
 
+
+//////////////////////////
+// funcionando no zod/v4
+// export type DBSchema = z.ZodObject<z.ZodRawShape>
+
+// export type SchemaObject = z.ZodRawShape
+
+// export type SchemaKeys<TSchema extends DBSchema | SchemaObject> =
+//   TSchema extends z.ZodObject<infer TShape extends z.ZodRawShape>
+//     ? keyof TShape
+//     : TSchema extends z.ZodRawShape
+//       ? keyof TSchema
+//       : never
+
 // TODO: transform QueryBuilder<S, T, C> into a interface
 export type RunFn<S, T, C extends keyof T = keyof T> = (qb: QueryBuilder<S, T, C>) => Promise<Result<T, C>>
 // export type RunBatchFn<S, T, C extends keyof T = keyof T> = (qb: QueryBuilder<S, T, C>[]) => Promise<Result<T, C>>[]

package/src/utils.ts

@@ -1,5 +1,5 @@
 import pluralize from 'pluralize'
-import type { ZodTypeAny } from 'zod'
+import type * as z from 'zod'
 import type { DBSchema } from './types'
 
 export const types = {
@@ -70,9 +70,9 @@ const zodTypeMap: Record<string, string> = {
   ZodFunction: 'function',
 }
 
-export const isZod = (obj: any): obj is ZodTypeAny => obj && typeof obj == 'object' && '_def' in obj
+export const isZod = (obj: any): obj is z.ZodTypeAny => obj && typeof obj == 'object' && '_def' in obj
 
-const getDef = (schema: any) => schema?._def ?? {}
+const getDef = (schema: any) => schema?._def ?? schema?.def ?? {}
 
 const getTypeName = (def: any): string => {
   if (!def) return ''
@@ -95,8 +95,8 @@ const unwrap = (schema: any): any => {
   let allowNull = false
   let allowUndefined = false
 
-  while (current?._def) {
-    const def = current._def
+  while (current?._def || current?.def) {
+    const def = current._def || current?.def
     const type = getTypeName(def)
 
     if (type == 'ZodNullable')
@@ -146,7 +146,7 @@ export const zHas = (key: string, schema?: any): boolean => {
   return true
 }
 
-export const zGet = (key: string, schema?: any): [string, ZodTypeAny] | false => {
+export const zGet = (key: string, schema?: any): [string, z.ZodTypeAny] | false => {
   const keys = key.split('.')
 
   for (const k of keys) {
@@ -194,9 +194,9 @@ export const zSame = (key: string, val: any, schema?: any, deep: boolean = false
   if (val === undefined) return _schema.allowUndefined
   if (val === null) return _schema.allowNull
 
-  if (!_schema.schema?._def) return false
+  const def = getDef(_schema.schema)
+  if (!def) return false
 
-  const def = _schema.schema._def
   const type = getTypeName(def)
 
   if (!type) return false