pockethost 1.6.1 → 3.0.0

package/src/cli/index.ts

@@ -1,70 +0,0 @@
-#!/usr/bin/env tsx
-
-import { uniq } from '@s-libs/micro-dash'
-import { program } from 'commander'
-import { readFileSync } from 'fs'
-import minimist from 'minimist'
-import updateNotifier from 'update-notifier'
-import { PH_PLUGINS, PH_PROJECT_DIR } from '../../core'
-import {
-  DEBUG,
-  LogLevelName,
-  LoggerService,
-  doAfterPluginsLoadedAction,
-  doCliCommandsFilter,
-  loadPlugins,
-} from '../common'
-import { pockethost } from '../plugin'
-import { ConfigCommand } from './commands/ConfigCommand'
-import { PluginCommand } from './commands/PluginCommand'
-import { ServeCommand } from './commands/ServeCommand'
-
-export const { dbg, info, error } = LoggerService({
-  level: DEBUG() ? LogLevelName.Debug : LogLevelName.Info,
-})
-
-export type GlobalOptions = {
-  extraPlugins: string[]
-}
-
-export const main = async () => {
-  const pkg = await JSON.parse(
-    readFileSync(PH_PROJECT_DIR(`package.json`), 'utf8').toString(),
-  )
-  updateNotifier({ pkg }).notify()
-
-  const { version } = pkg
-
-  const argv = minimist<{ e: string }>(process.argv.slice(2), {
-    alias: { e: 'extra-plugins' },
-    default: { e: '' },
-  })
-  const extraPlugins = argv.e
-    .split(/,/)
-    .map((s) => s.trim())
-    .filter((v) => !!v)
-
-  await loadPlugins([pockethost, ...uniq(PH_PLUGINS()), ...extraPlugins])
-
-  await doAfterPluginsLoadedAction()
-
-  program
-    .name('pockethost')
-    .description('Multitenant PocketBase hosting')
-    .version(version)
-    .option(`-e, --extra-plugins <plugins...>`, `Extra plugins to load`, [])
-
-  const commands = await doCliCommandsFilter([
-    await ServeCommand(),
-    ConfigCommand(),
-    PluginCommand(),
-  ])
-
-  for (const command of commands) {
-    program.addCommand(command)
-  }
-
-  await program.parseAsync()
-}
-
-main()

package/src/common/CleanupManager.ts

@@ -1,65 +0,0 @@
-import { reduce, uniqueId, values } from '@s-libs/micro-dash'
-import { LoggerService } from '.'
-
-export type CleanupFunc = () => Promise<void> | void
-
-type CleanupRec = {
-  cleanup: CleanupFunc
-  priority: number
-}
-
-export const CLEANUP_DEFAULT_PRIORITY = 10
-export const CLEANUP_PRIORITY_HIGH = 1
-export const CLEANUP_PRIORITY_LOW = 20
-export const CLEANUP_PRIORITY_LAST = 1000
-
-export type CleanupManagerApi = ReturnType<typeof createCleanupManager>
-
-export const createCleanupManager = (slug?: string) => {
-  const _slug = slug || uniqueId()
-
-  const { error, warn, dbg } = LoggerService().create(`cleanupManager:${_slug}`)
-
-  let i = 0
-
-  const cleanups: { [_: number]: CleanupRec } = {}
-
-  const add = (cb: CleanupFunc, priority = CLEANUP_DEFAULT_PRIORITY) => {
-    const idx = i++
-
-    const cleanup = async () => {
-      await cb()
-      delete cleanups[idx]
-    }
-
-    cleanups[idx] = { cleanup, priority }
-
-    return cleanup
-  }
-
-  let _shutdownP: Promise<void> | undefined = undefined
-
-  const shutdown: () => Promise<void> = () => {
-    if (_shutdownP) return _shutdownP
-
-    const _cleanupFuncs = values(cleanups)
-      .sort((a, b) => a.priority - b.priority)
-      .map((v) => v.cleanup)
-    _shutdownP = reduce(
-      _cleanupFuncs,
-      (c, v) => {
-        return c.then(() => v())
-      },
-      Promise.resolve(),
-    ).catch((e) => {
-      error(
-        `Cleanup functions are failing. This should never happen, check all cleanup functions to make sure they are trapping their exceptions.`,
-      )
-      throw e
-    })
-
-    return _shutdownP
-  }
-
-  return { add, shutdown }
-}

package/src/common/Logger.ts

@@ -1,174 +0,0 @@
-/// <require "node">
-
-import chalk from 'chalk'
-import stringify from 'json-stringify-safe'
-import { doLogAction, mergeConfig, mkSingleton } from '.'
-
-export type LoggerConfig = {
-  level: LogLevelName
-  pfx: string[]
-}
-
-export type Logger = ReturnType<typeof createLogger>
-
-export const isLevelLte = (a: LogLevelName, b: LogLevelName) => {
-  return LogLevels[a] <= LogLevels[b]
-}
-
-export const isLevelGt = (a: LogLevelName, b: LogLevelName) => {
-  return LogLevels[a] > LogLevels[b]
-}
-
-export const isLevelGte = (a: LogLevelName, b: LogLevelName) => {
-  return LogLevels[a] >= LogLevels[b]
-}
-
-export enum LogLevelName {
-  Trace = 'trace',
-  Raw = 'raw',
-  Debug = 'debug',
-  Info = 'info',
-  Warn = 'warn',
-  Error = 'error',
-  Abort = 'abort',
-}
-
-export const LEVEL_NAMES = [
-  LogLevelName.Trace,
-  LogLevelName.Raw,
-  LogLevelName.Debug,
-  LogLevelName.Info,
-  LogLevelName.Warn,
-  LogLevelName.Error,
-  LogLevelName.Abort,
-]
-
-export const LogLevels = {
-  [LogLevelName.Trace]: 0,
-  [LogLevelName.Raw]: 1,
-  [LogLevelName.Debug]: 2,
-  [LogLevelName.Info]: 3,
-  [LogLevelName.Warn]: 4,
-  [LogLevelName.Error]: 5,
-  [LogLevelName.Abort]: 6,
-} as const
-
-export const namespace = (...names: string[]) =>
-  names
-    .filter((v) => !!v)
-    .map((p) => `[${p}]`)
-    .join(' ')
-
-export const createLogger = (config: Partial<LoggerConfig>) => {
-  const _config = mergeConfig<LoggerConfig>(
-    {
-      level: LogLevelName.Debug,
-      pfx: [''],
-    },
-    config,
-  )
-  const { pfx } = _config
-
-  const setLevel = (level: LogLevelName) => {
-    _config.level = level
-  }
-
-  const _pfx = (s: string) => namespace(s, ...pfx)
-
-  const _log = (levelIn: LogLevelName, ...args: any[]) => {
-    doLogAction({
-      currentLevel: _config.level,
-      levelIn,
-      args,
-    })
-  }
-
-  const raw = (...args: any[]) => {
-    _log(LogLevelName.Raw, _pfx('RAW'), ...args)
-  }
-
-  const trace = (...args: any[]) => {
-    _log(LogLevelName.Trace, _pfx(`TRACE`), ...args)
-  }
-
-  const dbg = (...args: any[]) => {
-    _log(LogLevelName.Debug, _pfx(chalk.blueBright('DBG')), ...args)
-  }
-
-  const info = (...args: any[]) => {
-    const _args = (() => {
-      if (isLevelGt(LogLevelName.Info, _config.level)) {
-        return [_pfx(chalk.gray(`INFO`)), ...args]
-      }
-      return [...args]
-    })()
-    _log(
-      LogLevelName.Info,
-
-      ..._args,
-    )
-  }
-
-  const warn = (...args: any[]) => {
-    _log(
-      LogLevelName.Warn,
-      _pfx(chalk.yellow(chalk.cyanBright('WARN'))),
-      ...args,
-    )
-  }
-
-  const error = (...args: any[]) => {
-    _log(LogLevelName.Error, ...[_pfx(chalk.bgRed(`ERROR`)), ...args])
-  }
-
-  const criticalError = (...args: any[]) => {
-    _log(LogLevelName.Error, ...[_pfx(chalk.bgRed(`ERROR`)), ...args])
-    new Error().stack?.split(/\n/).forEach((line) => {
-      _log(LogLevelName.Debug, _pfx(chalk.bgRed(`ERROR`)), line)
-    })
-  }
-
-  const abort = (...args: any[]): never => {
-    _log(LogLevelName.Abort, true, ...[_pfx(chalk.bgRed(`ABORT`)), ...args])
-    throw new Error(`Fatal error: ${stringify(args)}`)
-  }
-
-  const create = (s: string, configOverride?: Partial<LoggerConfig>) =>
-    createLogger({
-      ..._config,
-      ...configOverride,
-      pfx: [..._config.pfx, s],
-    })
-
-  const breadcrumb = (s: string) => {
-    pfx.push(s)
-    return api
-  }
-
-  // Compatibility func
-  const child = (extra: any) => create(stringify(extra))
-
-  const api = {
-    raw,
-    dbg,
-    warn,
-    info,
-    error,
-    criticalError,
-    create,
-    child,
-    trace,
-    debug: dbg,
-    breadcrumb,
-    abort,
-    shutdown() {
-      dbg(`Logger shutting down`)
-    },
-    setLevel,
-  }
-  return api
-}
-
-export const LoggerService = mkSingleton((config: Partial<LoggerConfig> = {}) =>
-  createLogger(config),
-)

package/src/common/ResourceAllocator.ts

@@ -1,49 +0,0 @@
-export type Deallocator = () => void
-
-export type Allocator<T> = {
-  free: (item: T) => void
-  alloc: () => [T, Deallocator]
-}
-
-export function ResourceAllocator<T>(
-  initialPoolSize: number,
-  initializer: () => T,
-): Allocator<T> {
-  // Available queue to hold resolved items of type T
-  const available: T[] = []
-
-  // Function to add an item back to the available queue
-  const free = (item: T) => {
-    available.push(item)
-  }
-
-  // Pre-populate the available queue with initial items
-  for (let i = 0; i < initialPoolSize; i++) {
-    available.push(initializer())
-  }
-
-  return {
-    alloc() {
-      if (available.length === 0) {
-        available.push(initializer())
-      }
-      const newItem = initializer()
-      return [newItem, () => free(newItem)]
-    },
-    free,
-  }
-}
-
-/*
-// Example Usage
-const allocator = PromiseAllocator(2, async () => {
-    return new Promise<number>((resolve) => {
-        setTimeout(() => resolve(Math.random()), 1000);
-    });
-});
-
-allocator.alloc().then(([num, freeFunc]) => {
-    console.log(num);  // e.g. 0.123456789
-    freeFunc();  // Adds the number back to the available queue
-});
-*/

package/src/common/TimerManager.ts

@@ -1,64 +0,0 @@
-import { forEach, values } from '@s-libs/micro-dash'
-import { LoggerService } from '.'
-
-export type UnixTimestampMs = number
-export type TimerCanceler = () => void
-
-export type RepeatableTimerCallback = () => boolean | Promise<boolean>
-export type TimerCallback = () => void | Promise<void>
-export type TimeManagerConfig = {}
-
-export type TimeManager = ReturnType<typeof createTimerManager>
-
-export const createTimerManager = (config?: Partial<TimeManagerConfig>) => {
-  const { dbg, error } = LoggerService().create(`timerManager`)
-  let i = 0
-  const cleanups: any = {}
-  let isShutDown = false
-
-  const add = (cb: TimerCallback, ms: UnixTimestampMs) => {
-    if (isShutDown) throw new Error(`Already shut down`)
-    const idx = i++
-    const tid = setTimeout(async () => {
-      cancel()
-      try {
-        await cb()
-      } catch (e) {
-        error(e)
-      }
-    }, ms)
-    const cancel = () => {
-      clearTimeout(tid)
-      delete cleanups[idx]
-    }
-    cleanups[idx] = cancel
-    return cancel
-  }
-
-  const shutdown = () => {
-    isShutDown = true
-
-    dbg(`Canceling  ${values(cleanups.length).length} timers`)
-    forEach(cleanups, (c) => c())
-    dbg(`done`, cleanups)
-  }
-
-  const repeat = (
-    cb: RepeatableTimerCallback,
-    ms: UnixTimestampMs,
-    initial = true,
-  ) => {
-    let _unsub: TimerCanceler | undefined = undefined
-    const _again = async () => {
-      const shouldRepeat = await cb()
-      if (shouldRepeat && !isShutDown) _unsub = add(_again, ms)
-    }
-    add(_again, initial ? 0 : ms)
-    return () => {
-      _unsub?.()
-      _unsub = undefined
-    }
-  }
-
-  return { add, shutdown, repeat }
-}

package/src/common/assert.ts

@@ -1,26 +0,0 @@
-export function assertExists<TType>(
-  v: TType,
-  message = `Value does not exist`,
-): asserts v is NonNullable<TType> {
-  if (typeof v === 'undefined') {
-    throw new Error(message)
-  }
-}
-
-export function assertTruthy<TType>(
-  v: unknown,
-  message = `Value should be truthy`,
-): asserts v is NonNullable<TType> {
-  if (!v) {
-    throw new Error(message)
-  }
-}
-
-export function assert<T>(
-  v: T | undefined | void | null,
-  msg?: string,
-): asserts v is T {
-  if (!v) {
-    throw new Error(msg || `Assertion failure`)
-  }
-}

package/src/common/debug.ts

@@ -1,8 +0,0 @@
-import { boolean } from 'boolean'
-
-export const IS_DEV = () =>
-  `PH_DEV` in process.env
-    ? boolean(process.env.PH_DEV)
-    : process.env.NODE_ENV === 'development'
-export const DEBUG = () =>
-  `PH_DEBUG` in process.env ? boolean(process.env.PH_DEBUG) : IS_DEV()

package/src/common/error.ts

@@ -1,16 +0,0 @@
-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/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
-  }
-}