forj 0.1.6 → 0.1.8

package/src/types.ts

@@ -1,5 +1,7 @@
-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
 export type real = number
@@ -15,21 +17,57 @@ export type Values = Value[]
 // export type WriteType = Primitive | ArrayBuffer | ArrayBufferView | undefined
 // export type ReadType = Primitive | any[]
 
+export type QueryType = typeof types[keyof typeof types]
+export type TableOpts = {
+  timestamps?: boolean,
+  createdAt?: boolean,
+  updatedAt?: boolean,
+}
+
 export type Operator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'LIKE' // | 'IN' | 'NOT IN' | 'BETWEEN' | 'IS NULL' | 'IS NOT NULL'
 export type OrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc'
 
 export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'CROSS'
 
-export type DBSchema = z.ZodObject<any>
+// type ZodRawShapeCompat = Record<string, z.ZodTypeAny>
+
+// 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> =
-  TSchema extends z.ZodObject<infer TShape>
+
+export type SchemaKeys<TSchema extends DBSchema | SchemaObject> =
+  TSchema extends { shape: infer TShape }
     ? keyof TShape
     : 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>>[]
@@ -53,65 +91,57 @@ export type Item<B, S extends keyof B, T = Pick<B, S>> = { [K in keyof T]: T[K]
 
 export type ClauseOperator = 'AND' | 'OR'
 
-export type WhereFn<T, C extends keyof T = keyof T> = (q: IClauseBuilder<T, C>) => void
-export type WhereArgs<T, C extends keyof T = keyof T> = [WhereFn<T, C>] | [C, T[C]] | [C, Operator, T[C]]
+export type WhereFn<T> = (q: IClauseBuilder<T>) => void
+export type WhereArgs<T, C extends keyof T = keyof T> = [WhereFn<T>] | [C, T[C]] | [C, Operator, T[C]]
 
-export 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
+export interface IClauseBuilder<T> {
+  where<K extends keyof T>(column: K, value: T[K]): this
+  where<K extends keyof T>(column: K, operator: Operator, value: T[K]): 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
+  on<K extends keyof T>(column: K, value: T[K]): this
+  on<K extends keyof T>(column: K, operator: Operator, value: T[K]): 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
+  orWhere<K extends keyof T>(column: K, value: T[K]): this
+  orWhere<K extends keyof T>(column: K, operator: Operator, value: T[K]): 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
+  orOn<K extends keyof T>(column: K, value: T[K]): this
+  orOn<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
 
-  whereIn(column: C, values: T[C][]): this
-  in(column: C, values: T[C][]): this
+  whereIn<K extends keyof T>(column: K, values: T[K][]): this
+  in<K extends keyof T>(column: K, values: T[K][]): this
 
-  whereNotIn(column: C, values: T[C][]): this
-  notIn(column: C, values: T[C][]): this
+  whereNotIn<K extends keyof T>(column: K, values: T[K][]): this
+  notIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  orWhereIn(column: C, values: T[C][]): this
-  orIn(column: C, values: T[C][]): this
+  orWhereIn<K extends keyof T>(column: K, values: T[K][]): this
+  orIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  orWhereNotIn(column: C, values: T[C][]): this
-  orNotIn(column: C, values: T[C][]): this
+  orWhereNotIn<K extends keyof T>(column: K, values: T[K][]): this
+  orNotIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  whereBetween(column: C, one: T[C], two: T[C]): this
-  between(column: C, one: T[C], two: T[C]): this
+  whereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  between<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  orWhereBetween(column: C, one: T[C], two: T[C]): this
-  orBetween(column: C, one: T[C], two: T[C]): this
+  orWhereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  orBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  whereNotBetween(column: C, one: T[C], two: T[C]): this
-  notBetween(column: C, one: T[C], two: T[C]): this
+  whereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  notBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  orWhereNotBetween(column: C, one: T[C], two: T[C]): this
-  orNotBetween(column: C, one: T[C], two: T[C]): this
+  orWhereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  orNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  whereNull(column: C): this
-  onNull(column: C): this
+  whereNull<K extends keyof T>(column: K): this
+  onNull<K extends keyof T>(column: K): this
 
-  orWhereNull(column: C): this
-  orOnNull(column: C): this
+  orWhereNull<K extends keyof T>(column: K): this
+  orOnNull<K extends keyof T>(column: K): this
 
-  whereNotNull(column: C): this
-  onNotNull(column: C): this
+  whereNotNull<K extends keyof T>(column: K): this
+  onNotNull<K extends keyof T>(column: K): this
 
-  orWhereNotNull(column: C): this
-  orNotNull(column: C): this
+  orWhereNotNull<K extends keyof T>(column: K): this
+  orNotNull<K extends keyof T>(column: K): this
 }
 
 export type JoinArgs<S, J extends keyof S> =
@@ -123,7 +153,6 @@ export type JoinArgs<S, J extends keyof S> =
   | [keyof S[J], Operator, keyof S, keyof S[keyof S]]
 
 export interface IJoinBuilder<S> {
-  join<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   join<
     J extends keyof S,
     T extends S[J],
@@ -148,9 +177,7 @@ export interface IJoinBuilder<S> {
     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],
@@ -175,9 +202,7 @@ export interface IJoinBuilder<S> {
     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],
@@ -202,9 +227,7 @@ export interface IJoinBuilder<S> {
     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],
@@ -229,9 +252,7 @@ export interface IJoinBuilder<S> {
     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],
@@ -256,5 +277,4 @@ export interface IJoinBuilder<S> {
     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
 }

package/src/utils.ts

@@ -1,7 +1,14 @@
 import pluralize from 'pluralize'
-import type { ZodTypeAny } from 'zod'
+import type * as z from 'zod'
 import type { DBSchema } from './types'
 
+export const types = {
+  SELECT: 1,
+  INSERT: 2,
+  UPDATE: 3,
+  DELETE: 4,
+} as const
+
 const operators = ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT', 'BETWEEN']
 
 export function isOperator(o: any) {
@@ -21,6 +28,8 @@ export function parseSelectColumn(
     return col
 
   const [table, column] = explicit ? col.split('.') : [baseTable, col]
+  if (column == '*') return col
+
   return `${table}.${column} AS ${pluralize(table, 1)}_${column}`
 }
 
@@ -48,33 +57,109 @@ export function formatValue(value: any): string {
 }
 
 const zodTypeMap: Record<string, string> = {
-  'ZodString': 'string',
-  'ZodNumber': 'number',
-  'ZodBoolean': 'boolean',
-  'ZodObject': 'object',
-  'ZodArray': 'array',
-  'ZodDate': 'object',
-  'ZodNull': 'object',
-  'ZodUndefined': 'undefined',
-  'ZodSymbol': 'symbol',
-  'ZodBigInt': 'bigint',
-  'ZodFunction': 'function',
+  ZodString: 'string',
+  ZodNumber: 'number',
+  ZodBoolean: 'boolean',
+  ZodObject: 'object',
+  ZodArray: 'array',
+  ZodDate: 'object',
+  ZodNull: 'object',
+  ZodUndefined: 'undefined',
+  ZodSymbol: 'symbol',
+  ZodBigInt: 'bigint',
+  ZodFunction: 'function',
+}
+
+export const isZod = (obj: any): obj is z.ZodTypeAny => obj && typeof obj == 'object' && '_def' in obj
+
+const getDef = (schema: any) => schema?._def ?? schema?.def ?? {}
+
+const getTypeName = (def: any): string => {
+  if (!def) return ''
+  if (def.typeName) return def.typeName // zod v3
+  if (def.type) { // zod v4
+    if (typeof def.type == 'string') {
+      if (def.type.startsWith('Zod')) return def.type
+      return 'Zod'+ def.type[0].toUpperCase() + def.type.slice(1)
+      // return zodTypeMap[def.type] || def.type
+    }
+
+    if (def.type?.name) return def.type.name
+  }
+
+  return ''
 }
 
-export const isZod = (obj: any): obj is ZodTypeAny => obj && typeof obj == 'object' && '_def' in obj
+const unwrap = (schema: any): any => {
+  let current = schema
+  let allowNull = false
+  let allowUndefined = false
+
+  while (current?._def || current?.def) {
+    const def = current._def || current?.def
+    const type = getTypeName(def)
+
+    if (type == 'ZodNullable')
+      allowNull = true
 
-export const zHas = (key: string, schema?: any) => schema != null && typeof schema == 'object' && !Array.isArray(schema) && (key in schema || 'shape' in schema && key in (schema.shape as Record<string, ZodTypeAny>))
+    if (type == 'ZodOptional' || type == 'ZodDefault')
+      allowUndefined = true
 
-export const zGet = (key: string, schema?: any): [string, ZodTypeAny] | false => {
+    if (['ZodOptional', 'ZodNullable', 'ZodDefault', 'ZodReadonly'].includes(type)) {
+      current = def.innerType
+      continue
+    }
+
+    if (type == 'ZodEffects' || type == 'ZodPipeline') {
+      current = def.schema || def.innerType || def.out
+      continue
+    }
+
+    break
+  }
+
+  return { schema: current, allowNull, allowUndefined }
+  // return current
+}
+
+export const zHas = (key: string, schema?: any): boolean => {
+  if (!schema || typeof schema != 'object' || Array.isArray(schema))
+    return false
+
+  const keys = key.split('.')
+
+  for (const k of keys) {
+    schema = unwrap(schema).schema
+
+    if (!schema || typeof schema != 'object')
+      return false
+
+    if (schema.shape && k in schema.shape) {
+      schema = schema.shape[k]
+    } else if (k in schema) {
+      schema = schema[k]
+    } else {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const zGet = (key: string, schema?: any): [string, z.ZodTypeAny] | false => {
   const keys = key.split('.')
-  for (const i in keys) {
+
+  for (const k of keys) {
+    schema = unwrap(schema).schema
+
     if (typeof schema != 'object') return false
 
-    const k = keys[i]
-    if ('shape' in schema && k in schema.shape) {
+    if (schema?.shape && k in schema.shape) {
       schema = schema.shape[k]
       continue
-    } else if (k in schema) {
+    }
+
+    if (k in schema) {
       schema = schema[k]
       continue
     }
@@ -86,44 +171,49 @@ export const zGet = (key: string, schema?: any): [string, ZodTypeAny] | false =>
 }
 
 export const zType = (key: string, schema?: any): string => {
-  const _ = zGet(key, schema)
-  if (!_ || !('_def' in _[1]))
+  const result = zGet(key, schema)
+  if (!result)
+    return 'unknown'
+
+  const type = getTypeName(getDef(unwrap(result[1]).schema))
+  if (!type)
     return 'unknown'
-  key = _[0]
-  schema = _[1]
 
-  return ((schema?._def?.innerType?._def || schema?._def)?.typeName || '').split('Zod').pop().toLowerCase()
+  return type.replace('Zod', '').toLowerCase()
 }
 
 export const zSame = (key: string, val: any, schema?: any, deep: boolean = false): boolean => {
   if (!deep) {
-    const _ = zGet(key, schema)
-    if (!_) return _
-    key = _[0]
-    schema = _[1]
+    const result = zGet(key, schema)
+    if (!result) return false
+    schema = result[1]
   }
 
-  if (!('_def' in schema))
-    return false // typeof val == typeof schema[key] // TODO: improv it
+  const _schema = unwrap(schema)
 
-  let def = schema?._def || {}
-  if (schema?._def?.typeName == 'ZodOptional')
-    def = def?.innerType?._def || {}
+  if (val === undefined) return _schema.allowUndefined
+  if (val === null) return _schema.allowNull
 
-  const zType = def?.typeName || ''
+  const def = getDef(_schema.schema)
+  if (!def) return false
 
-  if (!zType) return false
+  const type = getTypeName(def)
 
-  if (zType == 'ZodUnion' && def?.options?.length)
-    return def?.options?.some((z: any) => zSame(key, val, z, true))
+  if (!type) return false
 
-  else if (zType == 'ZodArray')
+  if (type == 'ZodUnion' && def.options)
+    return def.options.some((z: any) => zSame(key, val, z, true))
+
+  if (type == 'ZodArray')
     return Array.isArray(val)
 
-  else if (zType == 'ZodDate')
+  if (type == 'ZodObject')
+    return typeof val == 'object' && val != null && !Array.isArray(val)
+
+  if (type == 'ZodDate')
     return val instanceof Date
 
-  return typeof val == zodTypeMap[zType]
+  return typeof val == zodTypeMap[type]
 }
 
 export function isJoinCompare(val: any, schema?: DBSchema) {