@classytic/arc 1.1.0 → 2.1.2

package/dist/plugins/index.js

@@ -1,1069 +0,0 @@
-import fp from 'fastify-plugin';
-import { randomUUID } from 'crypto';
-import { createRequire } from 'module';
-
-// src/plugins/requestId.ts
-var 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 requestId = typeof incomingId === "string" && incomingId.trim() ? incomingId.trim() : 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"
-});
-var httpMetrics = {
-  requestsTotal: {},
-  requestDurations: []};
-var healthPlugin = async (fastify, opts = {}) => {
-  const {
-    prefix = "/_health",
-    checks = [],
-    metrics = false,
-    metricsCollector,
-    version,
-    collectHttpMetrics = metrics
-  } = opts;
-  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 * 0.5)] || 0;
-          const p95 = sorted[Math.floor(sorted.length * 0.95)] || 0;
-          const p99 = sorted[Math.floor(sorted.length * 0.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;
-      httpMetrics.requestDurations.push(duration);
-      if (httpMetrics.requestDurations.length > 1e4) {
-        httpMetrics.requestDurations.shift();
-      }
-    });
-  }
-  fastify.log?.info?.(`Health plugin registered at ${prefix}`);
-};
-async function runChecks(checks) {
-  const results = [];
-  for (const check of checks) {
-    const start = Date.now();
-    const timeout = check.timeout ?? 5e3;
-    try {
-      const checkPromise = Promise.resolve(check.check());
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(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
-      });
-    }
-  }
-  return results;
-}
-var health_default = fp(healthPlugin, {
-  name: "arc-health",
-  fastify: "5.x"
-});
-var require2 = createRequire(import.meta.url);
-var trace;
-var context;
-var SpanStatusCode;
-var NodeTracerProvider;
-var BatchSpanProcessor;
-var OTLPTraceExporter;
-var HttpInstrumentation;
-var MongoDBInstrumentation;
-var getNodeAutoInstrumentations;
-var isAvailable = false;
-try {
-  const api = require2("@opentelemetry/api");
-  trace = api.trace;
-  context = api.context;
-  SpanStatusCode = api.SpanStatusCode;
-  const sdkNode = require2("@opentelemetry/sdk-node");
-  NodeTracerProvider = sdkNode.NodeTracerProvider;
-  BatchSpanProcessor = sdkNode.BatchSpanProcessor;
-  const exporterTraceOtlp = require2("@opentelemetry/exporter-trace-otlp-http");
-  OTLPTraceExporter = exporterTraceOtlp.OTLPTraceExporter;
-  const instrHttp = require2("@opentelemetry/instrumentation-http");
-  HttpInstrumentation = instrHttp.HttpInstrumentation;
-  const instrMongo = require2("@opentelemetry/instrumentation-mongodb");
-  MongoDBInstrumentation = instrMongo.MongoDBInstrumentation;
-  const autoInstr = require2("@opentelemetry/auto-instrumentations-node");
-  getNodeAutoInstrumentations = autoInstr.getNodeAutoInstrumentations;
-  isAvailable = true;
-} catch (e) {
-}
-function createTracerProvider(options) {
-  if (!isAvailable) {
-    return null;
-  }
-  const { serviceName = "@classytic/arc", exporterUrl = "http://localhost:4318/v1/traces" } = options;
-  const exporter = new OTLPTraceExporter({
-    url: exporterUrl
-  });
-  const provider = new NodeTracerProvider({
-    resource: {
-      attributes: {
-        "service.name": serviceName,
-        "service.version": "1.0.0"
-      }
-    }
-  });
-  provider.addSpanProcessor(new BatchSpanProcessor(exporter));
-  provider.register();
-  return provider;
-}
-async function tracingPlugin(fastify, options = {}) {
-  const {
-    serviceName = "@classytic/arc",
-    autoInstrumentation = true,
-    traceRepository = true,
-    traceController = true,
-    sampleRate = 1
-  } = options;
-  if (!isAvailable) {
-    fastify.log.warn("OpenTelemetry not installed. Tracing disabled.");
-    fastify.log.warn("Install: npm install @opentelemetry/api @opentelemetry/sdk-node");
-    return;
-  }
-  const provider = createTracerProvider(options);
-  if (!provider) {
-    return;
-  }
-  if (autoInstrumentation && getNodeAutoInstrumentations) {
-    getNodeAutoInstrumentations({
-      "@opentelemetry/instrumentation-http": {
-        enabled: true
-      },
-      "@opentelemetry/instrumentation-mongodb": {
-        enabled: true
-      }
-    });
-  }
-  const tracer = trace.getTracer(serviceName);
-  fastify.decorateRequest("tracer", void 0);
-  fastify.addHook("onRequest", async (request, reply) => {
-    if (Math.random() > sampleRate) {
-      return;
-    }
-    const span = tracer.startSpan(`HTTP ${request.method} ${request.url}`, {
-      kind: 1,
-      // SpanKind.SERVER
-      attributes: {
-        "http.method": request.method,
-        "http.url": request.url,
-        "http.target": request.routeOptions?.url ?? request.url,
-        "http.host": request.hostname,
-        "http.scheme": request.protocol,
-        "http.user_agent": request.headers["user-agent"]
-      }
-    });
-    request.tracer = {
-      tracer,
-      currentSpan: span
-    };
-    context.with(trace.setSpan(context.active(), span), () => {
-    });
-  });
-  fastify.addHook("onResponse", async (request, reply) => {
-    if (!request.tracer?.currentSpan) {
-      return;
-    }
-    const span = request.tracer.currentSpan;
-    span.setAttributes({
-      "http.status_code": reply.statusCode,
-      "http.response_content_length": reply.getHeader("content-length")
-    });
-    if (reply.statusCode >= 500) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: `HTTP ${reply.statusCode}`
-      });
-    } else {
-      span.setStatus({ code: SpanStatusCode.OK });
-    }
-    span.end();
-  });
-  fastify.addHook("onError", async (request, reply, error) => {
-    if (!request.tracer?.currentSpan) {
-      return;
-    }
-    const span = request.tracer.currentSpan;
-    span.recordException(error);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message
-    });
-  });
-  fastify.log.info({ serviceName }, "OpenTelemetry tracing enabled");
-}
-function createSpan(request, name, fn, attributes) {
-  if (!isAvailable || !request.tracer) {
-    return fn(null);
-  }
-  const { tracer, currentSpan } = request.tracer;
-  const span = tracer.startSpan(
-    name,
-    {
-      parent: currentSpan,
-      attributes: attributes || {}
-    },
-    trace.setSpan(context.active(), currentSpan)
-  );
-  return context.with(trace.setSpan(context.active(), span), async () => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error.message
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-function traced(spanName) {
-  return function(target, propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
-      const request = args.find((arg) => arg && arg.tracer);
-      if (!request?.tracer) {
-        return originalMethod.apply(this, args);
-      }
-      const name = spanName || `${target.constructor.name}.${propertyKey}`;
-      return createSpan(request, name, async (span) => {
-        if (span) {
-          span.setAttribute("db.operation", propertyKey);
-          span.setAttribute("db.system", "mongodb");
-        }
-        return originalMethod.apply(this, args);
-      });
-    };
-    return descriptor;
-  };
-}
-function isTracingAvailable() {
-  return isAvailable;
-}
-var tracing_default = fp(tracingPlugin, {
-  name: "arc-tracing",
-  fastify: "5.x"
-});
-var gracefulShutdownPlugin = async (fastify, opts = {}) => {
-  const {
-    timeout = 3e4,
-    onShutdown,
-    signals = ["SIGTERM", "SIGINT"],
-    logEvents = true
-  } = opts;
-  let isShuttingDown = false;
-  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");
-      }
-      process.exit(1);
-    }, 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);
-      process.exit(0);
-    } catch (err) {
-      if (logEvents) {
-        fastify.log?.error?.({ error: err.message }, "Error during shutdown");
-      }
-      clearTimeout(forceExitTimer);
-      process.exit(1);
-    }
-  };
-  for (const signal of signals) {
-    process.on(signal, () => {
-      void shutdown(signal);
-    });
-  }
-  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"
-});
-
-// src/utils/errors.ts
-var ArcError = class extends Error {
-  name;
-  code;
-  statusCode;
-  details;
-  cause;
-  timestamp;
-  requestId;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "ArcError";
-    this.code = options.code ?? "ARC_ERROR";
-    this.statusCode = options.statusCode ?? 500;
-    this.details = options.details;
-    this.cause = options.cause;
-    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    this.requestId = options.requestId;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  /**
-   * Set request ID (typically from request context)
-   */
-  withRequestId(requestId) {
-    this.requestId = requestId;
-    return this;
-  }
-  /**
-   * Convert to JSON response
-   */
-  toJSON() {
-    return {
-      success: false,
-      error: this.message,
-      code: this.code,
-      timestamp: this.timestamp,
-      ...this.requestId && { requestId: this.requestId },
-      ...this.details && { details: this.details }
-    };
-  }
-};
-function isArcError(error) {
-  return error instanceof ArcError;
-}
-
-// src/plugins/errorHandler.ts
-async function errorHandlerPluginFn(fastify, options = {}) {
-  const {
-    includeStack = process.env.NODE_ENV !== "production",
-    onError,
-    errorMap = {}
-  } = options;
-  fastify.setErrorHandler(async (error, request, reply) => {
-    if (onError) {
-      try {
-        await onError(error, request);
-      } catch (callbackError) {
-        request.log.error({ err: callbackError }, "Error in onError callback");
-      }
-    }
-    const requestId = request.id;
-    const response = {
-      success: false,
-      error: error.message || "Internal Server Error",
-      code: "INTERNAL_ERROR",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      ...requestId && { requestId }
-    };
-    let statusCode = 500;
-    if (isArcError(error)) {
-      statusCode = error.statusCode;
-      response.code = error.code;
-      if (error.details) {
-        response.details = error.details;
-      }
-      if (error.requestId) {
-        response.requestId = error.requestId;
-      }
-    } else if ("validation" in error && Array.isArray(error.validation)) {
-      statusCode = 400;
-      response.code = "VALIDATION_ERROR";
-      response.error = "Validation failed";
-      response.details = {
-        errors: error.validation?.map((v) => ({
-          field: v.instancePath?.replace(/^\//, "") || v.params?.missingProperty || "unknown",
-          message: v.message || "Invalid value",
-          keyword: v.keyword
-        }))
-      };
-    } else if ("statusCode" in error && typeof error.statusCode === "number") {
-      statusCode = error.statusCode;
-      response.code = statusCodeToCode(statusCode);
-    } else if (error.name && errorMap[error.name]) {
-      const mapping = errorMap[error.name];
-      statusCode = mapping.statusCode;
-      response.code = mapping.code;
-      if (mapping.message) {
-        response.error = mapping.message;
-      }
-    } else if (error.name === "ValidationError" && "errors" in error) {
-      statusCode = 400;
-      response.code = "VALIDATION_ERROR";
-      const mongooseErrors = error.errors;
-      if (process.env.NODE_ENV === "production") {
-        response.details = { errorCount: Object.keys(mongooseErrors).length };
-      } else {
-        response.details = {
-          errors: Object.entries(mongooseErrors).map(([field, err]) => ({
-            field: err.path || field,
-            message: err.message
-          }))
-        };
-      }
-    } else if (error.name === "CastError") {
-      statusCode = 400;
-      response.code = "INVALID_ID";
-      response.error = "Invalid identifier format";
-    } else if (error.name === "MongoServerError" && error.code === 11e3) {
-      statusCode = 409;
-      response.code = "DUPLICATE_KEY";
-      response.error = "Resource already exists";
-      const keyValue = error.keyValue;
-      if (keyValue && process.env.NODE_ENV !== "production") {
-        response.details = { duplicateFields: Object.keys(keyValue) };
-      }
-    }
-    if (includeStack && error.stack) {
-      response.stack = error.stack;
-    }
-    if (statusCode >= 500) {
-      request.log.error({ err: error, statusCode }, "Server error");
-    } else if (statusCode >= 400) {
-      request.log.warn({ err: error, statusCode }, "Client error");
-    }
-    return reply.status(statusCode).send(response);
-  });
-}
-function statusCodeToCode(statusCode) {
-  const codes = {
-    400: "BAD_REQUEST",
-    401: "UNAUTHORIZED",
-    403: "FORBIDDEN",
-    404: "NOT_FOUND",
-    405: "METHOD_NOT_ALLOWED",
-    409: "CONFLICT",
-    422: "UNPROCESSABLE_ENTITY",
-    429: "RATE_LIMITED",
-    500: "INTERNAL_ERROR",
-    502: "BAD_GATEWAY",
-    503: "SERVICE_UNAVAILABLE",
-    504: "GATEWAY_TIMEOUT"
-  };
-  return codes[statusCode] ?? "ERROR";
-}
-var errorHandlerPlugin = fp(errorHandlerPluginFn, {
-  name: "arc-error-handler",
-  fastify: "5.x"
-});
-var errorHandler_default = errorHandlerPlugin;
-
-// src/hooks/HookSystem.ts
-var HookSystem = class {
-  hooks;
-  logger;
-  constructor(options) {
-    this.hooks = /* @__PURE__ */ new Map();
-    this.logger = options?.logger ?? { error: (...args) => console.error(...args) };
-  }
-  /**
-   * Generate hook key
-   */
-  getKey(resource, operation, phase) {
-    return `${resource}:${operation}:${phase}`;
-  }
-  /**
-   * Register a hook
-   * Supports both object parameter and positional arguments
-   */
-  register(resourceOrOptions, operation, phase, handler, priority = 10) {
-    let resource;
-    let finalOperation;
-    let finalPhase;
-    let finalHandler;
-    let finalPriority;
-    if (typeof resourceOrOptions === "object") {
-      resource = resourceOrOptions.resource;
-      finalOperation = resourceOrOptions.operation;
-      finalPhase = resourceOrOptions.phase;
-      finalHandler = resourceOrOptions.handler;
-      finalPriority = resourceOrOptions.priority ?? 10;
-    } else {
-      resource = resourceOrOptions;
-      finalOperation = operation;
-      finalPhase = phase;
-      finalHandler = handler;
-      finalPriority = priority;
-    }
-    const key = this.getKey(resource, finalOperation, finalPhase);
-    if (!this.hooks.has(key)) {
-      this.hooks.set(key, []);
-    }
-    const registration = {
-      resource,
-      operation: finalOperation,
-      phase: finalPhase,
-      handler: finalHandler,
-      priority: finalPriority
-    };
-    const hooks = this.hooks.get(key);
-    hooks.push(registration);
-    hooks.sort((a, b) => a.priority - b.priority);
-    return () => {
-      const idx = hooks.indexOf(registration);
-      if (idx !== -1) {
-        hooks.splice(idx, 1);
-      }
-    };
-  }
-  /**
-   * Register before hook
-   */
-  before(resource, operation, handler, priority = 10) {
-    return this.register(resource, operation, "before", handler, priority);
-  }
-  /**
-   * Register after hook
-   */
-  after(resource, operation, handler, priority = 10) {
-    return this.register(resource, operation, "after", handler, priority);
-  }
-  /**
-   * Execute hooks for a given context
-   */
-  async execute(ctx) {
-    const key = this.getKey(ctx.resource, ctx.operation, ctx.phase);
-    const hooks = this.hooks.get(key) ?? [];
-    const wildcardKey = this.getKey("*", ctx.operation, ctx.phase);
-    const wildcardHooks = this.hooks.get(wildcardKey) ?? [];
-    const allHooks = [...wildcardHooks, ...hooks];
-    allHooks.sort((a, b) => a.priority - b.priority);
-    let result = ctx.data;
-    for (const hook of allHooks) {
-      const handlerContext = {
-        resource: ctx.resource,
-        operation: ctx.operation,
-        phase: ctx.phase,
-        data: result,
-        result: ctx.result,
-        user: ctx.user,
-        context: ctx.context,
-        meta: ctx.meta
-      };
-      const hookResult = await hook.handler(handlerContext);
-      if (hookResult !== void 0 && hookResult !== null) {
-        result = hookResult;
-      }
-    }
-    return result;
-  }
-  /**
-   * Execute before hooks
-   */
-  async executeBefore(resource, operation, data, options) {
-    const result = await this.execute({
-      resource,
-      operation,
-      phase: "before",
-      data,
-      user: options?.user,
-      context: options?.context,
-      meta: options?.meta
-    });
-    return result ?? data;
-  }
-  /**
-   * Execute after hooks
-   * Errors in after hooks are logged but don't fail the request
-   */
-  async executeAfter(resource, operation, result, options) {
-    try {
-      await this.execute({
-        resource,
-        operation,
-        phase: "after",
-        result,
-        user: options?.user,
-        context: options?.context,
-        meta: options?.meta
-      });
-    } catch (error) {
-      this.logger.error(
-        `[HookSystem] Error in after hook for ${resource}:${operation}:`,
-        error
-      );
-    }
-  }
-  /**
-   * Get all registered hooks
-   */
-  getAll() {
-    const all = [];
-    for (const hooks of this.hooks.values()) {
-      all.push(...hooks);
-    }
-    return all;
-  }
-  /**
-   * Get hooks for a specific resource
-   */
-  getForResource(resource) {
-    const all = [];
-    for (const [key, hooks] of this.hooks.entries()) {
-      if (key.startsWith(`${resource}:`)) {
-        all.push(...hooks);
-      }
-    }
-    return all;
-  }
-  /**
-   * Clear all hooks
-   */
-  clear() {
-    this.hooks.clear();
-  }
-  /**
-   * Clear hooks for a specific resource
-   */
-  clearResource(resource) {
-    for (const key of this.hooks.keys()) {
-      if (key.startsWith(`${resource}:`)) {
-        this.hooks.delete(key);
-      }
-    }
-  }
-};
-var hookSystem = new HookSystem();
-
-// src/registry/ResourceRegistry.ts
-var ResourceRegistry = class {
-  _resources;
-  _frozen;
-  constructor() {
-    this._resources = /* @__PURE__ */ new Map();
-    this._frozen = false;
-  }
-  /**
-   * Register a resource
-   */
-  register(resource, options = {}) {
-    if (this._frozen) {
-      throw new Error(
-        `Registry frozen. Cannot register '${resource.name}' after startup.`
-      );
-    }
-    if (this._resources.has(resource.name)) {
-      throw new Error(`Resource '${resource.name}' already registered.`);
-    }
-    const entry = {
-      name: resource.name,
-      displayName: resource.displayName,
-      tag: resource.tag,
-      prefix: resource.prefix,
-      module: options.module ?? void 0,
-      adapter: resource.adapter ? {
-        type: resource.adapter.type,
-        name: resource.adapter.name
-      } : null,
-      permissions: resource.permissions,
-      presets: resource._appliedPresets ?? [],
-      routes: [],
-      // Populated later by getIntrospection()
-      additionalRoutes: resource.additionalRoutes.map((r) => ({
-        method: r.method,
-        path: r.path,
-        handler: typeof r.handler === "string" ? r.handler : r.handler.name || "anonymous",
-        summary: r.summary,
-        description: r.description,
-        permissions: r.permissions,
-        wrapHandler: r.wrapHandler,
-        schema: r.schema
-        // Include schema for OpenAPI docs
-      })),
-      events: Object.keys(resource.events ?? {}),
-      registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      disableDefaultRoutes: resource.disableDefaultRoutes,
-      openApiSchemas: options.openApiSchemas,
-      plugin: resource.toPlugin()
-      // Store plugin factory
-    };
-    this._resources.set(resource.name, entry);
-    return this;
-  }
-  /**
-   * Get resource by name
-   */
-  get(name) {
-    return this._resources.get(name);
-  }
-  /**
-   * Get all resources
-   */
-  getAll() {
-    return Array.from(this._resources.values());
-  }
-  /**
-   * Get resources by module
-   */
-  getByModule(moduleName) {
-    return this.getAll().filter((r) => r.module === moduleName);
-  }
-  /**
-   * Get resources by preset
-   */
-  getByPreset(presetName) {
-    return this.getAll().filter((r) => r.presets.includes(presetName));
-  }
-  /**
-   * Check if resource exists
-   */
-  has(name) {
-    return this._resources.has(name);
-  }
-  /**
-   * Get registry statistics
-   */
-  getStats() {
-    const resources = this.getAll();
-    const presetCounts = {};
-    for (const r of resources) {
-      for (const preset of r.presets) {
-        presetCounts[preset] = (presetCounts[preset] ?? 0) + 1;
-      }
-    }
-    return {
-      totalResources: resources.length,
-      byModule: this._groupBy(resources, "module"),
-      presetUsage: presetCounts,
-      totalRoutes: resources.reduce((sum, r) => {
-        const defaultRouteCount = r.disableDefaultRoutes ? 0 : 5;
-        return sum + (r.additionalRoutes?.length ?? 0) + defaultRouteCount;
-      }, 0),
-      totalEvents: resources.reduce((sum, r) => sum + (r.events?.length ?? 0), 0)
-    };
-  }
-  /**
-   * Get full introspection data
-   */
-  getIntrospection() {
-    return {
-      resources: this.getAll().map((r) => {
-        const defaultRoutes = r.disableDefaultRoutes ? [] : [
-          { method: "GET", path: r.prefix, operation: "list" },
-          { method: "GET", path: `${r.prefix}/:id`, operation: "get" },
-          { method: "POST", path: r.prefix, operation: "create" },
-          { method: "PATCH", path: `${r.prefix}/:id`, operation: "update" },
-          { method: "DELETE", path: `${r.prefix}/:id`, operation: "delete" }
-        ];
-        return {
-          name: r.name,
-          displayName: r.displayName,
-          prefix: r.prefix,
-          module: r.module,
-          presets: r.presets,
-          permissions: r.permissions,
-          routes: [
-            ...defaultRoutes,
-            ...r.additionalRoutes?.map((ar) => ({
-              method: ar.method,
-              path: `${r.prefix}${ar.path}`,
-              operation: typeof ar.handler === "string" ? ar.handler : "custom",
-              handler: typeof ar.handler === "string" ? ar.handler : void 0,
-              summary: ar.summary
-            })) ?? []
-          ],
-          events: r.events
-        };
-      }),
-      stats: this.getStats(),
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * Freeze registry (prevent further registrations)
-   */
-  freeze() {
-    this._frozen = true;
-  }
-  /**
-   * Check if frozen
-   */
-  isFrozen() {
-    return this._frozen;
-  }
-  /**
-   * Unfreeze registry (for testing)
-   */
-  _unfreeze() {
-    this._frozen = false;
-  }
-  /**
-   * Clear all resources (for testing)
-   */
-  _clear() {
-    this._resources.clear();
-    this._frozen = false;
-  }
-  /**
-   * Group by key
-   */
-  _groupBy(arr, key) {
-    const result = {};
-    for (const item of arr) {
-      const k = String(item[key] ?? "uncategorized");
-      result[k] = (result[k] ?? 0) + 1;
-    }
-    return result;
-  }
-};
-var registryKey = /* @__PURE__ */ Symbol.for("arc.resourceRegistry");
-var globalScope = globalThis;
-var resourceRegistry = globalScope[registryKey] ?? new ResourceRegistry();
-if (!globalScope[registryKey]) {
-  globalScope[registryKey] = resourceRegistry;
-}
-
-// src/core/arcCorePlugin.ts
-function hasEvents(instance) {
-  return "events" in instance && instance.events != null && typeof instance.events.publish === "function";
-}
-var arcCorePlugin = async (fastify, opts = {}) => {
-  const {
-    emitEvents = true,
-    hookSystem: hookSystem2,
-    registry,
-    useGlobalSingletons = false
-  } = opts;
-  const actualHookSystem = useGlobalSingletons ? hookSystem : hookSystem2 ?? new HookSystem();
-  const actualRegistry = useGlobalSingletons ? resourceRegistry : registry ?? new ResourceRegistry();
-  fastify.decorate("arc", {
-    hooks: actualHookSystem,
-    registry: actualRegistry,
-    emitEvents
-  });
-  if (emitEvents) {
-    const eventOperations = ["create", "update", "delete"];
-    for (const operation of eventOperations) {
-      actualHookSystem.after("*", operation, async (ctx) => {
-        if (!hasEvents(fastify)) return;
-        const eventType = `${ctx.resource}.${operation}d`;
-        const payload = {
-          resource: ctx.resource,
-          operation: ctx.operation,
-          data: ctx.result,
-          userId: ctx.user?.id ?? ctx.user?._id,
-          organizationId: ctx.context?.organizationId,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        try {
-          await fastify.events.publish(eventType, payload);
-        } catch (error) {
-          fastify.log?.warn?.(
-            { eventType, error },
-            "Failed to emit event"
-          );
-        }
-      });
-    }
-  }
-  fastify.addHook("onClose", async () => {
-    actualHookSystem.clear();
-    actualRegistry._clear();
-  });
-  fastify.log?.info?.("✅ Arc core plugin enabled (instance-scoped hooks & registry)");
-};
-var arcCorePlugin_default = fp(arcCorePlugin, {
-  name: "arc-core",
-  fastify: "5.x"
-});
-
-export { arcCorePlugin_default as arcCorePlugin, arcCorePlugin as arcCorePluginFn, createSpan, errorHandler_default as errorHandlerPlugin, errorHandlerPlugin as errorHandlerPluginFn, gracefulShutdown_default as gracefulShutdownPlugin, gracefulShutdownPlugin as gracefulShutdownPluginFn, health_default as healthPlugin, healthPlugin as healthPluginFn, isTracingAvailable, requestId_default as requestIdPlugin, requestIdPlugin as requestIdPluginFn, traced, tracing_default as tracingPlugin };