pockethost 1.4.0 → 1.6.0

package/src/common/plugin/action.ts

@@ -1,9 +1,12 @@
+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',
@@ -18,6 +21,8 @@ enum CoreActions {
   BeforeInstanceStarted = 'core_before_instance_started',
   AfterInstanceStarted = 'core_after_instance_started',
 
+  KillInstance = 'core_kill_instance',
+
   BeforeInstanceStopped = 'core_before_instance_stopped',
   AfterInstanceStopped = 'core_after_instance_stopped',
 
@@ -27,20 +32,34 @@ enum CoreActions {
   Request = 'core_edge_request',
 }
 
-const actions: {
-  [key: string]: ActionHandler<any>[]
-} = {}
-
 export type ActionHandler<TContext = {}> = (
   context: TContext extends never ? [] : TContext,
 ) => Promise<void>
 
-async function registerAction(
+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] = []
-  actions[action]!.push(handler)
+  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) {
@@ -49,7 +68,9 @@ async function action(actionName: string, context: any) {
   }
   const action = actions[actionName]
   if (!action) return false
-  await Promise.all(action.map((handler) => handler(context)))
+  for (const { handler } of action) {
+    await handler(context)
+  }
   return true
 }
 
@@ -58,18 +79,22 @@ export function createCustomActionWithContext<TContext extends {}>(
 ) {
   return [
     async (context: TContext) => action(actionName, context),
-    async (handler: ActionHandler<TContext>) =>
-      registerAction(actionName, handler),
+    (handler: ActionHandler<TContext>, priority = 10) =>
+      registerAction(actionName, handler, priority),
   ] as const
 }
 
 export function createCustomAction(actionName: CoreActions) {
   return [
     async () => action(actionName, {}),
-    async (handler: ActionHandler) => registerAction(actionName, handler),
+    (handler: ActionHandler, priority = 10) =>
+      registerAction(actionName, handler, priority),
   ] as const
 }
 
+export const [doAfterPluginsLoadedAction, onAfterPluginsLoadedAction] =
+  createCustomAction(CoreActions.AfterPluginsLoaded)
+
 export const [doRequestErrorAction, onRequestErrorAction] =
   createCustomActionWithContext<{
     err: Error
@@ -92,7 +117,9 @@ export const [doInstanceLogAction, onInstanceLogAction] =
   }>(CoreActions.InstanceLog)
 
 export const [doAppMountedAction, onAppMountedAction] =
-  createCustomActionWithContext<{ app: Express }>(CoreActions.AppMounted)
+  createCustomActionWithContext<{ app: Express; internalApp: Express }>(
+    CoreActions.AppMounted,
+  )
 
 export const [doIncomingRequestAction, onIncomingRequestAction] =
   createCustomActionWithContext<{ req: Request; res: Response; host: string }>(
@@ -117,6 +144,11 @@ export const [doAfterInstanceStartedAction, onAfterInstanceStartedAction] =
     CoreActions.AfterInstanceStarted,
   )
 
+export const [doKillInstanceAction, onKillInstanceAction] =
+  createCustomActionWithContext<{ instance: InstanceFields }>(
+    CoreActions.KillInstance,
+  )
+
 export const [doBeforeInstanceStoppedAction, onBeforeInstanceStoppedAction] =
   createCustomActionWithContext<{ instance: InstanceFields; url: string }>(
     CoreActions.BeforeInstanceStopped,

package/src/common/plugin/filter.ts

@@ -2,13 +2,19 @@ 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',
@@ -16,6 +22,7 @@ export enum CoreFilters {
   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> = (
@@ -30,14 +37,23 @@ const filters: {
   [key: string]: FilterEntry<any>[]
 } = {}
 
-async function registerFilter<TCarry, TContext extends {} = {}>(
+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 {} = {}>(
@@ -52,7 +68,14 @@ async function filter<TCarry, TContext extends {} = {}>(
   if (!filter) return initialValue
   return filter.reduce(
     (carry, entry) =>
-      carry.then((carryRes) => entry.handler(carryRes, context)),
+      carry
+        .then((carryRes) => entry.handler(carryRes, context))
+        .then((carryRes) => {
+          if (DEBUG()) {
+            console.log(`f:${filterName}`, carryRes, context)
+          }
+          return carryRes
+        }),
     Promise.resolve(initialValue),
   ) as TCarry
 }
@@ -63,8 +86,15 @@ function createCustomFilterWithContext<TCarry, TContext extends {} = {}>(
   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),
+    async <TExtraCarry = unknown>(
+      handler: FilterHandler<TCarry & TExtraCarry, TContext>,
+      priority = 10,
+    ) =>
+      registerFilter<TCarry & TExtraCarry, TContext>(
+        filterName,
+        handler,
+        priority,
+      ),
   ] as const
 }
 
@@ -72,11 +102,24 @@ function createCustomFilter<TCarry>(filterName: string) {
   return [
     async (initialValue: TCarry) =>
       filter<TCarry>(filterName, initialValue, {}),
-    async (handler: FilterHandler<TCarry, {}>, priority = 10) =>
-      registerFilter<TCarry, {}>(filterName, handler, priority),
+    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,
@@ -91,6 +134,22 @@ export const [doGetInstanceByIdFilter, onGetInstanceByIdFilter] =
     { 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)
@@ -105,12 +164,8 @@ export const [
   doGetOrProvisionInstanceUrlFilter,
   onGetOrProvisionInstanceUrlFilter,
 ] = createCustomFilterWithContext<
-  string,
+  string | undefined,
   {
-    req: Request
-    res: Response
-    host: string
-    subdomain: string
     instance: InstanceFields
   }
 >(CoreFilters.GetOrProvisionInstanceUrl)
@@ -118,3 +173,25 @@ export const [
 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/schema/BaseFields.ts

@@ -0,0 +1,10 @@
+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,4 +1,6 @@
 import { doNewInstanceRecordFilter } from '../plugin'
+import { IsoDate } from './BaseFields'
+import { newId, pocketNow } from './util'
 
 export type VersionId = string
 
@@ -21,16 +23,24 @@ export type InstanceSecretCollection = {
 }
 
 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) =>
-  doNewInstanceRecordFilter({
+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/util.ts

@@ -1 +1,7 @@
-export const pocketNow = () => new Date().toISOString()
+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,11 +1,10 @@
-import { forEach } from '@s-libs/micro-dash'
 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 { InstanceId } from './common'
+import { InstanceFields, InstanceId } from './common'
 import { DEBUG, IS_DEV } from './common/debug'
 import { Settings } from './core/Settings'
 
@@ -17,11 +16,7 @@ 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 _HTTP_PROTOCOL = process.env.HTTP_PROTOCOL || `https:`
 
-export function isSettingKey(key: string): key is keyof typeof settings {
-  return key in settings
-}
 export const settings = Settings({
   PH_PLUGINS: mkCsvString([
     `@pockethost/plugin-console-logger`,
@@ -32,6 +27,7 @@ export const settings = Settings({
   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),
@@ -39,6 +35,7 @@ export const settings = Settings({
   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 */
@@ -57,13 +54,17 @@ export const DATA_DIR = (...paths: string[]) =>
 export const NODE_ENV = () => process.env.NODE_ENV
 export const INSTANCE_DATA_DIR = (id: InstanceId, ...paths: string[]) =>
   join(DATA_DIR(), id, ...paths)
-
-export const logConstants = () => {
-  forEach(settings, (v, k) => {
-    console.log(`${k}: ${v}`)
-  })
-}
-
-if (DEBUG()) {
-  logConstants()
+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
 }

package/src/core/config.ts

@@ -0,0 +1,108 @@
+import { forEach, keys, omit, uniq } from '@s-libs/micro-dash'
+import { parse } from 'dotenv'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { info } from '../cli'
+import { PH_HOME, settings } from '../constants'
+
+const envFile = () => {
+  const envFile = PH_HOME(`.env`)
+  if (!existsSync(envFile)) {
+    writeFileSync(envFile, '')
+  }
+  return envFile
+}
+
+export const setConfig = (name: string, value: string) => {
+  if (value === '=') throw new Error(`Invalid value ${value}`)
+
+  const values = _parse()
+  values[name] = value
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  process.env[name] = value
+  info(`Set ${name}=${value}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const unsetConfig = (name: string) => {
+  const values = _parse()
+  delete values[name]
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Unset ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const listConfig = () => {
+  const values = _parse()
+
+  if (keys(values).length > 0) {
+    info()
+    info(`Config values from ${envFile()}:`)
+    forEach(values, (v, k) => {
+      info(`\t${k}=${v}`)
+    })
+    info()
+  } else {
+    info(`No config values found in ${envFile()}`)
+  }
+
+  const defaults = omit(settings, keys(values) as any)
+  if (keys(defaults).length > 0) {
+    info(`Default values:`)
+    forEach(settings, (v, k) => {
+      if (k in values) return
+      info(`\t${k}=${v}`)
+    })
+  } else {
+    info(`No default values because all values are defined in ${envFile()}`)
+  }
+}
+
+export const appendConfig = (name: string, value: string) => {
+  const values = _parse()
+  values[name] = uniq([
+    ...(values[name]
+      ?.split(/,/)
+      .map((v) => v.trim())
+      .filter((v) => !!v) || []),
+    value,
+  ]).join(`,`)
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Added ${value} to ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const filterConfig = (name: string, value: string) => {
+  const values = _parse()
+  values[name] = uniq([
+    ...(values[name]
+      ?.split(/,/)
+      .map((v) => v.trim())
+      .filter((v) => v !== value) || []),
+  ]).join(`,`)
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Filtered ${value} from ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const _parse = () =>
+  parse(readFileSync(envFile(), { encoding: 'utf8' }).toString())

package/src/core/index.ts

@@ -1,6 +1,7 @@
 export * from '../constants'
 export * from './Settings'
 export * from './asyncExecutionGuard'
+export * from './config'
 export * from './exit'
 export * from './internal'
 export * from './smartFetch'

package/src/core/tryFetch.ts

@@ -1,4 +1,4 @@
-import fetch, { Response } from 'node-fetch'
+import fetch, { RequestInit, Response } from 'node-fetch'
 import { LoggerService } from '../common'
 
 export const TRYFETCH_RETRY_MS = 50
@@ -6,7 +6,7 @@ export const TRYFETCH_RETRY_MS = 50
 export type TryFetchConfig = {
   preflight: () => Promise<boolean>
   retryMs: number
-}
+} & RequestInit
 
 /**
  * @param url The URL to fetch
@@ -53,7 +53,10 @@ export const tryFetch = async (
       }
       try {
         dbg(`Fetch: START`)
-        const res = await fetch(url, { signal: AbortSignal.timeout(500) })
+        const res = await fetch(url, {
+          ...config,
+          signal: AbortSignal.timeout(500),
+        })
         dbg(`Fetch: SUCCESS`)
         resolve(res)
       } catch (e) {

package/src/instance-app/types/all.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="./lib.d.ts" />
+/// <reference path="./goja.d.ts" />
+/// <reference path="./types.d.ts" />

package/src/instance-app/types/goja.d.ts

@@ -0,0 +1,58 @@
+interface Require {
+  (id: string): any
+}
+declare var require: Require
+
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
+interface Console {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert) */
+  assert(condition?: boolean, ...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear) */
+  clear(): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count) */
+  count(label?: string): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/countReset)
+   */
+  countReset(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug) */
+  debug(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir) */
+  dir(item?: any, options?: any): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml) */
+  dirxml(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error) */
+  error(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group) */
+  group(...data: any[]): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed)
+   */
+  groupCollapsed(...data: any[]): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd)
+   */
+  groupEnd(): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info) */
+  info(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log) */
+  log(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table) */
+  table(tabularData?: any, properties?: string[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time) */
+  time(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd) */
+  timeEnd(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog) */
+  timeLog(label?: string, ...data: any[]): void
+  timeStamp(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace) */
+  trace(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn) */
+  warn(...data: any[]): void
+}
+
+declare var console: Console

package/src/instance-app/types/lib.d.ts

@@ -0,0 +1,5 @@
+type Logger = (...args: any[]) => void
+
+interface Lib {
+  mkLog: (namespace: string) => Logger
+}