@kb-labs/rest-api-app 1.3.0

package/src/routes/openapi.ts

@@ -0,0 +1,101 @@
+/**
+ * @module @kb-labs/rest-api-app/routes/openapi
+ * OpenAPI specification endpoints
+ */
+
+import type { FastifyInstance } from 'fastify';
+import type { RestApiConfig } from '@kb-labs/rest-api-core';
+import type { IEntityRegistry } from '@kb-labs/core-registry';
+import { mergeOpenAPISpecs } from '@kb-labs/core-registry';
+import { restDomainOperationMetrics } from '../middleware/metrics.js';
+
+/**
+ * Register OpenAPI routes
+ */
+export async function registerOpenAPIRoutes(
+  fastify: FastifyInstance,
+  config: RestApiConfig,
+  repoRoot: string,
+  registry: IEntityRegistry
+) {
+  // Plugin-manifest-merged OpenAPI spec (renamed from /openapi.json).
+  // /openapi.json is now owned by @fastify/swagger (Fastify-native routes).
+  // This endpoint aggregates specs from plugin manifests only.
+  fastify.get('/openapi-plugins.json', {
+    schema: {
+      hide: true,
+    },
+    config: {
+      rateLimit: {
+        max: 10, // 10 requests
+        timeWindow: '1 minute',
+      },
+    },
+  }, async (_, reply) => {
+    try {
+      const plugins = await restDomainOperationMetrics.observeOperation('plugin.registry.list', async () =>
+        registry.listPlugins(),
+      );
+      const specs: unknown[] = [];
+      
+      for (const plugin of plugins) {
+        const spec = await restDomainOperationMetrics.observeOperation('openapi.plugin.get', async () =>
+          registry.getOpenAPISpec(plugin.id),
+        );
+        if (spec) {
+          specs.push(spec);
+        }
+      }
+      
+      const merged = await restDomainOperationMetrics.observeOperation('openapi.plugins.aggregate', async () =>
+        mergeOpenAPISpecs(specs as any),
+      );
+      
+      // Add caching headers (1 hour)
+      const snapshot = registry.snapshot();
+      reply.header('Cache-Control', 'public, max-age=3600');
+      reply.header('ETag', `"${snapshot.rev}"`);
+      
+      reply.send(merged);
+    } catch (error) {
+      reply.code(500).send({
+        ok: false,
+        error: {
+          code: 'OPENAPI_GENERATION_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
+  // Per-plugin OpenAPI spec
+  fastify.get('/openapi/:pluginId', async (req, reply) => {
+    try {
+      const { pluginId } = req.params as { pluginId: string };
+      const spec = await restDomainOperationMetrics.observeOperation('openapi.plugin.get', async () =>
+        registry.getOpenAPISpec(pluginId),
+      );
+      
+      if (!spec) {
+        reply.code(404).send({
+          ok: false,
+          error: {
+            code: 'PLUGIN_NOT_FOUND',
+            message: `Plugin ${pluginId} not found`,
+          },
+        });
+        return;
+      }
+
+      reply.send(spec);
+    } catch (error) {
+      reply.code(500).send({
+        ok: false,
+        error: {
+          code: 'OPENAPI_GENERATION_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+}

package/src/routes/platform.ts

@@ -0,0 +1,143 @@
+/**
+ * @module @kb-labs/rest-api-app/routes/platform
+ * Platform configuration endpoints
+ */
+
+import type { FastifyInstance } from 'fastify';
+import type { RestApiConfig } from '@kb-labs/rest-api-core';
+import type { PlatformConfigResponse, PlatformConfigPayload } from '@kb-labs/rest-api-contracts';
+import { normalizeBasePath, resolvePaths } from '../utils/path-helpers';
+import { readKbConfig } from '@kb-labs/core-config';
+import { platform } from '@kb-labs/core-runtime';
+import { restDomainOperationMetrics } from '../middleware/metrics.js';
+
+/**
+ * Sensitive keys to redact from adapterOptions
+ */
+const SENSITIVE_KEYS = [
+  'apiKey',
+  'secret',
+  'password',
+  'token',
+  'key',
+  'credentials',
+  'auth',
+];
+
+/**
+ * Recursively redact sensitive keys from an object
+ */
+function redactSensitiveData(
+  obj: Record<string, any>,
+  redacted: string[] = [],
+  path: string = ''
+): Record<string, any> {
+  const result: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    const lowerKey = key.toLowerCase();
+
+    // Check if key contains sensitive patterns
+    const isSensitive = SENSITIVE_KEYS.some(pattern => lowerKey.includes(pattern.toLowerCase()));
+
+    if (isSensitive && typeof value === 'string') {
+      result[key] = '***REDACTED***';
+      redacted.push(currentPath);
+    } else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = redactSensitiveData(value, redacted, currentPath);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Load platform configuration from kb.config.json using core-config utilities
+ */
+async function loadPlatformConfig(repoRoot: string): Promise<{
+  adapters: Record<string, string | null>;
+  adapterOptions: Record<string, unknown>;
+  execution: { mode: string };
+}> {
+  try {
+    const configResult = await readKbConfig(repoRoot);
+
+    if (!configResult || !configResult.data) {
+      // Return empty/default values if config not found
+      return {
+        adapters: {},
+        adapterOptions: {},
+        execution: { mode: 'in-process' },
+      };
+    }
+
+    const config = configResult.data as any;
+
+    return {
+      adapters: config.platform?.adapters ?? {},
+      adapterOptions: config.platform?.adapterOptions ?? {},
+      execution: config.platform?.execution ?? { mode: 'in-process' },
+    };
+  } catch (error) {
+    // Return empty/default values on error
+    return {
+      adapters: {},
+      adapterOptions: {},
+      execution: { mode: 'in-process' },
+    };
+  }
+}
+
+/**
+ * Register platform configuration routes
+ */
+export async function registerPlatformRoutes(
+  fastify: FastifyInstance,
+  config: RestApiConfig,
+  repoRoot: string
+): Promise<void> {
+  const basePath = normalizeBasePath(config.basePath);
+  const configPaths = resolvePaths(basePath, '/platform/config');
+
+  for (const path of configPaths) {
+    fastify.get(path, async (_request, reply) => {
+      try {
+        const { adapters, adapterOptions, execution } = await restDomainOperationMetrics.observeOperation(
+          'platform.config.get',
+          () => loadPlatformConfig(repoRoot),
+        );
+
+        const redacted: string[] = [];
+        const sanitizedOptions = redactSensitiveData(adapterOptions as Record<string, any>, redacted);
+
+        const payload: PlatformConfigPayload = {
+          schema: 'kb.platform.config/1',
+          ts: new Date().toISOString(),
+          adapters,
+          adapterOptions: sanitizedOptions,
+          execution,
+          redacted,
+        };
+
+        const response: PlatformConfigResponse = {
+          ok: true,
+          data: payload,
+        };
+
+        return reply.send(response);
+      } catch (error) {
+        platform.logger.error('Failed to load platform config', error instanceof Error ? error : new Error(String(error)));
+        return reply.code(500).send({
+          ok: false,
+          error: {
+            code: 'INTERNAL_SERVER_ERROR',
+            message: 'Failed to load platform configuration',
+          },
+        });
+      }
+    });
+  }
+}