pockethost 1.7.0 → 3.0.0

package/src/cli/commands/PluginCommand/plugin-template/src/plugin.ts

@@ -1,58 +0,0 @@
-import { Command } from 'commander'
-import { produce } from 'immer'
-import {
-  PocketHostPlugin,
-  onCliCommandsFilter,
-  onInstanceConfigFilter,
-  onServeAction,
-  onServeSlugsFilter,
-  onSettingsFilter,
-} from 'pockethost'
-import {
-  PLUGIN_NAME,
-  PLUGIN_NAME_CONSTANT_CASE,
-  PROJECT_DIR,
-  settings,
-} from './constants'
-import { DbService } from './db'
-import { dbg } from './log'
-
-export const plugin: PocketHostPlugin = async ({}) => {
-  dbg(`initializing ${PLUGIN_NAME}`)
-
-  await DbService({})
-
-  onInstanceConfigFilter(async (config) => {
-    return produce(config, (draft) => {
-      draft.env[`PH_${PLUGIN_NAME_CONSTANT_CASE}_ENABLED`] = true.toString()
-      draft.binds.hooks.push({
-        src: PROJECT_DIR(`src/instance-app/hooks/**/*`),
-        base: PROJECT_DIR(`src/instance-app/hooks`),
-      })
-    })
-  })
-
-  onCliCommandsFilter(async (commands) => {
-    return [
-      ...commands,
-      new Command(PLUGIN_NAME).description(`Command root`).addCommand(
-        new Command(`serve`)
-          .description(`Run a task`)
-          .action(async (options) => {
-            // do something
-          }),
-      ),
-    ]
-  })
-
-  onServeSlugsFilter(async (slugs) => {
-    return [...slugs, PLUGIN_NAME]
-  })
-
-  onServeAction(async ({ only }) => {
-    if (!only.includes(PLUGIN_NAME)) return
-    // Do something
-  })
-
-  onSettingsFilter(async (allSettings) => ({ ...allSettings, ...settings }))
-}

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

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

@@ -1,36 +0,0 @@
-import { Command } from 'commander'
-import {
-  LoggerService,
-  doServeAction,
-  doServeSlugsFilter,
-} from '../../../common'
-
-type Options = {
-  only: string[]
-}
-
-export const ServeCommand = async () => {
-  const serveSlugs = await doServeSlugsFilter([])
-
-  const cmd = new Command(`serve`)
-    .description(`Run PocketHost`)
-    .option(
-      `-o, --only <only>`,
-      `Only run the specified services`,
-      (s) =>
-        s
-          .split(/,/)
-          .map((s) => s.trim())
-          .filter((s) => serveSlugs.includes(s)),
-      serveSlugs,
-    )
-    .action(async (options: Options, cmd: Command) => {
-      const logger = LoggerService().create(`ServeCommand`)
-      const { dbg, error, info, warn } = logger
-      info(`Starting`)
-
-      const { only } = options
-      await doServeAction({ only })
-    })
-  return cmd
-}

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()]
-}