rajt 0.0.13 → 0.0.15

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.13",
+  "version": "0.0.15",
   "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,137 @@
-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 {
+  if (!target?.m)
+    throw Error(`Entity "${target?.name}" not registred, Use @Entity or @Model.`)
+
+  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]
+}
+
+function _model(target: any, opt?: ModelOpts) {
+  _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')
+}
+
+function _pk(target: any, prop: string) {
+  if (!target?.m) target.m = []
+  if (['string', 'undefined'].includes(typeof target.m[1])) {
+    target.m[1] = prop
+  } else {
+    target.m[1][0] = prop
   }
 }
 
-export function PartitionKey(attrName?: string) {
-  return function (target: any, propertyKey: string) {
-    registerKeyMetadata(target.constructor, 'PK', attrName || propertyKey)
+function _sk(target: any, prop: string) {
+  if (!target?.m) target.m = []
+  if (['string', 'undefined'].includes(typeof target.m[1])) {
+    target.m[1] = []
+    target.m[1][1] = prop
+  } else {
+    target.m[1][0] = prop
   }
 }
 
-export function SortKey(attrName?: string) {
-  return function (target: any, propertyKey: string) {
-    registerKeyMetadata(target.constructor, 'SK', attrName || propertyKey)
+export function Entity(target: Function): void
+export function Entity(opt?: ModelOpts): ClassDecorator
+export function Entity(...args: any[]): void | ClassDecorator {
+  if (args.length === 1 && typeof args[0] === 'function')
+    return _table(args[0])
+
+  return (target: any) => _table(target, ...args)
+}
+
+export function Model(target: Function): void
+export function Model(opt?: ModelOpts): ClassDecorator
+export function Model(...args: any[]): void | ClassDecorator {
+  if (args.length === 1 && typeof args[0] === 'function')
+    return _model(args[0])
+
+  return (target: any) => _model(target, ...args)
+}
+
+export function Zip(target: Function): void
+export function Zip(): ClassDecorator
+export function Zip(...args: any[]): void | ClassDecorator {
+  if (args.length === 1 && typeof args[0] === 'function')
+    return _zip(args[0])
+
+  return (target: any) => _zip(target)
+}
+
+export function Key(pk: string, sk?: string) {
+  return (target: any) => {
+    _key(target, pk, sk)
   }
 }
+export const Keys = Key
+
+export function PartitionKey(attrName: string): PropertyDecorator
+export function PartitionKey(target: any, propertyKey: string): void
+export function PartitionKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
+export function PartitionKey(...args: any[]): void | PropertyDecorator {
+  if (!args.length) return
+
+  if (typeof args[0] === 'function' && typeof args[1] === 'string' && args[1])
+    return _pk(args[0], args[1])
+
+  if (args.length === 1 && args[0])
+    return (target: any) => _pk(target, args[0])
+}
+
+export function SortKey(attrName: string): PropertyDecorator
+export function SortKey(target: any, propertyKey: string): void
+export function SortKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
+export function SortKey(...args: any[]): void | PropertyDecorator {
+  if (!args.length) return
+
+  if (typeof args[0] === 'function' && typeof args[1] === 'string' && args[1])
+    return _sk(args[0], args[1])
+
+  if (args.length === 1 && args[0])
+    return (target: any) => _sk(target, args[0])
+}

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)
-}