@classytic/arc 1.1.0 → 2.1.3

package/dist/plugins/index.d.mts

@@ -0,0 +1,172 @@
+import "../elevation-DGo5shaX.mjs";
+import { K as HookSystem, w as ResourceRegistry } from "../interface-e9XfSsUV.mjs";
+import "../types-RLkFVgaw.mjs";
+import { AdditionalRoute, AnyRecord, MiddlewareConfig, PresetHook, RouteSchemaOptions } from "../types/index.mjs";
+import { t as ExternalOpenApiPaths } from "../externalPaths-SyPF2tgK.mjs";
+import { a as ssePlugin, c as _default$1, i as _default$5, l as cachingPlugin, n as errorHandlerPlugin, o as CachingOptions, r as SSEOptions, s as CachingRule, t as ErrorHandlerOptions } from "../errorHandler-CW3OOeYq.mjs";
+import { t as TracingOptions } from "../tracing-8CEbhF0w.mjs";
+import { FastifyInstance, FastifyPluginAsync } from "fastify";
+
+//#region src/plugins/requestId.d.ts
+interface RequestIdOptions {
+  /** Header name to read/write request ID (default: 'x-request-id') */
+  header?: string;
+  /** Custom ID generator (default: crypto.randomUUID) */
+  generator?: () => string;
+  /** Whether to set response header (default: true) */
+  setResponseHeader?: boolean;
+}
+declare module 'fastify' {
+  interface FastifyRequest {
+    /** Unique request identifier for tracing */
+    requestId: string;
+  }
+}
+declare const requestIdPlugin: FastifyPluginAsync<RequestIdOptions>;
+declare const _default$4: FastifyPluginAsync<RequestIdOptions>;
+//#endregion
+//#region src/plugins/health.d.ts
+declare module 'fastify' {
+  interface FastifyRequest {
+    _startTime?: number;
+  }
+}
+interface HealthCheck {
+  /** Name of the dependency */
+  name: string;
+  /** Function that returns true if healthy, false otherwise */
+  check: () => Promise<boolean> | boolean;
+  /** Optional timeout in ms (default: 5000) */
+  timeout?: number;
+  /** Whether this check is critical for readiness (default: true) */
+  critical?: boolean;
+}
+interface HealthOptions {
+  /** Route prefix (default: '/_health') */
+  prefix?: string;
+  /** Health check dependencies */
+  checks?: HealthCheck[];
+  /** Enable metrics endpoint (default: false) */
+  metrics?: boolean;
+  /** Custom metrics collector function */
+  metricsCollector?: () => Promise<string> | string;
+  /** Version info to include in responses */
+  version?: string;
+  /** Collect HTTP request metrics (default: true if metrics enabled) */
+  collectHttpMetrics?: boolean;
+}
+declare const healthPlugin: FastifyPluginAsync<HealthOptions>;
+declare const _default$3: FastifyPluginAsync<HealthOptions>;
+//#endregion
+//#region src/plugins/gracefulShutdown.d.ts
+interface GracefulShutdownOptions {
+  /** Maximum time to wait for graceful shutdown in ms (default: 30000) */
+  timeout?: number;
+  /** Custom cleanup function called before exit */
+  onShutdown?: () => Promise<void> | void;
+  /** Signals to handle (default: ['SIGTERM', 'SIGINT']) */
+  signals?: NodeJS.Signals[];
+  /** Whether to log shutdown events (default: true) */
+  logEvents?: boolean;
+  /**
+   * Called when shutdown times out or encounters an error.
+   * Defaults to `process.exit(1)` — appropriate for production but dangerous in:
+   * - **Tests**: kills the test runner. Pass `() => {}` or `() => { throw … }`.
+   * - **Shared runtimes** (e.g., serverless): may kill unrelated handlers.
+   *
+   * @param reason - `'timeout'` if shutdown exceeded `timeout` ms,
+   *                 `'error'` if `onShutdown` or `fastify.close()` threw.
+   */
+  onForceExit?: (reason: 'timeout' | 'error') => void;
+}
+declare const gracefulShutdownPlugin: FastifyPluginAsync<GracefulShutdownOptions>;
+declare module 'fastify' {
+  interface FastifyInstance {
+    /** Trigger graceful shutdown manually */
+    shutdown: () => Promise<void>;
+  }
+}
+declare const _default$2: FastifyPluginAsync<GracefulShutdownOptions>;
+//#endregion
+//#region src/plugins/createPlugin.d.ts
+interface PluginResourceResult {
+  /** Additional routes to add to the resource */
+  additionalRoutes?: AdditionalRoute[];
+  /** Middlewares per operation */
+  middlewares?: MiddlewareConfig;
+  /** Hooks to register */
+  hooks?: PresetHook[];
+  /** Schema options to merge */
+  schemaOptions?: RouteSchemaOptions;
+}
+interface CreatePluginDefinition<TRootOpts extends AnyRecord = AnyRecord, TResourceOpts extends AnyRecord = AnyRecord> {
+  /**
+   * Global setup function. Called once when the plugin is registered on the Fastify instance.
+   * Use this for database connections, decorators, shared state, etc.
+   */
+  forRoot?: (fastify: FastifyInstance, opts: TRootOpts) => void | Promise<void>;
+  /**
+   * Per-resource configuration function. Called for each resource that uses this plugin.
+   * Returns hooks, routes, middlewares, etc. to merge into the resource config.
+   */
+  forResource?: (resourceConfig: AnyRecord, opts: TResourceOpts) => PluginResourceResult;
+}
+interface ArcPlugin<TRootOpts extends AnyRecord = AnyRecord, TResourceOpts extends AnyRecord = AnyRecord> {
+  /** Plugin name */
+  readonly name: string;
+  /**
+   * Register the plugin globally on a Fastify instance.
+   * Returns a Fastify plugin that can be passed to `app.register()`.
+   */
+  forRoot(opts?: TRootOpts): FastifyPluginAsync<TRootOpts>;
+  /**
+   * Apply per-resource configuration.
+   * Returns a partial resource config to spread into `defineResource()`.
+   */
+  forResource(opts?: TResourceOpts): PluginResourceResult;
+}
+/**
+ * Create a structured plugin with forRoot (global) and forResource (per-resource) support.
+ *
+ * @param name - Plugin name (used for Fastify registration and debugging)
+ * @param definition - Plugin setup functions
+ * @returns ArcPlugin with forRoot() and forResource() methods
+ */
+declare function createPlugin<TRootOpts extends AnyRecord = AnyRecord, TResourceOpts extends AnyRecord = AnyRecord>(name: string, definition: CreatePluginDefinition<TRootOpts, TResourceOpts>): ArcPlugin<TRootOpts, TResourceOpts>;
+//#endregion
+//#region src/core/arcCorePlugin.d.ts
+interface ArcCorePluginOptions {
+  /** Enable event emission for CRUD operations (requires eventPlugin) */
+  emitEvents?: boolean;
+  /** Hook system instance (for testing/custom setup) */
+  hookSystem?: HookSystem;
+  /** Resource registry instance (for testing/custom setup) */
+  registry?: ResourceRegistry;
+}
+interface PluginMeta {
+  name: string;
+  version?: string;
+  options?: Record<string, unknown>;
+  registeredAt: string;
+}
+interface ArcCore {
+  /** Instance-scoped hook system */
+  hooks: HookSystem;
+  /** Instance-scoped resource registry */
+  registry: ResourceRegistry;
+  /** Whether event emission is enabled */
+  emitEvents: boolean;
+  /** External OpenAPI paths contributed by auth adapters or third-party integrations */
+  externalOpenApiPaths: ExternalOpenApiPaths[];
+  /** Registered plugins for introspection */
+  plugins: Map<string, PluginMeta>;
+}
+declare module 'fastify' {
+  interface FastifyInstance {
+    arc: ArcCore;
+  }
+}
+declare const arcCorePlugin: FastifyPluginAsync<ArcCorePluginOptions>;
+declare const _default: FastifyPluginAsync<ArcCorePluginOptions>;
+//#endregion
+export { type ArcCore, type ArcCorePluginOptions, type ArcPlugin, type CachingOptions, type CachingRule, type CreatePluginDefinition, type ErrorHandlerOptions, type GracefulShutdownOptions, type HealthCheck, type HealthOptions, type PluginMeta, type PluginResourceResult, type RequestIdOptions, type SSEOptions, type TracingOptions, _default as arcCorePlugin, arcCorePlugin as arcCorePluginFn, _default$1 as cachingPlugin, cachingPlugin as cachingPluginFn, createPlugin, errorHandlerPlugin, errorHandlerPlugin as errorHandlerPluginFn, _default$2 as gracefulShutdownPlugin, gracefulShutdownPlugin as gracefulShutdownPluginFn, _default$3 as healthPlugin, healthPlugin as healthPluginFn, _default$4 as requestIdPlugin, requestIdPlugin as requestIdPluginFn, _default$5 as ssePlugin, ssePlugin as ssePluginFn };

package/dist/plugins/index.mjs

@@ -0,0 +1,522 @@
+import { p as MUTATION_OPERATIONS } from "../constants-DdXFXQtN.mjs";
+import { r as getOrgId } from "../types-Beqn1Un7.mjs";
+import { t as HookSystem } from "../HookSystem-BsGV-j2l.mjs";
+import { t as hasEvents } from "../typeGuards-DwxA1t_L.mjs";
+import { t as requestContext } from "../requestContext-xi6OKBL-.mjs";
+import { t as ResourceRegistry } from "../ResourceRegistry-7Ic20ZMw.mjs";
+import { t as errorHandlerPlugin } from "../errorHandler-C3GY3_ow.mjs";
+import { n as caching_default, t as cachingPlugin } from "../caching-GSDJcA6-.mjs";
+import { n as sse_default, t as ssePlugin } from "../sse-DkqQ1uxb.mjs";
+import fp from "fastify-plugin";
+import { randomUUID } from "crypto";
+
+//#region src/plugins/requestId.ts
+/**
+* Request ID Plugin
+*
+* Propagates request IDs for distributed tracing.
+* - Accepts incoming x-request-id header
+* - Generates UUID if not provided
+* - Attaches to request.id and response header
+*
+* @example
+* import { requestIdPlugin } from '@classytic/arc';
+*
+* await fastify.register(requestIdPlugin);
+*
+* // In handlers, access via request.id
+* fastify.get('/', async (request) => {
+*   console.log(request.id); // UUID
+* });
+*/
+const requestIdPlugin = async (fastify, opts = {}) => {
+	const { header = "x-request-id", generator = randomUUID, setResponseHeader = true } = opts;
+	if (!fastify.hasRequestDecorator("requestId")) fastify.decorateRequest("requestId", "");
+	fastify.addHook("onRequest", async (request) => {
+		const incomingId = request.headers[header];
+		const sanitized = typeof incomingId === "string" ? incomingId.trim() : "";
+		const requestId = sanitized.length > 0 && sanitized.length <= 128 && /^[\w.:-]+$/.test(sanitized) ? sanitized : generator();
+		request.id = requestId;
+		request.requestId = requestId;
+	});
+	if (setResponseHeader) fastify.addHook("onSend", async (request, reply) => {
+		reply.header(header, request.requestId);
+	});
+	fastify.log?.debug?.("Request ID plugin registered");
+};
+var requestId_default = fp(requestIdPlugin, {
+	name: "arc-request-id",
+	fastify: "5.x"
+});
+
+//#endregion
+//#region src/plugins/health.ts
+/**
+* Health Check Plugin
+*
+* Kubernetes-ready health endpoints:
+* - /health/live  - Liveness probe (is the process alive?)
+* - /health/ready - Readiness probe (can we serve traffic?)
+* - /health/metrics - Prometheus metrics (optional)
+*
+* @example
+* import { healthPlugin } from '@classytic/arc';
+*
+* await fastify.register(healthPlugin, {
+*   prefix: '/_health',
+*   checks: [
+*     { name: 'mongodb', check: async () => mongoose.connection.readyState === 1 },
+*     { name: 'redis', check: async () => redis.ping() === 'PONG' },
+*   ],
+* });
+*/
+function createHttpMetrics() {
+	return {
+		requestsTotal: {},
+		requestDurations: [],
+		_ringIndex: 0,
+		startTime: Date.now()
+	};
+}
+const healthPlugin = async (fastify, opts = {}) => {
+	const { prefix = "/_health", checks = [], metrics = false, metricsCollector, version, collectHttpMetrics = metrics } = opts;
+	const httpMetrics = createHttpMetrics();
+	fastify.get(`${prefix}/live`, { schema: {
+		tags: ["Health"],
+		summary: "Liveness probe",
+		description: "Returns 200 if the process is alive",
+		response: { 200: {
+			type: "object",
+			properties: {
+				status: {
+					type: "string",
+					enum: ["ok"]
+				},
+				timestamp: { type: "string" },
+				version: { type: "string" }
+			}
+		} }
+	} }, async () => {
+		return {
+			status: "ok",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...version ? { version } : {}
+		};
+	});
+	fastify.get(`${prefix}/ready`, { schema: {
+		tags: ["Health"],
+		summary: "Readiness probe",
+		description: "Returns 200 if all dependencies are healthy",
+		response: {
+			200: {
+				type: "object",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["ready", "not_ready"]
+					},
+					timestamp: { type: "string" },
+					checks: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								name: { type: "string" },
+								healthy: { type: "boolean" },
+								duration: { type: "number" },
+								error: { type: "string" }
+							}
+						}
+					}
+				}
+			},
+			503: {
+				type: "object",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["not_ready"]
+					},
+					timestamp: { type: "string" },
+					checks: { type: "array" }
+				}
+			}
+		}
+	} }, async (_, reply) => {
+		const results = await runChecks(checks);
+		const criticalFailed = results.some((r) => !r.healthy && (checks.find((c) => c.name === r.name)?.critical ?? true));
+		const response = {
+			status: criticalFailed ? "not_ready" : "ready",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			checks: results
+		};
+		if (criticalFailed) reply.code(503);
+		return response;
+	});
+	if (metrics) fastify.get(`${prefix}/metrics`, async (_, reply) => {
+		reply.type("text/plain; charset=utf-8");
+		if (metricsCollector) return await metricsCollector();
+		const uptime = process.uptime();
+		const memory = process.memoryUsage();
+		const cpu = process.cpuUsage();
+		const lines = [
+			"# HELP process_uptime_seconds Process uptime in seconds",
+			"# TYPE process_uptime_seconds gauge",
+			`process_uptime_seconds ${uptime.toFixed(2)}`,
+			"",
+			"# HELP process_memory_heap_bytes Heap memory usage in bytes",
+			"# TYPE process_memory_heap_bytes gauge",
+			`process_memory_heap_bytes{type="used"} ${memory.heapUsed}`,
+			`process_memory_heap_bytes{type="total"} ${memory.heapTotal}`,
+			"",
+			"# HELP process_memory_rss_bytes RSS memory in bytes",
+			"# TYPE process_memory_rss_bytes gauge",
+			`process_memory_rss_bytes ${memory.rss}`,
+			"",
+			"# HELP process_memory_external_bytes External memory in bytes",
+			"# TYPE process_memory_external_bytes gauge",
+			`process_memory_external_bytes ${memory.external}`,
+			"",
+			"# HELP process_cpu_user_microseconds User CPU time in microseconds",
+			"# TYPE process_cpu_user_microseconds counter",
+			`process_cpu_user_microseconds ${cpu.user}`,
+			"",
+			"# HELP process_cpu_system_microseconds System CPU time in microseconds",
+			"# TYPE process_cpu_system_microseconds counter",
+			`process_cpu_system_microseconds ${cpu.system}`,
+			""
+		];
+		if (collectHttpMetrics && Object.keys(httpMetrics.requestsTotal).length > 0) {
+			lines.push("# HELP http_requests_total Total HTTP requests by status code", "# TYPE http_requests_total counter");
+			for (const [status, count] of Object.entries(httpMetrics.requestsTotal)) lines.push(`http_requests_total{status="${status}"} ${count}`);
+			lines.push("");
+			if (httpMetrics.requestDurations.length > 0) {
+				const sorted = [...httpMetrics.requestDurations].sort((a, b) => a - b);
+				const p50 = sorted[Math.floor(sorted.length * .5)] || 0;
+				const p95 = sorted[Math.floor(sorted.length * .95)] || 0;
+				const p99 = sorted[Math.floor(sorted.length * .99)] || 0;
+				const sum = sorted.reduce((a, b) => a + b, 0);
+				lines.push("# HELP http_request_duration_milliseconds HTTP request duration", "# TYPE http_request_duration_milliseconds summary", `http_request_duration_milliseconds{quantile="0.5"} ${p50.toFixed(2)}`, `http_request_duration_milliseconds{quantile="0.95"} ${p95.toFixed(2)}`, `http_request_duration_milliseconds{quantile="0.99"} ${p99.toFixed(2)}`, `http_request_duration_milliseconds_sum ${sum.toFixed(2)}`, `http_request_duration_milliseconds_count ${sorted.length}`, "");
+			}
+		}
+		return lines.join("\n");
+	});
+	if (collectHttpMetrics) {
+		fastify.addHook("onRequest", async (request) => {
+			request._startTime = Date.now();
+		});
+		fastify.addHook("onResponse", async (request, reply) => {
+			const duration = Date.now() - (request._startTime ?? Date.now());
+			const statusBucket = `${Math.floor(reply.statusCode / 100)}xx`;
+			httpMetrics.requestsTotal[statusBucket] = (httpMetrics.requestsTotal[statusBucket] || 0) + 1;
+			if (httpMetrics.requestDurations.length < 1e4) httpMetrics.requestDurations.push(duration);
+			else httpMetrics.requestDurations[httpMetrics._ringIndex % 1e4] = duration;
+			httpMetrics._ringIndex = httpMetrics._ringIndex + 1;
+		});
+	}
+	fastify.log?.debug?.(`Health plugin registered at ${prefix}`);
+};
+/**
+* Run all health checks with timeout
+*/
+async function runChecks(checks) {
+	const results = [];
+	for (const check of checks) {
+		const start = Date.now();
+		const timeout = check.timeout ?? 5e3;
+		let timer;
+		try {
+			const checkPromise = Promise.resolve(check.check());
+			const timeoutPromise = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Health check timeout")), timeout);
+			});
+			const healthy = await Promise.race([checkPromise, timeoutPromise]);
+			results.push({
+				name: check.name,
+				healthy: Boolean(healthy),
+				duration: Date.now() - start
+			});
+		} catch (err) {
+			results.push({
+				name: check.name,
+				healthy: false,
+				duration: Date.now() - start,
+				error: err.message
+			});
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	return results;
+}
+var health_default = fp(healthPlugin, {
+	name: "arc-health",
+	fastify: "5.x"
+});
+
+//#endregion
+//#region src/plugins/gracefulShutdown.ts
+/**
+* Graceful Shutdown Plugin
+*
+* Handles SIGTERM and SIGINT signals for clean shutdown:
+* - Stops accepting new connections
+* - Waits for in-flight requests to complete
+* - Closes database connections
+* - Exits cleanly
+*
+* Essential for Kubernetes deployments.
+*
+* @example
+* import { gracefulShutdownPlugin } from '@classytic/arc';
+*
+* // Production
+* await fastify.register(gracefulShutdownPlugin, {
+*   timeout: 30000, // 30 seconds max
+*   onShutdown: async () => {
+*     await mongoose.disconnect();
+*     await redis.quit();
+*   },
+* });
+*
+* // Tests — prevent process.exit from killing the runner
+* await fastify.register(gracefulShutdownPlugin, {
+*   onForceExit: () => {},
+* });
+*/
+const gracefulShutdownPlugin = async (fastify, opts = {}) => {
+	const { timeout = 3e4, onShutdown, signals = ["SIGTERM", "SIGINT"], logEvents = true, onForceExit = () => process.exit(1) } = opts;
+	let isShuttingDown = false;
+	const signalHandlers = /* @__PURE__ */ new Map();
+	const shutdown = async (signal) => {
+		if (isShuttingDown) {
+			if (logEvents) fastify.log?.warn?.({ signal }, "Shutdown already in progress, ignoring signal");
+			return;
+		}
+		isShuttingDown = true;
+		if (logEvents) fastify.log?.info?.({
+			signal,
+			timeout
+		}, "Shutdown signal received, starting graceful shutdown");
+		const forceExitTimer = setTimeout(() => {
+			if (logEvents) fastify.log?.error?.("Graceful shutdown timeout exceeded, forcing exit");
+			onForceExit("timeout");
+		}, timeout);
+		forceExitTimer.unref();
+		try {
+			if (logEvents) fastify.log?.info?.("Closing server to new connections");
+			await fastify.close();
+			if (onShutdown) {
+				if (logEvents) fastify.log?.info?.("Running custom shutdown handler");
+				await onShutdown();
+			}
+			if (logEvents) fastify.log?.info?.("Graceful shutdown complete");
+			clearTimeout(forceExitTimer);
+		} catch (err) {
+			if (logEvents) fastify.log?.error?.({ error: err.message }, "Error during shutdown");
+			clearTimeout(forceExitTimer);
+			onForceExit("error");
+		}
+	};
+	for (const signal of signals) {
+		const handler = () => {
+			shutdown(signal);
+		};
+		signalHandlers.set(signal, handler);
+		process.on(signal, handler);
+	}
+	fastify.addHook("onClose", async () => {
+		for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
+		signalHandlers.clear();
+	});
+	fastify.decorate("shutdown", async () => {
+		await shutdown("MANUAL");
+	});
+	if (logEvents) fastify.log?.debug?.({ signals }, "Graceful shutdown plugin registered");
+};
+var gracefulShutdown_default = fp(gracefulShutdownPlugin, {
+	name: "arc-graceful-shutdown",
+	fastify: "5.x"
+});
+
+//#endregion
+//#region src/plugins/createPlugin.ts
+/**
+* createPlugin() — forRoot/forFeature Pattern
+*
+* Standard pattern for plugins that need both global setup and per-resource configuration.
+* Inspired by NestJS forRoot/forFeature but simpler — plain functions, no decorators.
+*
+* @example
+* ```typescript
+* // Define a plugin with global + per-resource config
+* const analytics = createPlugin('analytics', {
+*   forRoot: async (fastify, opts) => {
+*     // Global setup: connect to analytics service, add decorators
+*     const client = new AnalyticsClient(opts.apiKey);
+*     fastify.decorate('analytics', client);
+*   },
+*   forResource: (resourceConfig, opts) => {
+*     // Per-resource: return hooks, middleware, or routes
+*     return {
+*       hooks: [{
+*         operation: 'create', phase: 'after', priority: 100,
+*         handler: (ctx) => client.track('created', ctx.result),
+*       }],
+*     };
+*   },
+* });
+*
+* // Usage — register globally once
+* await app.register(analytics.forRoot({ apiKey: 'xxx' }));
+*
+* // Then apply per-resource
+* const productResource = defineResource({
+*   name: 'product',
+*   adapter: productAdapter,
+*   ...analytics.forResource({ trackEvents: true }),
+* });
+* ```
+*/
+/**
+* Create a structured plugin with forRoot (global) and forResource (per-resource) support.
+*
+* @param name - Plugin name (used for Fastify registration and debugging)
+* @param definition - Plugin setup functions
+* @returns ArcPlugin with forRoot() and forResource() methods
+*/
+function createPlugin(name, definition) {
+	return {
+		name,
+		forRoot(opts) {
+			const plugin = async (fastify, pluginOpts) => {
+				const mergedOpts = {
+					...opts,
+					...pluginOpts
+				};
+				if (definition.forRoot) await definition.forRoot(fastify, mergedOpts);
+			};
+			return fp(plugin, {
+				name: `arc-plugin-${name}`,
+				fastify: "5.x"
+			});
+		},
+		forResource(opts) {
+			if (!definition.forResource) return {};
+			return definition.forResource({}, opts ?? {});
+		}
+	};
+}
+
+//#endregion
+//#region src/core/arcCorePlugin.ts
+/**
+* Arc Core Plugin
+*
+* Sets up instance-scoped Arc systems:
+* - HookSystem: Lifecycle hooks per app instance
+* - ResourceRegistry: Resource tracking per app instance
+* - Event integration: Wires CRUD operations to fastify.events
+*
+* This solves the global singleton leak problem where multiple
+* app instances (e.g., in tests) would share state.
+*
+* @example
+* import { arcCorePlugin } from '@classytic/arc';
+*
+* const app = Fastify();
+* await app.register(arcCorePlugin);
+*
+* // Now use instance-scoped hooks
+* app.arc.hooks.before('product', 'create', async (ctx) => {
+*   ctx.data.slug = slugify(ctx.data.name);
+* });
+*/
+const arcCorePlugin = async (fastify, opts = {}) => {
+	const { emitEvents = true, hookSystem, registry } = opts;
+	const actualHookSystem = hookSystem ?? new HookSystem();
+	const actualRegistry = registry ?? new ResourceRegistry();
+	fastify.decorate("arc", {
+		hooks: actualHookSystem,
+		registry: actualRegistry,
+		emitEvents,
+		externalOpenApiPaths: [],
+		plugins: /* @__PURE__ */ new Map()
+	});
+	fastify.addHook("onRequest", (request, _reply, done) => {
+		const store = {
+			requestId: request.id,
+			startTime: performance.now()
+		};
+		requestContext.storage.run(store, done);
+	});
+	fastify.addHook("preHandler", (request, _reply, done) => {
+		const store = requestContext.get();
+		if (store) {
+			store.user = request.user ?? null;
+			store.organizationId = request.scope?.kind === "member" ? request.scope.organizationId : request.scope?.kind === "elevated" ? request.scope.organizationId : void 0;
+		}
+		done();
+	});
+	if (emitEvents) {
+		const eventOperations = MUTATION_OPERATIONS;
+		for (const operation of eventOperations) actualHookSystem.after("*", operation, async (ctx) => {
+			if (!hasEvents(fastify)) return;
+			const store = requestContext.get();
+			const eventType = `${ctx.resource}.${operation}d`;
+			const userId = ctx.user?.id ?? ctx.user?._id;
+			const organizationId = ctx.context?._scope ? getOrgId(ctx.context._scope) : void 0;
+			const payload = {
+				resource: ctx.resource,
+				operation: ctx.operation,
+				data: ctx.result,
+				userId,
+				organizationId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			try {
+				await fastify.events.publish(eventType, payload, {
+					correlationId: store?.requestId,
+					resource: ctx.resource,
+					resourceId: extractId(ctx.result),
+					userId: userId ? String(userId) : void 0,
+					organizationId
+				});
+			} catch (error) {
+				fastify.log?.warn?.({
+					eventType,
+					error
+				}, "Failed to emit event");
+			}
+		});
+	}
+	fastify.addHook("onReady", async () => {
+		if (!hasEvents(fastify)) return;
+		try {
+			await fastify.events.publish("arc.ready", {
+				resources: actualRegistry.getAll().length,
+				hooks: actualHookSystem.getAll().length,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch {}
+	});
+	fastify.addHook("onClose", async () => {
+		actualHookSystem.clear();
+		actualRegistry._clear();
+	});
+	fastify.log?.debug?.("Arc core plugin enabled (instance-scoped hooks & registry)");
+};
+/** Extract document ID from a result (handles Mongoose docs and plain objects) */
+function extractId(doc) {
+	if (!doc || typeof doc !== "object") return void 0;
+	const d = doc;
+	const rawId = d._id ?? d.id;
+	return rawId ? String(rawId) : void 0;
+}
+var arcCorePlugin_default = fp(arcCorePlugin, {
+	name: "arc-core",
+	fastify: "5.x"
+});
+
+//#endregion
+export { arcCorePlugin_default as arcCorePlugin, arcCorePlugin as arcCorePluginFn, caching_default as cachingPlugin, cachingPlugin as cachingPluginFn, createPlugin, errorHandlerPlugin, errorHandlerPlugin as errorHandlerPluginFn, gracefulShutdown_default as gracefulShutdownPlugin, gracefulShutdownPlugin as gracefulShutdownPluginFn, health_default as healthPlugin, healthPlugin as healthPluginFn, requestId_default as requestIdPlugin, requestIdPlugin as requestIdPluginFn, sse_default as ssePlugin, ssePlugin as ssePluginFn };