rajt 0.0.9 → 0.0.11

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
     ".": "./src/index.ts",
+    "./dynamodb": "./src/dynamodb/index.ts",
     "./http": "./src/http.ts",
     "./types": "./src/types.ts"
   },
@@ -24,7 +25,7 @@
     "sam:local": "sam local start-api --warm-containers LAZY --debug --template-file ../../template-dev.yaml",
     "sam:package": "sam package --template-file ../../template-prod.yaml --output-template-file ../../packaged.yaml",
     "sam:deploy": "sam deploy --template-file ../../packaged.yaml --stack-name rajt-llrt --capabilities CAPABILITY_IAM",
-    "sam:update": "source ../../.env.prod && aws lambda update-function-code --function-name $AWS_NAME --zip-file fileb: //../../lambda.zip --region $AWS_REGION",
+    "sam:update": "source ../../.env.prod && aws lambda update-function-code --function-name $AWS_NAME --zip-file fileb://../../lambda.zip --region $AWS_REGION --no-cli-pager 2>&1 >/dev/null",
     "cache:routes": "tsx src/scripts/cache-routes.ts",
     "ensure-dirs": "rm -rf ../../dist ../../tmp && mkdir -p ../../tmp && chmod 755 ../../tmp && mkdir -p ../../dist && chmod 755 ../../dist",
     "clean": "rm -rf ../../dist ../../tmp",
@@ -34,6 +35,8 @@
     "start": "node ../../dist/index.js"
   },
   "dependencies": {
+    "@aws-lite/client": "^0.23.2",
+    "@aws-lite/dynamodb": "^0.3.9",
     "@hono/node-server": "^1.14.1",
     "@hono/zod-validator": "^0.4.3",
     "@types/node": "^20.11.0",

package/src/dev.ts

@@ -4,7 +4,7 @@ import createApp from './create-app'
 import getRoutes from './routes'
 import { getAvailablePort } from './utils/port'
 
-config({ path: '.env.dev' })
+config({ path: '../../.env.dev' })
 
 const routes = await getRoutes()
 const fetch = createApp({ routes }).fetch

package/src/dynamodb/client.ts

@@ -0,0 +1,13 @@
+import awsLite from '@aws-lite/client'
+import dynamodbLite from '@aws-lite/dynamodb'
+import AbstractModel from './model'
+
+export const aws = await awsLite({
+  plugins: [dynamodbLite]
+})
+
+export class Dynamodb {
+  static model<T extends object>(cls: new (...args: any[]) => T) {
+    return new AbstractModel<T>(cls, aws.DynamoDB)
+  }
+}

package/src/dynamodb/decorators.ts

@@ -0,0 +1,20 @@
+import { registerModelMetadata, registerKeyMetadata } from './metadata-registry'
+
+export function Model(opt: string | { table: string }) {
+  return function (target: Function) {
+    const table = typeof opt === 'string' ? opt : opt.table
+    registerModelMetadata(target, { table })
+  }
+}
+
+export function PartitionKey(attrName?: string) {
+  return function (target: any, propertyKey: string) {
+    registerKeyMetadata(target.constructor, 'PK', attrName || propertyKey)
+  }
+}
+
+export function SortKey(attrName?: string) {
+  return function (target: any, propertyKey: string) {
+    registerKeyMetadata(target.constructor, 'SK', attrName || propertyKey)
+  }
+}

package/src/dynamodb/index.ts

@@ -0,0 +1,2 @@
+export { Dynamodb } from './client'
+export { Model, PartitionKey, SortKey } from './decorators'

package/src/dynamodb/metadata-registry.ts

@@ -0,0 +1,28 @@
+export type ModelMetadata = {
+  table: string,
+  keys: Record<'PK' | 'SK', string>,
+}
+
+const modelRegistry = new Map<Function, ModelMetadata>()
+
+export function registerModelMetadata(target: Function, metadata: { table: string }) {
+  const data = modelRegistry.get(target)
+  if (data)
+    data.table = metadata.table
+  else
+    // @ts-ignore
+    modelRegistry.set(target, { table: metadata.table, keys: {} })
+}
+
+export function registerKeyMetadata(target: Function, keyType: 'PK' | 'SK', name: string) {
+  const data = modelRegistry.get(target)
+  if (data)
+    data.keys[keyType] = name
+  else
+    // @ts-ignore
+    modelRegistry.set(target, { table: '', keys: { [keyType]: name } })
+}
+
+export function getModelMetadata(target: Function) {
+  return modelRegistry.get(target)
+}

package/src/dynamodb/model.ts

@@ -0,0 +1,137 @@
+import type { AwsLiteDynamoDB } from '@aws-lite/dynamodb-types'
+import { getModelMetadata } from './metadata-registry'
+import type { ModelMetadata } from './metadata-registry'
+import QueryBuilder from './query-builder'
+
+export default class AbstractModel<T extends object> {
+  private meta: ModelMetadata
+  private lastKey?: Record<string, any>
+
+  constructor(
+    cls: (new (...args: any[]) => T) | ModelMetadata,
+    private db: AwsLiteDynamoDB,
+    private queryBuilder?: QueryBuilder,
+    private model?: AbstractModel<T>
+  ) {
+    if (typeof (cls as ModelMetadata).table === 'string') {
+      this.meta = cls as ModelMetadata
+      return
+    }
+
+    // @ts-ignore
+    const meta = getModelMetadata(cls)
+    if (!meta)
+      throw new Error('Missing model metadata')
+
+    this.meta = meta
+  }
+
+  get table(): string {
+    return this.meta.table
+  }
+
+  get keys() {
+    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
+  }
+
+  schema(pk: string, sk?: string) {
+    const keys = { [this.meta.keys.PK]: pk }
+    if (sk && this.meta.keys.SK)
+      keys[this.meta.keys.SK] = sk
+
+    return keys
+  }
+
+  where(builderFn: (q: QueryBuilder) => void) {
+    const qb = new QueryBuilder()
+    builderFn(qb)
+    const model = new AbstractModel<T>(this.meta, this.db, qb, this)
+    return model
+  }
+
+  async scan(filterFn?: (item: T) => boolean) {
+    const result = await this.db.Scan({ TableName: this.table, ...this.queryBuilder?.filters })
+    this.lastEvaluatedKey = result.LastEvaluatedKey
+    const items = result.Items as T[]
+    return filterFn ? items.filter(filterFn) : items
+  }
+
+  async query(filterFn?: (item: T) => boolean) {
+    const result = await this.db.Query({ TableName: this.table, ...this.queryBuilder?.conditions })
+    this.lastEvaluatedKey = result.LastEvaluatedKey
+    const items = result.Items as T[]
+    return filterFn ? items.filter(filterFn) : items
+  }
+
+  async get(pk: string, sk?: string) {
+    const result = await this.db.GetItem({ TableName: this.table, Key: this.schema(pk, sk) })
+    return result.Item as T
+  }
+
+  async put(item: Partial<T>) {
+    await this.db.PutItem({ TableName: this.table, Item: item })
+    return item
+  }
+
+  async update(key: string | [string, string], attrs: Partial<T>) {
+    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]))
+
+    return this.db.UpdateItem({
+      TableName: this.table,
+      Key: Array.isArray(key) ? this.schema(key[0], key[1]) : this.schema(key),
+      UpdateExpression,
+      ExpressionAttributeValues,
+      ExpressionAttributeNames
+    })
+  }
+
+  async delete(pk: string, sk?: string) {
+    return this.db.DeleteItem({ TableName: this.table, Key: this.schema(pk, sk) })
+  }
+
+  async batchGet(keys: Array<{ pk: string, sk?: string }>) {
+    const result = await this.db.BatchGetItem({ RequestItems: {
+      [this.table]: { Keys: keys.map(({ pk, sk }) => this.schema(pk, sk)) }
+    } })
+    return result.Responses?.[this.table] as T[]
+  }
+
+  async batchWrite(items: Array<{ put?: Partial<T>, delete?: { pk: string, sk?: string } }>) {
+    const WriteRequests = items.map(i => {
+      if (i.put) {
+        return { PutRequest: { Item: i.put } }
+      } else if (i.delete) {
+        return { DeleteRequest: { Key: this.schema(i.delete.pk, i.delete.sk) } }
+      }
+      return null
+    }).filter(Boolean)
+
+    return this.db.BatchWriteItem({ RequestItems: {[this.table]: WriteRequests} })
+  }
+
+  async deleteMany(keys: Array<{ pk: string, sk?: string }>) {
+    return this.batchWrite(keys.map(k => ({ delete: k })))
+  }
+
+  async putMany(items: Array<Partial<T>>) {
+    return this.batchWrite(items.map(i => ({ put: i })))
+  }
+}

package/src/dynamodb/query-builder.ts

@@ -0,0 +1,155 @@
+type Operator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'begins_with' | 'between' | 'in' | 'attribute_exists' | 'attribute_not_exists' | 'attribute_type' | 'contains' | 'size'
+
+type Condition = {
+  type: 'filter' | 'keyCondition',
+  field: string,
+  operator: Operator,
+  value: any
+}
+
+export default class QueryBuilder {
+  private _conditions: Condition[] = []
+  private _limit?: number
+  private _startKey?: Record<string, any>
+  private _index?: string
+
+  filter(field: string, operator: Operator, value: any = null) {
+    this._conditions.push({ type: 'filter', field, operator, value })
+    return this
+  }
+
+  keyCondition(field: string, operator: Operator | any, value?: any) {
+    const noVal = value === undefined
+    this._conditions.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
+  }
+
+  buildExpression(type: 'filter' | 'keyCondition') {
+    const exprParts: string[] = []
+    const values: Record<string, any> = {}
+    const names: Record<string, string> = {}
+
+    let i = 0
+    for (const cond of this._conditions.filter(c => c.type === type)) {
+      const attr = `#attr${i}`
+      const val = `:val${i}`
+      names[attr] = cond.field
+
+      switch (cond.operator) {
+        case 'between': {
+          exprParts.push(`${attr} BETWEEN ${val}a AND ${val}b`)
+          values[`${val}a`] = cond.value[0]
+          values[`${val}b`] = 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, j: number) => {
+            const vKey = `${val}_${j}`
+            values[vKey] = v
+            return vKey
+          })
+          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
+        }
+      }
+
+      i++
+    }
+
+    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('filter')
+    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('keyCondition')
+    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/prod.ts

@@ -2,7 +2,7 @@ import { config } from 'dotenv'
 import { handle } from 'hono/aws-lambda'
 import createApp from './create-app'
 
-config({ path: '.env.prod' })
+config({ path: '../../.env.prod' })
 
 // @ts-ignore
 await import('../../../tmp/import-routes.mjs')