@obh/forge 0.2.0

package/dist/capabilities/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPABILITIES = void 0;
+exports.getCapability = getCapability;
+exports.isImplemented = isImplemented;
+exports.resolveOrder = resolveOrder;
+exports.missingPrerequisites = missingPrerequisites;
+const events_1 = require("./events");
+const jobs_1 = require("./jobs");
+const files_1 = require("./files");
+const audit_1 = require("./audit");
+const settings_1 = require("./settings");
+const api_keys_1 = require("./api-keys");
+const webhooks_1 = require("./webhooks");
+const import_export_1 = require("./import-export");
+const entitlements_1 = require("./entitlements");
+const search_1 = require("./search");
+const analytics_1 = require("./analytics");
+const notifications_1 = require("./notifications");
+/** Every OBH platform primitive Forge can install. */
+exports.CAPABILITIES = {
+    events: events_1.events,
+    jobs: jobs_1.jobs,
+    files: files_1.files,
+    audit: audit_1.audit,
+    settings: settings_1.settings,
+    "api-keys": api_keys_1.apiKeys,
+    webhooks: webhooks_1.webhooks,
+    "import-export": import_export_1.importExport,
+    entitlements: entitlements_1.entitlements,
+    search: search_1.search,
+    analytics: analytics_1.analytics,
+    notifications: notifications_1.notifications,
+};
+function getCapability(name) {
+    return exports.CAPABILITIES[name];
+}
+function isImplemented(name) {
+    return exports.CAPABILITIES[name] !== undefined;
+}
+/**
+ * Expand a requested set of capabilities to include their prerequisites, then
+ * return them in dependency order (requires-before-dependents). Unknown names
+ * are dropped by the caller after reporting.
+ */
+function resolveOrder(requested) {
+    const ordered = [];
+    const seen = new Set();
+    const visit = (name) => {
+        if (seen.has(name))
+            return;
+        seen.add(name);
+        const cap = exports.CAPABILITIES[name];
+        if (!cap)
+            return;
+        for (const req of cap.requires ?? [])
+            visit(req);
+        ordered.push(name);
+    };
+    for (const name of requested)
+        visit(name);
+    return ordered;
+}
+/** Prerequisites of a capability that are not already installed/requested. */
+function missingPrerequisites(name, installed) {
+    const cap = exports.CAPABILITIES[name];
+    if (!cap)
+        return [];
+    return (cap.requires ?? []).filter((r) => !installed(r));
+}
+//# sourceMappingURL=index.js.map

package/dist/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/capabilities/index.ts"],"names":[],"mappings":";;;AAiCA,sCAEC;AAED,sCAEC;AAOD,oCAeC;AAGD,oDAOC;AArED,qCAAiC;AACjC,iCAA6B;AAC7B,mCAA+B;AAC/B,mCAA+B;AAC/B,yCAAqC;AACrC,yCAAoC;AACpC,yCAAqC;AACrC,mDAA8C;AAC9C,iDAA6C;AAC7C,qCAAiC;AACjC,2CAAuC;AACvC,mDAA+C;AAI/C,sDAAsD;AACzC,QAAA,YAAY,GAAgD;IACvE,MAAM,EAAN,eAAM;IACN,IAAI,EAAJ,WAAI;IACJ,KAAK,EAAL,aAAK;IACL,KAAK,EAAL,aAAK;IACL,QAAQ,EAAR,mBAAQ;IACR,UAAU,EAAE,kBAAO;IACnB,QAAQ,EAAR,mBAAQ;IACR,eAAe,EAAE,4BAAY;IAC7B,YAAY,EAAZ,2BAAY;IACZ,MAAM,EAAN,eAAM;IACN,SAAS,EAAT,qBAAS;IACT,aAAa,EAAb,6BAAa;CACd,CAAA;AAED,SAAgB,aAAa,CAAC,IAAoB;IAChD,OAAO,oBAAY,CAAC,IAAI,CAAC,CAAA;AAC3B,CAAC;AAED,SAAgB,aAAa,CAAC,IAAoB;IAChD,OAAO,oBAAY,CAAC,IAAI,CAAC,KAAK,SAAS,CAAA;AACzC,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,SAA2B;IACtD,MAAM,OAAO,GAAqB,EAAE,CAAA;IACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAA;IAEtC,MAAM,KAAK,GAAG,CAAC,IAAoB,EAAQ,EAAE;QAC3C,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAM;QAC1B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACd,MAAM,GAAG,GAAG,oBAAY,CAAC,IAAI,CAAC,CAAA;QAC9B,IAAI,CAAC,GAAG;YAAE,OAAM;QAChB,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,QAAQ,IAAI,EAAE;YAAE,KAAK,CAAC,GAAG,CAAC,CAAA;QAChD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACpB,CAAC,CAAA;IAED,KAAK,MAAM,IAAI,IAAI,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,CAAA;IACzC,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,8EAA8E;AAC9E,SAAgB,oBAAoB,CAClC,IAAoB,EACpB,SAAyC;IAEzC,MAAM,GAAG,GAAG,oBAAY,CAAC,IAAI,CAAC,CAAA;IAC9B,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAA;IACnB,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;AAC1D,CAAC"}

package/dist/capabilities/jobs.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./types";
+export declare const jobs: Capability;
+//# sourceMappingURL=jobs.d.ts.map

package/dist/capabilities/jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../../src/capabilities/jobs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,IAAI,EAAE,UAyBlB,CAAA"}

package/dist/capabilities/jobs.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobs = void 0;
+const helpers_1 = require("./helpers");
+exports.jobs = {
+    name: "jobs",
+    describe: "Postgres job queue + worker — background/scheduled commands, idempotent handlers",
+    apply(ctx, plan) {
+        (0, helpers_1.addPlatformPackage)(plan, ctx, "jobs", { api: true, worker: true });
+        // defineJob validates payloads with a zod schema on both the enqueue and run sides.
+        if (ctx.hasApp("api"))
+            plan.addDependency("apps/api", "zod", "^3.23.8");
+        if (ctx.hasWorker())
+            plan.addDependency("apps/worker", "zod", "^3.23.8");
+        plan.create("scripts/migrations.d/jobs.ts", (0, helpers_1.migrationModule)("jobs"), "jobs migrations wiring");
+        const notes = (0, helpers_1.hasNotesExample)(ctx);
+        if (ctx.hasApp("api")) {
+            plan.create("apps/api/src/platform/jobs.ts", apiClient(notes), "jobs client + registry");
+            if (notes) {
+                // Enqueue a job whenever a note is created — inside the write transaction.
+                plan.create("apps/api/src/bus.d/jobs-index.ts", ENQUEUE, "enqueue a job on note.created");
+            }
+        }
+        if (ctx.hasWorker()) {
+            plan.create("apps/worker/src/consumers.d/jobs.ts", worker(notes), "jobs worker (claims + runs jobs)");
+        }
+        plan.patchManifest({ platform: { jobs: true } });
+        plan.nextStep("Run `pnpm migrate`. Enqueue with jobs.enqueue(tx, { name, workspaceId, payload }); the worker runs handlers.");
+    },
+};
+function jobExample(notes) {
+    return notes
+        ? { name: "send_welcome_email", export: "sendWelcomeEmail", schema: "z.object({ noteId: z.string() })", field: "note_id: payload.noteId" }
+        : { name: "example_job", export: "exampleJob", schema: "z.object({ id: z.string() })", field: "id: payload.id" };
+}
+function apiClient(notes) {
+    const d = jobExample(notes);
+    return `import { createJobClient, createJobRegistry, defineJob, type JobDb, type JobDefinition } from "@obh/jobs"
+import { z } from "zod"
+
+// Every platform row is scoped to a workspace. Single-tenant apps can leave this.
+export const WORKSPACE = process.env.WORKSPACE_ID ?? "default"
+
+// Jobs are commands (snake_case imperatives), not events. The handler runs in the
+// worker (apps/worker/src/consumers.d/jobs.ts); here the schema validates payloads
+// at enqueue time. Keep the name + schema in sync with the worker's copy.
+export const ${d.export} = defineJob({
+  name: "${d.name}",
+  version: 1,
+  schema: ${d.schema},
+  handler: async () => {
+    throw new Error("${d.name} runs in the worker, not the API")
+  },
+})
+
+export const registry = createJobRegistry([${d.export} as JobDefinition])
+
+export const jobs = createJobClient({ source: "app", registry })
+
+/** Adapt a raw pg transaction to the structural JobDb @obh/jobs expects. */
+export function asJobDb(tx: { query: (sql: string, params?: unknown[]) => Promise<{ rows: unknown[] }> }): JobDb {
+  return { query: (sql: string, params?: unknown[]) => tx.query(sql, params) as never }
+}
+`;
+}
+const ENQUEUE = `import { onEmit } from "../bus"
+import { asJobDb, jobs, sendWelcomeEmail, WORKSPACE } from "../platform/jobs"
+
+// Enqueue a job on the SAME transaction as the note write, so the job is durable
+// exactly when the note is (and never queued if the write rolls back). The
+// idempotency key makes a re-emit a no-op rather than a duplicate job.
+onEmit(async (tx, name, payload) => {
+  if (name !== "note.created") return
+  const noteId = String((payload as { id?: string }).id ?? "")
+  await jobs.enqueue(asJobDb(tx), {
+    name: sendWelcomeEmail.name,
+    workspaceId: WORKSPACE,
+    payload: { noteId },
+    idempotencyKey: \`welcome:\${noteId}\`,
+  })
+})
+`;
+function worker(notes) {
+    const d = jobExample(notes);
+    return `// Runs queued jobs: each tick claims a batch and executes the matching handler.
+// Handlers live here so the worker never imports across app boundaries; keep the
+// name + schema in sync with apps/api/src/platform/jobs.ts.
+import { createJobRegistry, createWorker, defineJob, pgAdapter, type JobDefinition } from "@obh/jobs"
+import { z } from "zod"
+import type { WorkerContext } from "../context"
+
+const ${d.export} = defineJob({
+  name: "${d.name}",
+  version: 1,
+  schema: ${d.schema},
+  handler: async (ctx, payload) => {
+    ctx.log.info("running ${d.name}", { ${d.field} })
+    // Real work goes here (call your mailer, render a PDF, …). Handlers must be
+    // idempotent: at-least-once execution means a job can run more than once.
+    console.log(JSON.stringify({ msg: "${d.name} done", ${d.field}, job_id: ctx.jobId }))
+  },
+})
+
+const registry = createJobRegistry([${d.export} as JobDefinition])
+
+let worker: ReturnType<typeof createWorker>
+
+export function init(ctx: WorkerContext): void {
+  worker = createWorker({ db: pgAdapter(ctx.pool), registry, instanceId: "worker" })
+}
+
+export async function tick(): Promise<void> {
+  await worker.tick()
+}
+`;
+}
+//# sourceMappingURL=jobs.js.map

package/dist/capabilities/jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.js","sourceRoot":"","sources":["../../src/capabilities/jobs.ts"],"names":[],"mappings":";;;AACA,uCAAgF;AAEnE,QAAA,IAAI,GAAe;IAC9B,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,kFAAkF;IAC5F,KAAK,CAAC,GAAG,EAAE,IAAI;QACb,IAAA,4BAAkB,EAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;QAClE,oFAAoF;QACpF,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;QACvE,IAAI,GAAG,CAAC,SAAS,EAAE;YAAE,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;QACxE,IAAI,CAAC,MAAM,CAAC,8BAA8B,EAAE,IAAA,yBAAe,EAAC,MAAM,CAAC,EAAE,wBAAwB,CAAC,CAAA;QAE9F,MAAM,KAAK,GAAG,IAAA,yBAAe,EAAC,GAAG,CAAC,CAAA;QAClC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,wBAAwB,CAAC,CAAA;YACxF,IAAI,KAAK,EAAE,CAAC;gBACV,2EAA2E;gBAC3E,IAAI,CAAC,MAAM,CAAC,kCAAkC,EAAE,OAAO,EAAE,+BAA+B,CAAC,CAAA;YAC3F,CAAC;QACH,CAAC;QACD,IAAI,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,qCAAqC,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,kCAAkC,CAAC,CAAA;QACvG,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;QAChD,IAAI,CAAC,QAAQ,CAAC,8GAA8G,CAAC,CAAA;IAC/H,CAAC;CACF,CAAA;AASD,SAAS,UAAU,CAAC,KAAc;IAChC,OAAO,KAAK;QACV,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,kCAAkC,EAAE,KAAK,EAAE,yBAAyB,EAAE;QAC1I,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,8BAA8B,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAA;AACpH,CAAC;AAED,SAAS,SAAS,CAAC,KAAc;IAC/B,MAAM,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;IAC3B,OAAO;;;;;;;;;eASM,CAAC,CAAC,MAAM;WACZ,CAAC,CAAC,IAAI;;YAEL,CAAC,CAAC,MAAM;;uBAEG,CAAC,CAAC,IAAI;;;;6CAIgB,CAAC,CAAC,MAAM;;;;;;;;CAQpD,CAAA;AACD,CAAC;AAED,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;CAgBf,CAAA;AAED,SAAS,MAAM,CAAC,KAAc;IAC5B,MAAM,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;IAC3B,OAAO;;;;;;;QAOD,CAAC,CAAC,MAAM;WACL,CAAC,CAAC,IAAI;;YAEL,CAAC,CAAC,MAAM;;4BAEQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,KAAK;;;yCAGR,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,KAAK;;;;sCAI3B,CAAC,CAAC,MAAM;;;;;;;;;;;CAW7C,CAAA;AACD,CAAC"}

package/dist/capabilities/notifications.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./types";
+export declare const notifications: Capability;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/capabilities/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../src/capabilities/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,aAAa,EAAE,UA+B3B,CAAA"}

package/dist/capabilities/notifications.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifications = void 0;
+const helpers_1 = require("./helpers");
+exports.notifications = {
+    name: "notifications",
+    requires: ["events"],
+    describe: "Email notification engine — templates + rules reacting to events, delivered over SMTP",
+    apply(ctx, plan) {
+        (0, helpers_1.addPlatformPackage)(plan, ctx, "notifications", { api: true, worker: true });
+        plan.create("scripts/migrations.d/notifications.ts", (0, helpers_1.migrationModule)("notifications"), "notifications migrations wiring");
+        const notes = (0, helpers_1.hasNotesExample)(ctx);
+        if (ctx.hasApp("api")) {
+            plan.create("apps/api/src/platform/notifications.ts", CLIENT, "direct-send notification client");
+        }
+        if (ctx.hasWorker()) {
+            plan.create("apps/worker/src/notification-defs.ts", defsFile(notes), "worker-side templates + rules");
+            plan.create("apps/worker/src/dispatch.d/notifications.ts", `export const consumer = { name: "notifications", events: ["*"] }\n`, "register notifications as an event consumer");
+            plan.create("apps/worker/src/consumers.d/notifications.ts", WORKER, "notification intake + send tick");
+        }
+        plan.addEnvVar({
+            name: "SMTP_URL",
+            example: "smtp://user:pass@localhost:1025",
+            comment: "smtp://user:pass@host:port (smtps:// for implicit TLS)",
+        });
+        plan.patchManifest({ platform: { notifications: true } });
+        plan.nextStep("Run `pnpm migrate` and set SMTP_URL. Rules turn events into intents the worker renders and sends.");
+    },
+};
+// The event-driven path (rules) is preferred; this client is the escape hatch
+// for notifications that aren't domain events (invites, password resets).
+const CLIENT = `import { createNotificationClient, pgAdapter } from "@obh/notifications"
+import { pool } from "../db"
+
+export const notifications = createNotificationClient({ db: pgAdapter(pool) })
+`;
+function defsFile(notes) {
+    const templates = notes
+        ? `  defineTemplate({
+    key: "note_created_email",
+    version: 1,
+    channel: "email",
+    name: "Note created",
+    subject: "New note: {{title}}",
+    bodyText: "A note titled {{title}} was just created.",
+  }),`
+        : `  // defineTemplate({ key: "thing_created_email", channel: "email", name: "Thing created", subject: "New thing", bodyText: "…" }),`;
+    const rules = notes
+        ? `  defineNotificationRule({
+    id: "rule_note_created",
+    eventName: "note.created",
+    templateKey: "note_created_email",
+    recipientStrategy: "static_email",
+    recipientConfig: { email: process.env.NOTIFY_TO ?? "ops@example.com" },
+    variableMapping: { title: "$.payload.title" },
+  }),`
+        : `  // defineNotificationRule({ id: "rule_thing_created", eventName: "thing.created", templateKey: "thing_created_email", recipientStrategy: "static_email", recipientConfig: { email: "ops@example.com" } }),`;
+    return `import {
+  defineNotificationRule,
+  defineTemplate,
+  type NotificationRule,
+  type NotificationTemplate,
+} from "@obh/notifications"
+
+// Worker-side template + rule definitions, seeded into the DB on startup.
+export const templates: NotificationTemplate[] = [
+${templates}
+]
+
+export const rules: NotificationRule[] = [
+${rules}
+]
+`;
+}
+const WORKER = `// Seeds templates/rules, then each tick: claim the "notifications" event
+// deliveries into intents, then render and send pending intents over SMTP
+// (retried, dead-lettered). intake and send both run in the default tick().
+import { createNotificationWorker, pgAdapter, smtpProvider, syncRules, syncTemplates } from "@obh/notifications"
+import { rules, templates } from "../notification-defs"
+import type { WorkerContext } from "../context"
+
+let worker: ReturnType<typeof createNotificationWorker>
+
+function providerFromEnv() {
+  const url = new URL(process.env.SMTP_URL ?? "smtp://localhost:1025")
+  return smtpProvider({
+    host: url.hostname,
+    port: Number(url.port) || 25,
+    secure: url.protocol === "smtps:",
+    user: url.username ? decodeURIComponent(url.username) : undefined,
+    pass: url.password ? decodeURIComponent(url.password) : undefined,
+    from: process.env.SMTP_FROM ?? "no-reply@example.com",
+  })
+}
+
+export async function init(ctx: WorkerContext): Promise<void> {
+  const db = pgAdapter(ctx.pool)
+  // Keep the DB in sync with the code-authored templates/rules (idempotent).
+  await syncTemplates(db, templates)
+  await syncRules(db, rules)
+  worker = createNotificationWorker({
+    db,
+    provider: providerFromEnv(),
+    instanceId: "worker",
+    defaultFrom: process.env.SMTP_FROM ?? "no-reply@example.com",
+  })
+}
+
+export async function tick(): Promise<void> {
+  await worker.tick()
+}
+`;
+//# sourceMappingURL=notifications.js.map

package/dist/capabilities/notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.js","sourceRoot":"","sources":["../../src/capabilities/notifications.ts"],"names":[],"mappings":";;;AACA,uCAAgF;AAEnE,QAAA,aAAa,GAAe;IACvC,IAAI,EAAE,eAAe;IACrB,QAAQ,EAAE,CAAC,QAAQ,CAAC;IACpB,QAAQ,EAAE,uFAAuF;IACjG,KAAK,CAAC,GAAG,EAAE,IAAI;QACb,IAAA,4BAAkB,EAAC,IAAI,EAAE,GAAG,EAAE,eAAe,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;QAC3E,IAAI,CAAC,MAAM,CAAC,uCAAuC,EAAE,IAAA,yBAAe,EAAC,eAAe,CAAC,EAAE,iCAAiC,CAAC,CAAA;QAEzH,MAAM,KAAK,GAAG,IAAA,yBAAe,EAAC,GAAG,CAAC,CAAA;QAClC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,wCAAwC,EAAE,MAAM,EAAE,iCAAiC,CAAC,CAAA;QAClG,CAAC;QACD,IAAI,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,sCAAsC,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,+BAA+B,CAAC,CAAA;YACrG,IAAI,CAAC,MAAM,CACT,6CAA6C,EAC7C,oEAAoE,EACpE,6CAA6C,CAC9C,CAAA;YACD,IAAI,CAAC,MAAM,CAAC,8CAA8C,EAAE,MAAM,EAAE,iCAAiC,CAAC,CAAA;QACxG,CAAC;QAED,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,UAAU;YAChB,OAAO,EAAE,iCAAiC;YAC1C,OAAO,EAAE,wDAAwD;SAClE,CAAC,CAAA;QAEF,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;QACzD,IAAI,CAAC,QAAQ,CAAC,mGAAmG,CAAC,CAAA;IACpH,CAAC;CACF,CAAA;AAED,8EAA8E;AAC9E,0EAA0E;AAC1E,MAAM,MAAM,GAAG;;;;CAId,CAAA;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,MAAM,SAAS,GAAG,KAAK;QACrB,CAAC,CAAC;;;;;;;MAOA;QACF,CAAC,CAAC,oIAAoI,CAAA;IACxI,MAAM,KAAK,GAAG,KAAK;QACjB,CAAC,CAAC;;;;;;;MAOA;QACF,CAAC,CAAC,8MAA8M,CAAA;IAClN,OAAO;;;;;;;;;EASP,SAAS;;;;EAIT,KAAK;;CAEN,CAAA;AACD,CAAC;AAED,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCd,CAAA"}

package/dist/capabilities/search.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./types";
+export declare const search: Capability;
+//# sourceMappingURL=search.d.ts.map

package/dist/capabilities/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/capabilities/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,MAAM,EAAE,UA8BpB,CAAA"}

package/dist/capabilities/search.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = void 0;
+const helpers_1 = require("./helpers");
+exports.search = {
+    name: "search",
+    requires: ["events"],
+    describe: "Workspace search + indexing — Postgres full-text/trigram, kept fresh from events",
+    apply(ctx, plan) {
+        (0, helpers_1.addPlatformPackage)(plan, ctx, "search", { api: true, worker: true });
+        plan.create("scripts/migrations.d/search.ts", (0, helpers_1.migrationModule)("search"), "search migrations wiring");
+        const notes = (0, helpers_1.hasNotesExample)(ctx);
+        if (ctx.hasApp("api")) {
+            plan.create("apps/api/src/platform/search.ts", CLIENT, "search client + query provider");
+            plan.create("apps/api/src/routes/search.ts", (0, helpers_1.apiFramework)(ctx) === "hono" ? ROUTE_HONO : ROUTE_EXPRESS, "search query route");
+        }
+        if (ctx.hasWorker()) {
+            plan.create("apps/worker/src/search-entities.ts", entitiesFile(notes), "worker-side search entity definitions");
+            plan.create("apps/worker/src/dispatch.d/search.ts", `export const consumer = { name: "search", events: ["*"] }\n`, "register search as an event consumer");
+            plan.create("apps/worker/src/consumers.d/search.ts", WORKER, "search indexer tick");
+        }
+        plan.patchManifest({ platform: { search: true } });
+        plan.nextStep("Run `pnpm migrate` (the @obh/search migration enables pg_trgm). The worker keeps the index fresh from events; query at GET /api/search?q=.");
+    },
+};
+// The client only needs the query provider; entity mappers live worker-side.
+const CLIENT = `import { createPostgresSearchProvider, createSearchClient, pgAdapter } from "@obh/search"
+import { pool } from "../db"
+
+// Postgres full-text + trigram provider. pg_trgm is enabled by the migration.
+const provider = createPostgresSearchProvider({ db: pgAdapter(pool) })
+
+export const search = createSearchClient({ provider })
+`;
+function entitiesFile(notes) {
+    const defs = notes
+        ? `  defineSearchEntity({
+    type: "note",
+    events: ["note.created", "note.updated"],
+    deleteEvents: ["note.deleted"],
+    buildDocument: (_ctx, event) => {
+      const p = event.payload as { id: string; title?: string; body?: string }
+      return {
+        workspaceId: event.workspaceId,
+        entityType: "note",
+        entityId: p.id,
+        title: p.title ?? "",
+        content: p.body ?? "",
+      }
+    },
+    buildDeleteRef: (_ctx, event) => {
+      const p = event.payload as { id: string }
+      return { workspaceId: event.workspaceId, entityType: "note", entityId: p.id }
+    },
+  }),`
+        : `  // defineSearchEntity({
+  //   type: "thing",
+  //   events: ["thing.created", "thing.updated"],
+  //   deleteEvents: ["thing.deleted"],
+  //   buildDocument: (_ctx, event) => ({ workspaceId: event.workspaceId, entityType: "thing", entityId: String((event.payload as { id: string }).id), title: "…", content: "…" }),
+  //   buildDeleteRef: (_ctx, event) => ({ workspaceId: event.workspaceId, entityType: "thing", entityId: String((event.payload as { id: string }).id) }),
+  // }),`;
+    return `import { defineSearchEntity, type SearchEntityDefinition } from "@obh/search"
+
+// Worker-side entity definitions: how domain events become search documents.
+// Kept here so the worker never imports across app boundaries.
+export const entities: SearchEntityDefinition[] = [
+${defs}
+]
+`;
+}
+const ROUTE_HONO = `import type { Hono } from "hono"
+import { search } from "../platform/search"
+import { WORKSPACE } from "../platform/events"
+
+export function register(app: Hono): void {
+  app.get("/api/search", async (c) => {
+    const q = c.req.query("q") ?? ""
+    return c.json(await search.query({ workspaceId: WORKSPACE, query: q }))
+  })
+}
+`;
+const ROUTE_EXPRESS = `import type { Express, Request, Response } from "express"
+import { search } from "../platform/search"
+import { WORKSPACE } from "../platform/events"
+
+export function register(app: Express): void {
+  app.get("/api/search", async (req: Request, res: Response) => {
+    const q = (req.query.q as string) ?? ""
+    res.json(await search.query({ workspaceId: WORKSPACE, query: q }))
+  })
+}
+`;
+const WORKER = `// Claims the "search" event deliveries and keeps the index in sync. The search
+// worker exposes an events consumer (index on create/update, unindex on delete);
+// createConsumerRunner drives it against this consumer's deliveries.
+import { createConsumerRunner, pgAdapter } from "@obh/events"
+import { createPostgresSearchProvider, createSearchClient, createSearchWorker, pgAdapter as searchPgAdapter } from "@obh/search"
+import { entities } from "../search-entities"
+import type { WorkerContext } from "../context"
+
+let runner: ReturnType<typeof createConsumerRunner>
+
+export function init(ctx: WorkerContext): void {
+  const provider = createPostgresSearchProvider({ db: searchPgAdapter(ctx.pool) })
+  const client = createSearchClient({ provider })
+  // deps are passed to mappers as ctx.db; the note mappers read straight from
+  // the event payload, so nothing product-specific is needed here.
+  const worker = createSearchWorker<unknown>({ client, entities, deps: undefined })
+  runner = createConsumerRunner({
+    db: pgAdapter(ctx.pool),
+    consumers: [worker.consumer],
+    instanceId: "worker",
+  })
+}
+
+export async function tick(): Promise<void> {
+  await runner.tick()
+}
+`;
+//# sourceMappingURL=search.js.map

package/dist/capabilities/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","sourceRoot":"","sources":["../../src/capabilities/search.ts"],"names":[],"mappings":";;;AACA,uCAA8F;AAEjF,QAAA,MAAM,GAAe;IAChC,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,QAAQ,CAAC;IACpB,QAAQ,EAAE,kFAAkF;IAC5F,KAAK,CAAC,GAAG,EAAE,IAAI;QACb,IAAA,4BAAkB,EAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;QACpE,IAAI,CAAC,MAAM,CAAC,gCAAgC,EAAE,IAAA,yBAAe,EAAC,QAAQ,CAAC,EAAE,0BAA0B,CAAC,CAAA;QAEpG,MAAM,KAAK,GAAG,IAAA,yBAAe,EAAC,GAAG,CAAC,CAAA;QAClC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,iCAAiC,EAAE,MAAM,EAAE,gCAAgC,CAAC,CAAA;YACxF,IAAI,CAAC,MAAM,CACT,+BAA+B,EAC/B,IAAA,sBAAY,EAAC,GAAG,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,EACzD,oBAAoB,CACrB,CAAA;QACH,CAAC;QACD,IAAI,GAAG,CAAC,SAAS,EAAE,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,oCAAoC,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,uCAAuC,CAAC,CAAA;YAC/G,IAAI,CAAC,MAAM,CACT,sCAAsC,EACtC,6DAA6D,EAC7D,sCAAsC,CACvC,CAAA;YACD,IAAI,CAAC,MAAM,CAAC,uCAAuC,EAAE,MAAM,EAAE,qBAAqB,CAAC,CAAA;QACrF,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;QAClD,IAAI,CAAC,QAAQ,CAAC,4IAA4I,CAAC,CAAA;IAC7J,CAAC;CACF,CAAA;AAED,6EAA6E;AAC7E,MAAM,MAAM,GAAG;;;;;;;CAOd,CAAA;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,MAAM,IAAI,GAAG,KAAK;QAChB,CAAC,CAAC;;;;;;;;;;;;;;;;;;MAkBA;QACF,CAAC,CAAC;;;;;;SAMG,CAAA;IACP,OAAO;;;;;EAKP,IAAI;;CAEL,CAAA;AACD,CAAC;AAED,MAAM,UAAU,GAAG;;;;;;;;;;CAUlB,CAAA;AAED,MAAM,aAAa,GAAG;;;;;;;;;;CAUrB,CAAA;AAED,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Bd,CAAA"}

package/dist/capabilities/settings.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./types";
+export declare const settings: Capability;
+//# sourceMappingURL=settings.d.ts.map

package/dist/capabilities/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,QAAQ,EAAE,UAiBtB,CAAA"}

package/dist/capabilities/settings.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settings = void 0;
+const helpers_1 = require("./helpers");
+exports.settings = {
+    name: "settings",
+    describe: "Typed, scoped configuration — defaults in code, overrides per workspace in Postgres",
+    apply(ctx, plan) {
+        (0, helpers_1.addPlatformPackage)(plan, ctx, "settings", { api: true });
+        // defineSetting validates values with a zod schema.
+        if (ctx.hasApp("api"))
+            plan.addDependency("apps/api", "zod", "^3.23.8");
+        plan.create("scripts/migrations.d/settings.ts", (0, helpers_1.migrationModule)("settings"), "settings migrations wiring");
+        if (ctx.hasApp("api")) {
+            plan.create("apps/api/src/platform/settings.ts", registryFile((0, helpers_1.hasNotesExample)(ctx)), "settings registry + client");
+            plan.create("apps/api/src/routes/settings.ts", (0, helpers_1.apiFramework)(ctx) === "hono" ? ROUTE_HONO : ROUTE_EXPRESS, "read a resolved setting");
+        }
+        plan.patchManifest({ platform: { settings: true } });
+        plan.nextStep("Run `pnpm migrate`. Defaults live in code; overrides resolve per scope from platform.settings.");
+    },
+};
+function registryFile(notes) {
+    const def = notes
+        ? `export const notesRetentionDays = defineSetting({
+  key: "notes.retention_days",
+  schema: z.number().int().positive(),
+  defaultValue: 30,
+  scopes: ["platform", "workspace"],
+})`
+        : `export const exampleFlag = defineSetting({
+  key: "app.example_flag",
+  schema: z.boolean(),
+  defaultValue: false,
+  scopes: ["platform", "workspace"],
+})`;
+    const exportName = notes ? "notesRetentionDays" : "exampleFlag";
+    return `import { createSettingsClient, createSettingsRegistry, defineSetting, pgAdapter } from "@obh/settings"
+import { z } from "zod"
+import { pool } from "../db"
+
+// Every platform row is scoped to a workspace. Single-tenant apps can leave this.
+export const WORKSPACE = process.env.WORKSPACE_ID ?? "default"
+
+// A typed setting: schema + default in code, overridable per scope (most specific
+// wins: user > group > workspace > platform > default).
+${def}
+
+export const registry = createSettingsRegistry([${exportName}])
+
+// The client is stateless; each call takes a db/tx handle and a resolution context.
+export const settings = createSettingsClient({ registry })
+export const settingsDb = pgAdapter(pool)
+`;
+}
+const ROUTE_HONO = `import type { Hono } from "hono"
+import { settings, settingsDb, WORKSPACE } from "../platform/settings"
+
+export function register(app: Hono): void {
+  // Resolve a setting's effective value for the current workspace, falling back
+  // through platform default to the definition default.
+  app.get("/settings/:key", async (c) => {
+    return c.json(await settings.resolve(settingsDb, c.req.param("key"), { workspaceId: WORKSPACE }))
+  })
+}
+`;
+const ROUTE_EXPRESS = `import type { Express, Request, Response } from "express"
+import { settings, settingsDb, WORKSPACE } from "../platform/settings"
+
+export function register(app: Express): void {
+  app.get("/settings/:key", async (req: Request, res: Response) => {
+    res.json(await settings.resolve(settingsDb, req.params.key, { workspaceId: WORKSPACE }))
+  })
+}
+`;
+//# sourceMappingURL=settings.js.map

package/dist/capabilities/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../src/capabilities/settings.ts"],"names":[],"mappings":";;;AACA,uCAA8F;AAEjF,QAAA,QAAQ,GAAe;IAClC,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE,qFAAqF;IAC/F,KAAK,CAAC,GAAG,EAAE,IAAI;QACb,IAAA,4BAAkB,EAAC,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAA;QACxD,oDAAoD;QACpD,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;QACvE,IAAI,CAAC,MAAM,CAAC,kCAAkC,EAAE,IAAA,yBAAe,EAAC,UAAU,CAAC,EAAE,4BAA4B,CAAC,CAAA;QAE1G,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,mCAAmC,EAAE,YAAY,CAAC,IAAA,yBAAe,EAAC,GAAG,CAAC,CAAC,EAAE,4BAA4B,CAAC,CAAA;YAClH,IAAI,CAAC,MAAM,CAAC,iCAAiC,EAAE,IAAA,sBAAY,EAAC,GAAG,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAA;QACtI,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;QACpD,IAAI,CAAC,QAAQ,CAAC,gGAAgG,CAAC,CAAA;IACjH,CAAC;CACF,CAAA;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,MAAM,GAAG,GAAG,KAAK;QACf,CAAC,CAAC;;;;;GAKH;QACC,CAAC,CAAC;;;;;GAKH,CAAA;IACD,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,aAAa,CAAA;IAC/D,OAAO;;;;;;;;;EASP,GAAG;;kDAE6C,UAAU;;;;;CAK3D,CAAA;AACD,CAAC;AAED,MAAM,UAAU,GAAG;;;;;;;;;;CAUlB,CAAA;AAED,MAAM,aAAa,GAAG;;;;;;;;CAQrB,CAAA"}

package/dist/capabilities/types.d.ts

@@ -0,0 +1,16 @@
+import type { CapabilityName } from "../types";
+import type { ProjectContext } from "../project/context";
+import type { Plan } from "../project/plan";
+/**
+ * A capability installs one OBH platform primitive into a project. It only ever
+ * builds up a Plan (which only ever creates files) — never patches shared code.
+ */
+export interface Capability {
+    name: CapabilityName;
+    /** Other capabilities that must be present first. */
+    requires?: CapabilityName[];
+    /** One-line description for prompts and docs. */
+    describe: string;
+    apply(ctx: ProjectContext, plan: Plan): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/capabilities/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/capabilities/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,cAAc,CAAA;IACpB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAA;IAC3B,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAC7C"}

package/dist/capabilities/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/capabilities/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/capabilities/types.ts"],"names":[],"mappings":""}

package/dist/capabilities/webhooks.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./types";
+export declare const webhooks: Capability;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/capabilities/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../src/capabilities/webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,eAAO,MAAM,QAAQ,EAAE,UAmCtB,CAAA"}