rajt 0.0.15 → 0.0.17

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
     ".": "./src/index.ts",
     "./dynamodb": "./src/dynamodb/index.ts",
+    "./dynamodb/types": "./src/dynamodb/types.ts",
     "./http": "./src/http.ts",
     "./types": "./src/types.ts"
   },
-  "files": [
-    "src"
-  ],
+  "files": ["src"],
   "scripts": {
     "dev": "tsx watch src/dev.ts",
     "local": "bun run --silent build && bun run --silent sam:local",
@@ -54,6 +53,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "author": "Zunq <open-source@zunq.com>",
+  "license": "MIT",
   "homepage": "https://zunq.dev",
   "repository": "git://github.com/attla/rajt",
   "bugs": "https://github.com/attla/rajt/issues",

package/src/dynamodb/client.ts

@@ -3,7 +3,11 @@ import dynamodbLite from '@aws-lite/dynamodb'
 import AbstractModel from './model'
 
 export const aws = await awsLite({
-  plugins: [dynamodbLite]
+  plugins: [dynamodbLite],
+  // https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-lib-dynamodb/#configuration
+  // @ts-ignore
+  awsjsonMarshall: {convertClassInstanceToMap: true},
+  awsjsonUnmarshall: {convertClassInstanceToMap: true}
 })
 
 export class Dynamodb {

package/src/dynamodb/compact.ts

@@ -0,0 +1,149 @@
+import type { SchemaStructure } from './types'
+import getLength from '../utils/lenght'
+
+export default class Compact {
+  private static typeMap: Record<string, string> = {
+    // Null
+    'null,': 'N,',
+    ',null': ',N',
+    'null]': 'N]',
+    // True
+    'true,': 'T,',
+    ',true': ',T',
+    'true]': 'T]',
+    // False
+    'false,': 'F,',
+    ',false': ',F',
+    'false]': 'F]',
+    // Array
+    '[],': 'A,',
+    ',[]': ',A',
+    '[]]': 'A]',
+    // Object
+    '{},': 'O,',
+    ',{}': ',O',
+    '{}]': 'O]'
+  }
+
+  static encode(obj: any, schema: SchemaStructure): string {
+    const seen: any[] = []
+    return this.replaceTypes(
+      JSON.stringify(this.zip(obj, schema, seen)).replace(/(,|\[)"(\^\d+)"(\]|,|$)/g, '$1$2$3')
+        .replace(/"/g, '~TDQ~')
+        .replace(/'/g, '"')
+        .replace(/~TDQ~/g, "'")
+        .replace(/\\'/g, "^'"),
+      this.typeMap
+    )
+  }
+
+  static smartDecode<T = any>(val: any, schema: SchemaStructure): T {
+    if (!val) return val as T
+
+    if (Array.isArray(val))
+      return val.map((i: { v: string }) => this.decode<T>(i?.V, schema)).filter(Boolean) as T
+
+    return val?.V ? this.decode<T>(val.V, schema) : val
+  }
+
+  static decode<T = any>(val: string, schema: SchemaStructure): T {
+    if (!val) return val as T
+
+    val = this.replaceTypes(val, this.reverseMap(this.typeMap))
+      .replace(/"/g, '~TSQ~')
+      .replace(/'/g, '"')
+      .replace(/~TSQ~/g, "'")
+      .replace(/\^"/g, '\\"')
+      .replace(/(,|\[)(\^\d+)(\]|,|$)/g, '$1"$2"$3')
+
+    return this.withSchema(this.unzip(JSON.parse(val)), schema) as T
+  }
+
+  static zip(obj: any, schema: SchemaStructure, seen: any[]): any[] {
+    return schema.map(key => {
+      if (typeof key === 'string')
+        return this.memo(obj[key], seen)
+
+      const mainKey = Object.keys(key)[0]
+      const subKeys = key[mainKey]
+      const val = obj[mainKey]
+
+      if (Array.isArray(val))
+        return val.map(item => this.zip(item, subKeys, seen))
+
+      return this.zip(val, subKeys, seen)
+    })
+  }
+
+  static unzip(array: any[], seen: any[] = [], deep = false): any[] {
+    return array.map(item => {
+      const length = getLength(item)
+
+      if ([null, true, false].includes(item) || typeof item !== 'object' && length < 2)
+        return item
+
+      if (Array.isArray(item))
+        return this.unzip(item, seen, true)
+
+      if (typeof item === 'string' && item.startsWith('^')) {
+        const pos = parseInt(item.slice(1), 10)
+        const val = seen[pos]
+        return deep || (val && !`${val}`.startsWith('^')) ? val : item
+      }
+
+      seen.push(item)
+      return item
+    })
+  }
+
+  static withSchema(value: any[], keys: any[]): any {
+    if (!value || !Array.isArray(value))
+      return value
+
+    return Object.fromEntries(
+      keys.map((key, index) => this.entry(key, value[index])).filter(Boolean)
+    )
+  }
+
+  static entry(key: any, value: any): any {
+    if (!key) return undefined
+
+    if (typeof key === 'string')
+      return [key, value]
+
+    const mainKey = Object.keys(key)[0]
+    const subKeys = key[mainKey]
+
+    if (Array.isArray(value)) {
+      if (value.length === 0)
+        return [mainKey, []]
+
+      return Array.isArray(value[0])
+        ? [mainKey, value.map(v => this.withSchema(v, subKeys))]
+        : [mainKey, this.withSchema(value, subKeys)]
+    }
+
+    return [mainKey, value]
+  }
+
+  static memo(val: any, seen: any[]): any {
+    const length = getLength(val)
+    // TODO: may be incompatible with empty objects or arrays
+    if (typeof val !== 'object' && length < 2) return val
+
+    const index = seen.indexOf(val)
+    if (index !== -1)
+      return `^${index}`
+
+    seen.push(val)
+    return val
+  }
+
+  static replaceTypes(str: string, map: Record<string, string>) {
+    return Object.entries(map).reduce((s, [from, to]) => s.replaceAll(from, to), str)
+  }
+
+  static reverseMap(map: Record<string, string>): Record<string, string> {
+    return Object.fromEntries(Object.entries(map).map(([k, v]) => [v, k]))
+  }
+}

package/src/dynamodb/decorators.ts

@@ -1,17 +1,5 @@
 import plur from 'plur'
-
-export type ModelMetadata = {
-  table: string,
-  keys?: Record<'PK' | 'SK', string>,
-  zip: boolean,
-}
-
-export type ModelOpts = string | {
-  table?: string,
-  partitionKey?: string,
-  sortKey?: string,
-  zip?: boolean,
-}
+import type { ModelMetadata, ModelOpts } from './types'
 
 export function getModelMetadata(target: Function | any): ModelMetadata {
   if (!target?.m)
@@ -22,6 +10,7 @@ export function getModelMetadata(target: Function | any): ModelMetadata {
     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,
+    defaultSK: target?.defaultSK || undefined,
     zip: target.m[2] || false,
     fields: target.m[3] || [],
   }
@@ -37,19 +26,19 @@ function _table(target: Function | any, opt?: ModelOpts) {
 function _zip(target: Function | any) {
   if (!target?.m) target.m = []
   target.m[2] = true
-  target.m[3] = Object.keys(new target)
+  target.m[3] = target?.schema || 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]
+  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)
+  if (!opt || !notStr || (typeof opt?.zip === undefined || opt?.zip))
     _zip(target)
 
   const pk = opt && notStr ? opt?.partitionKey : undefined

package/src/dynamodb/model.ts

@@ -1,14 +1,17 @@
 import type { AwsLiteDynamoDB } from '@aws-lite/dynamodb-types'
+import type { ModelMetadata, Keys, Model, Filter } from './types'
 import { getModelMetadata } from './decorators'
-import type { ModelMetadata } from './decorators'
 import QueryBuilder from './query-builder'
+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>
 
   constructor(
-    cls: (new (...args: any[]) => T) | ModelMetadata,
+    cls: Model<T> | ModelMetadata,
     private db: AwsLiteDynamoDB,
     private queryBuilder?: QueryBuilder,
     private model?: AbstractModel<T>
@@ -18,19 +21,19 @@ export default class AbstractModel<T extends object> {
       return
     }
 
-    // @ts-ignore
     const meta = getModelMetadata(cls)
     if (!meta)
       throw new Error('Missing model metadata')
 
     this.meta = meta
+    this.cls = cls as Model<T>
   }
 
   get table(): string {
     return this.meta.table
   }
 
-  get keys() {
+  get keySchema() {
     return this.meta.keys
   }
 
@@ -45,48 +48,57 @@ export default class AbstractModel<T extends object> {
     return this.lastKey
   }
 
-  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
-
-    return keys
-  }
-
   where(builderFn: (q: QueryBuilder) => void) {
     const qb = new QueryBuilder()
     builderFn(qb)
-    const model = new AbstractModel<T>(this.meta, this.db, qb, this)
-    return model
+    return new AbstractModel<T>(this.meta, this.db, qb, this)
   }
 
-  async scan(filterFn?: (item: T) => boolean) {
+  async scan(filterFn?: Filter<T>) {
     const result = await this.db.Scan({ TableName: this.table, ...this.queryBuilder?.filters })
+
     this.lastEvaluatedKey = result.LastEvaluatedKey
-    const items = result.Items as T[]
-    return filterFn ? items.filter(filterFn) : items
+    return this.processItems(result.Items, filterFn)
   }
 
-  async query(filterFn?: (item: T) => boolean) {
+  async query(filterFn?: Filter<T>) {
     const result = await this.db.Query({ TableName: this.table, ...this.queryBuilder?.conditions })
+
     this.lastEvaluatedKey = result.LastEvaluatedKey
-    const items = result.Items as T[]
-    return filterFn ? items.filter(filterFn) : items
+    return this.processItems(result.Items, filterFn)
   }
 
-  async get(pk: string, sk?: string) {
-    const result = await this.db.GetItem({ TableName: this.table, Key: this.schema(pk, sk) })
-    return result.Item as T
+  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
   }
 
-  async put(item: Partial<T>) {
+  async put(item: Partial<T>, key: Keys) {
+    let 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)}
+    } else {
+      this.validateKeys(item)
+    }
+
     await this.db.PutItem({ TableName: this.table, Item: item })
-    return item
+    return this.processItem(item, keys)
   }
 
-  async update(key: string | [string, string], attrs: Partial<T>) {
+  async update(attrs: Partial<T>, key: Keys) {
+    let 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)}
+    } else {
+      this.validateKeys(attrs)
+    }
+
     const UpdateExpressionParts: string[] = []
     const ExpressionAttributeValues: any = {}
     for (const [k, v] of Object.entries(attrs)) {
@@ -96,32 +108,34 @@ export default class AbstractModel<T extends object> {
     const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ')
     const ExpressionAttributeNames = Object.fromEntries(Object.keys(attrs).map(k => [`#${k}`, k]))
 
-    return this.db.UpdateItem({
+    await this.db.UpdateItem({
       TableName: this.table,
-      Key: Array.isArray(key) ? this.schema(key[0], key[1]) : this.schema(key),
+      Key: this.key(key),
       UpdateExpression,
       ExpressionAttributeValues,
       ExpressionAttributeNames
     })
+
+    return this.processItem(attrs, keys)
   }
 
-  async delete(pk: string, sk?: string) {
-    return this.db.DeleteItem({ TableName: this.table, Key: this.schema(pk, sk) })
+  async delete(key: Keys, sk?: string) {
+    return this.db.DeleteItem({ TableName: this.table, Key: this.key(key, sk) })
   }
 
-  async batchGet(keys: Array<{ pk: string, sk?: string }>) {
+  async batchGet(keys: Array<Keys>) {
     const result = await this.db.BatchGetItem({ RequestItems: {
-      [this.table]: { Keys: keys.map(({ pk, sk }) => this.schema(pk, sk)) }
+      [this.table]: { Keys: keys.map(key => this.key(key)) }
     } })
-    return result.Responses?.[this.table] as T[]
+    return (result.Responses?.[this.table] as T[] || []).map(item => this.processItem(item))
   }
 
-  async batchWrite(items: Array<{ put?: Partial<T>, delete?: { pk: string, sk?: string } }>) {
+  async batchWrite(items: Array<{ put?: Partial<T>, delete?: Keys }>) {
     const WriteRequests = items.map(i => {
       if (i.put) {
         return { PutRequest: { Item: i.put } }
       } else if (i.delete) {
-        return { DeleteRequest: { Key: this.schema(i.delete.pk, i.delete.sk) } }
+        return { DeleteRequest: { Key: this.key(i.delete) } }
       }
       return null
     }).filter(Boolean)
@@ -129,11 +143,121 @@ export default class AbstractModel<T extends object> {
     return this.db.BatchWriteItem({ RequestItems: {[this.table]: WriteRequests} })
   }
 
-  async deleteMany(keys: Array<{ pk: string, sk?: string }>) {
+  async deleteMany(keys: Array<Keys>) {
     return this.batchWrite(keys.map(k => ({ delete: k })))
   }
 
   async putMany(items: Array<Partial<T>>) {
-    return this.batchWrite(items.map(i => ({ put: i })))
+    return this.batchWrite(items.map(item => ({ put: item })))
+  }
+
+  private key(key: Keys, sk?: string) {
+    if (!this.meta.keys) return {}
+
+    let pk: string
+    let skValue: string | undefined
+    if (Array.isArray(key)) {
+      pk = key[0]
+      skValue = key[1] ?? sk
+    } else {
+      pk = key
+      skValue = sk
+    }
+
+    const keys = { [this.meta.keys.PK]: pk }
+
+    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
+      }
+    }
+
+    return keys
+  }
+
+  private 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)
+    else if (getLength(item) > 0)
+      this.processItemKeys(keys, item)
+
+    return keys
+  }
+
+  private processExplicitKey(keys: Record<string, string>, key: Keys): void {
+    if (!this.meta.keys) return
+    if (Array.isArray(key)) {
+      keys[this.meta.keys.PK] = key[0]
+
+      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 {
+      keys[this.meta.keys.PK] = String(key)
+    }
+  }
+
+  private 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>]
+    if (pkValue !== undefined)
+      keys[this.meta.keys.PK] = String(pkValue)
+
+    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
+    }
+  }
+
+  private 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))
+      throw new Error(`Missing partition key of table "${this.table}" `)
+
+    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 }
+
+    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[] {
+    if (!items) return []
+
+    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)
+
+      // @ts-ignore
+      return model.withKey(keys[this.meta.keys.PK], keys[this.meta.keys.SK] || undefined)
+    }
+
+    return new this.cls(item)
   }
 }

package/src/dynamodb/query-builder.ts

@@ -1,11 +1,4 @@
-type Operator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'begins_with' | 'between' | 'in' | 'attribute_exists' | 'attribute_not_exists' | 'attribute_type' | 'contains' | 'size'
-
-type Condition = {
-  type: 'filter' | 'keyCondition',
-  field: string,
-  operator: Operator,
-  value: any
-}
+import type { Condition, Operator } from './types'
 
 export default class QueryBuilder {
   private _conditions: Condition[] = []

package/src/dynamodb/schema.ts

@@ -1,21 +1,19 @@
 import { z, ZodTypeAny } from 'zod'
+import type { SchemaStructure } from './types'
 
-function extractZodKeys(schema: ZodTypeAny): any {
+function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   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) {
+      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 item instanceof z.ZodObject ? { [key]: extractZodKeys(item) } : key
       }
 
       return key
@@ -38,13 +36,29 @@ function unwrap(schema: ZodTypeAny): ZodTypeAny {
 export default function Schema<T extends ZodTypeAny>(schema: T) {
   return class {
     static _schema = schema
-
-    static getSchema() {
-      return extractZodKeys(schema)
-    }
+    static defaultSortKey?: string = undefined
+    #PK?: string = undefined
+    #SK?: string = undefined
 
     constructor(data: z.infer<T>) {
       Object.assign(this, data)
     }
+
+    get PK() { return this.#PK }
+    get SK() { return this.#SK }
+
+    static get schema() {
+      return extractZodKeys(this._schema)
+    }
+
+    static get defaultSK() {
+      return this.defaultSortKey
+    }
+
+    withKey(key: string, sk?: string) {
+      this.#PK = key
+      if (sk) this.#SK = sk
+      return this
+    }
   }
 }

package/src/dynamodb/types.ts

@@ -0,0 +1,32 @@
+export type Operator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'begins_with' | 'between' | 'in' | 'attribute_exists' | 'attribute_not_exists' | 'attribute_type' | 'contains' | 'size'
+
+export type Condition = {
+  type: 'filter' | 'keyCondition',
+  field: string,
+  operator: Operator,
+  value: any
+}
+
+export type ISchemaStructure = string | Record<string, ISchemaStructure[]>
+export type SchemaStructure = ISchemaStructure[]
+
+export type KeySchema = Record<'PK' | 'SK', string>
+export type ModelMetadata = {
+  table: string,
+  keys?: KeySchema,
+  defaultSK?: string,
+  zip: boolean,
+  fields: SchemaStructure,
+}
+
+export type ModelOpts = string | {
+  table?: string,
+  partitionKey?: string,
+  sortKey?: string,
+  defaultSK?: string,
+  zip?: boolean,
+}
+
+export type Keys = string | [string] | [string, string]
+export type Model<T extends object> = new (...args: any[]) => T
+export type Filter<T> = (item: T) => boolean

package/src/types.ts

@@ -25,13 +25,9 @@ export type LambdaResponse = {
 export type Errors = Record<string, string | string[]>
 export type ErrorResponse = {
   m?: string, // message
-  // c?: number, // http code
   e?: Errors, // error bag
-  // e?: Record<string, string | string[]>, // error bag
 }
 
-// export type Response<E> = E | ErrorResponse
-
 export type ResponseHeadersInit = [
     string,
     string

package/src/utils/lenght.ts

@@ -0,0 +1,32 @@
+export default function getLength(item: any): number {
+  const type = typeof item
+
+  switch (type) {
+    case 'string':
+      return item.length
+
+    case 'number':
+    case 'bigint':
+    // case 'function':
+      return item.toString().length
+
+    // case 'boolean':
+    //   return item ? 1 : 0
+
+    // case 'symbol':
+    //   return item.toString().length - 8
+
+    case 'object':
+      if (item === null)
+        return 0
+
+      if (Array.isArray(item))
+        return item.length
+
+      return Object.keys(item).length
+
+    case 'undefined':
+    default:
+      return 0
+  }
+}

package/src/utils/resolve.ts

@@ -1,5 +1,4 @@
 import Action, { ActionType } from '../action'
-// import BaseMiddleware, { MiddlewareType } from '../middleware'
 
 export default function resolve(obj: ActionType) {
   if (typeof obj === 'function' && obj?.length === 2)
@@ -17,40 +16,3 @@ export default function resolve(obj: ActionType) {
 
   throw new Error('Invalid action')
 }
-
-// export function resolveMiddleware(obj: MiddlewareType) {
-//   if (typeof obj === 'function' && obj.length === 2)
-//     return obj
-
-//   if (obj instanceof BaseMiddleware)
-//     return obj.handle
-
-//   if (BaseMiddleware.isPrototypeOf(obj)) {
-//     const instance = new (obj as new () => BaseMiddleware)()
-//     return instance.handle
-//   }
-
-//   throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
-// }
-
-// // import Action, { ActionType } from '../action'
-
-// export default function resolve(obj: any) {
-//   if (typeof obj === 'function' && obj?.length === 2)
-//     return [obj]
-
-//   // if (obj instanceof Action)
-//   //   return obj.run()
-
-//   // const instance = new (obj as new () => Action)()
-//   // @ts-ignore
-//   const instance = new obj()
-//   // if (Action.isPrototypeOf(obj))
-//   if (obj?.prototype?.run)
-//     return instance.run()
-
-//   if (obj?.prototype?.handle)
-//     return [instance.handle]
-
-//   throw new Error('Invalid action')
-// }