@celilo/cli 1.5.0 → 1.7.0

package/src/services/public-web-republish.test.ts

@@ -1,189 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { DbClient } from '../db/client';
-import { modules, webRoutes } from '../db/schema';
-import type { ModuleManifest } from '../manifest/schema';
-import { setupTestDatabase } from '../test-utils/setup-test-db';
-import { providesPublicWeb, republishStaticWebConsumers } from './public-web-republish';
-
-const caddyManifest = {
-  provides: { capabilities: [{ name: 'public_web', version: '3.0.0' }] },
-} as unknown as ModuleManifest;
-
-const plainManifest = { provides: { capabilities: [] } } as unknown as ModuleManifest;
-
-describe('republishStaticWebConsumers', () => {
-  let dir: string;
-  let db: DbClient;
-
-  function seedModule(id: string) {
-    db.insert(modules)
-      .values({ id, name: id, version: '1.0.0', manifestData: {}, sourcePath: `/tmp/${id}` })
-      .run();
-  }
-
-  function seedRoute(
-    moduleId: string,
-    slug: string,
-    path: string,
-    type: 'static' | 'reverse_proxy',
-  ) {
-    db.insert(webRoutes)
-      .values({
-        slug,
-        moduleId,
-        type,
-        path,
-        hostname: 'iamtheinternet.org',
-        targetHost: type === 'reverse_proxy' ? '10.0.20.5' : null,
-        targetPort: type === 'reverse_proxy' ? 8080 : null,
-      })
-      .run();
-  }
-
-  function recordingHook(failFor: string[] = []) {
-    const calls: string[] = [];
-    const runHook = (async (moduleId: string) => {
-      calls.push(moduleId);
-      return failFor.includes(moduleId)
-        ? { success: false, outputs: {}, error: 'boom', duration: 1 }
-        : { success: true, outputs: {}, duration: 1 };
-    }) as unknown as Parameters<typeof republishStaticWebConsumers>[0]['runHook'];
-    return { runHook, calls };
-  }
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'pwr-'));
-    const dbPath = join(dir, 'celilo.db');
-    process.env.CELILO_DB_PATH = dbPath;
-    db = await setupTestDatabase(dbPath);
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  test('providesPublicWeb reads the manifest', () => {
-    expect(providesPublicWeb(caddyManifest)).toBe(true);
-    expect(providesPublicWeb(plainManifest)).toBe(false);
-  });
-
-  test('does not run for a module that is not a public_web provider', async () => {
-    seedModule('hello-foo');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'namecheap',
-      manifest: plainManifest,
-      db,
-      runHook,
-    });
-
-    expect(result).toEqual({ ran: false, republished: [], failures: [] });
-    expect(calls).toEqual([]);
-  });
-
-  test('re-runs on_install for every static consumer', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedModule('hello-bar');
-    seedModule('celilo-website');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-bar', 'bar', '/bar', 'static');
-    seedRoute('celilo-website', 'celilo-website', '/', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(result.ran).toBe(true);
-    expect(calls.sort()).toEqual(['celilo-website', 'hello-bar', 'hello-foo']);
-    expect(result.republished.sort()).toEqual(['celilo-website', 'hello-bar', 'hello-foo']);
-    expect(result.failures).toEqual([]);
-  });
-
-  test('skips reverse-proxy-only consumers (no assets on the provider host)', async () => {
-    seedModule('caddy');
-    seedModule('forgejo');
-    seedModule('hello-foo');
-    seedRoute('forgejo', 'git', '/git', 'reverse_proxy');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    const { runHook, calls } = recordingHook();
-
-    await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual(['hello-foo']);
-  });
-
-  test('never re-runs the provider itself', async () => {
-    seedModule('caddy');
-    // A provider that also owns a static route (a landing page of its own).
-    seedRoute('caddy', 'caddy', '/', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual([]);
-    expect(result.republished).toEqual([]);
-  });
-
-  test('de-duplicates a consumer that owns several static routes', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-foo', 'foo-docs', '/foo/docs', 'static');
-    const { runHook, calls } = recordingHook();
-
-    await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual(['hello-foo']);
-  });
-
-  test('one consumer failing does not stop the others', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedModule('hello-bar');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-bar', 'bar', '/bar', 'static');
-    const { runHook, calls } = recordingHook(['hello-foo']);
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls.sort()).toEqual(['hello-bar', 'hello-foo']);
-    expect(result.republished).toEqual(['hello-bar']);
-    expect(result.failures).toEqual([{ moduleId: 'hello-foo', error: 'boom' }]);
-  });
-});

package/src/services/public-web-republish.ts

@@ -1,84 +0,0 @@
-/**
- * Restore consumer content after a public_web provider redeploy.
- *
- * A provider redeploy destroys the provider's host and rebuilds it, taking
- * `/srv/www` with it. The consumers' `web_routes` rows survive — they belong to
- * the consumer modules, not the provider — so the rebuilt provider renders
- * `root * /srv/www/<slug>` for directories that no longer exist and every
- * static site 404s. Nothing re-uploaded the assets; an operator had to redeploy
- * each consumer by hand and there was no signal telling them to.
- *
- * The fix is to do exactly what that operator did: after a provider deploy
- * lands, re-run `on_install` for every module holding a STATIC route.
- * `publishStaticSite` is idempotent (it upserts the route and re-tars the
- * source dir), so the re-run re-registers the route and refills the fresh
- * `/srv/www/<slug>`.
- *
- * Reverse-proxy consumers are skipped: they keep no state on the provider host,
- * so re-running them buys nothing and only widens the blast radius.
- *
- * ponytail: re-runs every static consumer unconditionally rather than probing
- * which /srv/www/<slug> directories are actually missing — O(static consumers)
- * per provider deploy, currently a handful. If a large fleet makes provider
- * deploys slow, probe the provider host first and re-run only the misses.
- */
-
-import { eq } from 'drizzle-orm';
-import type { DbClient } from '../db/client';
-import { webRoutes } from '../db/schema';
-import { createConsoleLogger } from '../hooks/logger';
-import { runNamedHook } from '../hooks/run-named-hook';
-import type { ModuleManifest } from '../manifest/schema';
-
-export interface RepublishFailure {
-  moduleId: string;
-  error: string;
-}
-
-export interface RepublishResult {
-  /** False when the deployed module isn't a public_web provider. */
-  ran: boolean;
-  /** Consumer modules whose on_install was re-run successfully. */
-  republished: string[];
-  failures: RepublishFailure[];
-}
-
-export function providesPublicWeb(manifest: ModuleManifest): boolean {
-  return (manifest.provides?.capabilities ?? []).some((c) => c.name === 'public_web');
-}
-
-export interface RepublishDeps {
-  providerModuleId: string;
-  manifest: ModuleManifest;
-  db: DbClient;
-  /** Injectable for tests. */
-  runHook?: typeof runNamedHook;
-}
-
-export async function republishStaticWebConsumers(deps: RepublishDeps): Promise<RepublishResult> {
-  const { providerModuleId, manifest, db, runHook = runNamedHook } = deps;
-
-  if (!providesPublicWeb(manifest)) {
-    return { ran: false, republished: [], failures: [] };
-  }
-
-  const staticRoutes = db.select().from(webRoutes).where(eq(webRoutes.type, 'static')).all();
-  const consumerIds = [
-    ...new Set(staticRoutes.map((r) => r.moduleId).filter((id) => id !== providerModuleId)),
-  ];
-
-  const republished: string[] = [];
-  const failures: RepublishFailure[] = [];
-
-  for (const moduleId of consumerIds) {
-    const logger = createConsoleLogger(moduleId, 'on_install');
-    const result = await runHook(moduleId, 'on_install', db, logger, {});
-    if (result.success) {
-      republished.push(moduleId);
-    } else {
-      failures.push({ moduleId, error: result.error ?? 'unknown error' });
-    }
-  }
-
-  return { ran: true, republished, failures };
-}