rajt 0.0.58 → 0.0.60

package/src/dynamodb/model.ts

@@ -1,258 +0,0 @@
-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 !== undefined)
-      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 !== undefined)
-        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

@@ -1,174 +0,0 @@
-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 === undefined
-    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

@@ -1,31 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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