rajt 0.0.12 → 0.0.14

package/README.md

@@ -7,7 +7,7 @@
 - ⚡️ Fast Cold Start
 - 📦 Optimized Build
 
-[Read the Docs to Learn More](https://github.com/attla/rajt/blob/main/DOCS.md).
+[Read the Docs to Learn More](https://github.com/attla/rajt/blob/main/DOCS.md)
 
 ## Packages
 

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.12",
+  "version": "0.0.14",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -45,6 +45,7 @@
     "dotenv": "^16.5.0",
     "esbuild": "^0.25.2",
     "hono": "^4.7.6",
+    "plur": "^5.1.0",
     "tsconfig-paths": "^4.2.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.3"

package/src/dynamodb/decorators.ts

@@ -1,20 +1,97 @@
-import { registerModelMetadata, registerKeyMetadata } from './metadata-registry'
+import plur from 'plur'
 
-export function Model(opt: string | { table: string }) {
-  return function (target: Function) {
-    const table = typeof opt === 'string' ? opt : opt.table
-    registerModelMetadata(target, { table })
+export type ModelMetadata = {
+  table: string,
+  keys?: Record<'PK' | 'SK', string>,
+  zip: boolean,
+}
+
+export type ModelOpts = string | {
+  table?: string,
+  partitionKey?: string,
+  sortKey?: string,
+  zip?: boolean,
+}
+
+export function getModelMetadata(target: Function | any): ModelMetadata {
+  const typeKeys = typeof target.m[1]
+  return {
+    table: target.m[0],
+    // @ts-ignore
+    keys: typeKeys !== 'undefined' ? (typeKeys === 'string' ? { PK: target.m[1] } : { PK: target.m[1][0], SK: target.m[1][1] }) : undefined,
+    zip: target.m[2] || false,
+    fields: target.m[3] || [],
+  }
+}
+
+function _table(target: Function | any, opt?: ModelOpts) {
+  if (!target?.m) target.m = []
+  const table = opt ? (typeof opt === 'string' ? opt : opt?.table) : undefined
+
+  target.m[0] = table || plur(target.name.toLocaleUpperCase())
+}
+
+function _zip(target: Function | any) {
+  if (!target?.m) target.m = []
+  target.m[2] = true
+  target.m[3] = Object.keys(new target)
+}
+
+function _key(target: Function | any, pk: string, sk?: string) {
+  if (!target?.m) target.m = []
+  target.m[1] = pk && sk? [pk, sk] : [pk]
+}
+
+export function Entity(opt?: ModelOpts) {
+  return (target: any) => _table(target, opt)
+}
+
+export function Model(opt?: ModelOpts) {
+  return (target: any) => {
+    _table(target, opt)
+    const notStr = typeof opt !== 'string'
+
+    if (!opt || notStr && opt?.zip)
+      _zip(target)
+
+    const pk = opt && notStr ? opt?.partitionKey : undefined
+    const sk = opt && notStr ? opt?.sortKey : undefined
+    _key(target, pk || 'PK', sk || 'SK')
   }
 }
 
+export function Zip() {
+  return (target: any) => _zip(target)
+}
+
+export function Key(pk: string, sk?: string) {
+  return (target: any) => {
+    _key(target, pk, sk)
+  }
+}
+export function Keys(pk: string, sk?: string) {
+  return Key(pk, sk)
+}
+
 export function PartitionKey(attrName?: string) {
-  return function (target: any, propertyKey: string) {
-    registerKeyMetadata(target.constructor, 'PK', attrName || propertyKey)
+  return (target: any, prop: string) => {
+    if (!target?.m) target.m = []
+    if (['string', 'undefined'].includes(typeof target.m[1])) {
+      target.m[1] = attrName || prop
+    } else {
+      target.m[1][0] = attrName || prop
+    }
   }
 }
 
 export function SortKey(attrName?: string) {
-  return function (target: any, propertyKey: string) {
-    registerKeyMetadata(target.constructor, 'SK', attrName || propertyKey)
+  return (target: any, prop: string) => {
+    if (!target?.m) target.m = []
+    if (['string', 'undefined'].includes(typeof target.m[1])) {
+      target.m[1] = []
+      target.m[1][1] = attrName || prop
+    } else {
+      target.m[1][0] = attrName || prop
+    }
   }
 }

package/src/dynamodb/index.ts

@@ -1,2 +1,3 @@
 export { Dynamodb } from './client'
-export { Model, PartitionKey, SortKey } from './decorators'
+export { Model, Entity, Zip, PartitionKey, SortKey, Key, Keys } from './decorators'
+export { default as Schema } from './schema'

package/src/dynamodb/model.ts

@@ -1,6 +1,6 @@
 import type { AwsLiteDynamoDB } from '@aws-lite/dynamodb-types'
-import { getModelMetadata } from './metadata-registry'
-import type { ModelMetadata } from './metadata-registry'
+import { getModelMetadata } from './decorators'
+import type { ModelMetadata } from './decorators'
 import QueryBuilder from './query-builder'
 
 export default class AbstractModel<T extends object> {
@@ -46,6 +46,8 @@ export default class AbstractModel<T extends object> {
   }
 
   schema(pk: string, sk?: string) {
+    if (!this.meta.keys) return {}
+
     const keys = { [this.meta.keys.PK]: pk }
     if (sk && this.meta.keys.SK)
       keys[this.meta.keys.SK] = sk

package/src/dynamodb/schema.ts

@@ -0,0 +1,50 @@
+import { z, ZodTypeAny } from 'zod'
+
+function extractZodKeys(schema: ZodTypeAny): any {
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape
+    return Object.entries(shape).map(([key, value]) => {
+      const inner = unwrap(value as ZodTypeAny)
+
+      if (inner instanceof z.ZodObject) {
+        return { [key]: extractZodKeys(inner) }
+      }
+
+      if (inner instanceof z.ZodArray) {
+        const item = unwrap(inner._def.type as ZodTypeAny)
+        if (item instanceof z.ZodObject)
+          return { [key]: extractZodKeys(item) }
+
+        return key
+      }
+
+      return key
+    })
+  }
+
+  return []
+}
+
+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)
+
+  return schema
+}
+
+export default function Schema<T extends ZodTypeAny>(schema: T) {
+  return class {
+    static _schema = schema
+
+    static getSchema() {
+      return extractZodKeys(schema)
+    }
+
+    constructor(data: z.infer<T>) {
+      Object.assign(this, data)
+    }
+  }
+}

package/src/dynamodb/metadata-registry.ts

@@ -1,28 +0,0 @@
-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)
-}