forj 0.0.1 → 0.0.3

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
+    }
+  }
+}