@celilo/cli 0.2.1 → 0.3.1

package/src/services/module-subscriptions.ts

@@ -0,0 +1,120 @@
+/**
+ * Wire a module's manifest `subscriptions:` block into the SQLite event
+ * bus. Called from `module/import.ts` on install and from
+ * `cli/commands/module-remove.ts` on remove.
+ *
+ * Substitutions performed at subscribe time:
+ *   - `$self` in `pattern`    → the module's id
+ *   - `${MODULE_PATH}` in `handler` → the module's installed targetPath
+ *
+ * The bus subscriber's name is namespaced as `<module-id>.<sub-name>`
+ * so two modules can declare a subscription named `smoke` without
+ * colliding.
+ */
+
+import { defineEvents, openBus } from '@celilo/event-bus';
+import { getEventBusPath } from '../config/paths';
+import type { ModuleManifest, ModuleSubscription } from '../manifest/schema';
+
+/**
+ * The bus is opened by the celilo CLI without an event registry — the
+ * CLI doesn't know the schemas of every module's events. The bus's
+ * empty-registry path skips payload validation, leaving that to the
+ * linked handlers (which open the bus *with* their own registry).
+ */
+const NO_SCHEMAS = defineEvents({});
+
+/**
+ * Resolve the per-module substitutions on a single subscription. Pure
+ * function: takes a parsed manifest entry, returns the bus-shaped
+ * subscribe options.
+ */
+export function resolveSubscription(
+  sub: ModuleSubscription,
+  moduleId: string,
+  modulePath: string,
+): {
+  name: string;
+  pattern: string;
+  handler: string;
+  maxAttempts?: number;
+  timeoutMs?: number;
+  registeredBy: string;
+} {
+  return {
+    name: scopedName(moduleId, sub.name),
+    pattern: substituteSelf(sub.pattern, moduleId),
+    handler: substituteModulePath(sub.handler, modulePath),
+    maxAttempts: sub.max_attempts,
+    timeoutMs: sub.timeout_ms,
+    registeredBy: moduleId,
+  };
+}
+
+/**
+ * Register all of a module's subscriptions on the bus. Idempotent —
+ * re-running with the same manifest updates existing rows in place.
+ *
+ * If the module's manifest declares no subscriptions, this is a
+ * cheap no-op (the bus DB isn't even touched).
+ */
+export function registerModuleSubscriptions(
+  manifest: ModuleManifest,
+  modulePath: string,
+): { registered: number } {
+  const subs = manifest.subscriptions ?? [];
+  if (subs.length === 0) return { registered: 0 };
+
+  const bus = openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  try {
+    for (const sub of subs) {
+      const resolved = resolveSubscription(sub, manifest.id, modulePath);
+      bus.subscribe(resolved);
+    }
+    return { registered: subs.length };
+  } finally {
+    bus.close();
+  }
+}
+
+/**
+ * Tear down every bus subscription that belongs to this module. Looks
+ * up rows by name prefix `<module-id>.` rather than rereading the
+ * old manifest, so a stale subscription left behind by a manifest
+ * change still gets cleaned up.
+ *
+ * Best-effort: if the bus DB doesn't exist (never opened), returns 0.
+ */
+export function unregisterModuleSubscriptions(moduleId: string): {
+  unregistered: number;
+} {
+  const bus = openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  try {
+    const likePattern = `${moduleId}.%`;
+    const rows = bus.db
+      .query<{ name: string }, [string]>('SELECT name FROM subscribers WHERE name LIKE ?')
+      .all(likePattern);
+    for (const row of rows) {
+      bus.unsubscribe(row.name);
+    }
+    return { unregistered: rows.length };
+  } finally {
+    bus.close();
+  }
+}
+
+function scopedName(moduleId: string, subName: string): string {
+  return `${moduleId}.${subName}`;
+}
+
+function substituteSelf(pattern: string, moduleId: string): string {
+  // `$self` matches when followed by a dot or end-of-string, so a
+  // pattern like `deploy.$self.foo` substitutes correctly without
+  // confusing `$selfish` if anyone wrote that. (No real reason they
+  // would, but be precise.)
+  return pattern.replace(/\$self(?=\.|$)/g, moduleId);
+}
+
+function substituteModulePath(handler: string, modulePath: string): string {
+  return handler.replace(/\$\{MODULE_PATH\}/g, modulePath);
+}