rajt 0.0.46 → 0.0.48

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/auth/token.ts

@@ -16,14 +16,14 @@ export class Token {
     const header = c.cx.req.header(this.#name) || c.cx.req.header('HTTP_AUTHORIZATION') || c.cx.req.header('REDIRECT_HTTP_AUTHORIZATION') || null
 
     if (header) {
-      const position = header.toLowerCase().indexOf(this.#prefix.toLowerCase())
-      if (position !== -1) {
-        let token = header.slice(position + this.#prefix.length).trim()
-        const commaPos = token.indexOf(',')
-        if (commaPos !== -1) token = token.slice(0, commaPos).trim()
-
-        return token
-      }
+      const pos = header.toLowerCase().indexOf(this.#prefix.toLowerCase())
+      if (pos < 0) return header
+
+      let token = header.slice(pos + this.#prefix.length).trim()
+      const commaPos = token.indexOf(',')
+      if (commaPos > -1) token = token.slice(0, commaPos).trim()
+
+      return token
     }
 
     return null

package/src/dynamodb/client.ts

@@ -1,6 +1,27 @@
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-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 } from './types'
 
 const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
   region: process.env.AWS_REGION || "us-east-1",
@@ -11,10 +32,74 @@ const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
   },
 } : {})
 
-export const ddb = DynamoDBDocumentClient.from(client)
+export const DocumentClient = DynamoDBDocumentClient.from(client)
 
 export class Dynamodb {
   static model<T extends object>(cls: new (...args: any[]) => T) {
-    return new AbstractModel<T>(cls, ddb)
+    return new AbstractModel<T>(cls)
+  }
+
+  static raw() {
+    return RawClient
+  }
+}
+
+export class RawClient {
+  static async get(TableName: string, key: Keys, sk?: string) {
+    return DocumentClient.send(new GetCommand({
+      TableName,
+      Key: this.#key(key, sk),
+    }))
+  }
+
+  static async scan(TableName: string, filters: ScanCommandInput) {
+    return DocumentClient.send(new ScanCommand({ ...filters, TableName }))
+  }
+
+  static async query(TableName: string, filters: QueryCommandInput) {
+    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: UpdateCommandInput, key: Keys, sk?: string) {
+    return DocumentClient.send(new UpdateCommand({
+      ...filters, TableName, Key: this.#key(key, sk),
+    }))
+  }
+
+  static async delete(TableName: string, key: Keys, 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, sk?: string) {
+    if (typeof key == 'object' && key != null) return key
+
+    let pk: string
+    let skValue: string | undefined
+
+    if (Array.isArray(key)) {
+      pk = key[0]
+      skValue = key[1] ?? sk
+    } else {
+      pk = key
+      skValue = sk
+    }
+
+    const keys = {PK: pk}
+    // @ts-ignore
+    if (skValue) keys.SK = skValue
+
+    return keys
   }
 }

package/src/dynamodb/index.ts

@@ -1,4 +1,4 @@
-export { Dynamodb } from './client'
+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

@@ -1,18 +1,11 @@
 import {
-  DynamoDBDocumentClient,
-  BatchGetCommand,
-  BatchWriteCommand,
-  DeleteCommand,
-  GetCommand,
-  PutCommand,
-  QueryCommand,
-  ScanCommand,
-  UpdateCommand,
+  UpdateCommandInput,
 } from '@aws-sdk/lib-dynamodb'
 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 '../utils/lenght'
 
@@ -20,17 +13,14 @@ export default class AbstractModel<T extends object> {
   #meta: ModelMetadata
   cls?: Model<T>
   lastKey?: Record<string, any>
-  #db: DynamoDBDocumentClient
   #queryBuilder?: QueryBuilder
   #model?: AbstractModel<T>
 
   constructor(
     cls: Model<T> | ModelMetadata,
-    db: DynamoDBDocumentClient,
     queryBuilder?: QueryBuilder,
     model?: AbstractModel<T>
   ) {
-    this.#db = db
     this.#queryBuilder = queryBuilder
     this.#model = model
 
@@ -70,34 +60,25 @@ export default class AbstractModel<T extends object> {
   where(builderFn: (q: QueryBuilder) => void) {
     const qb = new QueryBuilder()
     builderFn(qb)
-    return new AbstractModel<T>(this.#meta, this.#db, qb, this)
+    return new AbstractModel<T>(this.#meta, qb, this)
   }
 
   async scan(filterFn?: Filter<T>) {
-    const result = await this.#db.send(new ScanCommand({
-      TableName: this.table,
-      ...this.#queryBuilder?.filters,
-    }))
+    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 this.#db.send(new QueryCommand({
-      TableName: this.table,
-      ...this.#queryBuilder?.conditions,
-    }))
+    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 this.#db.send(new GetCommand({
-      TableName: this.table,
-      Key: this.#key(key, sk),
-    }))
+    const result = await RawClient.get(this.table, key, sk)
     return result.Item ? this.#processItem(result.Item) : undefined
   }
 
@@ -112,7 +93,7 @@ export default class AbstractModel<T extends object> {
       this.#validateKeys(item)
     }
 
-    await this.#db.send(new PutCommand({ TableName: this.table, Item: item }))
+    await RawClient.put(this.table, item)
     return this.#processItem(item, keys)
   }
 
@@ -136,28 +117,23 @@ export default class AbstractModel<T extends object> {
     const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ')
     const ExpressionAttributeNames = Object.fromEntries(Object.keys(attrs).map(k => [`#${k}`, k]))
 
-    await this.#db.send(new UpdateCommand({
-      TableName: this.table,
-      Key: this.#key(key),
+    await RawClient.update(this.table, {
       UpdateExpression,
       ExpressionAttributeValues,
       ExpressionAttributeNames,
-    }))
+    } as UpdateCommandInput, key)
 
     return this.#processItem(attrs, keys)
   }
 
   async delete(key: Keys, sk?: string) {
-    return this.#db.send(new DeleteCommand({
-      TableName: this.table,
-      Key: this.#key(key, sk),
-    }))
+    return RawClient.delete(this.table, key, sk)
   }
 
   async batchGet(keys: Array<Keys>) {
-    const result = await this.#db.send(new BatchGetCommand({
+    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))
   }
 
@@ -171,7 +147,7 @@ export default class AbstractModel<T extends object> {
       return null
     }).filter(Boolean) as any[]
 
-    return this.#db.send(new BatchWriteCommand({ RequestItems: { [this.table]: WriteRequests } }))
+    return RawClient.batchWrite({ RequestItems: { [this.table]: WriteRequests } })
   }
 
   async deleteMany(keys: Array<Keys>) {