rajt 0.0.17 → 0.0.19

package/src/dynamodb/model.ts

@@ -1,4 +1,14 @@
-import type { AwsLiteDynamoDB } from '@aws-lite/dynamodb-types'
+import {
+  DynamoDBDocumentClient,
+  BatchGetCommand,
+  BatchWriteCommand,
+  DeleteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  UpdateCommand,
+} from '@aws-sdk/lib-dynamodb'
 import type { ModelMetadata, Keys, Model, Filter } from './types'
 import { getModelMetadata } from './decorators'
 import QueryBuilder from './query-builder'
@@ -6,18 +16,25 @@ import Compact from './compact'
 import getLength from '../utils/lenght'
 
 export default class AbstractModel<T extends object> {
-  private meta: ModelMetadata
-  private cls!: Model<T>
-  private lastKey?: Record<string, any>
+  #meta: ModelMetadata
+  #cls!: Model<T>
+  lastKey?: Record<string, any>
+  #db: DynamoDBDocumentClient
+  #queryBuilder?: QueryBuilder
+  #model?: AbstractModel<T>
 
   constructor(
     cls: Model<T> | ModelMetadata,
-    private db: AwsLiteDynamoDB,
-    private queryBuilder?: QueryBuilder,
-    private model?: AbstractModel<T>
+    db: DynamoDBDocumentClient,
+    queryBuilder?: QueryBuilder,
+    model?: AbstractModel<T>
   ) {
+    this.#db = db
+    this.#queryBuilder = queryBuilder
+    this.#model = model
+
     if (typeof (cls as ModelMetadata).table === 'string') {
-      this.meta = cls as ModelMetadata
+      this.#meta = cls as ModelMetadata
       return
     }
 
@@ -25,21 +42,21 @@ export default class AbstractModel<T extends object> {
     if (!meta)
       throw new Error('Missing model metadata')
 
-    this.meta = meta
-    this.cls = cls as Model<T>
+    this.#meta = meta
+    this.#cls = cls as Model<T>
   }
 
   get table(): string {
-    return this.meta.table
+    return this.#meta.table
   }
 
   get keySchema() {
-    return this.meta.keys
+    return this.#meta.keys
   }
 
   set lastEvaluatedKey(val: Record<string, any> | undefined) {
-    if (this.model) {
-      this.model.lastKey = val
+    if (this.#model) {
+      this.#model.lastKey = val
     } else {
       this.lastKey = val
     }
@@ -51,52 +68,61 @@ export default class AbstractModel<T extends object> {
   where(builderFn: (q: QueryBuilder) => void) {
     const qb = new QueryBuilder()
     builderFn(qb)
-    return new AbstractModel<T>(this.meta, this.db, qb, this)
+    return new AbstractModel<T>(this.#meta, this.#db, qb, this)
   }
 
   async scan(filterFn?: Filter<T>) {
-    const result = await this.db.Scan({ TableName: this.table, ...this.queryBuilder?.filters })
+    const result = await this.#db.send(new ScanCommand({
+      TableName: this.table,
+      ...this.#queryBuilder?.filters,
+    }))
 
     this.lastEvaluatedKey = result.LastEvaluatedKey
-    return this.processItems(result.Items, filterFn)
+    return this.#processItems(result.Items, filterFn)
   }
 
   async query(filterFn?: Filter<T>) {
-    const result = await this.db.Query({ TableName: this.table, ...this.queryBuilder?.conditions })
+    const result = await this.#db.send(new QueryCommand({
+      TableName: this.table,
+      ...this.#queryBuilder?.conditions,
+    }))
 
     this.lastEvaluatedKey = result.LastEvaluatedKey
-    return this.processItems(result.Items, filterFn)
+    return this.#processItems(result.Items, filterFn)
   }
 
   async get(key: Keys, sk?: string) {
-    const result = await this.db.GetItem({ TableName: this.table, Key: this.key(key, sk) })
-    return result.Item ? this.processItem(result.Item) : undefined
+    const result = await this.#db.send(new GetCommand({
+      TableName: this.table,
+      Key: this.#key(key, sk),
+    }))
+    return result.Item ? this.#processItem(result.Item) : undefined
   }
 
   async put(item: Partial<T>, key: Keys) {
     let keys
-    if (this.meta.zip) {
-      keys = this.getItemKey(item, key)
-      this.validateKeys(keys)
+    if (this.#meta.zip) {
+      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)
+      this.#validateKeys(item)
     }
 
-    await this.db.PutItem({ TableName: this.table, Item: item })
-    return this.processItem(item, keys)
+    await this.#db.send(new PutCommand({ TableName: this.table, Item: item }))
+    return this.#processItem(item, keys)
   }
 
   async update(attrs: Partial<T>, key: Keys) {
     let keys
-    if (this.meta.zip) {
-      keys = this.getItemKey(attrs, key)
-      this.validateKeys(keys)
+    if (this.#meta.zip) {
+      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)
+      this.#validateKeys(attrs)
     }
 
     const UpdateExpressionParts: string[] = []
@@ -108,26 +134,29 @@ export default class AbstractModel<T extends object> {
     const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ')
     const ExpressionAttributeNames = Object.fromEntries(Object.keys(attrs).map(k => [`#${k}`, k]))
 
-    await this.db.UpdateItem({
+    await this.#db.send(new UpdateCommand({
       TableName: this.table,
-      Key: this.key(key),
+      Key: this.#key(key),
       UpdateExpression,
       ExpressionAttributeValues,
-      ExpressionAttributeNames
-    })
+      ExpressionAttributeNames,
+    }))
 
-    return this.processItem(attrs, keys)
+    return this.#processItem(attrs, keys)
   }
 
   async delete(key: Keys, sk?: string) {
-    return this.db.DeleteItem({ TableName: this.table, Key: this.key(key, sk) })
+    return this.#db.send(new DeleteCommand({
+      TableName: this.table,
+      Key: this.#key(key, sk),
+    }))
   }
 
   async batchGet(keys: Array<Keys>) {
-    const result = await this.db.BatchGetItem({ RequestItems: {
-      [this.table]: { Keys: keys.map(key => this.key(key)) }
-    } })
-    return (result.Responses?.[this.table] as T[] || []).map(item => this.processItem(item))
+    const result = await this.#db.send(new BatchGetCommand({
+      RequestItems: { [this.table]: { Keys: keys.map(key => this.#key(key)) } },
+    }))
+    return (result.Responses?.[this.table] as T[] || []).map(item => this.#processItem(item))
   }
 
   async batchWrite(items: Array<{ put?: Partial<T>, delete?: Keys }>) {
@@ -135,12 +164,12 @@ export default class AbstractModel<T extends object> {
       if (i.put) {
         return { PutRequest: { Item: i.put } }
       } else if (i.delete) {
-        return { DeleteRequest: { Key: this.key(i.delete) } }
+        return { DeleteRequest: { Key: this.#key(i.delete) } }
       }
       return null
-    }).filter(Boolean)
+    }).filter(Boolean) as any[]
 
-    return this.db.BatchWriteItem({ RequestItems: {[this.table]: WriteRequests} })
+    return this.#db.send(new BatchWriteCommand({ RequestItems: { [this.table]: WriteRequests } }))
   }
 
   async deleteMany(keys: Array<Keys>) {
@@ -151,8 +180,8 @@ export default class AbstractModel<T extends object> {
     return this.batchWrite(items.map(item => ({ put: item })))
   }
 
-  private key(key: Keys, sk?: string) {
-    if (!this.meta.keys) return {}
+  #key(key: Keys, sk?: string) {
+    if (!this.#meta.keys) return {}
 
     let pk: string
     let skValue: string | undefined
@@ -164,100 +193,100 @@ export default class AbstractModel<T extends object> {
       skValue = sk
     }
 
-    const keys = { [this.meta.keys.PK]: pk }
+    const keys = { [this.#meta.keys.PK]: pk }
 
-    if (this.meta.keys?.SK) {
+    if (this.#meta.keys?.SK) {
       if (skValue) {
-        keys[this.meta.keys.SK] = skValue
-      } else if (this.meta.defaultSK) {
-        keys[this.meta.keys.SK] = this.meta.defaultSK
+        keys[this.#meta.keys.SK] = skValue
+      } else if (this.#meta.defaultSK) {
+        keys[this.#meta.keys.SK] = this.#meta.defaultSK
       }
     }
 
     return keys
   }
 
-  private getItemKey(item: Partial<T>, key?: Keys): Record<string, string> {
-    if (!this.meta.keys) return {}
+  #getItemKey(item: Partial<T>, key?: Keys): Record<string, string> {
+    if (!this.#meta.keys) return {}
 
     const keys: Record<string, string> = {}
     if (key)
-      this.processExplicitKey(keys, key)
+      this.#processExplicitKey(keys, key)
     else if (getLength(item) > 0)
-      this.processItemKeys(keys, item)
+      this.#processItemKeys(keys, item)
 
     return keys
   }
 
-  private processExplicitKey(keys: Record<string, string>, key: Keys): void {
-    if (!this.meta.keys) return
+  #processExplicitKey(keys: Record<string, string>, key: Keys): void {
+    if (!this.#meta.keys) return
     if (Array.isArray(key)) {
-      keys[this.meta.keys.PK] = key[0]
+      keys[this.#meta.keys.PK] = key[0]
 
-      if (this.meta.keys?.SK) {
+      if (this.#meta.keys?.SK) {
         if (key.length > 1)
           // @ts-ignore
           keys[this.meta.keys.SK] = key[1]
-        else if (this.meta.defaultSK)
-          keys[this.meta.keys.SK] = this.meta.defaultSK
+        else if (this.#meta.defaultSK)
+          keys[this.#meta.keys.SK] = this.#meta.defaultSK
       }
     } else {
-      keys[this.meta.keys.PK] = String(key)
+      keys[this.#meta.keys.PK] = String(key)
     }
   }
 
-  private processItemKeys(keys: Record<string, string>, item: Partial<T>): void {
-    if (!this.meta.keys) return
+  #processItemKeys(keys: Record<string, string>, item: Partial<T>): void {
+    if (!this.#meta.keys) return
 
-    const pkValue = item[this.meta.keys.PK as keyof Partial<T>]
+    const pkValue = item[this.#meta.keys.PK as keyof Partial<T>]
     if (pkValue !== undefined)
-      keys[this.meta.keys.PK] = String(pkValue)
+      keys[this.#meta.keys.PK] = String(pkValue)
 
-    if (this.meta.keys?.SK) {
-      const skValue = item[this.meta.keys.SK as keyof Partial<T>]
+    if (this.#meta.keys?.SK) {
+      const skValue = item[this.#meta.keys.SK as keyof Partial<T>]
       if (skValue !== undefined)
-        keys[this.meta.keys.SK] = String(skValue)
-      else if (this.meta.defaultSK)
-        keys[this.meta.keys.SK] = this.meta.defaultSK
+        keys[this.#meta.keys.SK] = String(skValue)
+      else if (this.#meta.defaultSK)
+        keys[this.#meta.keys.SK] = this.#meta.defaultSK
     }
   }
 
-  private validateKeys(keys: Record<string, any>) {
-    if (!this.meta.keys)
+  #validateKeys(keys: Record<string, any>) {
+    if (!this.#meta.keys)
       throw new Error(`Missing keys of table "${this.table}"`)
 
-    if (!(this.meta.keys.PK in keys))
+    if (!(this.#meta.keys.PK in keys))
       throw new Error(`Missing partition key of table "${this.table}" `)
 
-    if (this.meta.keys?.SK && !(this.meta.keys.SK in keys))
+    if (this.#meta.keys?.SK && !(this.#meta.keys.SK in keys))
       throw new Error(`Missing sort key of table "${this.table}"`)
   }
 
-  private getItemWithoutKeys(item: Partial<T>): Partial<T> {
-    if (!this.meta.keys || !item) return { ...item }
+  #getItemWithoutKeys(item: Partial<T>): Partial<T> {
+    if (!this.#meta.keys || !item) return { ...item }
 
-    const { PK, SK } = this.meta.keys
+    const { PK, SK } = this.#meta.keys
     const { [PK as keyof T]: _, [SK as keyof T]: __, ...rest } = item
 
     return rest as Partial<T>
   }
 
-  private processItems(items: any[] | undefined, filterFn?: Filter<T>): T[] {
+  #processItems(items: any[] | undefined, filterFn?: Filter<T>): T[] {
     if (!items) return []
 
-    items = this.meta.zip ? Compact.smartDecode<T[]>(items, this.meta.fields) : items as T[]
+    items = this.#meta.zip ? Compact.smartDecode<T[]>(items, this.#meta.fields) : items as T[]
     return filterFn ? items.filter(filterFn) : items
   }
 
-  private processItem(item: any, keys?: Record<string, string>): T {
-    if (this.meta.zip && item?.V) {
-      const model = new this.cls(Compact.decode(item.V, this.meta.fields))
-      if (!keys) keys = this.getItemKey(item)
+  #processItem(item: any, keys?: Record<string, string>): T {
+    if (this.#meta.zip && item?.V) {
+      const model = new this.#cls(Compact.decode(item.V, this.#meta.fields))
+      if (!keys) keys = this.#getItemKey(item)
 
       // @ts-ignore
       return model.withKey(keys[this.meta.keys.PK], keys[this.meta.keys.SK] || undefined)
     }
 
-    return new this.cls(item)
+    return new this.#cls(item)
   }
 }

package/src/dynamodb/query-builder.ts

@@ -1,34 +1,34 @@
 import type { Condition, Operator } from './types'
 
 export default class QueryBuilder {
-  private _conditions: Condition[] = []
-  private _limit?: number
-  private _startKey?: Record<string, any>
-  private _index?: string
+  #conditions: Condition[] = []
+  #limit?: number
+  #startKey?: Record<string, any>
+  #index?: string
 
   filter(field: string, operator: Operator, value: any = null) {
-    this._conditions.push({ type: 'filter', field, operator, value })
+    this.#conditions.push({ type: 'filter', field, operator, value })
     return this
   }
 
   keyCondition(field: string, operator: Operator | any, value?: any) {
     const noVal = value === undefined
-    this._conditions.push({ type: 'keyCondition', field, operator: noVal ? '=' : operator, value: noVal ? operator : value })
+    this.#conditions.push({ type: 'keyCondition', field, operator: noVal ? '=' : operator, value: noVal ? operator : value })
     return this
   }
 
   limit(n: number) {
-    this._limit = n
+    this.#limit = n
     return this
   }
 
   exclusiveStartKey(key: Record<string, any>) {
-    this._startKey = key
+    this.#startKey = key
     return this
   }
 
   index(name: string) {
-    this._index = name
+    this.#index = name
     return this
   }
 
@@ -38,7 +38,7 @@ export default class QueryBuilder {
     const names: Record<string, string> = {}
 
     let i = 0
-    for (const cond of this._conditions.filter(c => c.type === type)) {
+    for (const cond of this.#conditions.filter(c => c.type === type)) {
       const attr = `#attr${i}`
       const val = `:val${i}`
       names[attr] = cond.field
@@ -107,11 +107,11 @@ export default class QueryBuilder {
     const filter = this.buildExpression('filter')
     const params: any = {}
 
-    if (this._limit)
-      params.Limit = this._limit
+    if (this.#limit)
+      params.Limit = this.#limit
 
-    if (this._startKey)
-      params.ExclusiveStartKey = this._startKey
+    if (this.#startKey)
+      params.ExclusiveStartKey = this.#startKey
 
     if (filter.expression)
       params.FilterExpression = filter.expression
@@ -131,8 +131,8 @@ export default class QueryBuilder {
 
     const params: any = { ...filters }
 
-    if (this._index)
-      params.IndexName = this._index
+    if (this.#index)
+      params.IndexName = this.#index
 
     if (keys.expression)
       params.KeyConditionExpression = keys.expression

package/src/http.ts

@@ -1,5 +1,9 @@
-import type { MiddlewareHandler } from 'hono'
-import BaseMiddleware, { MiddlewareType } from './middleware'
+import type { Context, Next } from 'hono'
+import { MiddlewareType } from './middleware'
+import JsonResponse from './response'
+import { Ability, Authnz, Token } from './auth'
+import { registerGlobalMiddleware } from './register'
+import mergeMiddleware from './utils/merge-middleware'
 
 function method(method: string, path = '/') {
   return function (target: any) {
@@ -31,27 +35,50 @@ export function Delete(path = '/') {
 
 export function Middleware(...handlers: MiddlewareType[]) {
   return function (target: any) {
-    const middlewareHandlers = handlers.map(handler => {
-      if (typeof handler === 'function' && handler.length === 2)
-        return handler
+    mergeMiddleware(target, ...handlers)
+  }
+}
+export function Middlewares(...handlers: MiddlewareType[]) {
+  return Middleware(...handlers)
+}
+
+type MiddlewareOpt = string | RegExp
+export function GlobalMiddleware(): ClassDecorator
+export function GlobalMiddleware(target: Function): void
+export function GlobalMiddleware(opt?: MiddlewareOpt): ClassDecorator
+export function GlobalMiddleware(...args: any[]): void | ClassDecorator {
+  if (typeof args[0] === 'function')
+    return _globalmw(args[0])
+
+  return (target: any) => _globalmw(target, ...args)
+}
+
+export function Auth(target: Function): void
+export function Auth(): ClassDecorator
+export function Auth(...args: any[]): void | ClassDecorator {
+  if (args.length === 1 && typeof args[0] === 'function')
+    return _auth(args[0])
 
-      if (handler instanceof BaseMiddleware)
-        return handler.handle
+  return (target: any) => _auth(target)
+}
 
-      if (BaseMiddleware.isPrototypeOf(handler)) {
-        const instance = new (handler as new () => BaseMiddleware)()
-        return instance.handle
-      }
+function _auth(target: Function | any) {
+  mergeMiddleware(target, async (c: Context, next: Next) => {
+    const unauthorized = JsonResponse.unauthorized()
 
-      throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
-    })
+    const auth = Authnz.fromToken(Token.fromRequest(c))
+    const ability = Ability.fromAction(target)
 
-    const existingMiddlewares: MiddlewareHandler[] = target?.mw || []
-    const allMiddlewares = [...existingMiddlewares, ...middlewareHandlers]
+    if (!auth || !ability || auth.cant(ability))
+      return unauthorized
 
-    target.mw = allMiddlewares
-  }
+    c.set('#auth', auth)
+    await next()
+  })
 }
-export function Middlewares(...handlers: MiddlewareType[]) {
-  return Middleware(...handlers)
+
+function _globalmw(target: Function | any, path?: string) {
+  target.gmw = true
+  target.p = path
+  registerGlobalMiddleware(target)
 }

package/src/middleware.ts

@@ -5,7 +5,7 @@ export type IMiddleware = {
 }
 
 export default abstract class Middleware implements IMiddleware {
-  public abstract handle(c: Context, next: Next): Promise<void> | void
+  abstract handle(c: Context, next: Next): Promise<void> | void
 }
 
 // export type MiddlewareHandler = (c: Context, next: Next) => Promise<void> | void

package/src/prod.ts

@@ -1,14 +1,18 @@
-import { config } from 'dotenv'
 import { handle } from 'hono/aws-lambda'
 import createApp from './create-app'
-
-config({ path: '../../.env.prod' })
+import { Ability } from './auth'
 
 // @ts-ignore
 await import('../../../tmp/import-routes.mjs')
 
 // @ts-ignore
 const routes = (await import('../../../tmp/routes.json')).default
+
+// @ts-ignore
+Ability.roles = (await import('../../../roles.json')).default
+// @ts-ignore
+Ability.fromRoutes(routes)
+
 // @ts-ignore
 const app = createApp({ routes })
 

package/src/register.ts

@@ -23,3 +23,9 @@ export function getHandler(id: string): Function {
   if (!handler) throw new Error(`Handler ${id} not registered`)
   return handler
 }
+
+export const _mw: Function[] = []
+export const getGlobalMiddlewares = () => _mw
+export function registerGlobalMiddleware(handler: any) {
+  _mw.push(handler)
+}

package/src/response.ts

@@ -25,19 +25,19 @@ class NullContext {
 }
 
 export default class JsonResponse {
-  private static _c?: Context
+  static #c?: Context
 
   static setContext(c: Context) {
-    this._c = c
+    this.#c = c
     return this
   }
 
-  private static context(): Context | NullContext {
-    return this._c ?? new NullContext()
+  static #context(): Context | NullContext {
+    return this.#c ?? new NullContext()
   }
 
   static raw(status?: StatusCode, body?: string) {
-    return this.context().newResponse(body ? body : null, { status })
+    return this.#context().newResponse(body ? body : null, { status })
   }
 
   static ok(): Response
@@ -46,7 +46,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(200)
 
-    return this.context().json(data, 200)
+    return this.#context().json(data, 200)
   }
 
   static created(): Response
@@ -55,7 +55,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(201)
 
-    return this.context().json(data, 201)
+    return this.#context().json(data, 201)
   }
 
   static accepted(): Response
@@ -64,7 +64,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(202)
 
-    return this.context().json(data, 202)
+    return this.#context().json(data, 202)
   }
 
   static deleted(): Response
@@ -88,7 +88,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(401)
 
-    return this.context().json(data, 401)
+    return this.#context().json(data, 401)
   }
 
   static forbidden(): Response
@@ -97,7 +97,7 @@ export default class JsonResponse {
     if (data === undefined)
       return this.raw(403)
 
-    return this.context().json(data, 403)
+    return this.#context().json(data, 403)
   }
 
   static notFound(): Response
@@ -122,7 +122,7 @@ export default class JsonResponse {
   }
 
   static error(errors?: Errors, msg?: string, status?: ContentfulStatusCode) {
-    const context = this.context()
+    const context = this.#context()
     status ??= 500
 
     if (!errors && !msg)