forj 0.0.2 → 0.0.4

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],
   "exports": {
     ".": "./src/index.ts",
-    "./d1": "./src/d1/index.ts"
+    "./d1": "./src/d1/index.ts",
+    "./d1/types": "./src/d1/types.ts",
+    "./dynamodb": "./src/dynamodb/index.ts",
+    "./dynamodb/types": "./src/dynamodb/types.ts"
   },
   "-exports": {
     ".": {
@@ -25,12 +28,15 @@
     "-prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@cloudflare/workers-types": "^4.20260113.0",
+    "@aws-sdk/client-dynamodb": "3.817.0",
+    "@aws-sdk/lib-dynamodb": "3.817.0",
     "pluralize": "^8.0",
+    "t0n": "^0.1",
     "zod": "^3.19.1"
   },
   "devDependencies": {
     "@types/pluralize": "^0.0.33",
+    "@cloudflare/workers-types": "^4.20260113.0",
     "bun-types": "^1.2.13",
     "terser": "^5.46.0",
     "tiny-glob": "^0.2",

package/src/d1/model.ts

@@ -1,33 +1,32 @@
 import type {
   D1Database,
-  D1PreparedStatement,
-  D1Result, D1ExecResult, D1Meta,
-} from '@cloudflare/workers-types'
+  // D1PreparedStatement,
+  // D1Result, D1ExecResult, D1Meta,
+} from './types'
 
 import z from 'zod'
+import { Envir } from 't0n'
 
-import { QueryBuilder } from '../query-builder'
-import { default as BaseModel } from '../model'
+import QueryBuilder from '../query-builder'
+import BModel from '../model'
 import type {
   DBSchema, SchemaKeys,
   Item,
   Pipe, Result, RunFn,
 } from '../types'
 
-export function ModelBuilder<
+export function Model<
   TSchema extends DBSchema,
   TBase extends SchemaKeys<TSchema>
 >(schema: TSchema, base: TBase) {
   type S = z.infer<typeof schema>
-  return class extends Model<TBase, S> {
+  return class extends BaseModel<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> {
+export abstract class BaseModel<TB extends keyof DB, DB> extends BModel<TB, DB> {
   static $db: string | D1Database = 'DB'
 
   static pipe<S, T>(): Pipe<S, T> {
@@ -40,11 +39,11 @@ export abstract class Model<TB extends keyof DB, DB> extends BaseModel<TB, DB> {
 
   static DB() {
     if (typeof this.$db == 'string') { // TODO: improv compatibility without nodejs_compat
-      if (!(this.$db in process.env))
+      if (!Envir.has(this.$db))
         throw new Error(`Database '${this.$db}' instance not provided.`)
 
       // @ts-ignore
-      return process.env[this.$db] as D1Database
+      return Envir.get(this.$db) as D1Database
     }
 
     return this.$db

package/src/d1/types.ts

@@ -0,0 +1,7 @@
+export type {
+  D1Database,
+  D1PreparedStatement,
+  D1Result, D1ExecResult, D1Meta,
+} from '@cloudflare/workers-types'
+
+export * from '../types'

package/src/dynamodb/client.ts

@@ -0,0 +1,125 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
+import {
+  DynamoDBDocumentClient,
+
+  BatchGetCommand,
+  BatchWriteCommand,
+
+  DeleteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  UpdateCommand,
+
+  ScanCommandInput,
+  QueryCommandInput,
+  UpdateCommandInput,
+
+  BatchGetCommandInput,
+  BatchWriteCommandInput,
+} from '@aws-sdk/lib-dynamodb'
+import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb'
+import AbstractModel from './model'
+import { Keys, KeySchema } from './types'
+
+const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
+  region: process.env.AWS_REGION || 'us-east-1',
+  endpoint: process.env.AWS_ENDPOINT_URL || undefined,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'DUMMYIDEXAMPLE',
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'DUMMYEXAMPLEKEY',
+  },
+} : {})
+
+export const DocumentClient = DynamoDBDocumentClient.from(client)
+
+export class Dynamodb {
+  static model<T extends object>(cls: new (...args: any[]) => T) {
+    return new AbstractModel<T>(cls)
+  }
+
+  static raw() {
+    return RawClient
+  }
+}
+
+export class RawClient {
+  static async get(TableName: string, key: Keys | Record<string, string>, sk?: string) {
+    return DocumentClient.send(new GetCommand({ TableName, Key: this.key(key, sk) }))
+  }
+
+  static async scan(TableName: string, filters: Omit<ScanCommandInput, 'TableName'>) {
+    return DocumentClient.send(new ScanCommand({ ...filters, TableName }))
+  }
+
+  static async query(TableName: string, filters: Omit<QueryCommandInput, 'TableName'>) {
+    return DocumentClient.send(new QueryCommand({ ...filters, TableName }))
+  }
+
+  static async put(TableName: string, Item: Record<string, NativeAttributeValue>) {
+    return DocumentClient.send(new PutCommand({ TableName, Item }))
+  }
+
+  static async update(
+    TableName: string,
+    filters: Omit<UpdateCommandInput, 'TableName' | 'Key'>,
+    key: Keys | Record<string, string>,
+    sk?: string
+  ) {
+    return DocumentClient.send(new UpdateCommand({
+      ...filters, TableName, Key: this.key(key, sk),
+    }))
+  }
+
+  static async delete(TableName: string, key: Keys | Record<string, string>, sk?: string) {
+    return DocumentClient.send(new DeleteCommand({ TableName, Key: this.key(key, sk) }))
+  }
+
+  static async batchGet(batch: BatchGetCommandInput) {
+    return DocumentClient.send(new BatchGetCommand(batch))
+  }
+
+  static async batchWrite(batch: BatchWriteCommandInput) {
+    return DocumentClient.send(new BatchWriteCommand(batch))
+  }
+
+  static key(
+    key: Keys | Record<string, string>,
+    sk?: string,
+    schema?: KeySchema,
+    defaultSK?: string,
+  ) {
+    let pk: string
+    let skValue: string | undefined
+
+    if (Array.isArray(key)) {
+      pk = key[0]
+      skValue = key[1] ?? sk
+    } else if (typeof key == 'object' && key != null) {
+      return key
+    } else {
+      pk = key
+      skValue = sk
+    }
+
+    if (!schema) {
+      const keys = {PK: pk}
+      // @ts-ignore
+      if (skValue) keys.SK = skValue
+      return keys
+    }
+
+    const keys = { [schema.PK]: pk }
+
+    if (schema?.SK) {
+      if (skValue) {
+        keys[schema.SK] = skValue
+      } else if (defaultSK) {
+        keys[schema.SK] = defaultSK
+      }
+    }
+
+    return keys
+  }
+}

package/src/dynamodb/compact.ts

@@ -0,0 +1,205 @@
+import { getLength } from 't0n'
+import { isArraySchema } from './schema'
+import type { SchemaStructure } from './types'
+
+export default class Compact {
+  static #typeRegex: RegExp
+  static #reverseTypeRegex: RegExp
+  static #reverseTypeMap: Record<string, string>
+  static #typeMap: Record<string, string> = {
+    // Boolean
+    'true': 'T',
+    'false': 'F',
+    // Null
+    'null': 'N',
+    // Array
+    '[]': 'A',
+    '["0"]': 'A0',
+    '["1"]': 'A1',
+    '["false"]': 'A2',
+    '["true"]': 'A3',
+    // Object
+    '{}': 'O',
+    // String
+    '""': 'S',
+    '"0"': 'S0',
+    '"1"': 'S1',
+    '"false"': 'S2',
+    '"true"': 'S3',
+  }
+
+  static {
+    const keys = []
+    const values = []
+    const reverseTypeMap: Record<string, string> = {}
+    for (const key in this.#typeMap) {
+      const val = this.#typeMap[key]
+      const k = key.replace(/"/g, "'")
+      keys.push(k)
+      values.push(val)
+
+      reverseTypeMap[val] = k
+      this.#typeMap[k] = val
+    }
+
+    this.#reverseTypeMap = reverseTypeMap
+    this.#typeRegex = this.#mapRegex(keys)
+    this.#reverseTypeRegex = this.#mapRegex(values)
+  }
+
+  static encode(obj: any, schema: SchemaStructure): string {
+    const seen: any[] = []
+
+    return this.#pack(
+      JSON.stringify(this.zip(obj, schema, seen))
+        .replace(/"\^(\d+)"/g, '^$1')
+        .replace(/"/g, '~TDQ~')
+        .replace(/'/g, '"')
+        .replace(/~TDQ~/g, "'")
+        .replace(/\\'/g, "^'")
+    )
+  }
+
+  static smartDecode<T = any>(val: any, schema: SchemaStructure): T {
+    if (!val) return val as T
+
+    if (Array.isArray(val)) // @ts-ignore
+      return val.map((i: {v: string}) => this.decode<T>(i?.V, schema)).filter(Boolean) as T
+
+    return val?.V ? this.decode<T>(val.V, schema) : val
+  }
+
+  static decode<T = any>(val: string, schema: SchemaStructure): T {
+    if (!val || typeof val != 'string') return val as T
+
+    return this.withSchema(this.unzip(JSON.parse(
+      this.#unpack(val)
+        .replace(/"/g, '~TSQ~')
+        .replace(/'/g, '"')
+        .replace(/~TSQ~/g, "'")
+        .replace(/\^"/g, '\\"')
+        .replace(/(?<=[,{\[]|^)(\^\d+)(?=[,\]}[]|$)/g, '"$1"')
+    )), schema) as T
+  }
+
+  static zip(obj: any, schema: SchemaStructure, seen: any[]): any[] {
+    if (Array.isArray(obj))
+      return obj?.length ? obj.map(item => this.zip(item, schema, seen)) : []
+
+    if (this.#cantZip(obj)) return obj
+
+    return schema.map(key => {
+      if (typeof key == 'string')
+        return this.memo(obj[key], seen)
+
+      const mainKey = Object.keys(key)[0]
+      const subKeys = key[mainKey]
+      const val = obj[mainKey]
+
+      if (Array.isArray(val))
+        return val.map(item => this.zip(item, subKeys, seen))
+
+      return this.zip(val, subKeys, seen)
+    })
+  }
+
+  static unzip(val: any, seen: any[] = []): any[] {
+    if (Array.isArray(val))
+      return val?.length ? val.map(item => this.unzip(item, seen)) : []
+
+    const type = typeof val
+    const length = getLength(val, type)
+
+    if (this.#cantZip(val, type, length)) return val
+
+    if (type == 'object') {
+      for (const key in val)
+        val[key] = this.unzip(val[key], seen)
+
+      return val
+    }
+
+    if (type == 'string' && val.startsWith('^')) {
+      const item = seen[parseInt(val.slice(1), 10)]
+      return item ? item : val
+    }
+
+    seen.push(val)
+    return val
+  }
+
+  static withSchema(value: any[], keys: any[], deep = false): any {
+    if (!value || !Array.isArray(value))
+      return value
+
+    if (!deep && isArraySchema(keys))
+      return value?.length ? value.map(v => this.withSchema(v, keys, true)) : []
+
+    return Object.fromEntries(
+      keys.map((key, index) => this.entry(key, value[index])).filter(Boolean)
+    )
+  }
+
+  static entry(key: any, value: any): any {
+    if (!key) return undefined
+
+    if (typeof key == 'string')
+      return [key, value == null ? null : value]
+
+    const mainKey = Object.keys(key)[0]
+    const subKeys = key[mainKey]
+
+    if (Array.isArray(value)) {
+      if (value.length < 1)
+        return [mainKey, []]
+
+      return Array.isArray(value[0])
+        ? [mainKey, value.map(v => this.withSchema(v, subKeys))]
+        : [mainKey, this.withSchema(value, subKeys)]
+    }
+
+    return [mainKey, value == null ? null : value]
+  }
+
+  static memo(val: any, seen: any[]): any {
+    if (Array.isArray(val))
+      return val.map(item => this.memo(item, seen))
+
+    const type = typeof val
+    if (type == 'object' && val != null) {
+      for (const key in val)
+        val[key] = this.memo(val[key], seen)
+
+      return val
+    }
+
+    const length = getLength(val, type)
+    if (this.#cantZip(val, type, length)) return val
+
+    const index = seen.indexOf(val)
+    if (index != -1)
+      return `^${index}`
+
+    seen.push(val)
+    return val
+  }
+
+  static #mapRegex(keys: string[]) {
+    keys = keys.sort((a, b) => b.length - a.length).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    return new RegExp(`(?<![^\\s,\\[\\{:])(${keys.join('|')})(?![^\\s,\\]\\}:])`, 'g')
+  }
+
+  static #pack(val: string): string {
+    return val.replace(this.#typeRegex, match => this.#typeMap[match])
+  }
+
+  static #unpack(val: string): string {
+    return val.replace(this.#reverseTypeRegex, match => this.#reverseTypeMap[match])
+  }
+
+  static #cantZip(val: any, type: string = '', length: number = 0) {
+    if (!val || [null, true, false, 'true', 'false'].includes(val)) return true
+
+    return !type && !length ? false : type != 'object' && length < 2
+  }
+}

package/src/dynamodb/decorators.ts

@@ -0,0 +1,126 @@
+import pluralize from 'pluralize'
+import type { ModelMetadata, ModelOpts } from './types'
+
+export function getModelMetadata(target: Function | any): ModelMetadata {
+  if (!target?.m)
+    throw Error(`Entity "${target?.name}" not registred, Use @Entity or @Model.`)
+
+  const typeKeys = typeof target.m[1]
+  return {
+    table: target.m[0],
+    // @ts-ignore
+    keys: typeKeys != 'undefined' ? (typeKeys == 'string' ? { PK: target.m[1] } : { PK: target.m[1][0], SK: target.m[1][1] }) : undefined,
+    defaultSK: target?.defaultSK || undefined,
+    zip: target.m[2] || false,
+    fields: target.m[3] || [],
+  }
+}
+
+function _table(target: Function | any, opt?: ModelOpts) {
+  if (!target?.m) target.m = []
+  const table = opt ? (typeof opt == 'string' ? opt : opt?.table) : undefined
+
+  target.m[0] = table || pluralize(target.name.toLocaleUpperCase())
+}
+
+function _zip(target: Function | any) {
+  if (!target?.m) target.m = []
+  target.m[2] = true
+  target.m[3] = target?.schema || Object.keys(new target)
+}
+
+function _key(target: Function | any, pk: string, sk?: string) {
+  if (!target?.m) target.m = []
+  target.m[1] = pk && sk ? [pk, sk] : [pk]
+}
+
+export function _model(target: any, opt?: ModelOpts) {
+  _table(target, opt)
+  const notStr = typeof opt != 'string'
+
+  if (!opt || !notStr || (opt?.zip == null || opt?.zip))
+    _zip(target)
+
+  const pk = opt && notStr ? opt?.partitionKey : undefined
+  const sk = opt && notStr ? opt?.sortKey : undefined
+  _key(target, pk || 'PK', sk || 'SK')
+}
+
+function _pk(target: any, prop: string) {
+  if (!target?.m) target.m = []
+  if (['string', 'undefined'].includes(typeof target.m[1])) {
+    target.m[1] = prop
+  } else {
+    target.m[1][0] = prop
+  }
+}
+
+function _sk(target: any, prop: string) {
+  if (!target?.m) target.m = []
+  if (['string', 'undefined'].includes(typeof target.m[1])) {
+    target.m[1] = []
+    target.m[1][1] = prop
+  } else {
+    target.m[1][0] = prop
+  }
+}
+
+export function Entity(target: Function): void
+export function Entity(opt?: ModelOpts): ClassDecorator
+export function Entity(...args: any[]): void | ClassDecorator {
+  if (args.length == 1 && typeof args[0] == 'function')
+    return _table(args[0])
+
+  return (target: any) => _table(target, ...args)
+}
+
+export function Model(target: Function): void
+export function Model(opt?: ModelOpts): ClassDecorator
+export function Model(...args: any[]): void | ClassDecorator {
+  if (args.length == 1 && typeof args[0] == 'function')
+    return _model(args[0])
+
+  return (target: any) => _model(target, ...args)
+}
+
+export function Zip(target: Function): void
+export function Zip(): ClassDecorator
+export function Zip(...args: any[]): void | ClassDecorator {
+  if (args.length == 1 && typeof args[0] == 'function')
+    return _zip(args[0])
+
+  return (target: any) => _zip(target)
+}
+
+export function Key(pk: string, sk?: string) {
+  return (target: any) => {
+    _key(target, pk, sk)
+  }
+}
+export const Keys = Key
+
+export function PartitionKey(attrName: string): PropertyDecorator
+export function PartitionKey(target: any, propertyKey: string): void
+export function PartitionKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
+export function PartitionKey(...args: any[]): void | PropertyDecorator {
+  if (!args.length) return
+
+  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
+    return _pk(args[0], args[1])
+
+  if (args.length == 1 && args[0])
+    return (target: any) => _pk(target, args[0])
+}
+
+export function SortKey(attrName: string): PropertyDecorator
+export function SortKey(target: any, propertyKey: string): void
+export function SortKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
+export function SortKey(...args: any[]): void | PropertyDecorator {
+  if (!args.length) return
+
+  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
+    return _sk(args[0], args[1])
+
+  if (args.length == 1 && args[0])
+    return (target: any) => _sk(target, args[0])
+}

package/src/dynamodb/index.ts

@@ -0,0 +1,4 @@
+export { Dynamodb, DocumentClient, RawClient } from './client'
+export { Model, Entity, Zip, PartitionKey, SortKey, Key, Keys } from './decorators'
+export { Schema } from './schema'
+export { Repository } from './repository'

package/src/dynamodb/model.ts

@@ -0,0 +1,258 @@
+import type { ModelMetadata, Keys, Model, Filter } from './types'
+import { getModelMetadata } from './decorators'
+import QueryBuilder from './query-builder'
+import Compact from './compact'
+import { RawClient } from './client'
+import { isArraySchema } from './schema'
+import { getLength } from 't0n'
+
+export default class AbstractModel<T extends object> {
+  #meta: ModelMetadata
+  cls?: Model<T>
+  lastKey?: Record<string, any>
+  #queryBuilder?: QueryBuilder
+  #model?: AbstractModel<T>
+
+  constructor(
+    cls: Model<T> | ModelMetadata,
+    queryBuilder?: QueryBuilder,
+    model?: AbstractModel<T>
+  ) {
+    this.#queryBuilder = queryBuilder
+    this.#model = model
+
+    if (typeof (cls as ModelMetadata).table == 'string') {
+      this.#meta = cls as ModelMetadata
+      this.cls = model?.cls
+      return
+    }
+
+    const meta = getModelMetadata(cls)
+    if (!meta)
+      throw new Error('Missing model metadata')
+
+    this.#meta = meta
+    this.cls = cls as Model<T>
+  }
+
+  get table(): string {
+    return this.#meta.table
+  }
+
+  get keySchema() {
+    return this.#meta.keys
+  }
+
+  set lastEvaluatedKey(val: Record<string, any> | undefined) {
+    if (this.#model) {
+      this.#model.lastKey = val
+    } else {
+      this.lastKey = val
+    }
+  }
+  get lastEvaluatedKey() {
+    return this.lastKey
+  }
+
+  where(builderFn: (q: QueryBuilder) => void) {
+    const qb = new QueryBuilder()
+    builderFn(qb)
+    return new AbstractModel<T>(this.#meta, qb, this)
+  }
+
+  async scan(filterFn?: Filter<T>) {
+    const result = await RawClient.scan(this.table, this.#queryBuilder?.filters)
+
+    this.lastEvaluatedKey = result.LastEvaluatedKey
+    return this.#processItems(result.Items, filterFn)
+  }
+
+  async query(filterFn?: Filter<T>) {
+    const result = await RawClient.query(this.table, this.#queryBuilder?.conditions)
+
+    this.lastEvaluatedKey = result.LastEvaluatedKey
+    return this.#processItems(result.Items, filterFn)
+  }
+
+  async get(key: Keys, sk?: string) {
+    const result = await RawClient.get(this.table, this.#key(key, sk))
+    return result.Item ? this.#processItem(result.Item) : undefined
+  }
+
+  async put(item: Partial<T>, key: Keys) {
+    let keys
+    if (this.#meta.zip) {
+      keys = this.#getItemKey(item, key)
+      this.#validateKeys(keys)
+      // @ts-ignore
+      item = { ...keys, V: Compact.encode(this.#getItemWithoutKeys(item), this.#meta.fields) }
+    } else {
+      this.#validateKeys(item)
+    }
+
+    await RawClient.put(this.table, item)
+    return this.#processItem(item, keys)
+  }
+
+  async update(attrs: Partial<T>, key: Keys) {
+    let keys
+    if (this.#meta.zip) {
+      keys = this.#getItemKey(attrs, key)
+      this.#validateKeys(keys)
+      // @ts-ignore
+      attrs = { V: Compact.encode(this.#getItemWithoutKeys(attrs), this.#meta.fields) }
+    } else {
+      this.#validateKeys(attrs)
+    }
+
+    const UpdateExpressionParts: string[] = []
+    const ExpressionAttributeValues: any = {}
+    for (const [k, v] of Object.entries(attrs)) {
+      UpdateExpressionParts.push(`#${k} = :${k}`)
+      ExpressionAttributeValues[`:${k}`] = v
+    }
+    const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ')
+    const ExpressionAttributeNames = Object.fromEntries(Object.keys(attrs).map(k => [`#${k}`, k]))
+
+    await RawClient.update(this.table, {
+      UpdateExpression,
+      ExpressionAttributeValues,
+      ExpressionAttributeNames,
+    }, this.#key(key))
+
+    return this.#processItem(attrs, keys)
+  }
+
+  async delete(key: Keys, sk?: string) {
+    return RawClient.delete(this.table, this.#key(key, sk))
+  }
+
+  async batchGet(keys: Array<Keys>) {
+    const result = await RawClient.batchGet({
+      RequestItems: { [this.table]: { Keys: keys.map(key => this.#key(key)) } },
+    })
+    return (result.Responses?.[this.table] as T[] || []).map(item => this.#processItem(item))
+  }
+
+  async batchWrite(items: Array<{ put?: Partial<T>, delete?: Keys }>) {
+    const WriteRequests = items.map(i => {
+      if (i.put) {
+        return { PutRequest: { Item: i.put } }
+      } else if (i.delete) {
+        return { DeleteRequest: { Key: this.#key(i.delete) } }
+      }
+      return null
+    }).filter(Boolean) as any[]
+
+    return RawClient.batchWrite({ RequestItems: { [this.table]: WriteRequests } })
+  }
+
+  async deleteMany(keys: Array<Keys>) {
+    return this.batchWrite(keys.map(k => ({ delete: k })))
+  }
+
+  async putMany(items: Array<Partial<T>>) {
+    return this.batchWrite(items.map(item => ({ put: item })))
+  }
+
+  #key(key: Keys, sk?: string) {
+    if (!this.#meta.keys) return {}
+    return RawClient.key(key, sk, this.#meta.keys, this.#meta.defaultSK)
+  }
+
+  #getItemKey(item: Partial<T>, key?: Keys): Record<string, string> {
+    if (!this.#meta.keys) return {}
+
+    const keys: Record<string, string> = {}
+    if (key)
+      this.#processExplicitKey(keys, key)
+    else if (getLength(item) > 0)
+      this.#processItemKeys(keys, item)
+
+    return keys
+  }
+
+  #processExplicitKey(keys: Record<string, string>, key: Keys): void {
+    if (!this.#meta.keys) return
+    if (Array.isArray(key)) {
+      keys[this.#meta.keys.PK] = key[0]
+
+      if (this.#meta.keys?.SK) {
+        if (key.length > 1)
+          // @ts-ignore
+          keys[this.#meta.keys.SK] = key[1]
+        else if (this.#meta.defaultSK)
+          keys[this.#meta.keys.SK] = this.#meta.defaultSK
+      }
+    } else {
+      keys[this.#meta.keys.PK] = String(key)
+    }
+  }
+
+  #processItemKeys(keys: Record<string, string>, item: Partial<T>): void {
+    if (!this.#meta.keys) return
+
+    const pkValue = item[this.#meta.keys.PK as keyof Partial<T>]
+    if (pkValue != null)
+      keys[this.#meta.keys.PK] = String(pkValue)
+
+    if (this.#meta.keys?.SK) {
+      const skValue = item[this.#meta.keys.SK as keyof Partial<T>]
+      if (skValue != null)
+        keys[this.#meta.keys.SK] = String(skValue)
+      else if (this.#meta.defaultSK)
+        keys[this.#meta.keys.SK] = this.#meta.defaultSK
+    }
+  }
+
+  #validateKeys(keys: Record<string, any>) {
+    if (!this.#meta.keys)
+      throw new Error(`Missing keys of table "${this.table}"`)
+
+    if (!(this.#meta.keys.PK in keys))
+      throw new Error(`Missing partition key of table "${this.table}" `)
+
+    if (this.#meta.keys?.SK && !(this.#meta.keys.SK in keys))
+      throw new Error(`Missing sort key of table "${this.table}"`)
+  }
+
+  #getItemWithoutKeys(item: Partial<T>): Partial<T> {
+    if (Array.isArray(item))
+      return item?.length ? item.map(i => this.#getItemWithoutKeys(i)) as T : [] as T
+
+    if (!this.#meta.keys || !item) return { ...item }
+
+    const { PK, SK } = this.#meta.keys
+    const { [PK as keyof T]: _, [SK as keyof T]: __, ...rest } = item
+
+    return rest as Partial<T>
+  }
+
+  #processItems(items: any[] | undefined, filterFn?: Filter<T>): T[] {
+    if (!items || !items.length) return []
+    items = items.map(item => this.#processItem(item))
+    return filterFn ? items.filter(filterFn) : items
+  }
+
+  #processItem(item: any, keys?: Record<string, string>): T {
+    if (this.#meta.zip && item?.V) {
+      const value = Compact.decode<T>(item.V, this.#meta.fields)
+      const model = isArraySchema(this.#meta.fields) && Array.isArray(value)
+        ? value.map(v => new this.cls!(v))
+        : new this.cls!(value)
+
+      if (!keys) keys = this.#getItemKey(item)
+
+      return this.#withKey(model as T, keys)
+    }
+
+    return new this.cls!(item)
+  }
+
+  #withKey(model: T, keys: Record<string, string>): T {
+    // @ts-ignore
+    if (Array.isArray(model)) return model.map(m => this.#withKey(m, keys))
+    // @ts-ignore
+    return model.withKey(keys[this.#meta.keys.PK], keys[this.#meta.keys.SK] || undefined)
+  }
+}

package/src/dynamodb/query-builder.ts

@@ -0,0 +1,174 @@
+import type { Condition, Operator } from './types'
+
+export default class QueryBuilder {
+  #filters: Condition[] = []
+  #keyConditions: Condition[] = []
+  #limit?: number
+  #startKey?: Record<string, any>
+  #index?: string
+  #attrCounter = 1
+  #valCounter = 1
+  #fieldAttrMap: Record<string, string> = {}
+  #fieldValMap: Record<string, string> = {}
+
+  filter(field: string, operator: Operator, value: any = null) {
+    this.#filters.push({ type: 'filter', field, operator, value })
+    return this
+  }
+
+  keyCondition(field: string, operator: Operator | any, value?: any) {
+    const noVal = value == null
+    this.#keyConditions.push({ type: 'keyCondition', field, operator: noVal ? '=' : operator, value: noVal ? operator : value })
+    return this
+  }
+
+  limit(n: number) {
+    this.#limit = n
+    return this
+  }
+
+  exclusiveStartKey(key: Record<string, any>) {
+    this.#startKey = key
+    return this
+  }
+
+  index(name: string) {
+    this.#index = name
+    return this
+  }
+
+  private attrName(field: string) {
+    if (!this.#fieldAttrMap[field])
+      this.#fieldAttrMap[field] = '#a'+ this.#attrCounter++
+
+    return this.#fieldAttrMap[field]
+  }
+
+  private valName(val: any) {
+    val = String(val)
+    if (!this.#fieldValMap[val])
+      this.#fieldValMap[val] = ':v'+ this.#valCounter++
+
+    return this.#fieldValMap[val]
+  }
+
+  #resetCounters() {
+    this.#attrCounter = 0
+    this.#valCounter = 0
+    this.#fieldAttrMap = {}
+    this.#fieldValMap = {}
+  }
+
+  buildExpression(conditions: Condition[]) {
+    const exprParts: string[] = []
+    const values: Record<string, any> = {}
+    const names: Record<string, string> = {}
+
+    for (const cond of conditions) {
+      const attr = this.attrName(cond.field)
+      const val = Array.isArray(cond.value) ? '' : this.valName(cond.value)
+      names[attr] = cond.field
+
+      switch (cond.operator) {
+        case 'between': {
+          const val0 = this.valName(cond.value[0])
+          const val1 = this.valName(cond.value[1])
+          exprParts.push(`${attr} BETWEEN ${val0} AND ${val1}`)
+          values[val0] = cond.value[0]
+          values[val1] = cond.value[1]
+          break
+        }
+        case 'begins_with': {
+          exprParts.push(`begins_with(${attr}, ${val})`)
+          values[val] = cond.value
+          break
+        }
+        case 'in': {
+          const inVals = cond.value.map((v: any) => {
+            const key = this.valName(v)
+            values[key] = v
+            return key
+          })
+          exprParts.push(`${attr} IN (${inVals.join(', ')})`)
+          break
+        }
+        case 'attribute_exists': {
+          exprParts.push(`attribute_exists(${attr})`)
+          break
+        }
+        case 'attribute_not_exists': {
+          exprParts.push(`attribute_not_exists(${attr})`)
+          break
+        }
+        case 'attribute_type': {
+          exprParts.push(`attribute_type(${attr}, ${val})`)
+          values[val] = cond.value
+          break
+        }
+        case 'contains': {
+          exprParts.push(`contains(${attr}, ${val})`)
+          values[val] = cond.value
+          break
+        }
+        case 'size': {
+          exprParts.push(`size(${attr}) = ${val}`)
+          values[val] = cond.value
+          break
+        }
+        default: {
+          exprParts.push(`${attr} ${cond.operator} ${val}`)
+          values[val] = cond.value
+        }
+      }
+    }
+
+    return {
+      expression: exprParts.length ? exprParts.join(' AND ') : undefined,
+      names: Object.keys(names).length ? names : undefined,
+      values: Object.keys(values).length ? values : undefined,
+    }
+  }
+
+  get filters() {
+    const filter = this.buildExpression(this.#filters)
+    const params: any = {}
+
+    if (this.#limit)
+      params.Limit = this.#limit
+
+    if (this.#startKey)
+      params.ExclusiveStartKey = this.#startKey
+
+    if (filter.expression)
+      params.FilterExpression = filter.expression
+
+    if (filter.names)
+      params.ExpressionAttributeNames = filter.names
+
+    if (filter.values)
+      params.ExpressionAttributeValues = filter.values
+
+    return params
+  }
+
+  get conditions() {
+    const keys = this.buildExpression(this.#keyConditions)
+    const filters = this.filters
+
+    const params: any = { ...filters }
+
+    if (this.#index)
+      params.IndexName = this.#index
+
+    if (keys.expression)
+      params.KeyConditionExpression = keys.expression
+
+    if (keys.names || filters?.ExpressionAttributeNames)
+      params.ExpressionAttributeNames = { ...(keys?.names || {}), ...(filters?.ExpressionAttributeNames || {}) }
+
+    if (keys.values || filters?.ExpressionAttributeValues)
+      params.ExpressionAttributeValues = { ...(keys?.values || {}), ...(filters?.ExpressionAttributeValues || {}) }
+
+    return params
+  }
+}

package/src/dynamodb/repository.ts

@@ -0,0 +1,31 @@
+import { z, ZodTypeAny } 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,
+  B extends new (...args: any[]) => any
+>(
+  schema: S,
+  base?: B | ModelOpts,
+  opts?: ModelOpts
+) {
+  const isClass = typeof base == 'function'
+  type M = z.infer<S>
+
+  const Repo = Schema(schema, isClass ? base : undefined)
+  _model(Repo, isClass ? opts : base)
+
+  return class extends Repo {
+    static model = Dynamodb.model<M>(Repo as any)
+
+    static get lastKey() {
+      return this.model?.lastEvaluatedKey || null
+    }
+  } as unknown as (typeof Repo) & {
+    new (...args: any[]): InstanceType<typeof Repo>
+    model: ReturnType<typeof Dynamodb.model<M>>
+  }
+}

package/src/dynamodb/schema.ts

@@ -0,0 +1,107 @@
+import { z, ZodTypeAny } from 'zod'
+import type { SchemaStructure } from './types'
+
+const m = Symbol('a')
+export function isArraySchema(v: any): boolean {
+  return v[m] || false
+}
+
+export function arraySchema(v: any): any {
+  // @ts-ignore
+  v[m] = true
+  return v
+}
+
+export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
+  if (schema instanceof z.ZodObject) {
+    return Object.entries(schema.shape).map(([key, value]) => {
+      const inner = unwrap(value as 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
+      }
+
+      return key
+    })
+  }
+
+  if (schema instanceof z.ZodArray) {
+    const item = unwrap(schema._def.type as ZodTypeAny)
+    if (item instanceof z.ZodObject)
+      return arraySchema(extractZodKeys(item))
+
+    return []
+  }
+
+  return []
+}
+
+export function unwrap(schema: ZodTypeAny): ZodTypeAny {
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable)
+    return unwrap(schema._def.innerType)
+
+  if (schema instanceof z.ZodDefault)
+    return unwrap(schema._def.innerType)
+
+  // if (schema instanceof z.ZodUnion)
+  //   return unwrap(schema._def.options[0] as ZodTypeAny)
+
+  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]
+  }
+
+  if (schema instanceof z.ZodEffects)
+    return unwrap(schema._def.schema)
+
+  return schema
+}
+
+function notEmpty(key: string, schema: SchemaStructure): string | Record<string, SchemaStructure> {
+  return schema?.length ? {[key]: schema} : key
+}
+
+export function Schema<
+  T extends ZodTypeAny,
+  B extends object
+>(
+  schema: T,
+  BaseClass?: new (...args: any[]) => B
+) {
+  const Base = (BaseClass || class {})
+
+  return class extends Base {
+    static _schema = schema
+    static defaultSortKey?: string
+
+    #PK?: string
+    #SK?: string
+
+    constructor(data: z.infer<T>) {
+      super()
+      Object.assign(this, data)
+    }
+
+    get PK() { return this.#PK }
+    get SK() { return this.#SK }
+
+    static get schema() {
+      return extractZodKeys(this._schema)
+    }
+
+    static get defaultSK() {
+      return this.defaultSortKey
+    }
+
+    withKey(key: string, sk?: string) {
+      this.#PK = key
+      if (sk) this.#SK = sk
+      return this
+    }
+  }
+}

package/src/dynamodb/types.ts

@@ -0,0 +1,32 @@
+export type Operator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'begins_with' | 'between' | 'in' | 'attribute_exists' | 'attribute_not_exists' | 'attribute_type' | 'contains' | 'size'
+
+export type Condition = {
+  type: 'filter' | 'keyCondition',
+  field: string,
+  operator: Operator,
+  value: any
+}
+
+export type ISchemaStructure = string | Record<string, ISchemaStructure[]>
+export type SchemaStructure = ISchemaStructure[]
+
+export type KeySchema = Record<'PK' | 'SK', string>
+export type ModelMetadata = {
+  table: string,
+  keys?: KeySchema,
+  defaultSK?: string,
+  zip: boolean,
+  fields: SchemaStructure,
+}
+
+export type ModelOpts = string | {
+  table?: string,
+  partitionKey?: string,
+  sortKey?: string,
+  defaultSK?: string,
+  zip?: boolean,
+}
+
+export type Keys = string | [string] | [string, string]
+export type Model<T extends object> = new (...args: any[]) => T
+export type Filter<T> = (item: T) => boolean

package/src/index.ts

@@ -1 +1 @@
-export * from './query-builder'
+export { default as QueryBuilder } from './query-builder'

package/src/model.ts

@@ -1,5 +1,5 @@
 import pluralize from 'pluralize'
-import { QueryBuilder } from './query-builder'
+import QueryBuilder from './query-builder'
 import type {
   Operator, OrderDirection,
   WhereFn, WhereArgs,

package/src/query-builder.ts

@@ -18,7 +18,7 @@ import type {
   Pipe,
 } from './types'
 
-export class QueryBuilder<
+export default class QueryBuilder<
   S,
   T,
   C extends keyof T = keyof T //,
@@ -42,23 +42,19 @@ export class QueryBuilder<
   #joins: string[] = []
 
   #pipe?: Pipe<S, T, C>
-  // #runFn?: RunFn<S, T, C>
 
   constructor(
     table: string,
     schema?: DBSchema,
     pipe?: Pipe<S, T, C>
-    // runFn?: RunFn<S, T, C>
   ) {
     this.#table = table
     this.#schema = schema
     this.#pipe = pipe
-    // this.#runFn = runFn
     this.#clauses = new ClauseBuilder<T>(table, schema)
   }
 
   async run() {
-    // if (!this.#runFn)
     if (!this.#pipe?.run)
       throw new Error(`No database connection.`)
 

package/src/types.ts

@@ -1,5 +1,5 @@
 import z from 'zod'
-import { QueryBuilder } from './query-builder'
+import QueryBuilder from './query-builder'
 
 export type text = string
 export type real = number