@headless-lms/adapter-defaults 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mdwt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/email/index.d.ts

@@ -0,0 +1,15 @@
+import { EmailMessage, EmailSender, EmailTemplateId, Logger, TemplateRenderer } from "@headless-lms/core/shared/ports";
+//#region src/email/index.d.ts
+declare class EmailAdapter implements EmailSender {
+  private readonly logger;
+  constructor(logger?: Logger);
+  send(_message: EmailMessage): Promise<void>;
+}
+declare class StubTemplateRenderer implements TemplateRenderer {
+  private readonly logger;
+  constructor(logger?: Logger);
+  render(id: EmailTemplateId): Promise<never>;
+}
+//#endregion
+export { EmailAdapter, StubTemplateRenderer };
+//# sourceMappingURL=index.d.ts.map

package/dist/email/index.js

@@ -0,0 +1,26 @@
+import { noopLogger } from "@headless-lms/core/shared/logger";
+//#region src/email/index.ts
+var EmailAdapter = class {
+	logger;
+	constructor(logger = noopLogger) {
+		this.logger = logger;
+	}
+	async send(_message) {
+		this.logger.error("email send failed: no transport configured");
+		throw new Error("not implemented");
+	}
+};
+var StubTemplateRenderer = class {
+	logger;
+	constructor(logger = noopLogger) {
+		this.logger = logger;
+	}
+	async render(id) {
+		this.logger.error("template render failed: no renderer configured", { id });
+		throw new Error("no template renderer configured");
+	}
+};
+//#endregion
+export { EmailAdapter, StubTemplateRenderer };
+
+//# sourceMappingURL=index.js.map

package/dist/email/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/email/index.ts"],"sourcesContent":["// Default when no EmailSender is injected — fails loudly on use.\nimport type { EmailSender, EmailMessage, EmailTemplateId, Logger, TemplateRenderer } from '@headless-lms/core/shared/ports';\nimport { noopLogger } from '@headless-lms/core/shared/logger';\n\nexport class EmailAdapter implements EmailSender {\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  async send(_message: EmailMessage): Promise<void> {\n    this.logger.error('email send failed: no transport configured');\n    throw new Error('not implemented');\n  }\n}\n\nexport class StubTemplateRenderer implements TemplateRenderer {\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  async render(id: EmailTemplateId): Promise<never> {\n    this.logger.error('template render failed: no renderer configured', { id });\n    throw new Error('no template renderer configured');\n  }\n}\n"],"mappings":";;AAIA,IAAa,eAAb,MAAiD;CAClB;CAA7B,YAAY,SAAkC,YAAY;EAA7B,KAAA,SAAA;CAA8B;CAE3D,MAAM,KAAK,UAAuC;EAChD,KAAK,OAAO,MAAM,4CAA4C;EAC9D,MAAM,IAAI,MAAM,iBAAiB;CACnC;AACF;AAEA,IAAa,uBAAb,MAA8D;CAC/B;CAA7B,YAAY,SAAkC,YAAY;EAA7B,KAAA,SAAA;CAA8B;CAE3D,MAAM,OAAO,IAAqC;EAChD,KAAK,OAAO,MAAM,kDAAkD,EAAE,GAAG,CAAC;EAC1E,MAAM,IAAI,MAAM,iCAAiC;CACnD;AACF"}

package/dist/events/index.d.ts

@@ -0,0 +1,13 @@
+import { DomainEvent, EventBus, EventDefinition } from "@headless-lms/core/shared/ports";
+//#region src/events/index.d.ts
+declare class InMemoryEventBus implements EventBus {
+  private readonly handlers;
+  private readonly allHandlers;
+  publish(event: DomainEvent): Promise<void>;
+  subscribe<E extends DomainEvent>(definition: EventDefinition<E>, handler: (e: E) => Promise<void>): void;
+  subscribe(type: string, handler: (e: DomainEvent) => Promise<void>): void;
+  subscribeAll(handler: (e: DomainEvent) => Promise<void>): void;
+}
+//#endregion
+export { InMemoryEventBus };
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.js

@@ -0,0 +1,23 @@
+//#region src/events/index.ts
+var InMemoryEventBus = class {
+	handlers = /* @__PURE__ */ new Map();
+	allHandlers = [];
+	async publish(event) {
+		for (const handler of this.handlers.get(event.type) ?? []) await handler(event);
+		for (const handler of this.allHandlers) await handler(event);
+	}
+	subscribe(typeOrDefinition, handler) {
+		const type = typeof typeOrDefinition === "string" ? typeOrDefinition : typeOrDefinition.type;
+		const parsedHandler = typeof typeOrDefinition === "string" ? handler : async (event) => handler(typeOrDefinition.parse(event));
+		const list = this.handlers.get(type) ?? [];
+		list.push(parsedHandler);
+		this.handlers.set(type, list);
+	}
+	subscribeAll(handler) {
+		this.allHandlers.push(handler);
+	}
+};
+//#endregion
+export { InMemoryEventBus };
+
+//# sourceMappingURL=index.js.map

package/dist/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/events/index.ts"],"sourcesContent":["// In-process event bus. Implements the shared EventBus port: publish invokes\n// every handler subscribed to the event's type, sequentially, awaiting each,\n// then every all-events handler (subscribeAll), also sequentially awaited.\nimport type { DomainEvent, EventBus, EventDefinition } from '@headless-lms/core/shared/ports';\n\nexport class InMemoryEventBus implements EventBus {\n  private readonly handlers = new Map<string, Array<(e: DomainEvent) => Promise<void>>>();\n  private readonly allHandlers: Array<(e: DomainEvent) => Promise<void>> = [];\n\n  async publish(event: DomainEvent): Promise<void> {\n    for (const handler of this.handlers.get(event.type) ?? []) {\n      await handler(event);\n    }\n    for (const handler of this.allHandlers) {\n      await handler(event);\n    }\n  }\n\n  subscribe<E extends DomainEvent>(\n    definition: EventDefinition<E>,\n    handler: (e: E) => Promise<void>,\n  ): void;\n  subscribe(type: string, handler: (e: DomainEvent) => Promise<void>): void;\n  subscribe(\n    typeOrDefinition: string | EventDefinition<DomainEvent>,\n    handler: (e: DomainEvent) => Promise<void>,\n  ): void {\n    const type = typeof typeOrDefinition === 'string' ? typeOrDefinition : typeOrDefinition.type;\n    const parsedHandler =\n      typeof typeOrDefinition === 'string'\n        ? handler\n        : async (event: DomainEvent) => handler(typeOrDefinition.parse(event));\n    const list = this.handlers.get(type) ?? [];\n    list.push(parsedHandler);\n    this.handlers.set(type, list);\n  }\n\n  subscribeAll(handler: (e: DomainEvent) => Promise<void>): void {\n    this.allHandlers.push(handler);\n  }\n}\n"],"mappings":";AAKA,IAAa,mBAAb,MAAkD;CAChD,2BAA4B,IAAI,IAAsD;CACtF,cAAyE,CAAC;CAE1E,MAAM,QAAQ,OAAmC;EAC/C,KAAK,MAAM,WAAW,KAAK,SAAS,IAAI,MAAM,IAAI,KAAK,CAAC,GACtD,MAAM,QAAQ,KAAK;EAErB,KAAK,MAAM,WAAW,KAAK,aACzB,MAAM,QAAQ,KAAK;CAEvB;CAOA,UACE,kBACA,SACM;EACN,MAAM,OAAO,OAAO,qBAAqB,WAAW,mBAAmB,iBAAiB;EACxF,MAAM,gBACJ,OAAO,qBAAqB,WACxB,UACA,OAAO,UAAuB,QAAQ,iBAAiB,MAAM,KAAK,CAAC;EACzE,MAAM,OAAO,KAAK,SAAS,IAAI,IAAI,KAAK,CAAC;EACzC,KAAK,KAAK,aAAa;EACvB,KAAK,SAAS,IAAI,MAAM,IAAI;CAC9B;CAEA,aAAa,SAAkD;EAC7D,KAAK,YAAY,KAAK,OAAO;CAC/B;AACF"}

package/dist/events/outbox-relay.d.ts

@@ -0,0 +1,38 @@
+import { EventBus, Logger, OutboxRelay, OutboxStore } from "@headless-lms/core/shared/ports";
+//#region src/events/outbox-relay.d.ts
+/** Backoff base: first retry 5s after the first failure, doubling per attempt. */
+declare const OUTBOX_BACKOFF_BASE_MS = 5000;
+/** Backoff ceiling: retries never wait longer than 15 minutes. */
+declare const OUTBOX_BACKOFF_MAX_MS: number;
+/** Exponential backoff delay after a failure: min(base × 2^attempts, max),
+ *  where `attempts` is the PRIOR failure count (0 on the first failure). */
+declare function outboxBackoffMs(attempts: number): number;
+interface PollingOutboxRelayConfig {
+  /** Master switch: false → start() is a no-op. */
+  enabled: boolean;
+  /** Idle delay between polls. */
+  pollIntervalMs: number;
+  /** Max rows fetched/dispatched per tick; a full batch re-polls immediately. */
+  batchSize: number;
+}
+declare class PollingOutboxRelay implements OutboxRelay {
+  private readonly store;
+  private readonly bus;
+  private readonly config;
+  private readonly logger;
+  private pollTimer;
+  private running;
+  private inFlight;
+  constructor(store: OutboxStore, bus: EventBus, config: PollingOutboxRelayConfig, logger: Logger);
+  start(): void;
+  stop(): Promise<void>;
+  private schedule;
+  /** One poll: fetch a batch, dispatch in order, reschedule — immediately when
+   *  the batch was full (drain bursts), else after the idle interval. Never
+   *  throws: a poll failure is logged and retried next tick. */
+  private tick;
+  private dispatch;
+}
+//#endregion
+export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, PollingOutboxRelayConfig, outboxBackoffMs };
+//# sourceMappingURL=outbox-relay.d.ts.map

package/dist/events/outbox-relay.js

@@ -0,0 +1,92 @@
+import { OUTBOX_MAX_ATTEMPTS } from "@headless-lms/adapter-db";
+//#region src/events/outbox-relay.ts
+/** Backoff base: first retry 5s after the first failure, doubling per attempt. */
+const OUTBOX_BACKOFF_BASE_MS = 5e3;
+/** Backoff ceiling: retries never wait longer than 15 minutes. */
+const OUTBOX_BACKOFF_MAX_MS = 15 * 6e4;
+/** Exponential backoff delay after a failure: min(base × 2^attempts, max),
+*  where `attempts` is the PRIOR failure count (0 on the first failure). */
+function outboxBackoffMs(attempts) {
+	return Math.min(OUTBOX_BACKOFF_BASE_MS * 2 ** attempts, OUTBOX_BACKOFF_MAX_MS);
+}
+var PollingOutboxRelay = class {
+	store;
+	bus;
+	config;
+	logger;
+	pollTimer;
+	running = false;
+	inFlight = Promise.resolve();
+	constructor(store, bus, config, logger) {
+		this.store = store;
+		this.bus = bus;
+		this.config = config;
+		this.logger = logger;
+	}
+	start() {
+		if (!this.config.enabled || this.running) return;
+		this.running = true;
+		this.schedule(this.config.pollIntervalMs);
+		this.logger.info("outbox relay started", {
+			pollIntervalMs: this.config.pollIntervalMs,
+			batchSize: this.config.batchSize
+		});
+	}
+	async stop() {
+		if (this.pollTimer) clearTimeout(this.pollTimer);
+		this.pollTimer = void 0;
+		const wasRunning = this.running;
+		this.running = false;
+		await this.inFlight;
+		if (wasRunning) this.logger.info("outbox relay stopped");
+	}
+	schedule(delayMs) {
+		if (!this.running) return;
+		this.pollTimer = setTimeout(() => {
+			this.inFlight = this.tick();
+		}, delayMs);
+	}
+	/** One poll: fetch a batch, dispatch in order, reschedule — immediately when
+	*  the batch was full (drain bursts), else after the idle interval. Never
+	*  throws: a poll failure is logged and retried next tick. */
+	async tick() {
+		let fetched = 0;
+		try {
+			const batch = await this.store.fetchBatch(this.config.batchSize);
+			fetched = batch.length;
+			if (fetched > 0) this.logger.debug("outbox batch fetched", { count: fetched });
+			for (const message of batch) await this.dispatch(message);
+		} catch (err) {
+			this.logger.error("outbox poll failed", { error: String(err) });
+		}
+		this.schedule(fetched >= this.config.batchSize ? 0 : this.config.pollIntervalMs);
+	}
+	async dispatch(message) {
+		try {
+			await this.bus.publish(message.payload);
+			await this.store.markProcessed(message.id);
+			this.logger.info("outbox event dispatched", {
+				id: message.id,
+				type: message.payload.type
+			});
+		} catch (err) {
+			const error = String(err);
+			const nextAttemptAt = new Date(Date.now() + outboxBackoffMs(message.attempts));
+			await this.store.markFailed(message.id, error, nextAttemptAt);
+			const attempt = message.attempts + 1;
+			const meta = {
+				id: message.id,
+				type: message.payload.type,
+				attempt,
+				nextAttemptAt: nextAttemptAt.toISOString(),
+				error
+			};
+			if (attempt >= OUTBOX_MAX_ATTEMPTS) this.logger.warn("outbox event parked", meta);
+			else this.logger.error("outbox dispatch failed", meta);
+		}
+	}
+};
+//#endregion
+export { OUTBOX_BACKOFF_BASE_MS, OUTBOX_BACKOFF_MAX_MS, PollingOutboxRelay, outboxBackoffMs };
+
+//# sourceMappingURL=outbox-relay.js.map

package/dist/events/outbox-relay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-relay.js","names":[],"sources":["../../src/events/outbox-relay.ts"],"sourcesContent":["// Same-process outbox relay (implements the core OutboxRelay port). A\n// setTimeout-CHAINED poller (never setInterval — a slow batch must not overlap\n// the next tick): each tick fetches unprocessed rows in id order and publishes\n// them to the EventBus.\n//\n// Delivery is at-least-once — handlers must be idempotent, keyed on event.id.\n// Ordering is skip-past-failures: a failing row is stamped with the error and\n// an exponential-backoff next_attempt_at (retried once due) while later rows\n// flow; the store stops fetching it after OUTBOX_MAX_ATTEMPTS failures.\nimport type {\n  EventBus,\n  Logger,\n  OutboxMessage,\n  OutboxRelay,\n  OutboxStore,\n} from '@headless-lms/core/shared/ports';\nimport { OUTBOX_MAX_ATTEMPTS } from '@headless-lms/adapter-db';\n\n/** Backoff base: first retry 5s after the first failure, doubling per attempt. */\nexport const OUTBOX_BACKOFF_BASE_MS = 5_000;\n/** Backoff ceiling: retries never wait longer than 15 minutes. */\nexport const OUTBOX_BACKOFF_MAX_MS = 15 * 60_000;\n\n/** Exponential backoff delay after a failure: min(base × 2^attempts, max),\n *  where `attempts` is the PRIOR failure count (0 on the first failure). */\nexport function outboxBackoffMs(attempts: number): number {\n  return Math.min(OUTBOX_BACKOFF_BASE_MS * 2 ** attempts, OUTBOX_BACKOFF_MAX_MS);\n}\n\nexport interface PollingOutboxRelayConfig {\n  /** Master switch: false → start() is a no-op. */\n  enabled: boolean;\n  /** Idle delay between polls. */\n  pollIntervalMs: number;\n  /** Max rows fetched/dispatched per tick; a full batch re-polls immediately. */\n  batchSize: number;\n}\n\nexport class PollingOutboxRelay implements OutboxRelay {\n  private pollTimer: NodeJS.Timeout | undefined;\n  private running = false;\n  private inFlight: Promise<void> = Promise.resolve();\n\n  constructor(\n    private readonly store: OutboxStore,\n    private readonly bus: EventBus,\n    private readonly config: PollingOutboxRelayConfig,\n    private readonly logger: Logger,\n  ) {}\n\n  start(): void {\n    if (!this.config.enabled || this.running) {\n      return;\n    }\n    this.running = true;\n    this.schedule(this.config.pollIntervalMs);\n    this.logger.info('outbox relay started', {\n      pollIntervalMs: this.config.pollIntervalMs,\n      batchSize: this.config.batchSize,\n    });\n  }\n\n  async stop(): Promise<void> {\n    if (this.pollTimer) {\n      clearTimeout(this.pollTimer);\n    }\n    this.pollTimer = undefined;\n    const wasRunning = this.running;\n    this.running = false;\n    await this.inFlight;\n    if (wasRunning) {\n      this.logger.info('outbox relay stopped');\n    }\n  }\n\n  private schedule(delayMs: number): void {\n    if (!this.running) {\n      return;\n    }\n    this.pollTimer = setTimeout(() => {\n      this.inFlight = this.tick();\n    }, delayMs);\n  }\n\n  /** One poll: fetch a batch, dispatch in order, reschedule — immediately when\n   *  the batch was full (drain bursts), else after the idle interval. Never\n   *  throws: a poll failure is logged and retried next tick. */\n  private async tick(): Promise<void> {\n    let fetched = 0;\n    try {\n      const batch = await this.store.fetchBatch(this.config.batchSize);\n      fetched = batch.length;\n      if (fetched > 0) {\n        this.logger.debug('outbox batch fetched', { count: fetched });\n      }\n      for (const message of batch) {\n        await this.dispatch(message);\n      }\n    } catch (err) {\n      this.logger.error('outbox poll failed', { error: String(err) });\n    }\n    this.schedule(fetched >= this.config.batchSize ? 0 : this.config.pollIntervalMs);\n  }\n\n  private async dispatch(message: OutboxMessage): Promise<void> {\n    try {\n      await this.bus.publish(message.payload);\n      await this.store.markProcessed(message.id);\n      this.logger.info('outbox event dispatched', {\n        id: message.id,\n        type: message.payload.type,\n      });\n    } catch (err) {\n      const error = String(err);\n      const nextAttemptAt = new Date(Date.now() + outboxBackoffMs(message.attempts));\n      await this.store.markFailed(message.id, error, nextAttemptAt);\n      const attempt = message.attempts + 1;\n      const meta = {\n        id: message.id,\n        type: message.payload.type,\n        attempt,\n        nextAttemptAt: nextAttemptAt.toISOString(),\n        error,\n      };\n      // The store stops fetching after OUTBOX_MAX_ATTEMPTS — this failure parks the row.\n      if (attempt >= OUTBOX_MAX_ATTEMPTS) {\n        this.logger.warn('outbox event parked', meta);\n      } else {\n        this.logger.error('outbox dispatch failed', meta);\n      }\n    }\n  }\n}\n"],"mappings":";;;AAmBA,MAAa,yBAAyB;;AAEtC,MAAa,wBAAwB,KAAK;;;AAI1C,SAAgB,gBAAgB,UAA0B;CACxD,OAAO,KAAK,IAAI,yBAAyB,KAAK,UAAU,qBAAqB;AAC/E;AAWA,IAAa,qBAAb,MAAuD;CAMlC;CACA;CACA;CACA;CARnB;CACA,UAAkB;CAClB,WAAkC,QAAQ,QAAQ;CAElD,YACE,OACA,KACA,QACA,QACA;EAJiB,KAAA,QAAA;EACA,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,SAAA;CAChB;CAEH,QAAc;EACZ,IAAI,CAAC,KAAK,OAAO,WAAW,KAAK,SAC/B;EAEF,KAAK,UAAU;EACf,KAAK,SAAS,KAAK,OAAO,cAAc;EACxC,KAAK,OAAO,KAAK,wBAAwB;GACvC,gBAAgB,KAAK,OAAO;GAC5B,WAAW,KAAK,OAAO;EACzB,CAAC;CACH;CAEA,MAAM,OAAsB;EAC1B,IAAI,KAAK,WACP,aAAa,KAAK,SAAS;EAE7B,KAAK,YAAY,KAAA;EACjB,MAAM,aAAa,KAAK;EACxB,KAAK,UAAU;EACf,MAAM,KAAK;EACX,IAAI,YACF,KAAK,OAAO,KAAK,sBAAsB;CAE3C;CAEA,SAAiB,SAAuB;EACtC,IAAI,CAAC,KAAK,SACR;EAEF,KAAK,YAAY,iBAAiB;GAChC,KAAK,WAAW,KAAK,KAAK;EAC5B,GAAG,OAAO;CACZ;;;;CAKA,MAAc,OAAsB;EAClC,IAAI,UAAU;EACd,IAAI;GACF,MAAM,QAAQ,MAAM,KAAK,MAAM,WAAW,KAAK,OAAO,SAAS;GAC/D,UAAU,MAAM;GAChB,IAAI,UAAU,GACZ,KAAK,OAAO,MAAM,wBAAwB,EAAE,OAAO,QAAQ,CAAC;GAE9D,KAAK,MAAM,WAAW,OACpB,MAAM,KAAK,SAAS,OAAO;EAE/B,SAAS,KAAK;GACZ,KAAK,OAAO,MAAM,sBAAsB,EAAE,OAAO,OAAO,GAAG,EAAE,CAAC;EAChE;EACA,KAAK,SAAS,WAAW,KAAK,OAAO,YAAY,IAAI,KAAK,OAAO,cAAc;CACjF;CAEA,MAAc,SAAS,SAAuC;EAC5D,IAAI;GACF,MAAM,KAAK,IAAI,QAAQ,QAAQ,OAAO;GACtC,MAAM,KAAK,MAAM,cAAc,QAAQ,EAAE;GACzC,KAAK,OAAO,KAAK,2BAA2B;IAC1C,IAAI,QAAQ;IACZ,MAAM,QAAQ,QAAQ;GACxB,CAAC;EACH,SAAS,KAAK;GACZ,MAAM,QAAQ,OAAO,GAAG;GACxB,MAAM,gBAAgB,IAAI,KAAK,KAAK,IAAI,IAAI,gBAAgB,QAAQ,QAAQ,CAAC;GAC7E,MAAM,KAAK,MAAM,WAAW,QAAQ,IAAI,OAAO,aAAa;GAC5D,MAAM,UAAU,QAAQ,WAAW;GACnC,MAAM,OAAO;IACX,IAAI,QAAQ;IACZ,MAAM,QAAQ,QAAQ;IACtB;IACA,eAAe,cAAc,YAAY;IACzC;GACF;GAEA,IAAI,WAAW,qBACb,KAAK,OAAO,KAAK,uBAAuB,IAAI;QAE5C,KAAK,OAAO,MAAM,0BAA0B,IAAI;EAEpD;CACF;AACF"}

package/dist/logging/index.d.ts

@@ -0,0 +1,23 @@
+import { RequestLogContext, requestLogContext } from "./request-context.js";
+import { DestinationStream, Logger as PinoInstance } from "pino";
+import { Logger } from "@headless-lms/core/shared/ports";
+//#region src/logging/index.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare class PinoLogger implements Logger {
+  private readonly instance;
+  constructor(instance: PinoInstance);
+  debug(msg: string, meta?: Record<string, unknown>): void;
+  info(msg: string, meta?: Record<string, unknown>): void;
+  warn(msg: string, meta?: Record<string, unknown>): void;
+  error(msg: string, meta?: Record<string, unknown>): void;
+  child(bindings: Record<string, unknown>): Logger;
+}
+/** The process-wide root: JSON lines, Error serialization under `err`.
+ *  `destination` exists for tests; omitted → stdout. */
+declare function createRootLogger(level: LogLevel, destination?: DestinationStream): {
+  instance: PinoInstance;
+  logger: Logger;
+};
+//#endregion
+export { LogLevel, type PinoInstance, PinoLogger, type RequestLogContext, createRootLogger, requestLogContext };
+//# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -0,0 +1,41 @@
+import { requestLogContext } from "./request-context.js";
+import { pino, stdSerializers } from "pino";
+//#region src/logging/index.ts
+var PinoLogger = class PinoLogger {
+	instance;
+	constructor(instance) {
+		this.instance = instance;
+	}
+	debug(msg, meta) {
+		this.instance.debug(meta ?? {}, msg);
+	}
+	info(msg, meta) {
+		this.instance.info(meta ?? {}, msg);
+	}
+	warn(msg, meta) {
+		this.instance.warn(meta ?? {}, msg);
+	}
+	error(msg, meta) {
+		this.instance.error(meta ?? {}, msg);
+	}
+	child(bindings) {
+		return new PinoLogger(this.instance.child(bindings));
+	}
+};
+/** The process-wide root: JSON lines, Error serialization under `err`.
+*  `destination` exists for tests; omitted → stdout. */
+function createRootLogger(level, destination) {
+	const instance = pino({
+		level,
+		serializers: { err: stdSerializers.err },
+		mixin: () => requestLogContext.current()
+	}, destination);
+	return {
+		instance,
+		logger: new PinoLogger(instance)
+	};
+}
+//#endregion
+export { PinoLogger, createRootLogger, requestLogContext };
+
+//# sourceMappingURL=index.js.map

package/dist/logging/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/logging/index.ts"],"sourcesContent":["// Logging adapter — implements the core Logger port over pino. One root\n// instance per process: the container creates it, Fastify reuses it via\n// `loggerInstance`, and every component gets a child bound with { name }.\nimport { pino, stdSerializers, type DestinationStream, type Logger as PinoInstance } from 'pino';\nimport type { Logger } from '@headless-lms/core/shared/ports';\nimport { requestLogContext } from './request-context.js';\n\nexport { requestLogContext, type RequestLogContext } from './request-context.js';\nexport type { PinoInstance };\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\nexport class PinoLogger implements Logger {\n  constructor(private readonly instance: PinoInstance) {}\n\n  debug(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.debug(meta ?? {}, msg);\n  }\n  info(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.info(meta ?? {}, msg);\n  }\n  warn(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.warn(meta ?? {}, msg);\n  }\n  error(msg: string, meta?: Record<string, unknown>): void {\n    this.instance.error(meta ?? {}, msg);\n  }\n  child(bindings: Record<string, unknown>): Logger {\n    return new PinoLogger(this.instance.child(bindings));\n  }\n}\n\n/** The process-wide root: JSON lines, Error serialization under `err`.\n *  `destination` exists for tests; omitted → stdout. */\nexport function createRootLogger(\n  level: LogLevel,\n  destination?: DestinationStream,\n): { instance: PinoInstance; logger: Logger } {\n  const instance = pino(\n    {\n      level,\n      serializers: { err: stdSerializers.err },\n      // Ambient request correlation (reqId/orgId); call-site meta wins on clash.\n      mixin: () => requestLogContext.current(),\n    },\n    destination,\n  );\n  return { instance, logger: new PinoLogger(instance) };\n}\n"],"mappings":";;;AAYA,IAAa,aAAb,MAAa,WAA6B;CACX;CAA7B,YAAY,UAAyC;EAAxB,KAAA,WAAA;CAAyB;CAEtD,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,KAAK,KAAa,MAAsC;EACtD,KAAK,SAAS,KAAK,QAAQ,CAAC,GAAG,GAAG;CACpC;CACA,MAAM,KAAa,MAAsC;EACvD,KAAK,SAAS,MAAM,QAAQ,CAAC,GAAG,GAAG;CACrC;CACA,MAAM,UAA2C;EAC/C,OAAO,IAAI,WAAW,KAAK,SAAS,MAAM,QAAQ,CAAC;CACrD;AACF;;;AAIA,SAAgB,iBACd,OACA,aAC4C;CAC5C,MAAM,WAAW,KACf;EACE;EACA,aAAa,EAAE,KAAK,eAAe,IAAI;EAEvC,aAAa,kBAAkB,QAAQ;CACzC,GACA,WACF;CACA,OAAO;EAAE;EAAU,QAAQ,IAAI,WAAW,QAAQ;CAAE;AACtD"}

package/dist/logging/request-context.d.ts

@@ -0,0 +1,13 @@
+//#region src/logging/request-context.d.ts
+interface RequestLogContext {
+  /** Runs `fn` with `fields` as the ambient log context for its async scope. */
+  run<T>(fields: Record<string, unknown>, fn: () => T): T;
+  /** Merges fields into the current request's context; noop outside a request. */
+  set(fields: Record<string, unknown>): void;
+  /** A copy of the current context ({} outside a request) — safe for pino's mutating mixin merge. */
+  current(): Record<string, unknown>;
+}
+declare const requestLogContext: RequestLogContext;
+//#endregion
+export { RequestLogContext, requestLogContext };
+//# sourceMappingURL=request-context.d.ts.map

package/dist/logging/request-context.js

@@ -0,0 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/logging/request-context.ts
+const storage = new AsyncLocalStorage();
+const requestLogContext = {
+	run(fields, fn) {
+		return storage.run(fields, fn);
+	},
+	set(fields) {
+		const store = storage.getStore();
+		if (store) Object.assign(store, fields);
+	},
+	current() {
+		return { ...storage.getStore() };
+	}
+};
+//#endregion
+export { requestLogContext };
+
+//# sourceMappingURL=request-context.js.map

package/dist/logging/request-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.js","names":[],"sources":["../../src/logging/request-context.ts"],"sourcesContent":["// Request-scoped log context. The HTTP layer enters a store per request and the\n// root pino mixin folds it into every line logged inside that request — so\n// lines emitted deep in adapters (e.g. a failed invite email inside better-auth\n// callbacks) still carry the reqId/orgId of the request that triggered them.\nimport { AsyncLocalStorage } from 'node:async_hooks';\n\nconst storage = new AsyncLocalStorage<Record<string, unknown>>();\n\nexport interface RequestLogContext {\n  /** Runs `fn` with `fields` as the ambient log context for its async scope. */\n  run<T>(fields: Record<string, unknown>, fn: () => T): T;\n  /** Merges fields into the current request's context; noop outside a request. */\n  set(fields: Record<string, unknown>): void;\n  /** A copy of the current context ({} outside a request) — safe for pino's mutating mixin merge. */\n  current(): Record<string, unknown>;\n}\n\nexport const requestLogContext: RequestLogContext = {\n  run(fields, fn) {\n    return storage.run(fields, fn);\n  },\n  set(fields) {\n    const store = storage.getStore();\n    if (store) {\n      Object.assign(store, fields);\n    }\n  },\n  current() {\n    return { ...storage.getStore() };\n  },\n};\n"],"mappings":";;AAMA,MAAM,UAAU,IAAI,kBAA2C;AAW/D,MAAa,oBAAuC;CAClD,IAAI,QAAQ,IAAI;EACd,OAAO,QAAQ,IAAI,QAAQ,EAAE;CAC/B;CACA,IAAI,QAAQ;EACV,MAAM,QAAQ,QAAQ,SAAS;EAC/B,IAAI,OACF,OAAO,OAAO,OAAO,MAAM;CAE/B;CACA,UAAU;EACR,OAAO,EAAE,GAAG,QAAQ,SAAS,EAAE;CACjC;AACF"}

package/dist/storage/index.d.ts

@@ -0,0 +1,18 @@
+import { Logger, ObjectStorage, PresignDownloadInput, PresignedUpload, StoredObjectInfo } from "@headless-lms/core/shared/ports";
+//#region src/storage/index.d.ts
+declare class StorageAdapter implements ObjectStorage {
+  private readonly logger;
+  constructor(logger?: Logger);
+  presignUpload(_input: {
+    key: string;
+    contentType?: string;
+    expiresInSeconds?: number;
+  }): Promise<PresignedUpload>;
+  presignDownload(_input: PresignDownloadInput): Promise<string>;
+  stat(_key: string): Promise<StoredObjectInfo | null>;
+  remove(_key: string): Promise<void>;
+  private fail;
+}
+//#endregion
+export { StorageAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -0,0 +1,28 @@
+import { noopLogger } from "@headless-lms/core/shared/logger";
+//#region src/storage/index.ts
+var StorageAdapter = class {
+	logger;
+	constructor(logger = noopLogger) {
+		this.logger = logger;
+	}
+	async presignUpload(_input) {
+		return this.fail("presignUpload");
+	}
+	async presignDownload(_input) {
+		return this.fail("presignDownload");
+	}
+	async stat(_key) {
+		return this.fail("stat");
+	}
+	async remove(_key) {
+		return this.fail("remove");
+	}
+	fail(op) {
+		this.logger.error(`storage ${op} failed: no storage adapter configured`);
+		throw new Error("not implemented");
+	}
+};
+//#endregion
+export { StorageAdapter };
+
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/storage/index.ts"],"sourcesContent":["// Default when no ObjectStorage is injected — boots, fails loudly on use.\nimport type {\n  Logger,\n  ObjectStorage,\n  PresignDownloadInput,\n  PresignedUpload,\n  StoredObjectInfo,\n} from '@headless-lms/core/shared/ports';\nimport { noopLogger } from '@headless-lms/core/shared/logger';\n\nexport class StorageAdapter implements ObjectStorage {\n  constructor(private readonly logger: Logger = noopLogger) {}\n\n  async presignUpload(_input: {\n    key: string;\n    contentType?: string;\n    expiresInSeconds?: number;\n  }): Promise<PresignedUpload> {\n    return this.fail('presignUpload');\n  }\n\n  async presignDownload(_input: PresignDownloadInput): Promise<string> {\n    return this.fail('presignDownload');\n  }\n\n  async stat(_key: string): Promise<StoredObjectInfo | null> {\n    return this.fail('stat');\n  }\n\n  async remove(_key: string): Promise<void> {\n    return this.fail('remove');\n  }\n\n  private fail(op: string): never {\n    this.logger.error(`storage ${op} failed: no storage adapter configured`);\n    throw new Error('not implemented');\n  }\n}\n"],"mappings":";;AAUA,IAAa,iBAAb,MAAqD;CACtB;CAA7B,YAAY,SAAkC,YAAY;EAA7B,KAAA,SAAA;CAA8B;CAE3D,MAAM,cAAc,QAIS;EAC3B,OAAO,KAAK,KAAK,eAAe;CAClC;CAEA,MAAM,gBAAgB,QAA+C;EACnE,OAAO,KAAK,KAAK,iBAAiB;CACpC;CAEA,MAAM,KAAK,MAAgD;EACzD,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,MAAM,OAAO,MAA6B;EACxC,OAAO,KAAK,KAAK,QAAQ;CAC3B;CAEA,KAAa,IAAmB;EAC9B,KAAK,OAAO,MAAM,WAAW,GAAG,uCAAuC;EACvE,MAAM,IAAI,MAAM,iBAAiB;CACnC;AACF"}

package/dist/workflows/index.d.ts

@@ -0,0 +1,12 @@
+import { AutomationDispatch, AutomationEngine, AutomationExecutor } from "@headless-lms/core/types";
+//#region src/workflows/index.d.ts
+declare class InlineAutomationEngine implements AutomationEngine {
+  private executor;
+  register(executor: AutomationExecutor): void;
+  dispatch(d: AutomationDispatch): Promise<void>;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+//#endregion
+export { InlineAutomationEngine };
+//# sourceMappingURL=index.d.ts.map

package/dist/workflows/index.js

@@ -0,0 +1,31 @@
+//#region src/workflows/index.ts
+var InlineAutomationEngine = class {
+	executor;
+	register(executor) {
+		this.executor = executor;
+	}
+	async dispatch(d) {
+		if (!this.executor) throw new Error("InlineAutomationEngine.dispatch called before register()");
+		const executor = this.executor;
+		const results = [];
+		for (let index = 0; index < d.actions.length; index++) try {
+			results.push(await executor.runAction(d, index));
+		} catch (err) {
+			const message = err?.message ?? err;
+			results.push({
+				index,
+				type: d.actions[index].type,
+				status: "failed",
+				error: String(message)
+			});
+			break;
+		}
+		await executor.finalize(d, results);
+	}
+	async start() {}
+	async stop() {}
+};
+//#endregion
+export { InlineAutomationEngine };
+
+//# sourceMappingURL=index.js.map

package/dist/workflows/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/workflows/index.ts"],"sourcesContent":["// Default in-process engine — runs a dispatched automation immediately, one\n// attempt per action; durable engines (Hatchet, …) are installation adapters.\nimport type {\n  AutomationActionResult,\n  AutomationDispatch,\n  AutomationEngine,\n  AutomationExecutor,\n} from '@headless-lms/core/types';\n\nexport class InlineAutomationEngine implements AutomationEngine {\n  private executor: AutomationExecutor | undefined;\n\n  register(executor: AutomationExecutor): void {\n    this.executor = executor;\n  }\n\n  async dispatch(d: AutomationDispatch): Promise<void> {\n    if (!this.executor) {\n      throw new Error('InlineAutomationEngine.dispatch called before register()');\n    }\n    const executor = this.executor;\n\n    const results: AutomationActionResult[] = [];\n    for (let index = 0; index < d.actions.length; index++) {\n      try {\n        results.push(await executor.runAction(d, index));\n      } catch (err) {\n        const message = (err as { message?: unknown } | undefined)?.message ?? err;\n        results.push({ index, type: d.actions[index]!.type, status: 'failed', error: String(message) });\n        break;\n      }\n    }\n\n    await executor.finalize(d, results);\n  }\n\n  async start(): Promise<void> {}\n\n  async stop(): Promise<void> {}\n}\n"],"mappings":";AASA,IAAa,yBAAb,MAAgE;CAC9D;CAEA,SAAS,UAAoC;EAC3C,KAAK,WAAW;CAClB;CAEA,MAAM,SAAS,GAAsC;EACnD,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,0DAA0D;EAE5E,MAAM,WAAW,KAAK;EAEtB,MAAM,UAAoC,CAAC;EAC3C,KAAK,IAAI,QAAQ,GAAG,QAAQ,EAAE,QAAQ,QAAQ,SAC5C,IAAI;GACF,QAAQ,KAAK,MAAM,SAAS,UAAU,GAAG,KAAK,CAAC;EACjD,SAAS,KAAK;GACZ,MAAM,UAAW,KAA2C,WAAW;GACvE,QAAQ,KAAK;IAAE;IAAO,MAAM,EAAE,QAAQ,MAAM,CAAE;IAAM,QAAQ;IAAU,OAAO,OAAO,OAAO;GAAE,CAAC;GAC9F;EACF;EAGF,MAAM,SAAS,SAAS,GAAG,OAAO;CACpC;CAEA,MAAM,QAAuB,CAAC;CAE9B,MAAM,OAAsB,CAAC;AAC/B"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@headless-lms/adapter-defaults",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    "./email": {
+      "types": "./dist/email/index.d.ts",
+      "default": "./dist/email/index.js"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "default": "./dist/storage/index.js"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.ts",
+      "default": "./dist/events/index.js"
+    },
+    "./events/outbox-relay": {
+      "types": "./dist/events/outbox-relay.d.ts",
+      "default": "./dist/events/outbox-relay.js"
+    },
+    "./logging": {
+      "types": "./dist/logging/index.d.ts",
+      "default": "./dist/logging/index.js"
+    },
+    "./logging/request-context": {
+      "types": "./dist/logging/request-context.d.ts",
+      "default": "./dist/logging/request-context.js"
+    },
+    "./workflows": {
+      "types": "./dist/workflows/index.d.ts",
+      "default": "./dist/workflows/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "pino": "^10.3.1",
+    "@headless-lms/adapter-db": "0.1.0",
+    "@headless-lms/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.9",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "description": "Default in-process adapters (email, storage, events, logging, workflows) for the headless LMS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdwt/headless-lms.git",
+    "directory": "adapters/defaults"
+  },
+  "homepage": "https://github.com/mdwt/headless-lms#readme",
+  "bugs": {
+    "url": "https://github.com/mdwt/headless-lms/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}