pockethost 1.7.0 → 3.1.0

package/src/core/Settings.ts

@@ -1,119 +0,0 @@
-import { boolean as castToBoolean } from 'boolean'
-import { existsSync, mkdirSync } from 'fs'
-
-export type SettingsCaster<TValue, TConfig = {}> = {
-  stringToType: (value: string, config?: Partial<TConfig>) => TValue
-  typeToString: (value: TValue, config?: Partial<TConfig>) => string
-}
-
-export type SettingsHandler<TValue> = {
-  get: () => TValue
-  set: (value: TValue) => void
-}
-
-export type SettingsHandlerFactory<TValue> = (
-  key: string,
-) => SettingsHandler<TValue>
-
-export type SettingsMaker<TValue, TConfig = {}> = (
-  _default?: TValue,
-  config?: Partial<TConfig>,
-) => SettingsHandlerFactory<TValue>
-
-const mkMaker =
-  <TValue, TConfig = {}>(
-    caster: SettingsCaster<TValue, TConfig>,
-  ): SettingsMaker<TValue, TConfig> =>
-  (_default, config) =>
-  (name: string) => {
-    return {
-      get(): TValue {
-        const v = process.env[name]
-        if (typeof v === `undefined`) {
-          if (typeof _default === `undefined`)
-            throw new Error(`${name} must be defined`)
-          this.set(_default)
-          return this.get()
-        }
-        try {
-          return caster.stringToType(v, config)
-        } catch (e) {
-          throw new Error(`${name}: ${e}`)
-        }
-      },
-      set(v: TValue) {
-        try {
-          process.env[name] = caster.typeToString(v, config)
-        } catch (e) {
-          throw new Error(`${name}: ${e}`)
-        }
-      },
-    }
-  }
-
-export const mkBoolean = mkMaker<boolean>({
-  stringToType: (v) => castToBoolean(v),
-  typeToString: (v) => `${v}`,
-})
-
-export const mkNumber = mkMaker<number>({
-  stringToType: (s) => parseInt(s, 10),
-  typeToString: (v) => v.toString(),
-})
-
-export const mkPath = mkMaker<string, { create: boolean; required: boolean }>({
-  stringToType: (v, options) => {
-    const { create = false, required = true } = options || {}
-    if (create) {
-      mkdirSync(v, { recursive: true })
-    }
-    if (required && !existsSync(v)) {
-      throw new Error(`${v} must exist.`)
-    }
-    return v
-  },
-  typeToString: (v, options) => {
-    const { create = false, required = true } = options || {}
-    if (create) {
-      mkdirSync(v, { recursive: true })
-    }
-    if (required && !existsSync(v)) {
-      throw new Error(`${v} must exist.`)
-    }
-    return v
-  },
-})
-
-export const mkString = mkMaker<string>({
-  typeToString: (v) => v,
-  stringToType: (v) => v,
-})
-
-export const mkCsvString = mkMaker<string[]>({
-  typeToString: (v) => v.join(','),
-  stringToType: (s) =>
-    s
-      .split(/,/)
-      .map((s) => s.trim())
-      .filter((v) => !!v),
-})
-
-type Config<T> = {
-  [K in keyof T]: SettingsHandlerFactory<T[K]>
-}
-
-export const Settings = <T extends Object>(config: Config<T>) => {
-  const lookup: Partial<T> = {}
-
-  for (const key in config) {
-    const handler = config[key as keyof T](key)
-    Object.defineProperty(lookup, key, {
-      get: () => handler.get(),
-      set: (value) => handler.set(value),
-      enumerable: true,
-    })
-    handler.get() // Initialize process.env
-  }
-
-  return lookup as T
-}

package/src/core/asyncExecutionGuard.ts

@@ -1,49 +0,0 @@
-import { uniqueId } from '@s-libs/micro-dash'
-import Bottleneck from 'bottleneck'
-import { SetReturnType } from 'type-fest'
-import { LoggerService } from '../common/Logger'
-
-const limiters: { [lane: string]: Bottleneck } = {}
-export const serialAsyncExecutionGuard = <
-  T extends (...args: any[]) => Promise<any>,
->(
-  cb: T,
-  lane?: SetReturnType<T, string>,
-): T => {
-  const uuid = uniqueId()
-  const _lane = lane || (() => uuid)
-  const wrapper = (...args: Parameters<T>) => {
-    const { dbg } = LoggerService().create('serialAsyncExecutionGuard')
-    const key = _lane(...args)
-    if (!limiters[key]) {
-      dbg(`New serial limiter with key ${key}`)
-      limiters[key] = new Bottleneck({ maxConcurrent: 1 })
-    }
-    const limiter = limiters[key]!
-    return limiter.schedule(() => cb(...args)) as unknown as ReturnType<T>
-  }
-  return wrapper as unknown as T
-}
-
-const singletons: { [_: string]: Promise<any> } = {}
-export const singletonAsyncExecutionGuard = <
-  T extends (...args: any[]) => Promise<any>,
->(
-  cb: T,
-  key: SetReturnType<T, string>,
-): T => {
-  const uuid = uniqueId()
-  const keyFactory = key || (() => uuid)
-  const wrapper = (...args: Parameters<T>) => {
-    const { dbg } = LoggerService().create(`singletonAsyncExecutionGuard`)
-    const key = keyFactory(...args)
-    //@ts-ignore
-    if (singletons[key]) {
-      return singletons[key] as unknown as ReturnType<T>
-    }
-    dbg(`New singleton guard with key ${key}`)
-    singletons[key] = cb(...args)
-    return singletons[key] as unknown as ReturnType<T>
-  }
-  return wrapper as unknown as T
-}

package/src/core/config.ts

@@ -1,108 +0,0 @@
-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/exit.ts

@@ -1,11 +0,0 @@
-import exitHook, { asyncExitHook as _, gracefulExit as __ } from 'exit-hook'
-
-export const asyncExitHook = (cb: () => Promise<void>) => _(cb, { wait: 5000 })
-
-export const gracefulExit = async (signal?: number) => {
-  __(signal)
-  await new Promise((resolve) => {
-    process.on('exit', resolve)
-  })
-}
-export { exitHook }

package/src/core/index.ts

@@ -1,8 +0,0 @@
-export * from '../constants'
-export * from './Settings'
-export * from './asyncExecutionGuard'
-export * from './config'
-export * from './exit'
-export * from './internal'
-export * from './smartFetch'
-export * from './tryFetch'

package/src/core/internal.ts

@@ -1,3 +0,0 @@
-export const mkInternalAddress = (port: number) => `127.0.0.1:${port}`
-export const mkInternalUrl = (port: number) =>
-  `http://${mkInternalAddress(port)}`

package/src/core/smartFetch.ts

@@ -1,32 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
-import fetch from 'node-fetch'
-import { dirname } from 'path'
-import { LoggerService } from '../common'
-
-export const smartFetch = async <TRet>(
-  url: string,
-  path: string,
-): Promise<TRet> => {
-  const { dbg } = LoggerService().create(`smartFetch`)
-
-  const data = await (async () => {
-    try {
-      const res = await fetch(url)
-      if (res.status !== 200) {
-        throw new Error(`API appears to be down`)
-      }
-      const data = (await res.json()) as TRet
-      return data
-    } catch (e) {
-      dbg(`Caught error on fetch: ${e}`)
-      if (!existsSync(path)) {
-        throw new Error(`API down and no cache`)
-      }
-      dbg(`Using data from cache`)
-      return JSON.parse(readFileSync(path).toString()) as TRet
-    }
-  })()
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, JSON.stringify(data))
-  return data as TRet
-}

package/src/core/tryFetch.ts

@@ -1,69 +0,0 @@
-import fetch, { RequestInit, Response } from 'node-fetch'
-import { LoggerService } from '../common'
-
-export const TRYFETCH_RETRY_MS = 50
-
-export type TryFetchConfig = {
-  preflight: () => Promise<boolean>
-  retryMs: number
-} & RequestInit
-
-/**
- * @param url The URL to fetch
- * @param config { preflight: ()=>Promise<boolean>, retryMs: number}
- * @returns Promise<Response>
- *
- *   TryFetch will continuously try to fetch a URL every `retryMs`, with an
- *   optional `preflight`. If `preflight` is specified, it must resolve to
- *   `true` before tryFetch will attempt to fetch the URL. If `preflight`
- *   resolves to `false`, tryFetch will delay by `retryMs` and then check again.
- *   If `preflight` rejects, then tryFetch rejects and exits.
- *
- *   Note: tryFetch exits ONLY on success or a rejected preflight.
- */
-export const tryFetch = async (
-  url: string,
-  config?: Partial<TryFetchConfig>,
-) => {
-  const { preflight, retryMs }: TryFetchConfig = {
-    preflight: async () => true,
-    retryMs: TRYFETCH_RETRY_MS,
-    ...config,
-  }
-  const logger = LoggerService().create(`tryFetch`).breadcrumb(url)
-  const { dbg } = logger
-  return new Promise<Response>((resolve, reject) => {
-    const again = () => setTimeout(_real_tryFetch, retryMs)
-    const _real_tryFetch = async () => {
-      if (preflight) {
-        try {
-          dbg(`Preflight: CHECK`)
-          const shouldFetch = await preflight()
-          if (!shouldFetch) {
-            dbg(`Preflight: NOT READY`)
-            again()
-            return
-          }
-          dbg(`Preflight: READY`)
-        } catch (e) {
-          dbg(`Preflight: ABORT`)
-          reject(e)
-          return
-        }
-      }
-      try {
-        dbg(`Fetch: START`)
-        const res = await fetch(url, {
-          ...config,
-          signal: AbortSignal.timeout(500),
-        })
-        dbg(`Fetch: SUCCESS`)
-        resolve(res)
-      } catch (e) {
-        dbg(`Fetch: ERROR: trying again in ${retryMs}ms | ${e}`)
-        again()
-      }
-    }
-    _real_tryFetch()
-  })
-}

package/src/plugin.ts

@@ -1,54 +0,0 @@
-import { forEach } from '@s-libs/micro-dash'
-import { produce } from 'immer'
-import {
-  PocketHostPlugin,
-  doSettingsFilter,
-  namespace,
-  newId,
-  onAfterPluginsLoadedAction,
-  onInstanceConfigFilter,
-  onInstanceLogAction,
-  onServeAction,
-  onServeSlugsFilter,
-} from '../common'
-import { dbg, info } from './cli'
-import { INTERNAL_APP_SECRET, PH_PROJECT_DIR, settings } from './constants'
-import { setConfig } from './core/config'
-import { serve } from './server'
-
-export const pockethost: PocketHostPlugin = async ({}) => {
-  onInstanceConfigFilter(async (config) => {
-    return produce(config, (draft) => {
-      draft.binds.hooks.push({
-        src: PH_PROJECT_DIR(`src/instance-app/hooks/**/*`),
-        base: PH_PROJECT_DIR(`src/instance-app/hooks`),
-      })
-    })
-  })
-
-  onInstanceLogAction(async ({ instance, type, data }) => {
-    dbg(namespace(instance.subdomain, type), data.toString())
-  })
-
-  onServeAction(async ({ only }) => {
-    if (!only.includes(`pockethost`)) return
-    serve()
-  })
-
-  onServeSlugsFilter(async (slugs) => {
-    return [...slugs, `pockethost`]
-  })
-
-  onAfterPluginsLoadedAction(async () => {
-    const allSettings = await doSettingsFilter(settings)
-    forEach(allSettings, (v, k) => {
-      dbg(`${k}: ${v}`)
-    })
-  }, 99)
-
-  onAfterPluginsLoadedAction(async () => {
-    if (INTERNAL_APP_SECRET()) return
-    info(`Generating internal app secret...`)
-    setConfig(`PH_INTERNAL_APP_SECRET`, newId(30))
-  })
-}

package/src/server.ts

@@ -1,129 +0,0 @@
-import express, { ErrorRequestHandler } from 'express'
-import 'express-async-errors'
-import { default as httpProxy } from 'http-proxy'
-import {
-  LoggerService,
-  doAfterInstanceFoundAction,
-  doAfterServerStartAction,
-  doAppMountedAction,
-  doGetInstanceByRequestInfoFilter,
-  doGetOrProvisionInstanceUrlFilter,
-  doIncomingRequestAction,
-  doRequestErrorAction,
-  doRequestErrorMessageFilter,
-} from '../common'
-import {
-  APEX_DOMAIN,
-  INTERNAL_APP_AUTH_HEADER,
-  INTERNAL_APP_PREFIX,
-  INTERNAL_APP_SECRET,
-  PORT,
-  asyncExitHook,
-} from '../core'
-
-export const serve = async () => {
-  const _proxyLogger = LoggerService().create('ProxyService')
-  const { dbg, error, info, trace, warn } = _proxyLogger
-
-  // 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) => {
-    warn(`Proxy error ${err} on ${req.url} (${req.headers.host})`)
-    console.log(err)
-  })
-
-  const app = express()
-
-  app.get('/_api/health', (req, res, next) => {
-    res.json({ status: 'ok' })
-    res.end
-  })
-
-  const errorHandler: ErrorRequestHandler = async (err, req, res, next) => {
-    doRequestErrorAction({ err })
-    res.status(500).send(await doRequestErrorMessageFilter(err.toString()))
-  }
-  app.use(errorHandler)
-
-  const internalApp = express()
-  internalApp.use((req, res, next) => {
-    dbg(`Got a request to internal app ${req.url}`)
-    next()
-  })
-  internalApp.use((req, res, next) => {
-    const authHeader = req.headers[INTERNAL_APP_AUTH_HEADER]
-    const internalAppSecret = INTERNAL_APP_SECRET()
-
-    if (authHeader !== internalAppSecret) {
-      res.status(403).send('Forbidden')
-      return
-    }
-
-    next()
-  })
-  app.use(`/${INTERNAL_APP_PREFIX}`, internalApp)
-
-  doAppMountedAction({ app, internalApp })
-
-  app.all(`*`, async (req, res, next) => {
-    const method = req.method
-    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} (${subdomain}) -> ${`http://localhost:${PORT()}`}`,
-    )
-
-    await doIncomingRequestAction({ req, res, host })
-
-    const instance = await doGetInstanceByRequestInfoFilter(undefined, {
-      req,
-      res,
-      host,
-      subdomain,
-    })
-    if (!instance) {
-      res.status(404).end(`${host} not found`)
-      return
-    }
-
-    await doAfterInstanceFoundAction({
-      instance,
-      req,
-      res,
-      host,
-    })
-
-    const url = await doGetOrProvisionInstanceUrlFilter('', {
-      instance,
-    })
-
-    dbg(`Forwarding request for ${req.url} to instance ${url}`)
-
-    proxy.web(req, res, { target: url })
-
-    // next()
-  })
-
-  app.listen(PORT(), () => {
-    info(`pockethost listening on port ${PORT()}`)
-    doAfterServerStartAction()
-  })
-
-  asyncExitHook(async () => {
-    info(`Shutting down pockethost`)
-  })
-}