rajt 0.0.22 → 0.0.23

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

package/src/dynamodb/decorators.ts

@@ -34,7 +34,7 @@ function _key(target: Function | any, pk: string, sk?: string) {
   target.m[1] = pk && sk ? [pk, sk] : [pk]
 }
 
-function _model(target: any, opt?: ModelOpts) {
+export function _model(target: any, opt?: ModelOpts) {
   _table(target, opt)
   const notStr = typeof opt !== 'string'
 

package/src/dynamodb/index.ts

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

package/src/dynamodb/repository.ts

@@ -0,0 +1,21 @@
+import { ZodTypeAny } from 'zod'
+import { Dynamodb } from './client'
+import { Schema } from './schema'
+import { _model } from './decorators'
+import type { ModelOpts } from './types'
+
+export function Repository<M extends object, S extends ZodTypeAny>(
+  schema: S,
+  model: new (...args: any[]) => M,
+  opts?: ModelOpts
+) {
+  const BaseSchemaClass = Schema(schema, model)
+  _model(BaseSchemaClass, opts)
+
+  return class extends BaseSchemaClass {
+    static model = Dynamodb.model<M>(BaseSchemaClass as unknown as new (...args: any[]) => M)
+  } as unknown as (typeof BaseSchemaClass) & {
+    model: ReturnType<typeof Dynamodb.model<M>>
+    new (...args: any[]): InstanceType<typeof BaseSchemaClass>
+  }
+}

package/src/dynamodb/schema.ts

@@ -3,9 +3,7 @@ import type { SchemaStructure } from './types'
 
 function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   if (schema instanceof z.ZodObject) {
-    const shape = schema.shape
-
-    return Object.entries(shape).map(([key, value]) => {
+    return Object.entries(schema.shape).map(([key, value]) => {
       const inner = unwrap(value as ZodTypeAny)
 
       if (inner instanceof z.ZodObject)
@@ -33,14 +31,24 @@ function unwrap(schema: ZodTypeAny): ZodTypeAny {
   return schema
 }
 
-export default function Schema<T extends ZodTypeAny>(schema: T) {
-  return class {
+export function Schema<
+  T extends ZodTypeAny,
+  B extends object
+>(
+  schema: T,
+  BaseClass?: new (...args: any[]) => B
+) {
+  const Base = (BaseClass || class {})
+
+  return class extends Base {
     static _schema = schema
-    static defaultSortKey?: string = undefined
-    #PK?: string = undefined
-    #SK?: string = undefined
+    static defaultSortKey?: string
+
+    #PK?: string
+    #SK?: string
 
     constructor(data: z.infer<T>) {
+      super()
       Object.assign(this, data)
     }