@schmock/openapi 1.1.0

package/dist/plugin.js

@@ -0,0 +1,129 @@
+/// <reference path="../../../types/schmock.d.ts" />
+import { detectCrudResources } from "./crud-detector.js";
+import { createCreateGenerator, createDeleteGenerator, createListGenerator, createReadGenerator, createStaticGenerator, createUpdateGenerator, } from "./generators.js";
+import { parseSpec } from "./parser.js";
+import { loadSeed } from "./seed.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Create an OpenAPI plugin that auto-registers CRUD routes from a spec.
+ *
+ * @example
+ * ```typescript
+ * const mock = schmock();
+ * mock.pipe(await openapi({
+ *   spec: "./petstore.yaml",
+ *   seed: { pets: { count: 10 } },
+ * }));
+ * ```
+ */
+export async function openapi(options) {
+    const spec = await parseSpec(options.spec);
+    const { resources, nonCrudPaths } = detectCrudResources(spec.paths);
+    const seedData = options.seed
+        ? loadSeed(options.seed, resources)
+        : new Map();
+    return {
+        name: "@schmock/openapi",
+        version: "1.0.0",
+        install(instance) {
+            // Seed initial state — we need state to be initialized before registering routes
+            // The state is populated via generator context.state on first request,
+            // but we need to pre-populate it. We'll use a global config state approach.
+            // Since generators use ctx.state (the global config state), we set up seed
+            // data through a setup route that runs on first access, or we just seed
+            // in the generators themselves.
+            // Register CRUD routes
+            for (const resource of resources) {
+                registerCrudRoutes(instance, resource, seedData.get(resource.name));
+            }
+            // Register non-CRUD routes with static generators
+            for (const parsedPath of nonCrudPaths) {
+                const routeKey = `${parsedPath.method} ${parsedPath.path}`;
+                instance(routeKey, createStaticGenerator(parsedPath));
+            }
+        },
+        process(context, response) {
+            // Pass through — generators handle everything
+            return { context, response };
+        },
+    };
+}
+function registerCrudRoutes(instance, resource, seedItems) {
+    // Create a seeded generator wrapper that initializes state on first call
+    const ensureSeeded = createSeeder(resource, seedItems);
+    for (const op of resource.operations) {
+        switch (op) {
+            case "list": {
+                const gen = createListGenerator(resource);
+                const routeKey = `GET ${resource.basePath}`;
+                instance(routeKey, wrapWithSeeder(ensureSeeded, gen));
+                break;
+            }
+            case "create": {
+                const gen = createCreateGenerator(resource);
+                const routeKey = `POST ${resource.basePath}`;
+                instance(routeKey, wrapWithSeeder(ensureSeeded, gen));
+                break;
+            }
+            case "read": {
+                const gen = createReadGenerator(resource);
+                const routeKey = `GET ${resource.itemPath}`;
+                instance(routeKey, wrapWithSeeder(ensureSeeded, gen));
+                break;
+            }
+            case "update": {
+                const gen = createUpdateGenerator(resource);
+                const putKey = `PUT ${resource.itemPath}`;
+                const patchKey = `PATCH ${resource.itemPath}`;
+                instance(putKey, wrapWithSeeder(ensureSeeded, gen));
+                instance(patchKey, wrapWithSeeder(ensureSeeded, gen));
+                break;
+            }
+            case "delete": {
+                const gen = createDeleteGenerator(resource);
+                const routeKey = `DELETE ${resource.itemPath}`;
+                instance(routeKey, wrapWithSeeder(ensureSeeded, gen));
+                break;
+            }
+        }
+    }
+}
+/**
+ * Create a seeder function that initializes collection state once.
+ */
+function createSeeder(resource, seedItems) {
+    const stateKey = `openapi:collections:${resource.name}`;
+    const counterKey = `openapi:counter:${resource.name}`;
+    const seededKey = `openapi:seeded:${resource.name}`;
+    return (state) => {
+        if (state[seededKey])
+            return;
+        state[seededKey] = true;
+        if (seedItems && seedItems.length > 0) {
+            state[stateKey] = [...seedItems];
+            // Set counter to highest existing ID
+            let maxId = 0;
+            for (const item of seedItems) {
+                if (isRecord(item) && resource.idParam in item) {
+                    const id = item[resource.idParam];
+                    if (typeof id === "number" && id > maxId) {
+                        maxId = id;
+                    }
+                }
+            }
+            state[counterKey] = maxId;
+        }
+        else {
+            state[stateKey] = [];
+            state[counterKey] = 0;
+        }
+    };
+}
+function wrapWithSeeder(seeder, generator) {
+    return (ctx) => {
+        seeder(ctx.state);
+        return generator(ctx);
+    };
+}

package/dist/seed.d.ts

@@ -0,0 +1,15 @@
+import type { CrudResource } from "./crud-detector.js";
+export type SeedSource = unknown[] | string | {
+    count: number;
+};
+export type SeedConfig = Record<string, SeedSource>;
+/**
+ * Load seed data for CRUD resources.
+ *
+ * Sources:
+ * - unknown[]: inline array of objects
+ * - string: file path to a JSON array
+ * - { count: number }: auto-generate N items from resource schema
+ */
+export declare function loadSeed(config: SeedConfig, resources: CrudResource[]): Map<string, unknown[]>;
+//# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,MAAM,MAAM,UAAU,GAAG,OAAO,EAAE,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEpD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,YAAY,EAAE,GACxB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAwCxB"}

package/dist/seed.js

@@ -0,0 +1,41 @@
+/// <reference path="../../../types/schmock.d.ts" />
+import { readFileSync } from "node:fs";
+import { generateSeedItems } from "./generators.js";
+/**
+ * Load seed data for CRUD resources.
+ *
+ * Sources:
+ * - unknown[]: inline array of objects
+ * - string: file path to a JSON array
+ * - { count: number }: auto-generate N items from resource schema
+ */
+export function loadSeed(config, resources) {
+    const result = new Map();
+    for (const [resourceName, source] of Object.entries(config)) {
+        const resource = resources.find((r) => r.name === resourceName);
+        if (Array.isArray(source)) {
+            // Inline array
+            result.set(resourceName, [...source]);
+        }
+        else if (typeof source === "string") {
+            // File path
+            const content = readFileSync(source, "utf-8");
+            const parsed = JSON.parse(content);
+            if (!Array.isArray(parsed)) {
+                throw new Error(`Seed file "${source}" for resource "${resourceName}" must contain a JSON array`);
+            }
+            result.set(resourceName, parsed);
+        }
+        else if (typeof source === "object" &&
+            source !== null &&
+            "count" in source) {
+            // Auto-generate from schema
+            if (!resource?.schema) {
+                throw new Error(`Cannot auto-generate seed for "${resourceName}": no schema found in spec`);
+            }
+            const items = generateSeedItems(resource.schema, source.count, resource.idParam);
+            result.set(resourceName, items);
+        }
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@schmock/openapi",
+  "description": "OpenAPI/Swagger spec-driven auto-registration plugin for Schmock",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build:lib && bun build:types",
+    "build:lib": "bun build --minify --outdir=dist src/index.ts",
+    "build:types": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:bdd": "vitest run --config vitest.config.bdd.ts",
+    "lint": "biome check src/*.ts",
+    "lint:fix": "biome check --write --unsafe src/*.ts"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.1",
+    "@schmock/schema": "workspace:*",
+    "openapi-types": "^12.1.3"
+  },
+  "peerDependencies": {
+    "@schmock/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@amiceli/vitest-cucumber": "^6.2.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^25.1.0",
+    "vitest": "^4.0.15"
+  }
+}