chore(pockethost): remove action/filter typings

packages/plugin-console-logger/src/index.ts

@@ -1,6 +1,5 @@
 import {
   LogLevelName,
-  PocketHostAction,
   PocketHostPlugin,
   isLevelGte,
   isLevelLte,
@@ -18,35 +17,38 @@ export const LogLevelConsoleMap = {
 } as const
 
 const plugin: PocketHostPlugin = async ({ registerAction }) => {
-  registerAction(PocketHostAction.Log, (currentLevel, levelIn, args) => {
+  registerAction(
-    if (!isLevelGte(levelIn, currentLevel)) return
+    `log`,
-    const finalArgs = [args.shift()]
+    async (currentLevel: LogLevelName, levelIn: LogLevelName, args: any[]) => {
-    while (args.length > 0) {
+      if (!isLevelGte(levelIn, currentLevel)) return
-      let arg = args.shift()
+      const finalArgs = [args.shift()]
-      const t = typeof arg
+      while (args.length > 0) {
-      if (arg instanceof Error) {
+        let arg = args.shift()
-        finalArgs.push(...[arg.name, arg.message.toString()])
+        const t = typeof arg
-        if (isLevelLte(levelIn, LogLevelName.Debug) && arg.stack) {
+        if (arg instanceof Error) {
-          finalArgs.push(...arg.stack.split(/\n/))
+          finalArgs.push(...[arg.name, arg.message.toString()])
+          if (isLevelLte(levelIn, LogLevelName.Debug) && arg.stack) {
+            finalArgs.push(...arg.stack.split(/\n/))
+          }
+          continue
         }
-        continue
+        if (t === 'string' && !!arg.match(/\n/)) {
+          finalArgs.push(...arg.split(/\n/))
+          continue
+        }
+        if (t === 'object') {
+          finalArgs.push(...stringify(arg, undefined, 2).split(/\n/))
+          continue
+        }
+        if (t === 'function') {
+          finalArgs.push(`<<function ${stringify(arg.toString())}>>`)
+          continue
+        }
+        finalArgs.push(arg)
       }
-      if (t === 'string' && !!arg.match(/\n/)) {
+      LogLevelConsoleMap[levelIn](...finalArgs)
-        finalArgs.push(...arg.split(/\n/))
+    },
-        continue
+  )
-      }
-      if (t === 'object') {
-        finalArgs.push(...stringify(arg, undefined, 2).split(/\n/))
-        continue
-      }
-      if (t === 'function') {
-        finalArgs.push(`<<function ${stringify(arg.toString())}>>`)
-        continue
-      }
-      finalArgs.push(arg)
-    }
-    LogLevelConsoleMap[levelIn](...finalArgs)
-  })
 }
 
 export default plugin

packages/pockethost/src/common/Logger.ts

@@ -2,7 +2,7 @@
 
 import chalk from 'chalk'
 import stringify from 'json-stringify-safe'
-import { PocketHostAction, action, mergeConfig, mkSingleton } from '.'
+import { action, mergeConfig, mkSingleton } from '.'
 
 export type LoggerConfig = {
   level: LogLevelName
@@ -74,7 +74,7 @@ export const createLogger = (config: Partial<LoggerConfig>) => {
       .join(' ')
 
   const _log = (levelIn: LogLevelName, ...args: any[]) => {
-    action(PocketHostAction.Log, _config.level, levelIn, args)
+    action(`log`, _config.level, levelIn, args)
   }
 
   const raw = (...args: any[]) => {

packages/pockethost/src/common/plugin.ts

@@ -1,107 +1,49 @@
 import { isString } from '@s-libs/micro-dash'
-import { Request } from 'express'
-import { InstanceFields, LogLevelName } from '.'
 
-export enum PocketHostAction {
+export type PocketHostAction = string
-  Request = 'request',
-  BeforeDaemonStart = 'before_daemon_start',
-  Log = 'log',
-  InstanceApiTimeout = 'instance_api_timeout',
-  UpdateInstance = 'update_instance',
-}
 
-export enum PocketHostFilter {
+export type PocketHostFilter = string
-  ExtraBinds = 'extra_binds',
-}
 
 export type PocketHostPlugin = (api: PocketHostPluginApi) => Promise<void>
 
-const filters: { [key in PocketHostFilter]: FilterHandler[] } = {
+const filters: { [key in PocketHostFilter]: FilterHandler[] } = {}
-  [PocketHostFilter.ExtraBinds]: [],
-}
 
 const actions: {
   [key in PocketHostAction]: ActionHandler[]
-} = {
+} = {}
-  [PocketHostAction.Request]: [],
-  [PocketHostAction.BeforeDaemonStart]: [],
-  [PocketHostAction.Log]: [],
-  [PocketHostAction.InstanceApiTimeout]: [],
-  [PocketHostAction.UpdateInstance]: [],
-}
 
 export type FilterHandler = (carry: any) => any
 export type ActionHandler = (...args: any[]) => void
 
 export async function registerFilter(
-  filter: PocketHostFilter.ExtraBinds,
+  filter: PocketHostFilter,
-  handler: (carry: string[]) => string[],
+  handler: (carry: any) => any,
 ) {
-  filters[filter].push(handler)
+  if (!(filter in filters)) filters[filter] = []
+  filters[filter]!.push(handler)
 }
 
-export async function registerAction(
-  action: PocketHostAction.BeforeDaemonStart,
-  handler: (req: Request) => void,
-): Promise<void>
-export async function registerAction(
-  action: PocketHostAction.Request,
-  handler: (req: Request) => void,
-): Promise<void>
-export async function registerAction(
-  action: PocketHostAction.Log,
-  handler: (
-    currentLevel: LogLevelName,
-    level: LogLevelName,
-    args: any[],
-  ) => void,
-): Promise<void>
-export async function registerAction(
-  action: PocketHostAction.InstanceApiTimeout,
-  handler: (instance: InstanceFields) => void,
-): Promise<void>
-export async function registerAction(
-  action: PocketHostAction.UpdateInstance,
-  handler: (id: string, fields: InstanceFields) => void,
-): Promise<void>
 export async function registerAction(
   action: PocketHostAction,
-  handler: ActionHandler,
+  handler: (...args: any[]) => Promise<void>,
-): Promise<void> {
-  actions[action].push(handler)
-}
-
-export async function filter(
-  filter: PocketHostFilter.ExtraBinds,
-  initial: string[],
 ) {
-  return filters[filter].reduce((carry, handler) => handler(carry), initial)
+  if (!(action in actions)) actions[action] = []
+  actions[action]!.push(handler)
 }
 
-export async function action(
+export async function filter<T>(filterName: PocketHostFilter, initialValue: T) {
-  action: PocketHostAction.Request,
+  const filter = filters[filterName]
-  req: Request,
+  if (!filter) return initialValue
-): Promise<void>
+  return filter.reduce(
-export async function action(
+    (carry, handler) => carry.then((carryRes) => handler(carryRes)),
-  action: PocketHostAction.BeforeDaemonStart,
+    Promise.resolve(initialValue),
-): Promise<void>
+  )
-export async function action(
+}
-  action: PocketHostAction.Log,
+
-  currentLevel: LogLevelName,
+export async function action(actionName: PocketHostAction, ...rest: any[]) {
-  levelIn: LogLevelName,
+  const action = actions[actionName]
-  ...rest: any[]
+  if (!action) return
-): Promise<void>
+  await Promise.all(action.map((handler) => handler(...rest)))
-export async function action(
-  action: PocketHostAction.InstanceApiTimeout,
-  instance: InstanceFields,
-): Promise<void>
-export async function action(
-  action: PocketHostAction.UpdateInstance,
-  id: string,
-  fields: Partial<InstanceFields>,
-): Promise<void>
-export async function action(action: PocketHostAction, ...args: any[]) {
-  await Promise.all(actions[action].map((handler) => handler(...args)))
 }
 
 export type PocketHostPluginApi = {