@websublime/vite-plugin-open-api-server 0.24.0-next.8 → 0.24.0-next.9

package/dist/index.d.ts

@@ -513,14 +513,11 @@ interface OrchestratorResult {
     /**
      * Shared WebSocket hub for the orchestrator.
      *
-     * Created with `autoConnect: false` so the orchestrator controls
-     * the `connected` event (enhanced with `specs` metadata).
-     *
-     * In multi-spec mode (Epic 3, Task 3.1), this hub will be replaced by
-     * `createMultiSpecWebSocketHub()` which also wires broadcast interception
-     * and multi-spec command routing.
-     *
-     * @experimental Will be replaced by `createMultiSpecWebSocketHub()` in Epic 3.
+     * Created via `createMultiSpecWebSocketHub()` with:
+     * - `autoConnect: false` to suppress default connected events
+     * - Enhanced `addClient()` that sends specs metadata
+     * - Broadcast interception that adds `specId` to all events
+     * - Multi-spec command handler for spec-scoped routing
      */
     wsHub: WebSocketHub;
     /** Start the shared HTTP server on the configured port */

package/dist/index.js

@@ -2,7 +2,7 @@ import { createRequire } from 'module';
 import pc from 'picocolors';
 import { existsSync } from 'fs';
 import path, { dirname, join } from 'path';
-import { executeSeeds, mountInternalApi, createOpenApiServer, mountDevToolsRoutes, createWebSocketHub } from '@websublime/vite-plugin-open-api-core';
+import { executeSeeds, createOpenApiServer, mountDevToolsRoutes, createWebSocketHub } from '@websublime/vite-plugin-open-api-core';
 export { defineHandlers, defineSeeds } from '@websublime/vite-plugin-open-api-core';
 import fg from 'fast-glob';
 import { fileURLToPath } from 'url';
@@ -582,7 +582,336 @@ function configureMultiProxy(vite, instances, port) {
 
 // package.json
 var package_default = {
-  version: "0.24.0-next.7"};
+  version: "0.24.0-next.8"};
+
+// src/multi-internal-api.ts
+var PACKAGE_VERSION = package_default.version;
+function mountMultiSpecInternalApi(app, instances) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const inst of instances) {
+    if (seen.has(inst.id)) {
+      throw new Error(
+        `[vite-plugin-open-api-server] Duplicate specId "${inst.id}" in instances array`
+      );
+    }
+    seen.add(inst.id);
+  }
+  const instanceMap = new Map(instances.map((i) => [i.id, i]));
+  app.get("/_api/specs", (c) => {
+    const specs = instances.map((i) => ({
+      id: i.id,
+      title: i.info.title,
+      version: i.info.version,
+      proxyPath: i.config.proxyPath,
+      color: i.info.color,
+      endpoints: i.server.registry.endpoints.size,
+      schemas: i.server.store.getSchemas().length,
+      simulations: i.server.simulationManager.count()
+    }));
+    return c.json({ specs, count: specs.length });
+  });
+  app.get("/_api/registry", (c) => {
+    const registries = instances.map((i) => ({
+      specId: i.id,
+      specTitle: i.info.title,
+      specColor: i.info.color,
+      endpoints: Array.from(i.server.registry.endpoints.entries()).map(([key, entry]) => ({
+        ...entry,
+        key
+      })),
+      stats: i.server.registry.stats
+    }));
+    const totalEndpoints = registries.reduce((sum, r) => sum + r.endpoints.length, 0);
+    return c.json({
+      specs: registries,
+      totalEndpoints,
+      totalSpecs: registries.length
+    });
+  });
+  app.get("/_api/health", (c) => {
+    const specs = instances.map((i) => ({
+      id: i.id,
+      endpoints: i.server.registry.endpoints.size,
+      schemas: i.server.store.getSchemas().length,
+      simulations: i.server.simulationManager.count()
+    }));
+    return c.json({
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: PACKAGE_VERSION,
+      totalSpecs: instances.length,
+      totalEndpoints: specs.reduce((s, i) => s + i.endpoints, 0),
+      specs
+    });
+  });
+  const specApi = new Hono();
+  specApi.use("/:specId/*", async (c, next) => {
+    const specId = c.req.param("specId");
+    const instance = instanceMap.get(specId);
+    if (!instance) {
+      return c.json({ error: `Unknown spec: ${specId}` }, 404);
+    }
+    c.set("specInstance", instance);
+    await next();
+  });
+  specApi.get("/:specId/registry", (c) => {
+    const instance = c.get("specInstance");
+    return c.json({
+      specId: instance.id,
+      endpoints: Array.from(instance.server.registry.endpoints.entries()).map(([key, entry]) => ({
+        ...entry,
+        key
+      })),
+      stats: instance.server.registry.stats
+    });
+  });
+  specApi.get("/:specId/store", (c) => {
+    const instance = c.get("specInstance");
+    const schemas = instance.server.store.getSchemas().map((schema) => ({
+      name: schema,
+      count: instance.server.store.getCount(schema),
+      idField: instance.server.store.getIdField(schema)
+    }));
+    return c.json({ specId: instance.id, schemas });
+  });
+  specApi.get("/:specId/store/:schema", (c) => {
+    const instance = c.get("specInstance");
+    const schema = c.req.param("schema");
+    const allItems = instance.server.store.list(schema);
+    const total = allItems.length;
+    const rawOffset = Number(c.req.query("offset"));
+    const offset = Number.isFinite(rawOffset) ? Math.max(Math.floor(rawOffset), 0) : 0;
+    const rawLimit = Number(c.req.query("limit"));
+    const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.floor(rawLimit), 0), 1e3) : Math.min(total, 1e3);
+    const items = limit === 0 ? [] : allItems.slice(offset, offset + limit);
+    return c.json({
+      specId: instance.id,
+      schema,
+      idField: instance.server.store.getIdField(schema),
+      items,
+      count: items.length,
+      total,
+      offset,
+      limit
+    });
+  });
+  specApi.get("/:specId/document", (c) => {
+    const instance = c.get("specInstance");
+    return c.json(instance.server.document);
+  });
+  specApi.get("/:specId/simulations", (c) => {
+    const instance = c.get("specInstance");
+    return c.json({
+      specId: instance.id,
+      simulations: instance.server.simulationManager.list(),
+      count: instance.server.simulationManager.count()
+    });
+  });
+  specApi.get("/:specId/timeline", (c) => {
+    const instance = c.get("specInstance");
+    const parsed = Number(c.req.query("limit"));
+    const limit = Number.isFinite(parsed) ? Math.min(Math.max(Math.floor(parsed), 0), 1e3) : 100;
+    const timeline = instance.server.getTimeline();
+    const entries = limit === 0 ? [] : timeline.slice(-limit);
+    return c.json({
+      specId: instance.id,
+      entries,
+      count: entries.length,
+      total: timeline.length,
+      limit
+    });
+  });
+  app.route("/_api/specs", specApi);
+}
+
+// src/multi-command.ts
+var SPEC_SCOPED_COMMANDS = /* @__PURE__ */ new Set([
+  "get:store",
+  "set:store",
+  "clear:store",
+  "set:simulation",
+  "clear:simulation",
+  "reseed"
+]);
+function sendError(hub, client, command, message) {
+  hub.sendTo(client, { type: "error", data: { command, message } });
+}
+function resolveInstance(specId, instanceMap, hub, client, commandType) {
+  if (!specId) return void 0;
+  const instance = instanceMap.get(specId);
+  if (!instance) {
+    sendError(hub, client, commandType, `Unknown spec: ${specId}`);
+  }
+  return instance;
+}
+function handleGetSpecs(hub, client, specsInfo, serverVersion) {
+  hub.sendTo(client, { type: "connected", data: { serverVersion, specs: specsInfo } });
+}
+function handleGetRegistry(cmd, hub, client, instances, instanceMap) {
+  const sendRegistry = (instance, id) => {
+    const registryEvent = {
+      type: "registry",
+      data: {
+        specId: id,
+        endpoints: Array.from(instance.server.registry.endpoints.entries()).map(([key, entry]) => ({
+          ...entry,
+          key
+        })),
+        stats: { ...instance.server.registry.stats }
+      }
+    };
+    hub.sendTo(client, registryEvent);
+  };
+  const specId = cmd.data?.specId;
+  if (specId) {
+    const instance = resolveInstance(specId, instanceMap, hub, client, cmd.type);
+    if (!instance) return;
+    sendRegistry(instance, specId);
+  } else {
+    for (const instance of instances) {
+      sendRegistry(instance, instance.id);
+    }
+  }
+}
+function handleGetTimeline(cmd, hub, client, instances, instanceMap) {
+  const specId = cmd.data?.specId;
+  const rawLimit = Number(cmd.data?.limit);
+  const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.floor(rawLimit), 0), 1e3) : 100;
+  const sendTimeline = (instance, id) => {
+    const timeline = instance.server.getTimeline();
+    const entries = limit === 0 ? [] : timeline.slice(-limit);
+    const timelineEvent = {
+      type: "timeline",
+      data: {
+        specId: id,
+        entries,
+        count: entries.length,
+        total: timeline.length
+      }
+    };
+    hub.sendTo(client, timelineEvent);
+  };
+  if (specId) {
+    const instance = resolveInstance(specId, instanceMap, hub, client, cmd.type);
+    if (!instance) return;
+    sendTimeline(instance, specId);
+  } else {
+    for (const instance of instances) {
+      sendTimeline(instance, instance.id);
+    }
+  }
+}
+function handleClearTimeline(cmd, hub, client, instances, instanceMap) {
+  const specId = cmd.data?.specId;
+  const clearAndNotify = (instance, id) => {
+    const count = instance.server.clearTimeline();
+    hub.sendTo(client, { type: "timeline:cleared", data: { specId: id, count } });
+  };
+  if (specId) {
+    const instance = resolveInstance(specId, instanceMap, hub, client, cmd.type);
+    if (!instance) return;
+    clearAndNotify(instance, specId);
+  } else {
+    for (const instance of instances) {
+      clearAndNotify(instance, instance.id);
+    }
+  }
+}
+function handleSpecScoped(cmd, hub, client, instanceMap) {
+  const specId = cmd.data?.specId;
+  if (!specId) {
+    sendError(hub, client, cmd.type, "specId is required for this command");
+    return;
+  }
+  const instance = resolveInstance(specId, instanceMap, hub, client, cmd.type);
+  if (!instance) return;
+  const { specId: _, ...coreData } = cmd.data ?? {};
+  const coreCommand = Object.keys(coreData).length > 0 ? { type: cmd.type, data: coreData } : { type: cmd.type };
+  instance.server.wsHub.handleMessage(client, JSON.stringify(coreCommand));
+}
+function createMultiSpecCommandHandler(deps) {
+  const { hub, instances, specsInfo, serverVersion } = deps;
+  const instanceMap = new Map(instances.map((i) => [i.id, i]));
+  return (client, command) => {
+    if (!command || typeof command !== "object" || !("type" in command)) {
+      return;
+    }
+    const cmd = command;
+    if (typeof cmd.type !== "string") {
+      return;
+    }
+    switch (cmd.type) {
+      case "get:specs":
+        handleGetSpecs(hub, client, specsInfo, serverVersion);
+        break;
+      case "get:registry":
+        handleGetRegistry(cmd, hub, client, instances, instanceMap);
+        break;
+      case "get:timeline":
+        handleGetTimeline(cmd, hub, client, instances, instanceMap);
+        break;
+      case "clear:timeline":
+        handleClearTimeline(cmd, hub, client, instances, instanceMap);
+        break;
+      default:
+        if (SPEC_SCOPED_COMMANDS.has(cmd.type)) {
+          handleSpecScoped(cmd, hub, client, instanceMap);
+        } else {
+          sendError(hub, client, cmd.type, `Unknown command type: ${cmd.type}`);
+        }
+        break;
+    }
+  };
+}
+
+// src/multi-ws.ts
+var PACKAGE_VERSION2 = package_default.version;
+var MULTI_SPEC_ONLY_COMMANDS = /* @__PURE__ */ new Set(["get:specs"]);
+function createMultiSpecWebSocketHub(instances, specsInfo) {
+  const hub = createWebSocketHub({ autoConnect: false });
+  const originalAddClient = hub.addClient.bind(hub);
+  hub.addClient = (ws) => {
+    originalAddClient(ws);
+    hub.sendTo(ws, {
+      type: "connected",
+      // biome-ignore lint/suspicious/noExplicitAny: MultiSpecServerEvent extends ServerEvent with specs[]
+      data: { serverVersion: PACKAGE_VERSION2, specs: specsInfo }
+    });
+  };
+  for (const instance of instances) {
+    instance.server.wsHub.broadcast = (event) => {
+      const enriched = { type: event.type, data: { ...event.data, specId: instance.id } };
+      hub.broadcast(enriched);
+    };
+    instance.server.wsHub.sendTo = (client, event) => {
+      const enriched = { type: event.type, data: { ...event.data, specId: instance.id } };
+      return hub.sendTo(client, enriched);
+    };
+  }
+  const commandHandler = createMultiSpecCommandHandler({
+    hub,
+    instances,
+    specsInfo,
+    serverVersion: PACKAGE_VERSION2
+  });
+  hub.setCommandHandler(commandHandler);
+  const originalHandleMessage = hub.handleMessage.bind(hub);
+  hub.handleMessage = (client, message) => {
+    try {
+      const parsed = typeof message === "string" ? JSON.parse(message) : message;
+      if (parsed && typeof parsed === "object" && "type" in parsed) {
+        const cmd = parsed;
+        if (MULTI_SPEC_ONLY_COMMANDS.has(cmd.type)) {
+          commandHandler(client, cmd);
+          return;
+        }
+      }
+    } catch {
+    }
+    originalHandleMessage(client, message);
+  };
+  return hub;
+}
 
 // src/types.ts
 var ValidationError = class extends Error {
@@ -821,7 +1150,6 @@ function validateUniqueIds(ids) {
 }
 
 // src/orchestrator.ts
-var PACKAGE_VERSION = package_default.version;
 var SPEC_COLORS = [
   "#4ade80",
   // green
@@ -908,25 +1236,6 @@ function mountDevToolsSpa(mainApp, logger) {
     logger
   });
 }
-function createOrchestratorHub(specsInfo) {
-  const wsHub = createWebSocketHub({ autoConnect: false });
-  const descriptor = Object.getOwnPropertyDescriptor(wsHub, "addClient");
-  if (descriptor && !descriptor.writable && !descriptor.configurable) {
-    throw new Error(
-      "[vite-plugin-open-api-server] Cannot override wsHub.addClient: property is non-writable and non-configurable. The core WebSocketHub implementation may have changed. This will be resolved by createMultiSpecWebSocketHub() in Epic 3."
-    );
-  }
-  const originalAddClient = wsHub.addClient.bind(wsHub);
-  wsHub.addClient = (ws) => {
-    originalAddClient(ws);
-    wsHub.sendTo(ws, {
-      type: "connected",
-      // biome-ignore lint/suspicious/noExplicitAny: MultiSpecServerEvent connected data extends ServerEvent connected data with specs[]
-      data: { serverVersion: PACKAGE_VERSION, specs: specsInfo }
-    });
-  };
-  return wsHub;
-}
 async function mountWebSocketRoute(mainApp, wsHub, logger) {
   let nodeWsModule;
   try {
@@ -1024,30 +1333,11 @@ async function createOrchestrator(options, vite, cwd) {
   if (options.devtools) {
     mountDevToolsSpa(mainApp, logger);
   }
-  if (instances.length > 1) {
-    logger.warn?.(
-      "[vite-plugin-open-api-server] Only first spec's internal API mounted on /_api; multi-spec support planned in Epic 3 (Task 3.x)."
-    );
-    mainApp.use("/_api/*", async (c, next) => {
-      await next();
-      c.header("X-Multi-Spec-Warning", `Only showing data for spec "${instances[0].id}"`);
-    });
-  }
   if (instances.length > 0) {
-    const firstInstance = instances[0];
-    mountInternalApi(mainApp, {
-      store: firstInstance.server.store,
-      registry: firstInstance.server.registry,
-      simulationManager: firstInstance.server.simulationManager,
-      wsHub: firstInstance.server.wsHub,
-      timeline: firstInstance.server.getTimeline(),
-      timelineLimit: options.timelineLimit,
-      clearTimeline: () => firstInstance.server.truncateTimeline(),
-      document: firstInstance.server.document
-    });
+    mountMultiSpecInternalApi(mainApp, instances);
   }
   const specsInfo = instances.map((inst) => inst.info);
-  const wsHub = createOrchestratorHub(specsInfo);
+  const wsHub = createMultiSpecWebSocketHub(instances, specsInfo);
   const { injectWebSocket } = await mountWebSocketRoute(mainApp, wsHub, logger);
   const instanceMap = new Map(instances.map((inst) => [inst.id, inst]));
   mainApp.use("*", createDispatchMiddleware(instanceMap));