rajt 0.0.42 → 0.0.44

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.42",
+  "version": "0.0.44",
   "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
@@ -13,19 +14,22 @@ export default class Compact {
     'null': 'N',
     // Array
     '[]': 'A',
-    // Object
-    '{}': 'O',
-    // Commons
     '["0"]': 'A0',
     '["1"]': 'A1',
-    '["true"]': 'A2',
-    '["false"]': 'A3',
-    '"true"': 'T1',
-    '"false"': 'T0',
+    '["false"]': 'A2',
+    '["true"]': 'A3',
+    // Object
+    '{}': 'O',
+    // String
+    '""': 'S',
+    '"0"': 'S0',
+    '"1"': 'S1',
+    '"false"': 'S2',
+    '"true"': 'S3',
   }
 
   static {
-    this.#reverseTypeMap = Object.fromEntries(Object.entries(this.#typeMap).map(([k, v]) => [v, k]))
+    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))
   }
@@ -46,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
   }
@@ -65,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 => {
@@ -82,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)
@@ -108,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/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
 }