rajt 0.0.49 → 0.0.51

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.49",
+  "version": "0.0.51",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/dynamodb/client.ts

@@ -21,14 +21,14 @@ import {
 } from '@aws-sdk/lib-dynamodb'
 import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb'
 import AbstractModel from './model'
-import { Keys } from './types'
+import { Keys, KeySchema } from './types'
 
 const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
-  region: process.env.AWS_REGION || "us-east-1",
+  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",
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'DUMMYIDEXAMPLE',
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'DUMMYEXAMPLEKEY',
   },
 } : {})
 
@@ -46,10 +46,7 @@ export class Dynamodb {
 
 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),
-    }))
+    return DocumentClient.send(new GetCommand({ TableName, Key: this.key(key, sk) }))
   }
 
   static async scan(TableName: string, filters: Omit<ScanCommandInput, 'TableName'>) {
@@ -71,12 +68,12 @@ export class RawClient {
     sk?: string
   ) {
     return DocumentClient.send(new UpdateCommand({
-      ...filters, TableName, Key: this.#key(key, sk),
+      ...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) }))
+    return DocumentClient.send(new DeleteCommand({ TableName, Key: this.key(key, sk) }))
   }
 
   static async batchGet(batch: BatchGetCommandInput) {
@@ -87,23 +84,41 @@ export class RawClient {
     return DocumentClient.send(new BatchWriteCommand(batch))
   }
 
-  static #key(key: Keys | Record<string, string>, sk?: string) {
-    if (typeof key == 'object' && key != null) return key
-
+  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
     }
 
-    const keys = {PK: pk}
-    // @ts-ignore
-    if (skValue) keys.SK = skValue
+    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

@@ -29,14 +29,28 @@ export default class Compact {
   }
 
   static {
-    this.#reverseTypeMap = Object.fromEntries(Object.entries(this.#typeMap).map(([k, v]) => [v, k.replace(/"/g, "'")]))
-    this.#typeRegex = this.#mapRegex(Object.keys(this.#typeMap))
-    this.#reverseTypeRegex = this.#mapRegex(Object.keys(this.#reverseTypeMap))
+    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.#minify(
+
+    return this.#pack(
       JSON.stringify(this.zip(obj, schema, seen))
         .replace(/"\^(\d+)"/g, '^$1')
         .replace(/"/g, '~TDQ~')
@@ -49,7 +63,7 @@ export default class Compact {
   static smartDecode<T = any>(val: any, schema: SchemaStructure): T {
     if (!val) return val as T
 
-    if (Array.isArray(val))
+    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
@@ -59,7 +73,7 @@ export default class Compact {
     if (!val || typeof val !== 'string') return val as T
 
     return this.withSchema(this.unzip(JSON.parse(
-      this.#deminify(val)
+      this.#unpack(val)
         .replace(/"/g, '~TSQ~')
         .replace(/'/g, '"')
         .replace(/~TSQ~/g, "'")
@@ -72,7 +86,7 @@ export default class Compact {
     if (Array.isArray(obj))
       return obj?.length ? obj.map(item => this.zip(item, schema, seen)) : []
 
-    if (!obj || [null, true, false].includes(obj)) return obj
+    if (this.#cantZip(obj)) return obj
 
     return schema.map(key => {
       if (typeof key === 'string')
@@ -96,8 +110,7 @@ export default class Compact {
     const type = typeof val
     const length = getLength(val, type)
 
-    if ([null, true, false].includes(val) || type != 'object' && length < 2)
-      return val
+    if (this.#cantZip(val, type, length)) return val
 
     if (type == 'object') {
       for (const key in val)
@@ -131,7 +144,7 @@ export default class Compact {
     if (!key) return undefined
 
     if (typeof key == 'string')
-      return [key, value || null]
+      return [key, value === undefined ? null : value]
 
     const mainKey = Object.keys(key)[0]
     const subKeys = key[mainKey]
@@ -145,7 +158,7 @@ export default class Compact {
         : [mainKey, this.withSchema(value, subKeys)]
     }
 
-    return [mainKey, value || null]
+    return [mainKey, value === undefined ? null : value]
   }
 
   static memo(val: any, seen: any[]): any {
@@ -161,8 +174,7 @@ export default class Compact {
     }
 
     const length = getLength(val, type)
-    if ([null, true, false].includes(val) || type != 'object' && length < 2)
-      return val
+    if (this.#cantZip(val, type, length)) return val
 
     const index = seen.indexOf(val)
     if (index !== -1)
@@ -177,11 +189,17 @@ export default class Compact {
     return new RegExp(`(?<![^\\s,\\[\\{:])(${keys.join('|')})(?![^\\s,\\]\\}:])`, 'g')
   }
 
-  static #minify(val: string): string {
+  static #pack(val: string): string {
     return val.replace(this.#typeRegex, match => this.#typeMap[match])
   }
 
-  static #deminify(val: string): string {
+  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/model.ts

@@ -75,7 +75,7 @@ export default class AbstractModel<T extends object> {
   }
 
   async get(key: Keys, sk?: string) {
-    const result = await RawClient.get(this.table, key, sk)
+    const result = await RawClient.get(this.table, this.#key(key, sk))
     return result.Item ? this.#processItem(result.Item) : undefined
   }
 
@@ -118,13 +118,13 @@ export default class AbstractModel<T extends object> {
       UpdateExpression,
       ExpressionAttributeValues,
       ExpressionAttributeNames,
-    }, key)
+    }, this.#key(key))
 
     return this.#processItem(attrs, keys)
   }
 
   async delete(key: Keys, sk?: string) {
-    return RawClient.delete(this.table, key, sk)
+    return RawClient.delete(this.table, this.#key(key, sk))
   }
 
   async batchGet(keys: Array<Keys>) {
@@ -157,28 +157,7 @@ export default class AbstractModel<T extends object> {
 
   #key(key: Keys, sk?: string) {
     if (!this.#meta.keys) return {}
-
-    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 = { [this.#meta.keys.PK]: pk }
-
-    if (this.#meta.keys?.SK) {
-      if (skValue) {
-        keys[this.#meta.keys.SK] = skValue
-      } else if (this.#meta.defaultSK) {
-        keys[this.#meta.keys.SK] = this.#meta.defaultSK
-      }
-    }
-
-    return keys
+    return RawClient.key(key, sk, this.#meta.keys, this.#meta.defaultSK)
   }
 
   #getItemKey(item: Partial<T>, key?: Keys): Record<string, string> {

package/src/dynamodb/schema.ts

@@ -2,21 +2,27 @@ import { z, ZodTypeAny } from 'zod'
 import type { SchemaStructure } from './types'
 
 const m = Symbol('a')
-export function isArraySchema(v: any) : boolean {
+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 { [key]: extractZodKeys(inner) }
+        return notEmpty(key, extractZodKeys(inner))
 
       if (inner instanceof z.ZodArray) {
         const item = unwrap(inner._def.type as ZodTypeAny)
-        return item instanceof z.ZodObject ? { [key]: extractZodKeys(item) } : key
+        return item instanceof z.ZodObject ? notEmpty(key, extractZodKeys(item)) : key
       }
 
       return key
@@ -25,12 +31,8 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
 
   if (schema instanceof z.ZodArray) {
     const item = unwrap(schema._def.type as ZodTypeAny)
-    if (item instanceof z.ZodObject) {
-      const r = extractZodKeys(item)
-      // @ts-ignore
-      r[m] = true
-      return r
-    }
+    if (item instanceof z.ZodObject)
+      return arraySchema(extractZodKeys(item))
 
     return []
   }
@@ -60,6 +62,10 @@ export function unwrap(schema: ZodTypeAny): ZodTypeAny {
   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