pockethost 1.0.0-rc.1 → 1.1.0

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

@@ -0,0 +1,140 @@
+import { exec } from 'child_process'
+import fs from 'fs/promises'
+import { Listr, ListrTask } from 'listr2'
+import { createRequire } from 'module'
+import fetch from 'node-fetch'
+import semver from 'semver'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+const require = createRequire(import.meta.url)
+
+export async function getPackageJson(packageName: string): Promise<any | null> {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'))
+    return packageJson
+  } catch (error) {
+    return null
+  }
+}
+
+export async function fetchPackageData(
+  packageName: string,
+): Promise<any | null> {
+  const npmRegistryUrl = `https://registry.npmjs.org/${packageName}`
+  try {
+    const response = await fetch(npmRegistryUrl)
+    return await response.json()
+  } catch (error) {
+    return null
+  }
+}
+
+async function installPackage(
+  packageName: string,
+  version: string,
+): Promise<void> {
+  try {
+    await execPromise(`npm install -g ${packageName}@${version}`)
+  } catch (e) {
+    throw new Error(`Error installing ${packageName}@${version}: ${e}`)
+  }
+}
+
+export async function removePackage(packageName: string): Promise<void> {
+  try {
+    await execPromise(`npm remove -g ${packageName}`)
+  } catch (e) {
+    throw new Error(`Error removing ${packageName}: ${e}`)
+  }
+}
+
+async function checkPackageCompatibility(
+  packageA: string,
+  versionA: string,
+  packageB: string,
+): Promise<string> {
+  const localPackageJson = await getPackageJson(packageB)
+
+  if (localPackageJson) {
+    const { version: localPackageBVersion, dependencies } = localPackageJson
+
+    if (dependencies && semver.satisfies(versionA, dependencies[packageA])) {
+      return `Local ${packageB}@${localPackageBVersion} is already compatible with ${packageA}@${versionA}`
+    }
+  }
+
+  const packageBData = await fetchPackageData(packageB)
+  if (!packageBData) {
+    throw new Error(`Error fetching data for ${packageB}`)
+  }
+
+  const versions = packageBData.versions
+  let latestCompatibleVersion: string | null = null
+
+  for (const version in versions) {
+    const dependencies = versions[version].dependencies
+    if (
+      dependencies &&
+      packageA in dependencies &&
+      semver.satisfies(versionA, dependencies[packageA])
+    ) {
+      if (
+        !latestCompatibleVersion ||
+        semver.gt(version, latestCompatibleVersion)
+      ) {
+        latestCompatibleVersion = version
+      }
+    }
+  }
+
+  if (latestCompatibleVersion) {
+    await installPackage(packageB, latestCompatibleVersion)
+    return `${packageB}@${latestCompatibleVersion} installed successfully`
+  } else {
+    throw new Error(
+      `No compatible version of ${packageB} found for ${packageA}@${versionA}`,
+    )
+  }
+}
+
+export async function getCompatibleVersions(
+  packageA: string,
+  versionA: string,
+  packagesB: string[],
+): Promise<void> {
+  const tasks = packagesB.map(
+    (packageB) =>
+      ({
+        title: `Checking ${packageB}...`,
+        task: async (_, task) => {
+          try {
+            const result = await checkPackageCompatibility(
+              packageA,
+              versionA,
+              packageB,
+            )
+            task.output = result
+          } catch (error) {
+            task.output = `${error}`
+            throw error
+          }
+        },
+      }) as ListrTask,
+  )
+
+  const listr = new Listr(tasks, {
+    concurrent: true,
+    rendererOptions: { collapseSubtasks: false },
+  })
+
+  await listr.run()
+}
+
+// Example usage
+// const packageA = 'express'
+// const versionA = '4.17.1'
+// const packagesB = ['some-package', 'another-package', 'yet-another-package']
+
+// getCompatibleVersions(packageA, versionA, packagesB)

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

@@ -0,0 +1,20 @@
+import { Command } from 'commander'
+import { LoggerService } from '../../../common'
+import { serve } from '../../../server'
+
+type Options = {
+  isolate: boolean
+}
+
+export const ServeCommand = () => {
+  const cmd = new Command(`serve`)
+    .description(`Run PocketHost`)
+    .action(async (options: Options) => {
+      const logger = LoggerService().create(`ServeCommand`)
+      const { dbg, error, info, warn } = logger
+      info(`Starting`)
+
+      await serve()
+    })
+  return cmd
+}

package/src/cli/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env tsx
+
+import { uniq } from '@s-libs/micro-dash'
+import { Command, program } from 'commander'
+import {
+  DEBUG,
+  LogLevelName,
+  LoggerService,
+  PH_PLUGINS,
+  PocketHostFilter,
+  filter,
+  loadPlugins,
+} from '../../core'
+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 const main = async () => {
+  await loadPlugins(uniq(PH_PLUGINS()))
+
+  program.name('pockethost').description('Multitenant PocketBase hosting')
+
+  const commands = await filter<Command[]>(PocketHostFilter.Core_CliCommands, [
+    ServeCommand(),
+    ConfigCommand(),
+    PluginCommand(),
+  ])
+  for (const command of commands) {
+    program.addCommand(command)
+  }
+
+  await program.parseAsync()
+}
+
+main()

package/src/common/CleanupManager.ts

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,168 @@
+/// <require "node">
+
+import chalk from 'chalk'
+import stringify from 'json-stringify-safe'
+import { PocketHostAction, action, 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 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) =>
+    [s, ...pfx]
+      .filter((v) => !!v)
+      .map((p) => `[${p}]`)
+      .join(' ')
+
+  const _log = (levelIn: LogLevelName, ...args: any[]) => {
+    action(PocketHostAction.Core_Log, _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 [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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,26 @@
+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

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,12 @@
+export * from './CleanupManager'
+export * from './Logger'
+export * from './TimerManager'
+export * from './assert'
+export * from './debug'
+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/mergeConfig.ts

@@ -0,0 +1,27 @@
+/**
+ * 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

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