pockethost 1.7.0 → 3.0.0

package/src/common/events.ts

@@ -1,53 +0,0 @@
-import { values } from '@s-libs/micro-dash'
-
-export type Unsubscribe = () => void
-
-export type EventSubscriber<TPayload> = (
-  cb: EventHandler<TPayload>,
-) => Unsubscribe
-export type EventEmitter<TPayload> = (
-  payload: TPayload,
-  stopOnHandled?: boolean,
-) => Promise<boolean>
-export type EventHandler<TPayload> = (
-  payload: TPayload,
-  isHandled: boolean,
-) => boolean | void | Promise<boolean | void>
-
-/**
- * @param defaultHandler Optional handler to call if no handler calls
- *   `handled()`
- * @returns Void
- */
-export const createEvent = <TPayload>(
-  defaultHandler?: EventHandler<TPayload>,
-): [EventSubscriber<TPayload>, EventEmitter<TPayload>] => {
-  let i = 0
-  const callbacks: any = {}
-  let callbacksArray: EventHandler<TPayload>[] = []
-  const onEvent = (cb: EventHandler<TPayload>) => {
-    const id = i++
-    callbacks[id] = cb
-    callbacksArray = values(callbacks)
-    return () => {
-      delete callbacks[id]
-    }
-  }
-
-  const fireEvent = async (payload: TPayload, stopOnHandled = false) => {
-    let _handled = false
-    for (let i = 0; i < callbacksArray.length; i++) {
-      const cb = callbacksArray[i]
-      if (!cb) continue
-      const res: boolean = !!(await cb(payload, _handled))
-      _handled = _handled || res
-      if (stopOnHandled && _handled) break
-    }
-    if (!_handled) {
-      await defaultHandler?.(payload, false)
-    }
-    return _handled
-  }
-
-  return [onEvent, fireEvent]
-}

package/src/common/index.ts

@@ -1,12 +0,0 @@
-export * from './CleanupManager'
-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 './promiseSerializer'
-export * from './schema'

package/src/common/mergeConfig.ts

@@ -1,27 +0,0 @@
-/**
- * Merges a config object with defaults. Shallow copies root descendants,
- * skipping`undefined` values.
- *
- * @param defaultConfig The default config values
- * @param partialConfigs A partial config to merge with defaults
- * @returns
- */
-export function mergeConfig<T>(
-  defaultConfig: T,
-  ...partialConfigs: Partial<T>[]
-): T {
-  const result: T = { ...defaultConfig }
-
-  for (const partialConfig of partialConfigs) {
-    for (const key in partialConfig) {
-      if (Object.prototype.hasOwnProperty.call(partialConfig, key)) {
-        const value = partialConfig[key as keyof typeof partialConfig]
-        if (value !== undefined) {
-          result[key as keyof T] = value as T[keyof T]
-        }
-      }
-    }
-  }
-
-  return result
-}

package/src/common/mkSingleton.ts

@@ -1,28 +0,0 @@
-export type SingletonApi = Object
-
-export type SingletonBaseConfig = {}
-
-export function mkSingleton<TConfig, TInstance>(
-  factory: (config: TConfig) => TInstance,
-): (config?: TConfig) => TInstance {
-  let instance: TInstance | undefined
-
-  return (config?: TConfig): TInstance => {
-    if (instance && config) {
-      console.warn('Attempted to initialize service twice.')
-      console.warn(new Error().stack)
-      return instance
-    }
-
-    if (!instance && !config) {
-      console.warn(new Error().stack)
-      throw new Error('Attempted to use service before initialization.')
-    }
-
-    if (!instance) {
-      instance = factory(config as TConfig)
-    }
-
-    return instance
-  }
-}

package/src/common/plugin/action.ts

@@ -1,164 +0,0 @@
-import { uniqueId } from '@s-libs/micro-dash'
-import { Express, Request, Response } from 'express'
-import { dbg } from '../../cli'
-import { LogLevelName } from '../Logger'
-import { DEBUG } from '../debug'
-import { InstanceFields } from '../schema'
-
-enum CoreActions {
-  AfterPluginsLoaded = 'core_after_plugins_loaded',
-  Init = 'core_init',
-  Serve = 'core_serve',
-  AppMounted = 'core_on_app_mount',
-  AfterServeStart = 'core_after_serve_start',
-
-  Cli_Before_ServeCommand = 'core_before_serve',
-  Log = 'core_log',
-  InstanceLog = 'core_instance_log',
-
-  StartInstance = 'core_start_instance',
-
-  BeforeInstanceStarted = 'core_before_instance_started',
-  AfterInstanceStarted = 'core_after_instance_started',
-
-  KillInstance = 'core_kill_instance',
-
-  BeforeInstanceStopped = 'core_before_instance_stopped',
-  AfterInstanceStopped = 'core_after_instance_stopped',
-
-  AfterInstanceFound = 'core_after_instance_found',
-
-  RequestError = 'core_edge_on_request_error',
-  Request = 'core_edge_request',
-}
-
-export type ActionHandler<TContext = {}> = (
-  context: TContext extends never ? [] : TContext,
-) => Promise<void>
-
-interface Action {
-  priority: number
-  handler: ActionHandler<any>
-}
-
-const actions: {
-  [key: string]: Action[]
-} = {}
-
-function registerAction(
-  action: string,
-  handler: (...args: any[]) => Promise<void>,
-  priority: number = 10,
-): () => void {
-  if (!(action in actions)) actions[action] = []
-  const uid = uniqueId(`a:${action}:`)
-  dbg(`${uid}:subscribe`)
-  actions[action]!.push({ priority, handler })
-  actions[action]!.sort((a, b) => a.priority - b.priority)
-
-  return () => {
-    dbg(`${uid}:unsubscribe`)
-    actions[action] = actions[action]!.filter((a) => a.handler !== handler)
-  }
-}
-
-async function action(actionName: string, context: any) {
-  if (DEBUG() && actionName !== CoreActions.Log) {
-    console.log(`a:${actionName}`)
-  }
-  const action = actions[actionName]
-  if (!action) return false
-  for (const { handler } of action) {
-    await handler(context)
-  }
-  return true
-}
-
-export function createCustomActionWithContext<TContext extends {}>(
-  actionName: CoreActions,
-) {
-  return [
-    async (context: TContext) => action(actionName, context),
-    (handler: ActionHandler<TContext>, priority = 10) =>
-      registerAction(actionName, handler, priority),
-  ] as const
-}
-
-export function createCustomAction(actionName: CoreActions) {
-  return [
-    async () => action(actionName, {}),
-    (handler: ActionHandler, priority = 10) =>
-      registerAction(actionName, handler, priority),
-  ] as const
-}
-
-export const [doAfterPluginsLoadedAction, onAfterPluginsLoadedAction] =
-  createCustomAction(CoreActions.AfterPluginsLoaded)
-
-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; internalApp: 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 [doKillInstanceAction, onKillInstanceAction] =
-  createCustomActionWithContext<{ instance: InstanceFields }>(
-    CoreActions.KillInstance,
-  )
-
-export const [doBeforeInstanceStoppedAction, onBeforeInstanceStoppedAction] =
-  createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
-    CoreActions.BeforeInstanceStopped,
-  )
-
-export const [doAfterInstanceStoppedAction, onAfterInstanceStoppedAction] =
-  createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
-    CoreActions.AfterInstanceStopped,
-  )
-
-export const [doServeAction, onServeAction] = createCustomActionWithContext<{
-  only: string[]
-}>(CoreActions.Serve)

package/src/common/plugin/filter.ts

@@ -1,197 +0,0 @@
-import { Command } from 'commander'
-import { Request, Response } from 'express'
-import { DEBUG } from '../debug'
-import { InstanceFields, InstanceId } from '../schema'
-import { UserId } from '../schema/BaseFields'
-
-export enum CoreFilters {
-  Settings = 'core_settings',
-  CliCommands = 'core_cli_commands',
-  ServeSlugs = 'core_serve_slugs',
-  SpawnConfig = 'core_spawn_config',
-  AuthenticateUser = 'core_authenticate_user',
-  GetInstanceByRequestInfo = 'core_get_instance_by_request_info',
-  GetInstanceById = 'core_get_instance_by_id',
-  GetOneInstanceByExactCriteria = 'core_get_one_instance_by_exact_criteria',
-  GetAllInstancesByExactCriteria = 'core_get_all_instances_by_exact_criteria',
-  InstanceConfig = 'core_instance_config',
-  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',
-  IsInstanceRunning = 'core_is_instance_running',
-}
-
-export type FilterHandler<TCarry, TContext> = (
-  carry: TCarry,
-  context: TContext,
-) => TCarry | Promise<TCarry>
-type FilterEntry<T> = {
-  priority: number
-  handler: FilterHandler<T, any>
-}
-const filters: {
-  [key: string]: FilterEntry<any>[]
-} = {}
-
-function registerFilter<TCarry, TContext extends {} = {}>(
-  filter: string,
-  handler: FilterHandler<TCarry, TContext>,
-  priority = 10,
-): () => void {
-  if (!(filter in filters)) filters[filter] = []
-  filters[filter]!.push({ priority, handler })
-  filters[filter]!.sort((a, b) => a.priority - b.priority)
-
-  return () => {
-    const index = filters[filter]!.findIndex(
-      (entry) => entry.handler === handler,
-    )
-    if (index !== -1) {
-      filters[filter]!.splice(index, 1)
-    }
-  }
-}
-
-async function filter<TCarry, TContext extends {} = {}>(
-  filterName: string,
-  initialValue: TCarry,
-  context: TContext,
-) {
-  if (DEBUG()) {
-    console.log(`f:${filterName}`)
-  }
-  const filter = filters[filterName]
-  if (!filter) return initialValue
-  return filter.reduce(
-    (carry, entry) =>
-      carry
-        .then((carryRes) => entry.handler(carryRes, context))
-        .then((carryRes) => {
-          if (DEBUG()) {
-            console.log(`f:${filterName}`, carryRes, context)
-          }
-          return carryRes
-        }),
-    Promise.resolve(initialValue),
-  ) as TCarry
-}
-
-function createCustomFilterWithContext<TCarry, TContext extends {} = {}>(
-  filterName: CoreFilters,
-) {
-  return [
-    async (initialValue: TCarry, context: TContext) =>
-      filter<TCarry, TContext>(filterName, initialValue, context),
-    async <TExtraCarry = unknown>(
-      handler: FilterHandler<TCarry & TExtraCarry, TContext>,
-      priority = 10,
-    ) =>
-      registerFilter<TCarry & TExtraCarry, TContext>(
-        filterName,
-        handler,
-        priority,
-      ),
-  ] as const
-}
-
-function createCustomFilter<TCarry>(filterName: string) {
-  return [
-    async (initialValue: TCarry) =>
-      filter<TCarry>(filterName, initialValue, {}),
-    async <TExtraCarry = unknown>(
-      handler: FilterHandler<TCarry & TExtraCarry, {}>,
-      priority = 10,
-    ) =>
-      registerFilter<TCarry & TExtraCarry, {}>(filterName, handler, priority),
-  ] as const
-}
-
-export const [doSettingsFilter, onSettingsFilter] = createCustomFilter<{
-  [_: string]: any
-}>(CoreFilters.Settings)
-
-export const [doAuthenticateUserFilter, onAuthenticateUserFilter] =
-  createCustomFilterWithContext<
-    UserId | undefined,
-    { username: string; password: string }
-  >(CoreFilters.AuthenticateUser)
-
-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 [
-  doGetOneInstanceByExactCriteriaFilter,
-  onGetOneInstanceByExactCriteriaFilter,
-] = createCustomFilterWithContext<
-  InstanceFields | undefined,
-  Partial<InstanceFields & { [_: string]: string | number }>
->(CoreFilters.GetOneInstanceByExactCriteria)
-
-export const [
-  doGetAllInstancesByExactCriteriaFilter,
-  onGetAllInstancesByExactCriteriaFilter,
-] = createCustomFilterWithContext<
-  InstanceFields[],
-  Partial<InstanceFields & { [_: string]: string | number }>
->(CoreFilters.GetAllInstancesByExactCriteria)
-
-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 | undefined,
-  {
-    instance: InstanceFields
-  }
->(CoreFilters.GetOrProvisionInstanceUrl)
-
-export const [doServeSlugsFilter, onServeSlugsFilter] = createCustomFilter<
-  string[]
->(CoreFilters.ServeSlugs)
-
-export type Bind = {
-  base: string
-  src: string
-}
-export type Binds = {
-  data: Bind[]
-  hooks: Bind[]
-  migrations: Bind[]
-  public: Bind[]
-}
-export type InstanceConfig = {
-  binds: Binds
-  env: { [_: string]: string }
-}
-export const [doInstanceConfigFilter, onInstanceConfigFilter] =
-  createCustomFilter<InstanceConfig>(CoreFilters.InstanceConfig)
-
-export const [doIsInstanceRunningFilter, onIsInstanceRunningFilter] =
-  createCustomFilterWithContext<boolean, { instance: InstanceFields }>(
-    CoreFilters.IsInstanceRunning,
-  )

package/src/common/plugin/index.ts

@@ -1,21 +0,0 @@
-import { isString } from '@s-libs/micro-dash'
-export * from './action'
-export * from './filter'
-
-export type PocketHostPlugin = (api: PocketHostPluginApi) => Promise<void>
-
-export type PocketHostPluginApi = {}
-
-export const loadPlugins = async (plugins: (string | PocketHostPlugin)[]) => {
-  await Promise.all(
-    plugins.map(async (pluginPathOrModule) => {
-      const plugin = await (async () => {
-        if (!isString(pluginPathOrModule)) return pluginPathOrModule
-        const plugin = await import(pluginPathOrModule)
-        return plugin.default
-      })()
-      await plugin({})
-    }),
-  )
-  return plugins
-}

package/src/common/promiseSerializer.ts

@@ -1,22 +0,0 @@
-type JobQueue = {
-  [key: string]: Promise<any> | undefined
-}
-
-const jobQueue: JobQueue = {}
-
-export function enqueueJob(
-  key: string,
-  promiseFn: () => Promise<any>,
-): Promise<any> {
-  const currentJob = jobQueue[key]
-
-  const chainedPromise = currentJob ? currentJob.then(promiseFn) : promiseFn()
-
-  jobQueue[key] = chainedPromise.finally(() => {
-    if (jobQueue[key] === chainedPromise) {
-      delete jobQueue[key]
-    }
-  })
-
-  return chainedPromise
-}

package/src/common/schema/BaseFields.ts

@@ -1,10 +0,0 @@
-export type RecordId = string
-export type UserId = RecordId
-export type IsoDate = string
-export type BaseFields = {
-  id: RecordId
-  created: IsoDate
-  updated: IsoDate
-}
-
-export type AnyField = { [_: string]: string | number }

package/src/common/schema/Instance.ts

@@ -1,46 +0,0 @@
-import { doNewInstanceRecordFilter } from '../plugin'
-import { IsoDate } from './BaseFields'
-import { newId, pocketNow } from './util'
-
-export type VersionId = string
-
-export const INSTANCE_COLLECTION = 'instances'
-
-export enum InstanceStatus {
-  Unknown = '',
-  Idle = 'idle',
-  Port = 'porting',
-  Starting = 'starting',
-  Running = 'running',
-  Failed = 'failed',
-}
-
-export type InstanceId = string
-export type InstanceSecretKey = string
-export type InstanceSecretValue = string
-export type InstanceSecretCollection = {
-  [name: InstanceSecretKey]: InstanceSecretValue
-}
-
-export type InstanceFields = {
-  id: string
-  subdomain: string
-  version: VersionId
-  secrets: InstanceSecretCollection
-  dev: boolean // Should instance run in --dev mode
-  created: IsoDate
-  updated: IsoDate
-}
-
-export const mkInstance = (subdomain: string, id = newId()) => {
-  const now = pocketNow()
-  return doNewInstanceRecordFilter({
-    id,
-    subdomain,
-    version: '*',
-    secrets: {},
-    dev: false,
-    created: now,
-    updated: now,
-  })
-}

package/src/common/schema/InstanceLog.ts

@@ -1,12 +0,0 @@
-export enum StreamNames {
-  StdOut = 'stdout',
-  StdErr = 'stderr',
-}
-
-export type InstanceLogFields = {
-  message: string
-  time: string
-  stream: StreamNames
-}
-
-export type InstanceLogFields_Create = InstanceLogFields

package/src/common/schema/index.ts

@@ -1,3 +0,0 @@
-export * from './Instance'
-export * from './InstanceLog'
-export * from './util'

package/src/common/schema/util.ts

@@ -1,7 +0,0 @@
-import { customAlphabet } from 'nanoid'
-import { IsoDate } from './BaseFields'
-
-export const newId = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10)
-export const pocketNow = () => toPocketDate(new Date())
-export const toPocketDate = (date: Date) => date.toISOString()
-export const fromPocketDate = (iso: IsoDate) => new Date(iso)

package/src/constants.ts

@@ -1,70 +0,0 @@
-import { config } from 'dotenv'
-import envPaths from 'env-paths'
-import { dirname, join } from 'path'
-import { cwd } from 'process'
-import { fileURLToPath } from 'url'
-import { mkBoolean, mkCsvString, mkNumber, mkPath, mkString } from '../core'
-import { InstanceFields, InstanceId } from './common'
-import { DEBUG, IS_DEV } from './common/debug'
-import { Settings } from './core/Settings'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export const _PH_HOME = process.env.PH_HOME || envPaths(`pockethost`).data
-
-config({ path: [join(_PH_HOME, '.env'), join(cwd(), `.env`)] })
-
-export const _PH_PROJECT_DIR = join(__dirname, '..')
-export const _APEX_DOMAIN = process.env.APEX_DOMAIN || 'pockethost.lvh.me'
-
-export const settings = Settings({
-  PH_PLUGINS: mkCsvString([
-    `@pockethost/plugin-console-logger`,
-    `@pockethost/plugin-launcher-spawn`,
-    `@pockethost/plugin-auto-admin`,
-  ]),
-
-  PH_HOME: mkPath(_PH_HOME),
-  PH_PROJECT_DIR: mkPath(_PH_PROJECT_DIR),
-
-  PH_INTERNAL_HOST: mkString('localhost'),
-  PH_APEX_DOMAIN: mkString(_APEX_DOMAIN),
-
-  PH_PORT: mkNumber(3000),
-
-  PH_DATA_DIR: mkPath(join(_PH_HOME, 'data'), { create: true }),
-  PH_DEV: mkBoolean(IS_DEV()),
-  PH_DEBUG: mkBoolean(DEBUG()),
-  PH_INTERNAL_APP_SECRET: mkString(''),
-})
-
-/** Accessors */
-export const PH_PLUGINS = () => settings.PH_PLUGINS
-
-export const PH_HOME = (...paths: string[]) => join(settings.PH_HOME, ...paths)
-export const PH_PROJECT_DIR = (...paths: string[]) =>
-  join(settings.PH_PROJECT_DIR, ...paths)
-
-export const APEX_DOMAIN = () => settings.PH_APEX_DOMAIN
-
-export const PORT = () => settings.PH_PORT
-
-export const DATA_DIR = (...paths: string[]) =>
-  join(settings.PH_DATA_DIR, ...paths)
-export const NODE_ENV = () => process.env.NODE_ENV
-export const INSTANCE_DATA_DIR = (id: InstanceId, ...paths: string[]) =>
-  join(DATA_DIR(), id, ...paths)
-export const INTERNAL_HOST = () => settings.PH_INTERNAL_HOST
-export const INTERNAL_APP_SECRET = () => settings.PH_INTERNAL_APP_SECRET
-export const INTERNAL_APP_URL = (...paths: string[]) =>
-  `${HTTP_PROTOCOL()}//${INTERNAL_HOST()}:${PORT()}/${INTERNAL_APP_PREFIX}/${join(
-    ...paths,
-  )}`
-export const INTERNAL_APP_PREFIX = `_internal`
-export const INTERNAL_APP_AUTH_HEADER = `x-pockethost-authorization`
-export const HTTP_PROTOCOL = () => (PORT() === 443 ? 'https:' : 'http:')
-export const PUBLIC_INSTANCE_URL = ({ subdomain }: Partial<InstanceFields>) => {
-  const url = new URL(`${HTTP_PROTOCOL()}//${subdomain}.${APEX_DOMAIN()}`)
-  url.port = `${PORT() === 80 || PORT() == 443 ? '' : PORT()}`
-  return url
-}