rajt 0.0.43 → 0.0.45

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

package/src/dynamodb/compact.ts

@@ -1,5 +1,6 @@
 import type { SchemaStructure } from './types'
 import getLength from '../utils/lenght'
+import { isArraySchema } from './schema'
 
 export default class Compact {
   static #typeRegex: RegExp
@@ -49,7 +50,7 @@ export default class Compact {
     if (!val) return val as T
 
     if (Array.isArray(val))
-      return val.map((i: { v: string }) => this.decode<T>(i?.V, schema)).filter(Boolean) as T
+      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
   }
@@ -68,6 +69,9 @@ export default class Compact {
   }
 
   static zip(obj: any, schema: SchemaStructure, seen: any[]): any[] {
+    if (Array.isArray(obj))
+      return obj?.length ? obj.map(item => this.zip(item, schema, seen)) : []
+
     if (!obj || [null, true, false].includes(obj)) return obj
 
     return schema.map(key => {
@@ -85,16 +89,16 @@ export default class Compact {
     })
   }
 
-  static unzip(val: any, seen: any[] = [], deep = false): any[] {
+  static unzip(val: any, seen: any[] = []): any[] {
+    if (Array.isArray(val))
+      return val?.length ? val.map(item => this.unzip(item, seen)) : []
+
     const type = typeof val
     const length = getLength(val, type)
 
     if ([null, true, false].includes(val) || type != 'object' && length < 2)
       return val
 
-    if (Array.isArray(val))
-      return val.map(item => this.unzip(item, seen, deep))
-
     if (type == 'object') {
       for (const key in val)
         val[key] = this.unzip(val[key], seen)
@@ -111,10 +115,13 @@ export default class Compact {
     return val
   }
 
-  static withSchema(value: any[], keys: any[]): any {
+  static withSchema(value: any[], keys: any[], deep = false): any {
     if (!value || !Array.isArray(value))
       return value
 
+    if (!deep && isArraySchema(keys))
+      return value?.length ? value.map(v => this.withSchema(v, keys, true)) : []
+
     return Object.fromEntries(
       keys.map((key, index) => this.entry(key, value[index])).filter(Boolean)
     )

package/src/dynamodb/model.ts

@@ -13,6 +13,7 @@ import type { ModelMetadata, Keys, Model, Filter } from './types'
 import { getModelMetadata } from './decorators'
 import QueryBuilder from './query-builder'
 import Compact from './compact'
+import { isArraySchema } from './schema'
 import getLength from '../utils/lenght'
 
 export default class AbstractModel<T extends object> {
@@ -280,13 +281,23 @@ export default class AbstractModel<T extends object> {
 
   #processItem(item: any, keys?: Record<string, string>): T {
     if (this.#meta.zip && item?.V) {
-      const model = new this.cls!(Compact.decode<T>(item.V, this.#meta.fields))
+      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)
 
-      // @ts-ignore
-      return model.withKey(keys[this.#meta.keys.PK], keys[this.#meta.keys.SK] || undefined)
+      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))
+    // @ts-ignore
+    return model.withKey(keys[this.#meta.keys.PK], keys[this.#meta.keys.SK] || undefined)
+  }
 }

package/src/dynamodb/schema.ts

@@ -1,7 +1,12 @@
 import { z, ZodTypeAny } from 'zod'
 import type { SchemaStructure } from './types'
 
-function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
+const m = Symbol('a')
+export function isArraySchema(v: any) : boolean {
+  return v[m] || false
+}
+
+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)
@@ -18,15 +23,39 @@ 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
+    }
+
+    return []
+  }
+
   return []
 }
 
-function unwrap(schema: ZodTypeAny): ZodTypeAny {
+export function unwrap(schema: ZodTypeAny): ZodTypeAny {
   if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable)
     return unwrap(schema._def.innerType)
 
-  if (schema instanceof z.ZodUnion)
-    return unwrap(schema._def.options[0] as ZodTypeAny)
+  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
 }