rajt 0.0.24 → 0.0.26

package/README.md

@@ -18,4 +18,4 @@
 
 ## License
 
-This package is licensed under the [MIT license](https://github.com/attla/rajt/blob/main/LICENSE) © [Zunq](https://zunq.com).
+This package is licensed under the [MIT license](https://github.com/attla/rajt/blob/main/LICENSE) © [Zunq](https://zunq.com)

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.24",
+  "version": "0.0.26",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -49,6 +49,12 @@
     "tsx": "^4.19.3",
     "typescript": "^5.8.3"
   },
+  "devDependencies": {
+    "bun-types": "^1.2.14"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "resolutions": {
     "@smithy/types": "^4.3.0"
   },

package/src/action.ts

@@ -101,7 +101,7 @@ export default abstract class Action {
 
   async body<E>() {
     const cType = this.context.req.header('Content-Type')
-    if (!cType) return {}
+    if (!cType) return {} as E
 
     if (/^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)) {
       return await this.json<E>()
@@ -114,7 +114,7 @@ export default abstract class Action {
         return await this.form() as E
     }
 
-    return {}
+    return {} as E
   }
 
   get response() {

package/src/dev.ts

@@ -17,7 +17,7 @@ const middlewares = await getMiddlewares()
 middlewares.forEach(mw => registerMiddleware(mw.handle))
 
 Ability.fromRoutes(routes)
-Ability.roles = jsonImport('../../../../.rolefile')
+Ability.roles = jsonImport('../../../../roles.json')
 
 const fetch = createApp({ routes }).fetch
 

package/src/dynamodb/model.ts

@@ -105,7 +105,7 @@ export default class AbstractModel<T extends object> {
       keys = this.#getItemKey(item, key)
       this.#validateKeys(keys)
       // @ts-ignore
-      item = { ...keys, V: Compact.encode(this.getItemWithoutKeys(item), this.meta.fields) }
+      item = { ...keys, V: Compact.encode(this.#getItemWithoutKeys(item), this.#meta.fields) }
     } else {
       this.#validateKeys(item)
     }
@@ -120,7 +120,7 @@ export default class AbstractModel<T extends object> {
       keys = this.#getItemKey(attrs, key)
       this.#validateKeys(keys)
       // @ts-ignore
-      attrs = { V: Compact.encode(this.getItemWithoutKeys(attrs), this.meta.fields) }
+      attrs = { V: Compact.encode(this.#getItemWithoutKeys(attrs), this.#meta.fields) }
     } else {
       this.#validateKeys(attrs)
     }
@@ -226,7 +226,7 @@ export default class AbstractModel<T extends object> {
       if (this.#meta.keys?.SK) {
         if (key.length > 1)
           // @ts-ignore
-          keys[this.meta.keys.SK] = key[1]
+          keys[this.#meta.keys.SK] = key[1]
         else if (this.#meta.defaultSK)
           keys[this.#meta.keys.SK] = this.#meta.defaultSK
       }
@@ -284,7 +284,7 @@ export default class AbstractModel<T extends object> {
       if (!keys) keys = this.#getItemKey(item)
 
       // @ts-ignore
-      return model.withKey(keys[this.meta.keys.PK], keys[this.meta.keys.SK] || undefined)
+      return model.withKey(keys[this.#meta.keys.PK], keys[this.#meta.keys.SK] || undefined)
     }
 
     return new this.#cls(item)

package/src/enum.ts

@@ -0,0 +1,75 @@
+type EnumType<T> = T extends string[]
+  ? { [K in T[number]]: K }
+  : T extends Record<string, string | number>
+  ? T
+  : never
+
+type EnumValue<T> = T extends string[]
+  ? T[number]
+  : T extends Record<string, infer V>
+    ? V
+    : never
+
+type EnumStatic<T> = {
+  has(search: string | number): boolean
+  key(search: string | number): string | null
+  value(search: string | number): EnumValue<T> | null
+  readonly keys: string[]
+  readonly values: Array<EnumValue<T>>
+  toObject(): EnumType<T>
+} & EnumType<T>
+
+export default function Enum<T extends string[] | Record<string, string | number>>(definition: T): EnumStatic<T> {
+  const enumObj = Array.isArray(definition)
+    ? Object.fromEntries(definition.map(key => [key, key])) as EnumType<T>
+    : definition as EnumType<T>
+
+  const keyToValueMap = new Map<string | number, string | number>()
+  const valueToKeyMap = new Map<string | number, string>()
+
+  Object.entries(enumObj).forEach(([key, value]) => {
+    keyToValueMap.set(key, value)
+    valueToKeyMap.set(String(value), key)
+    if (typeof value === 'number') valueToKeyMap.set(value.toString(), key)
+  })
+
+  const GeneratedEnum = class {
+    static has(search: string | number): boolean {
+      return keyToValueMap.has(search as string) || valueToKeyMap.has(String(search))
+    }
+
+    static key(search: string | number): string | null {
+      if (keyToValueMap.has(search as string))
+        return search as string
+
+      return valueToKeyMap.get(String(search)) || null
+    }
+
+    static value(search: string | number): EnumValue<T> | null {
+      if (keyToValueMap.has(search as string))
+        return keyToValueMap.get(search as string) as EnumValue<T>
+
+      return valueToKeyMap.has(String(search))
+        ? keyToValueMap.get(valueToKeyMap.get(String(search))!) as EnumValue<T>
+        : null
+    }
+
+    static get keys(): string[] {
+      return Object.keys(enumObj)
+    }
+
+    static get values(): Array<EnumValue<T>> {
+      return Object.values(enumObj) as Array<EnumValue<T>>
+    }
+
+    static toObject(): EnumType<T> {
+      return { ...enumObj }
+    }
+  }
+
+  Object.entries(enumObj).forEach(([key, value]) => {
+    (GeneratedEnum as any)[key] = value
+  })
+
+  return GeneratedEnum as unknown as EnumStatic<T>
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export { default as Action } from './action'
 export { default as Middleware } from './middleware'
 export { default as JsonResponse } from './response'
+export { default as Enum } from './enum'