@meith/cli 0.16.0

package/src/profile-fields.ts

@@ -0,0 +1,107 @@
+import { ValidationError } from '@meith/core'
+import { getDb, PostgresProfileFieldRepository } from '@meith/db'
+import { FIELD_TYPES, ProfileFieldService } from '@meith/profile-fields'
+
+import { type Flags, optional, parseFlags, required } from './args'
+import { requirePostgres } from './context'
+
+function service(): ProfileFieldService {
+  requirePostgres()
+  return new ProfileFieldService({ fields: new PostgresProfileFieldRepository(getDb()) })
+}
+
+function flag(flags: Flags, name: string): boolean {
+  const raw = optional(flags, name)
+  if (raw === undefined) return false
+  const value = raw.toLowerCase()
+  if (['1', 'true', 'yes', 'on'].includes(value)) return true
+  if (['0', 'false', 'no', 'off'].includes(value)) return false
+  throw new ValidationError(`--${name} must be true or false, got "${raw}".`)
+}
+
+export async function profileFieldList(): Promise<number> {
+  const fields = await service().listAll()
+
+  if (fields.length === 0) {
+    console.log(
+      'No custom profile fields.\n' +
+        'Add one:  community profile-field:add --key pronouns --label Pronouns --type text',
+    )
+    return 0
+  }
+
+  const width = Math.max(...fields.map((f) => f.key.length))
+  console.log(`${fields.length} custom profile field(s):\n`)
+
+  for (const field of fields) {
+    const marks = [
+      field.isActive ? null : 'inactive',
+      field.requiredAtRegistration ? 'required at registration' : null,
+      field.showInPostbit ? 'shown in postbit' : null,
+      field.defaultVisible ? null : 'hidden by default',
+      field.defaultEditable ? null : 'not member-editable',
+    ].filter((mark): mark is string => mark !== null)
+
+    console.log(
+      `  ${field.key.padEnd(width)}  ${field.type ?? 'unknown type'}` +
+        `  "${field.label}"` +
+        (marks.length === 0 ? '' : `  [${marks.join(', ')}]`),
+    )
+    if (field.options.length > 0) {
+      console.log(`  ${' '.repeat(width)}  options: ${field.options.join(', ')}`)
+    }
+  }
+  return 0
+}
+
+export async function profileFieldAdd(args: readonly string[]): Promise<number> {
+  const { flags } = parseFlags(args)
+
+  const type = required(flags, 'type')
+  if (!(FIELD_TYPES as readonly string[]).includes(type)) {
+    throw new ValidationError(`--type must be one of ${FIELD_TYPES.join(', ')}, got "${type}".`)
+  }
+
+  const rawOptions = optional(flags, 'options')
+  const options =
+    rawOptions === undefined
+      ? []
+      : rawOptions
+          .split(',')
+          .map((option) => option.trim())
+          .filter((option) => option !== '')
+
+  const field = await service().create({
+    key: required(flags, 'key'),
+    label: required(flags, 'label'),
+    type,
+    options,
+    requiredAtRegistration: flag(flags, 'required'),
+    showInPostbit: flag(flags, 'postbit'),
+    displayOrder: Number(optional(flags, 'order') ?? 0),
+  })
+
+  console.log(`Created profile field "${field.key}" (id ${field.id}, ${field.type}).`)
+  console.log('Every group can see and edit it. Per-group overrides arrive with the ACP screen.')
+  return 0
+}
+
+export async function profileFieldRemove(args: readonly string[]): Promise<number> {
+  const { positional } = parseFlags(args)
+  const key = positional[0]
+  if (key === undefined) {
+    throw new ValidationError('Usage: community profile-field:remove <key>')
+  }
+
+  const removed = await service().remove(key)
+  if (!removed) {
+    console.error(`No such profile field: ${key}`)
+    return 1
+  }
+
+  console.log(
+    `Removed profile field "${key}" and every member's answer to it.\n` +
+      'To keep the answers and only stop showing the field, set profile_fields.is_active = false instead.',
+  )
+  return 0
+}

package/src/push.ts

@@ -0,0 +1,47 @@
+import { generateVapidKeys } from '@meith/notifications'
+import { SettingsSnapshot, saveSettings } from '@meith/settings'
+
+import { parseFlags } from './args'
+import { createContext } from './context'
+
+export async function pushKeys(args: readonly string[]): Promise<number> {
+  const { flags } = parseFlags(args)
+  const keys = await generateVapidKeys()
+
+  if (flags.get('save') !== 'true') {
+    console.log('push.vapid_public_key   ' + keys.publicKey)
+    console.log('push.vapid_private_key  ' + keys.privateKey)
+    console.log(
+      '\nPaste these into Admin → Settings → Push, or run this again with --save. ' +
+        'Replacing a key that is already in use invalidates every subscription ' +
+        'stored against it.',
+    )
+    return 0
+  }
+
+  const ctx = await createContext()
+  const snapshot = SettingsSnapshot.fromOverrides(await ctx.settings.loadAll())
+
+  const result = await saveSettings(
+    ctx.settings,
+    {
+      'push.vapid_public_key': keys.publicKey,
+      'push.vapid_private_key': keys.privateKey,
+    },
+    snapshot,
+  )
+
+  console.log(
+    result.changed.length === 0
+      ? 'The keys already on this board were not replaced.'
+      : 'Saved a new VAPID key pair. Every subscription stored against the old ' +
+          'pair is now dead, and each browser will resubscribe on its next visit ' +
+          'to the notification preferences screen.',
+  )
+
+  if (!snapshot.get('push.enabled')) {
+    console.log('push.enabled is off — turn it on to offer web push to members.')
+  }
+
+  return 0
+}

package/src/redaction.ts

@@ -0,0 +1,23 @@
+export const SECRET_ENV_KEYS: ReadonlySet<string> = new Set([
+  'AUTH_SECRET',
+  'TICK_SECRET',
+  'METRICS_TOKEN',
+  'DATABASE_URL',
+  'DIRECT_DATABASE_URL',
+  'MAIL_HTTP_TOKEN',
+  'MAIL_SMTP_PASSWORD',
+  'REDIS_URL',
+  'S3_SECRET_ACCESS_KEY',
+])
+
+export const NOT_SECRET_DESPITE_THE_NAME: ReadonlySet<string> = new Set([
+  'MAIL_HTTP_ENDPOINT',
+  'S3_ENDPOINT',
+  'APP_URL',
+  'S3_ACCESS_KEY_ID',
+  'MAIL_SMTP_USERNAME',
+])
+
+export function looksLikeCredential(name: string): boolean {
+  return /SECRET|PASSWORD|TOKEN|_KEY|URL$/.test(name)
+}

package/src/search.ts

@@ -0,0 +1,33 @@
+import { getDb, PostgresSearchRepository } from '@meith/db'
+
+import { requirePostgres } from './context'
+
+const BATCH = 5_000
+
+export async function searchReindex(): Promise<number> {
+  requirePostgres()
+  const search = new PostgresSearchRepository(getDb())
+
+  const before = await search.indexProgress()
+  if (before.pending === 0) {
+    console.log(`Nothing to do: all ${before.indexed} post(s) are indexed.`)
+    return 0
+  }
+
+  console.log(`Indexing ${before.pending} post(s)…`)
+
+  let cursor = 0
+  let indexed = 0
+  for (;;) {
+    const chunk = await search.reindexChunk(cursor, BATCH)
+    indexed += chunk.indexed
+    if (chunk.nextCursor === null) break
+    cursor = chunk.nextCursor
+    console.log(`  ${indexed}…`)
+  }
+
+  const after = await search.indexProgress()
+
+  console.log(`Indexed ${indexed} post(s). ${after.indexed} indexed, ${after.pending} pending.`)
+  return after.pending === 0 ? 0 : 1
+}

package/src/tasks.ts

@@ -0,0 +1,69 @@
+import { drivers } from '@meith/drivers'
+import { imageProcessor } from '@meith/drivers/images'
+import { buildSchedulerBundle, type SchedulerBundle } from '@meith/runtime'
+import { tick } from '@meith/tasks'
+
+import { requirePostgres } from './context'
+
+function scheduler(): SchedulerBundle {
+  requirePostgres()
+  return buildSchedulerBundle({
+    queue: drivers().queue,
+    mail: drivers().mail,
+    files: drivers().files,
+    images: imageProcessor,
+  })
+}
+
+export async function taskList(): Promise<number> {
+  const { tasks } = scheduler()
+  const width = Math.max(...tasks.map((t) => t.id.length))
+  console.log(`${tasks.length} registered task(s):\n`)
+  for (const task of tasks) {
+    console.log(`  ${task.id.padEnd(width)}  every ${formatInterval(task.intervalSeconds)}`)
+    console.log(`  ${' '.repeat(width)}  ${task.title}`)
+  }
+  return 0
+}
+
+export async function taskRun(args: readonly string[]): Promise<number> {
+  const only = args[0]
+  const { repository, tasks, onTaskFailure } = scheduler()
+  const selected = only === undefined ? tasks : tasks.filter((t) => t.id === only)
+  if (only !== undefined && selected.length === 0) {
+    console.error(
+      `No such task: ${only}\n` + `Run \`community task:list\` to see what is registered.`,
+    )
+    return 1
+  }
+
+  const outcomes = await tick({ repository, tasks: selected, onError: onTaskFailure })
+
+  const ran = outcomes.filter((o) => o.status === 'ran')
+  const failed = outcomes.filter((o) => o.status === 'failed')
+  const skipped = outcomes.filter((o) => o.status === 'skipped')
+
+  for (const outcome of [...ran, ...failed]) {
+    const detail = outcome.detail === undefined ? '' : ` ${JSON.stringify(outcome.detail)}`
+    console.log(
+      `${outcome.status === 'ran' ? 'ran    ' : 'FAILED '} ${outcome.taskId}` +
+        ` (${outcome.durationMs}ms)${detail}` +
+        (outcome.error === undefined ? '' : `\n        ${outcome.error}`),
+    )
+  }
+  if (skipped.length > 0) {
+    console.log(
+      `skipped ${skipped.length} not due or already claimed: ` +
+        skipped.map((o) => o.taskId).join(', '),
+    )
+  }
+  if (outcomes.length === 0) console.log('Nothing registered to run.')
+
+  return failed.length > 0 ? 1 : 0
+}
+
+function formatInterval(seconds: number): string {
+  if (seconds % 3600 === 0) return `${seconds / 3600}h`
+  if (seconds % 60 === 0) return `${seconds / 60}m`
+  return `${seconds}s`
+}

package/src/upgrade.ts

@@ -0,0 +1,125 @@
+import {
+  appliedPluginMigrations,
+  applyPluginMigration,
+  getDb,
+  PostgresNavigationRepository,
+  readVersion,
+  recordVersion,
+  runMigrations,
+} from '@meith/db'
+import { type PluginDefinition, pluginNavigationPlacements } from '@meith/plugin-kit'
+import { runPluginLifecycle } from '@meith/runtime'
+import { type PluginUpgrade, planUpgrade, upgradeNotice } from '@meith/upgrade'
+
+export const CODE_VERSION = '0.16.0'
+
+export function pluginUpgrades(plugins: readonly PluginDefinition[]): readonly PluginUpgrade[] {
+  return plugins.map((plugin) => ({
+    key: plugin.key,
+    version: plugin.version,
+    dependsOn: plugin.dependsOn ?? [],
+    migrationIds: (plugin.migrations ?? []).map((migration) => migration.id),
+  }))
+}
+
+export interface UpgradeOptions {
+  readonly dryRun: boolean
+  readonly plugins: readonly PluginDefinition[]
+  readonly log: (line: string) => void
+}
+
+export async function upgrade(options: UpgradeOptions): Promise<number> {
+  const db = getDb()
+  const plugins = pluginUpgrades(options.plugins)
+
+  const recordedVersion = (await readVersion(db, 'core')) ?? CODE_VERSION
+
+  const fresh: string[] = []
+  for (const plugin of options.plugins) {
+    if ((await readVersion(db, `plugin:${plugin.key}`)) === null) fresh.push(plugin.key)
+  }
+
+  const applied: Record<string, readonly string[]> = {}
+  for (const plugin of plugins) {
+    applied[plugin.key] = await appliedPluginMigrations(db, plugin.key)
+  }
+
+  const state = {
+    recordedVersion,
+    codeVersion: CODE_VERSION,
+    pendingCoreMigrations: [] as readonly string[],
+    plugins,
+    appliedPluginMigrations: applied,
+  }
+
+  const plan = planUpgrade(state)
+
+  if (plan.refusal !== null || plan.orderFailure !== null) {
+    options.log(upgradeNotice(plan, state) ?? 'This board cannot be upgraded.')
+    return 1
+  }
+
+  options.log(options.dryRun ? 'Plan:' : 'Upgrading…')
+  options.log('  1. apply pending core migrations')
+
+  let stepNumber = 2
+  for (const plugin of plugins) {
+    const pending = plugin.migrationIds.filter((id) => !(applied[plugin.key] ?? []).includes(id))
+    if (pending.length === 0) continue
+    options.log(`  ${stepNumber++}. ${plugin.key}: ${pending.join(', ')}`)
+  }
+  for (const key of fresh) {
+    if (options.plugins.find((plugin) => plugin.key === key)?.onInstall === undefined) continue
+    options.log(`  ${stepNumber++}. ${key}: onInstall`)
+  }
+  options.log(`  ${stepNumber++}. reconcile plugin navigation`)
+  options.log(`  ${stepNumber}. record version ${CODE_VERSION}`)
+
+  if (options.dryRun) {
+    options.log('')
+    options.log('Nothing was changed. Run without --dry-run to apply.')
+    return 0
+  }
+
+  const count = await runMigrations()
+  options.log(count === 0 ? 'Core: already up to date.' : `Core: applied ${count} migration(s).`)
+
+  for (const plugin of plugins) {
+    const definition = options.plugins.find((entry) => entry.key === plugin.key)
+    for (const migration of definition?.migrations ?? []) {
+      const ran = await applyPluginMigration(db, plugin.key, migration.id, migration.statements)
+      if (ran) options.log(`${plugin.key}: applied ${migration.id}.`)
+    }
+    /*
+     * onInstall runs after this plugin's migrations, so its tables exist, and
+     * before the version row that will stop it running again. A throw here
+     * stops the upgrade: a plugin that could not finish installing is one the
+     * board should not start serving.
+     */
+    if (fresh.includes(plugin.key) && definition !== undefined) {
+      const { ran } = await runPluginLifecycle({ db, plugin: definition, phase: 'install' })
+      if (ran) options.log(`${plugin.key}: onInstall.`)
+    }
+
+    await recordVersion(db, `plugin:${plugin.key}`, plugin.version)
+  }
+
+  const navigation = await new PostgresNavigationRepository(db).syncPluginItems(
+    pluginNavigationPlacements(options.plugins).map((item) => ({
+      key: item.key,
+      href: item.href,
+      audience: item.audience,
+      parentKey: item.parentKey,
+    })),
+  )
+  if (navigation.added.length > 0) {
+    options.log(`Navigation: added ${navigation.added.join(', ')}.`)
+  }
+  if (navigation.removed.length > 0) {
+    options.log(`Navigation: removed ${navigation.removed.join(', ')}.`)
+  }
+
+  await recordVersion(db, 'core', CODE_VERSION)
+  options.log(`Recorded version ${CODE_VERSION}.`)
+  return 0
+}