pockethost 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -0,0 +1,43 @@
+# pockethost
+
+## 1.3.0
+
+### Minor Changes
+
+- 96f355a: Now auto-creates first admin account by default
+- 2fc2eeb: Added before/after instance start/stop events
+- 3f99ea0: Added subdomain to request action and filter context
+- 1384a86: BREAKING: refactored actions/filters
+
+### Patch Changes
+
+- 6812784: Added improved error parsing support
+- da82667: Fix: properly determine hostname when running on nonstandard port
+- cc4aa02: Moved mothership-related code into mothership plugin
+- Updated dependencies [9d626ec]
+  - @pockethost/plugin-launcher-spawn@0.1.0
+  - @pockethost/plugin-console-logger@0.1.0
+
+## 1.2.0
+
+### Minor Changes
+
+- 72a6c6d: --version now displays version number
+- ac10d1f: Display notification when new pockethost update is available.
+- f9aea10: Debugging info removed from `plugin ls`
+
+### Patch Changes
+
+- 76d57f6: CHANGELOG.md is now published with package.
+- 3783447: plugin-console-logger and plugin-launcher-spawn are now automatically installed.
+
+## 1.1.0
+
+### Minor Changes
+
+- 1695b59: New feature: list plugins (pockethost plugin ls)
+
+### Patch Changes
+
+- 2514c09: Fix: make sure PH_PLUGINS contains only unique values.
+- 1228840: Fixed extra newline when listing configs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pockethost",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "author": {
     "name": "Ben Allfree",
     "url": "https://github.com/benallfree"
@@ -37,7 +37,11 @@
     "tsx": "^4.15.7",
     "type-fest": "^4.6.0",
     "typescript": "^5.4.5",
-    "url-pattern": "^1.0.3"
+    "update-notifier": "^7.0.0",
+    "url-pattern": "^1.0.3",
+    "@pockethost/plugin-console-logger": "^0.1.0",
+    "@pockethost/plugin-launcher-spawn": "^0.1.0",
+    "@pockethost/plugin-auto-admin": "^0.0.1"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -45,7 +49,8 @@
     "@types/json-stringify-safe": "^5.0.2",
     "@types/node": "^20.8.10",
     "@types/semver": "^7.5.4",
-    "@types/tmp": "^0.2.5"
+    "@types/tmp": "^0.2.5",
+    "@types/update-notifier": "^6.0.8"
   },
   "scripts": {
     "check-types": "tsc --noEmit ",

package/src/cli/commands/PluginCommand/index.ts

@@ -63,7 +63,6 @@ export const PluginCommand = () => {
           try {
             for (const plugin of PH_PLUGINS()) {
               const pkg = await getPackageJson(plugin)
-              console.log({ pkg })
               info(`${plugin}@${pkg.version} - ${pkg?.description}`)
             }
           } catch (e) {

package/src/cli/index.ts

@@ -1,14 +1,16 @@
 #!/usr/bin/env tsx
 
 import { uniq } from '@s-libs/micro-dash'
-import { Command, program } from 'commander'
+import { program } from 'commander'
+import { readFileSync } from 'fs'
+import updateNotifier from 'update-notifier'
 import {
   DEBUG,
   LogLevelName,
   LoggerService,
   PH_PLUGINS,
-  PocketHostFilter,
-  filter,
+  PH_PROJECT_DIR,
+  doCliCommandsFilter,
   loadPlugins,
 } from '../../core'
 import { ConfigCommand } from './commands/ConfigCommand'
@@ -21,14 +23,24 @@ export const { dbg, info, error } = LoggerService({
 
 export const main = async () => {
   await loadPlugins(uniq(PH_PLUGINS()))
+  const pkg = await JSON.parse(
+    readFileSync(PH_PROJECT_DIR(`package.json`), 'utf8').toString(),
+  )
+  updateNotifier({ pkg }).notify()
 
-  program.name('pockethost').description('Multitenant PocketBase hosting')
+  const { version } = pkg
 
-  const commands = await filter<Command[]>(PocketHostFilter.Core_CliCommands, [
+  program
+    .name('pockethost')
+    .description('Multitenant PocketBase hosting')
+    .version(version)
+
+  const commands = await doCliCommandsFilter([
     ServeCommand(),
     ConfigCommand(),
     PluginCommand(),
   ])
+
   for (const command of commands) {
     program.addCommand(command)
   }

package/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 { doLogAction, mergeConfig, mkSingleton } from '.'
 
 export type LoggerConfig = {
   level: LogLevelName
@@ -74,7 +74,11 @@ export const createLogger = (config: Partial<LoggerConfig>) => {
       .join(' ')
 
   const _log = (levelIn: LogLevelName, ...args: any[]) => {
-    action(PocketHostAction.Core_Log, _config.level, levelIn, args)
+    doLogAction({
+      currentLevel: _config.level,
+      levelIn,
+      args,
+    })
   }
 
   const raw = (...args: any[]) => {

package/src/common/error.ts

@@ -0,0 +1,16 @@
+import { keys, map } from '@s-libs/micro-dash'
+import { ClientResponseError } from 'pocketbase'
+
+export const parseError = (e: any): string[] => {
+  if (e instanceof ClientResponseError) {
+    if (e.data.message && keys(e.data.data).length === 0)
+      return [e.data.message]
+    return map(e.data.data, (v, k) => (v ? v.message : undefined)).filter(
+      (v) => !!v,
+    )
+  }
+  if (e instanceof Error) {
+    return [e.message]
+  }
+  return [e.toString()]
+}

package/src/common/index.ts

@@ -3,10 +3,10 @@ export * from './Logger'
 export * from './TimerManager'
 export * from './assert'
 export * from './debug'
+export * from './error'
 export * from './events'
 export * from './mergeConfig'
 export * from './mkSingleton'
 export * from './plugin'
-export * from './pocketbase-client-helpers'
 export * from './promiseSerializer'
 export * from './schema'

package/src/common/plugin/action.ts

@@ -1,60 +1,127 @@
+import { Express, Request, Response } from 'express'
+import { LogLevelName } from '../Logger'
 import { DEBUG } from '../debug'
+import { InstanceFields } from '../schema'
 
-// Global registry of filters and actions
+enum CoreActions {
+  Init = 'core_init',
+  AppMounted = 'core_on_app_mount',
+  AfterServeStart = 'core_after_serve_start',
 
-export enum PocketHostAction {
-  /** Core actions */
-  Core_Init = 'init',
-  Core_OnAppMount = 'on_app_mount',
-  Core_AfterServeStart = 'after_serve_start',
+  Cli_Before_ServeCommand = 'core_before_serve',
+  Log = 'core_log',
+  InstanceLog = 'core_instance_log',
 
-  Core_Cli_Before_ServeCommand = 'before_serve',
-  Core_Log = 'log',
-  Core_InstanceLog = 'instance_log',
+  StartInstance = 'core_start_instance',
 
-  Core_StartInstance = 'start_instance',
+  BeforeInstanceStarted = 'core_before_instance_started',
+  AfterInstanceStarted = 'core_after_instance_started',
 
-  Core_BeforeInstanceStarted = 'before_instance_started',
-  Core_AfterInstanceStarted = 'after_instance_started',
+  BeforeInstanceStopped = 'core_before_instance_stopped',
+  AfterInstanceStopped = 'core_after_instance_stopped',
 
-  Core_BeforeInstanceStopped = 'before_instance_stopped',
-  Core_AfterInstanceStopped = 'after_instance_stopped',
+  AfterInstanceFound = 'core_after_instance_found',
 
-  Core_AfterInstanceFound = 'after_instance_found',
-
-  Core_OnRequestError = 'edge_on_request_error',
-  Core_Request = 'edge_request',
-
-  /** Firewall actions */
-  Waf_OnRequestError = 'waf_on_request_error',
-  Waf_OnAppMiddleware = 'waf_on_app_middleware',
-
-  /** Edge actions */
-  /** Health actions */
-  Health_OnMessage = 'health_on_message',
-  Health_OnError = 'health_on_error',
+  RequestError = 'core_edge_on_request_error',
+  Request = 'core_edge_request',
 }
 
 const actions: {
-  [key in PocketHostAction]?: ActionHandler[]
+  [key: string]: ActionHandler<any>[]
 } = {}
 
-export type ActionHandler = (...args: any[]) => Promise<void>
+export type ActionHandler<TContext = {}> = (
+  context: TContext extends never ? [] : TContext,
+) => Promise<void>
 
-export async function registerAction(
-  action: PocketHostAction,
+async function registerAction(
+  action: string,
   handler: (...args: any[]) => Promise<void>,
 ) {
   if (!(action in actions)) actions[action] = []
   actions[action]!.push(handler)
 }
 
-export async function action(actionName: PocketHostAction, ...rest: any[]) {
-  if (DEBUG() && actionName !== PocketHostAction.Core_Log) {
+async function action(actionName: string, context: any) {
+  if (DEBUG() && actionName !== CoreActions.Log) {
     console.log(`a:${actionName}`)
   }
   const action = actions[actionName]
   if (!action) return false
-  await Promise.all(action.map((handler) => handler(...rest)))
+  await Promise.all(action.map((handler) => handler(context)))
   return true
 }
+
+export function createCustomActionWithContext<TContext extends {}>(
+  actionName: CoreActions,
+) {
+  return [
+    async (context: TContext) => action(actionName, context),
+    async (handler: ActionHandler<TContext>) =>
+      registerAction(actionName, handler),
+  ] as const
+}
+
+export function createCustomAction(actionName: CoreActions) {
+  return [
+    async () => action(actionName, {}),
+    async (handler: ActionHandler) => registerAction(actionName, handler),
+  ] as const
+}
+
+export const [doRequestErrorAction, onRequestErrorAction] =
+  createCustomActionWithContext<{
+    err: Error
+  }>(CoreActions.RequestError)
+
+export const [doAfterServerStartAction, onAfterServerStartAction] =
+  createCustomAction(CoreActions.AfterServeStart)
+
+export const [doLogAction, onLogAction] = createCustomActionWithContext<{
+  currentLevel: LogLevelName
+  levelIn: LogLevelName
+  args: any[]
+}>(CoreActions.Log)
+
+export const [doInstanceLogAction, onInstanceLogAction] =
+  createCustomActionWithContext<{
+    instance: InstanceFields
+    type: 'stdout' | 'stderr'
+    data: string
+  }>(CoreActions.InstanceLog)
+
+export const [doAppMountedAction, onAppMountedAction] =
+  createCustomActionWithContext<{ app: Express }>(CoreActions.AppMounted)
+
+export const [doIncomingRequestAction, onIncomingRequestAction] =
+  createCustomActionWithContext<{ req: Request; res: Response; host: string }>(
+    CoreActions.Request,
+  )
+
+export const [doAfterInstanceFoundAction, onAfterInstanceFoundAction] =
+  createCustomActionWithContext<{
+    req: Request
+    res: Response
+    host: string
+    instance: InstanceFields
+  }>(CoreActions.AfterInstanceFound)
+
+export const [doBeforeInstanceStartedAction, onBeforeInstanceStartedAction] =
+  createCustomActionWithContext<{ instance: InstanceFields }>(
+    CoreActions.BeforeInstanceStarted,
+  )
+
+export const [doAfterInstanceStartedAction, onAfterInstanceStartedAction] =
+  createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
+    CoreActions.AfterInstanceStarted,
+  )
+
+export const [doBeforeInstanceStoppedAction, onBeforeInstanceStoppedAction] =
+  createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
+    CoreActions.BeforeInstanceStopped,
+  )
+
+export const [doAfterInstanceStoppedAction, onAfterInstanceStoppedAction] =
+  createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
+    CoreActions.AfterInstanceStopped,
+  )

package/src/common/plugin/filter.ts

@@ -1,56 +1,48 @@
+import { Command } from 'commander'
+import { Request, Response } from 'express'
 import { DEBUG } from '../debug'
+import { InstanceFields, InstanceId } from '../schema'
 
-export enum PocketHostFilter {
-  /** Core filters */
-  Core_CliCommands = 'core_cli_commands',
-  Core_SpawnConfig = 'core_spawn_config',
-  Core_GetInstanceByRequestInfo = 'core_get_instance_by_request_info',
-  Core_GetInstanceById = 'core_get_instance_by_id',
-  Core_ErrorSpawningInstanceMessage = 'core_error_spawning_instance_message',
-  Core_FailedToLaunchInstanceMessage = 'core_failed_to_launch_instance_message',
-  Core_AuthenticateRequest = 'core_authenticate_request',
-  Core_RequestError_Message = 'core_request_error_message',
-  Core_GetOrProvisionInstanceUrl = 'core_get_or_provision_instance_url',
-  Core_PocketBaseLaunchHandler = 'core_pocket_base_launch_handler',
-  Core_NewInstanceRecord = 'core_new_instance_record',
-
-  /** Mothership Filters */
-  Mothership_MaintenanceMode_Message = 'mothership_maintenance_mode_message',
-  Mothership_UnverifiedAccountError_Message = 'mothership_unverified_account_error_message',
-  Mothership_PublicUrl = 'mothership_public_url',
-
-  /** Firewall Filters */
-  Waf_VHosts = 'waf_vhosts',
-  Waf_OnError_Message = 'waf_on_error_message',
-  Waf_AppMount = 'waf_app_mount',
-
-  /** Edge self checks */
-  EdgeSelfCheck_Checks = 'edge_self_check_checks',
+export enum CoreFilters {
+  CliCommands = 'core_cli_commands',
+  SpawnConfig = 'core_spawn_config',
+  GetInstanceByRequestInfo = 'core_get_instance_by_request_info',
+  GetInstanceById = 'core_get_instance_by_id',
+  ErrorSpawningInstanceMessage = 'core_error_spawning_instance_message',
+  FailedToLaunchInstanceMessage = 'core_failed_to_launch_instance_message',
+  AuthenticateRequest = 'core_authenticate_request',
+  RequestError_Message = 'core_request_error_message',
+  GetOrProvisionInstanceUrl = 'core_get_or_provision_instance_url',
+  PocketBaseLaunchHandler = 'core_pocket_base_launch_handler',
+  NewInstanceRecord = 'core_new_instance_record',
 }
 
-export type FilterHandler<T> = (carry: T, ...rest: any[]) => T | Promise<T>
+export type FilterHandler<TCarry, TContext> = (
+  carry: TCarry,
+  context: TContext,
+) => TCarry | Promise<TCarry>
 type FilterEntry<T> = {
   priority: number
-  handler: FilterHandler<T>
+  handler: FilterHandler<T, any>
 }
 const filters: {
-  [key in PocketHostFilter]?: FilterEntry<any>[]
+  [key: string]: FilterEntry<any>[]
 } = {}
 
-export async function registerFilter<T>(
-  filter: PocketHostFilter,
-  handler: FilterHandler<T>,
-  priority: number = 10,
+async function registerFilter<TCarry, TContext extends {} = {}>(
+  filter: string,
+  handler: FilterHandler<TCarry, TContext>,
+  priority = 10,
 ) {
   if (!(filter in filters)) filters[filter] = []
   filters[filter]!.push({ priority, handler })
   filters[filter]!.sort((a, b) => a.priority - b.priority)
 }
 
-export async function filter<TRet, TIn = TRet>(
-  filterName: PocketHostFilter,
-  initialValue: TIn,
-  ...rest: any[]
+async function filter<TCarry, TContext extends {} = {}>(
+  filterName: string,
+  initialValue: TCarry,
+  context: TContext,
 ) {
   if (DEBUG()) {
     console.log(`f:${filterName}`)
@@ -59,7 +51,65 @@ export async function filter<TRet, TIn = TRet>(
   if (!filter) return initialValue
   return filter.reduce(
     (carry, entry) =>
-      carry.then((carryRes) => entry.handler(carryRes, ...rest)),
+      carry.then((carryRes) => entry.handler(carryRes, context)),
     Promise.resolve(initialValue),
-  ) as TRet
+  ) as TCarry
+}
+
+function createCustomFilterWithContext<TCarry, TContext extends {} = {}>(
+  filterName: CoreFilters,
+) {
+  return [
+    async (initialValue: TCarry, context: TContext) =>
+      filter<TCarry, TContext>(filterName, initialValue, context),
+    async (handler: FilterHandler<TCarry, TContext>, priority = 10) =>
+      registerFilter<TCarry, TContext>(filterName, handler, priority),
+  ] as const
+}
+
+function createCustomFilter<TCarry>(filterName: string) {
+  return [
+    async (initialValue: TCarry) =>
+      filter<TCarry>(filterName, initialValue, {}),
+    async (handler: FilterHandler<TCarry, {}>, priority = 10) =>
+      registerFilter<TCarry, {}>(filterName, handler, priority),
+  ] as const
 }
+
+export const [
+  doGetInstanceByRequestInfoFilter,
+  onGetInstanceByRequestInfoFilter,
+] = createCustomFilterWithContext<
+  InstanceFields | undefined,
+  { req: Request; res: Response; host: string; subdomain: string }
+>(CoreFilters.GetInstanceByRequestInfo)
+
+export const [doGetInstanceByIdFilter, onGetInstanceByIdFilter] =
+  createCustomFilterWithContext<
+    InstanceFields | undefined,
+    { instanceId: InstanceId }
+  >(CoreFilters.GetInstanceById)
+
+export const [doCliCommandsFilter, onCliCommandsFilter] = createCustomFilter<
+  Command[]
+>(CoreFilters.CliCommands)
+
+export const [doNewInstanceRecordFilter, onNewInstanceRecordFilter] =
+  createCustomFilter<InstanceFields>(CoreFilters.NewInstanceRecord)
+
+export const [doRequestErrorMessageFilter, onRequestErrorMessageFilter] =
+  createCustomFilter<string>(CoreFilters.RequestError_Message)
+
+export const [
+  doGetOrProvisionInstanceUrlFilter,
+  onGetOrProvisionInstanceUrlFilter,
+] = createCustomFilterWithContext<
+  string,
+  {
+    req: Request
+    res: Response
+    host: string
+    subdomain: string
+    instance: InstanceFields
+  }
+>(CoreFilters.GetOrProvisionInstanceUrl)

package/src/common/plugin/index.ts

@@ -1,16 +1,10 @@
 import { isString } from '@s-libs/micro-dash'
-import { registerAction } from './action'
-import { registerFilter } from './filter'
 export * from './action'
 export * from './filter'
-export * from './helpers'
 
 export type PocketHostPlugin = (api: PocketHostPluginApi) => Promise<void>
 
-export type PocketHostPluginApi = {
-  registerAction: typeof registerAction
-  registerFilter: typeof registerFilter
-}
+export type PocketHostPluginApi = {}
 
 export const loadPlugins = async (plugins: (string | PocketHostPlugin)[]) => {
   await Promise.all(
@@ -20,7 +14,7 @@ export const loadPlugins = async (plugins: (string | PocketHostPlugin)[]) => {
         const plugin = await import(pluginPathOrModule)
         return plugin.default
       })()
-      await plugin({ registerAction, registerFilter })
+      await plugin({})
     }),
   )
   return plugins

package/src/common/schema/Instance.ts

@@ -1,4 +1,4 @@
-import { BaseFields, RecordId, Subdomain, UserFields, UserId } from '.'
+import { doNewInstanceRecordFilter } from '../plugin'
 
 export type VersionId = string
 
@@ -13,33 +13,24 @@ export enum InstanceStatus {
   Failed = 'failed',
 }
 
+export type InstanceId = string
 export type InstanceSecretKey = string
 export type InstanceSecretValue = string
 export type InstanceSecretCollection = {
   [name: InstanceSecretKey]: InstanceSecretValue
 }
 
-export type InstanceFields = BaseFields & {
-  subdomain: Subdomain
-  uid: UserId
-  status: InstanceStatus
+export type InstanceFields = {
+  subdomain: string
   version: VersionId
-  secrets: InstanceSecretCollection | null
-  maintenance: boolean
-  suspension: string
-  syncAdmin: boolean
-  cname: string
-  dev: boolean
-  cname_active: boolean
-  notifyMaintenanceMode: boolean
+  secrets: InstanceSecretCollection
+  dev: boolean // Should instance run in --dev mode
 }
 
-export type WithUser = {
-  expand: { uid: UserFields }
-}
-
-export type InstanceFields_WithUser = InstanceFields & WithUser
-
-export type InstanceFields_Create = Omit<InstanceFields, keyof BaseFields>
-
-export type InstanceRecordsById = { [_: RecordId]: InstanceFields }
+export const mkInstance = (subdomain: string) =>
+  doNewInstanceRecordFilter({
+    subdomain,
+    version: '*',
+    secrets: {},
+    dev: false,
+  })

package/src/common/schema/index.ts

@@ -1,6 +1,3 @@
 export * from './Instance'
 export * from './InstanceLog'
-export * from './Rest'
-export * from './User'
-export * from './types'
 export * from './util'

package/src/constants.ts

@@ -32,6 +32,7 @@ export const settings = Settings({
   PH_PLUGINS: mkCsvString([
     `@pockethost/plugin-console-logger`,
     `@pockethost/plugin-launcher-spawn`,
+    `@pockethost/plugin-auto-admin`,
   ]),
 
   PH_HOME: mkPath(_PH_HOME),

package/src/server.ts

@@ -2,36 +2,36 @@ import express, { ErrorRequestHandler } from 'express'
 import 'express-async-errors'
 import { default as httpProxy } from 'http-proxy'
 import {
-  InstanceFields,
+  APEX_DOMAIN,
   LoggerService,
   PORT,
-  PocketHostAction,
-  PocketHostFilter,
-  action,
   asyncExitHook,
-  filter,
-  registerAction,
-  registerFilter,
+  doAfterInstanceFoundAction,
+  doAfterServerStartAction,
+  doAppMountedAction,
+  doGetInstanceByRequestInfoFilter,
+  doGetOrProvisionInstanceUrlFilter,
+  doIncomingRequestAction,
+  doRequestErrorAction,
+  doRequestErrorMessageFilter,
+  onInstanceLogAction,
 } from '../core'
 
 export const serve = async () => {
   const _proxyLogger = LoggerService().create('ProxyService')
   const { dbg, error, info, trace, warn } = _proxyLogger
 
-  registerAction(
-    PocketHostAction.Core_InstanceLog,
-    async ({ instance, type, data }) => {
-      dbg(data.toString())
-    },
-  )
-
-  registerFilter(
-    PocketHostFilter.Waf_VHosts,
-    async (routes: { [_: string]: string }) => {
-      return { ...routes, '*': `http://localhost:${PORT()}` }
-    },
-    99,
-  )
+  onInstanceLogAction(async ({ instance, type, data }) => {
+    dbg(data.toString())
+  })
+
+  // registerFilter(
+  //   CoreFilters.Waf_VHosts,
+  //   async (routes: { [_: string]: string }) => {
+  //     return { ...routes, '*': `http://localhost:${PORT()}` }
+  //   },
+  //   99,
+  // )
 
   const proxy = httpProxy.createProxyServer({})
   proxy.on('error', (err, req, res, target) => {
@@ -47,59 +47,55 @@ export const serve = async () => {
   })
 
   const errorHandler: ErrorRequestHandler = async (err, req, res, next) => {
-    action(PocketHostAction.Core_OnRequestError, { err })
-    res
-      .status(500)
-      .send(
-        await filter(
-          PocketHostFilter.Core_RequestError_Message,
-          err.toString(),
-        ),
-      )
+    doRequestErrorAction({ err })
+    res.status(500).send(await doRequestErrorMessageFilter(err.toString()))
   }
   app.use(errorHandler)
 
-  action(PocketHostAction.Core_OnAppMount, app)
+  doAppMountedAction({ app })
 
   app.all(`*`, async (req, res, next) => {
     const method = req.method
-    const fullUrl = req.protocol + '://' + req.get('host') + req.originalUrl
-    const host = req.headers.host
+    const fullUrl = new URL(
+      req.protocol + '://' + req.get('host') + req.originalUrl,
+    )
+    const host = fullUrl.hostname
     if (!host) {
       throw new Error(`Host not found`)
     }
+    const subdomain = host.slice(0, -`.${APEX_DOMAIN()}`.length)
 
-    dbg(`${method} ${fullUrl} -> ${`http://localhost:${PORT()}`}`)
+    dbg(
+      `${method} ${fullUrl} (${subdomain}) -> ${`http://localhost:${PORT()}`}`,
+    )
 
-    await action(PocketHostAction.Core_Request, { req, res, host })
+    await doIncomingRequestAction({ req, res, host })
 
-    const instance = await filter<undefined | InstanceFields>(
-      PocketHostFilter.Core_GetInstanceByRequestInfo,
-      undefined,
-      { req, res, host },
-    )
+    const instance = await doGetInstanceByRequestInfoFilter(undefined, {
+      req,
+      res,
+      host,
+      subdomain,
+    })
     if (!instance) {
       res.status(404).end(`${host} not found`)
       return
     }
 
-    await action(PocketHostAction.Core_AfterInstanceFound, {
+    await doAfterInstanceFoundAction({
       instance,
       req,
       res,
       host,
     })
 
-    const url = await filter<string>(
-      PocketHostFilter.Core_GetOrProvisionInstanceUrl,
-      '',
-      {
-        req,
-        res,
-        instance,
-        host,
-      },
-    )
+    const url = await doGetOrProvisionInstanceUrlFilter('', {
+      req,
+      res,
+      instance,
+      host,
+      subdomain,
+    })
 
     dbg(`Forwarding request for ${req.url} to instance ${url}`)
 
@@ -110,7 +106,7 @@ export const serve = async () => {
 
   app.listen(PORT(), () => {
     info(`pockethost listening on port ${PORT()}`)
-    action(PocketHostAction.Core_AfterServeStart)
+    doAfterServerStartAction()
   })
 
   asyncExitHook(async () => {

package/src/common/plugin/helpers.ts

@@ -1,17 +0,0 @@
-import { InstanceFields } from '../schema'
-import { ActionHandler, PocketHostAction, registerAction } from './action'
-import { PocketHostFilter, filter } from './filter'
-
-export async function getInstanceById(instanceId: string) {
-  return await filter<InstanceFields | undefined>(
-    PocketHostFilter.Core_GetInstanceById,
-    undefined,
-    { instanceId },
-  )
-}
-
-export const onAppMount = (cb: ActionHandler) =>
-  registerAction(PocketHostAction.Core_OnAppMount, cb)
-
-export const onInit = (cb: ActionHandler) =>
-  registerAction(PocketHostAction.Core_Init, cb)

package/src/common/pocketbase-client-helpers/RestHelper.ts

@@ -1,69 +0,0 @@
-import Ajv, { JSONSchemaType } from 'ajv'
-import PocketBase, { ClientResponseError } from 'pocketbase'
-import type { JsonObject } from 'type-fest'
-import { LoggerService, RestCommands, RestMethods } from '..'
-
-export type RestHelperConfig = {
-  client: PocketBase
-}
-
-export type RestHelper = ReturnType<typeof createRestHelper>
-
-export const createRestHelper = (config: RestHelperConfig) => {
-  const _logger = LoggerService().create(`RestHelper`)
-  const { client } = config
-
-  const mkRest = <TPayload extends JsonObject, TResult extends JsonObject>(
-    cmd: RestCommands,
-    method: RestMethods,
-    schema: JSONSchemaType<TPayload>,
-  ) => {
-    const validator = new Ajv().compile(schema)
-    return async (payload: TPayload): Promise<TResult> => {
-      const _restCallLogger = _logger.create(cmd)
-      const { dbg, error } = _restCallLogger
-
-      dbg(`Executing REST call`)
-      if (!validator(payload)) {
-        throw new Error(`Invalid REST payload: ${validator.errors}`)
-      }
-      const _payload = { ...payload }
-
-      const url = `/api/${cmd}${
-        method === RestMethods.Post ? '' : '/:id'
-      }`.replace(/:([a-zA-Z]+)/g, (_, key) => {
-        if (!(key in _payload)) {
-          throw new Error(`Payload must include '${key}`)
-        }
-        const value = _payload[key]!
-        delete _payload[key]
-        return encodeURIComponent(value.toString())
-      })
-
-      const options: any = {
-        method: method,
-      }
-
-      if (method !== RestMethods.Get) {
-        options.body = _payload
-      }
-
-      dbg({ url, options })
-
-      try {
-        const res = await client.send(url, options)
-        dbg(res)
-        return res
-      } catch (e) {
-        if (e instanceof ClientResponseError) {
-          error(`REST error: ${e.originalError}`)
-          throw e.originalError
-        }
-        error(`REST error: ${e}`)
-        throw e
-      }
-    }
-  }
-
-  return { mkRest }
-}

package/src/common/pocketbase-client-helpers/index.ts

@@ -1 +0,0 @@
-export * from './RestHelper'

package/src/common/schema/Rest/CreateInstance.ts

@@ -1,20 +0,0 @@
-import { JSONSchemaType } from 'ajv'
-import { InstanceFields, Subdomain } from '..'
-
-export type CreateInstancePayload = {
-  subdomain: Subdomain
-}
-
-export type CreateInstanceResult = {
-  instance: InstanceFields
-}
-
-export const CreateInstancePayloadSchema: JSONSchemaType<CreateInstancePayload> =
-  {
-    type: 'object',
-    properties: {
-      subdomain: { type: 'string' },
-    },
-    required: ['subdomain'],
-    additionalProperties: false,
-  }

package/src/common/schema/Rest/DeleteInstance.ts

@@ -1,21 +0,0 @@
-import { JSONSchemaType } from 'ajv'
-import { InstanceId } from '..'
-
-export type DeleteInstancePayload = {
-  id: InstanceId
-}
-
-export type DeleteInstanceResult = {
-  status: 'ok' | 'error'
-  message?: string
-}
-
-export const DeleteInstancePayloadSchema: JSONSchemaType<DeleteInstancePayload> =
-  {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-    },
-    required: ['id'],
-    additionalProperties: false,
-  }

package/src/common/schema/Rest/GetUserTokenInfo.ts

@@ -1,22 +0,0 @@
-import { JSONSchemaType } from 'ajv'
-import { UserId } from '..'
-
-export type GetUserTokenPayload = {
-  id: UserId
-}
-
-export type GetUserTokenResult = {
-  id: string
-  email: string
-  tokenKey: string
-  passwordHash: string
-}
-
-export const GetUserTokenPayloadSchema: JSONSchemaType<GetUserTokenPayload> = {
-  type: 'object',
-  properties: {
-    id: { type: 'string' },
-  },
-  required: ['id'],
-  additionalProperties: false,
-}

package/src/common/schema/Rest/UpdateInstance.ts

@@ -1,61 +0,0 @@
-import { JSONSchemaType } from 'ajv'
-import { InstanceFields, InstanceId } from '..'
-
-export type UpdateInstancePayload = {
-  id: InstanceId
-  fields: Partial<
-    Pick<
-      InstanceFields,
-      | 'maintenance'
-      | 'secrets'
-      | 'subdomain'
-      | 'syncAdmin'
-      | 'version'
-      | 'dev'
-      | 'cname'
-      | 'notifyMaintenanceMode'
-    >
-  >
-}
-
-export const SECRET_KEY_REGEX = /^[A-Z][A-Z0-9_]*$/
-
-export type UpdateInstanceResult = {
-  status: 'ok' | 'error'
-  message?: string
-}
-
-export const UpdateInstancePayloadSchema: JSONSchemaType<UpdateInstancePayload> =
-  {
-    type: 'object',
-    properties: {
-      id: { type: 'string' },
-      fields: {
-        type: 'object',
-        properties: {
-          syncAdmin: { type: 'boolean', nullable: true },
-          subdomain: { type: 'string', nullable: true },
-          maintenance: { type: 'boolean', nullable: true },
-          version: {
-            type: 'string',
-            nullable: true,
-          },
-          secrets: {
-            type: 'object',
-            nullable: true,
-            patternProperties: {
-              [SECRET_KEY_REGEX.source]: {
-                anyOf: [{ type: 'string' }],
-              },
-            },
-            required: [],
-          },
-          dev: { type: 'boolean', nullable: true },
-          cname: { type: 'string', nullable: true },
-          notifyMaintenanceMode: { type: 'boolean', nullable: true },
-        },
-      },
-    },
-    required: ['id', 'fields'],
-    additionalProperties: false,
-  }

package/src/common/schema/Rest/index.ts

@@ -1,23 +0,0 @@
-import Ajv from 'ajv'
-import { JsonObject } from 'type-fest'
-
-export enum RestMethods {
-  Get = 'GET',
-  Post = 'POST',
-  Put = 'PUT',
-  Delete = 'DELETE',
-}
-
-export enum RestCommands {
-  Instance = 'instance',
-  UserToken = 'userToken',
-}
-
-export type RestPayloadBase = JsonObject
-
-export const ajv = new Ajv()
-
-export * from './CreateInstance'
-export * from './DeleteInstance'
-export * from './GetUserTokenInfo'
-export * from './UpdateInstance'

package/src/common/schema/User.ts

@@ -1,24 +0,0 @@
-import { BaseFields } from './types'
-
-export enum SubscriptionType {
-  Legacy = 'legacy',
-  Free = 'free',
-  Premium = 'premium',
-  Lifetime = 'lifetime',
-}
-
-export const PLAN_NAMES = {
-  [SubscriptionType.Legacy]: 'Legacy',
-  [SubscriptionType.Free]: 'Hacker',
-  [SubscriptionType.Premium]: `Pro`,
-  [SubscriptionType.Lifetime]: `Founder's Edition`,
-}
-
-export type UserFields = BaseFields & {
-  email: string
-  verified: boolean
-  isLegacy: boolean
-  isFounder: boolean
-  subscription: SubscriptionType
-  notifyMaintenanceMode: boolean
-}

package/src/common/schema/types.ts

@@ -1,18 +0,0 @@
-export type RecordId = string
-export type UserId = RecordId
-export type InstanceId = RecordId
-export type Semver = string
-export type InternalInstanceId = RecordId
-export type Subdomain = string
-export type Port = number
-export type IsoDate = string
-export type ProcessId = number
-export type Username = string
-export type Password = string
-export type CollectionName = string
-export type Seconds = number
-export type BaseFields = {
-  id: RecordId
-  created: IsoDate
-  updated: IsoDate
-}