@schmock/openapi 1.1.0

package/dist/crud-detector.d.ts

@@ -0,0 +1,35 @@
+import type { JSONSchema7 } from "json-schema";
+import type { ParsedPath } from "./parser.js";
+export type CrudOperation = "list" | "create" | "read" | "update" | "delete";
+export interface CrudResource {
+    /** Resource name e.g. "pets" */
+    name: string;
+    /** Collection path e.g. "/pets" */
+    basePath: string;
+    /** Item path e.g. "/pets/:petId" */
+    itemPath: string;
+    /** ID parameter name e.g. "petId" */
+    idParam: string;
+    /** Detected CRUD operations */
+    operations: CrudOperation[];
+    /** Response schema for the resource item */
+    schema?: JSONSchema7;
+}
+interface DetectionResult {
+    resources: CrudResource[];
+    /** Paths that didn't match any CRUD pattern */
+    nonCrudPaths: ParsedPath[];
+}
+/**
+ * Detect CRUD resource patterns from parsed OpenAPI paths.
+ *
+ * Patterns:
+ * - GET /resources       → list
+ * - POST /resources      → create
+ * - GET /resources/:id   → read
+ * - PUT/PATCH /resources/:id → update
+ * - DELETE /resources/:id    → delete
+ */
+export declare function detectCrudResources(paths: ParsedPath[]): DetectionResult;
+export {};
+//# sourceMappingURL=crud-detector.d.ts.map

package/dist/crud-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-detector.d.ts","sourceRoot":"","sources":["../src/crud-detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,4CAA4C;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,+CAA+C;IAC/C,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,eAAe,CA6BxE"}

package/dist/crud-detector.js

@@ -0,0 +1,153 @@
+/// <reference path="../../../types/schmock.d.ts" />
+/**
+ * Detect CRUD resource patterns from parsed OpenAPI paths.
+ *
+ * Patterns:
+ * - GET /resources       → list
+ * - POST /resources      → create
+ * - GET /resources/:id   → read
+ * - PUT/PATCH /resources/:id → update
+ * - DELETE /resources/:id    → delete
+ */
+export function detectCrudResources(paths) {
+    // Group paths by their base path (strip trailing /:param)
+    const groups = new Map();
+    const nonCrudPaths = [];
+    for (const p of paths) {
+        const basePath = getCollectionPath(p.path);
+        if (!basePath) {
+            nonCrudPaths.push(p);
+            continue;
+        }
+        const existing = groups.get(basePath) ?? [];
+        existing.push(p);
+        groups.set(basePath, existing);
+    }
+    const resources = [];
+    for (const [basePath, groupPaths] of groups) {
+        const resource = buildResource(basePath, groupPaths);
+        if (resource) {
+            resources.push(resource);
+        }
+        else {
+            // If no CRUD pattern detected, treat as non-CRUD
+            nonCrudPaths.push(...groupPaths);
+        }
+    }
+    return { resources, nonCrudPaths };
+}
+/**
+ * Extract the collection base path from a path.
+ * "/pets" → "/pets"
+ * "/pets/:petId" → "/pets"
+ * "/owners/:ownerId/pets" → "/owners/:ownerId/pets"
+ * "/owners/:ownerId/pets/:petId" → "/owners/:ownerId/pets"
+ */
+function getCollectionPath(path) {
+    const segments = path.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return undefined;
+    // If last segment is a param (:xyz), remove it to get collection path
+    const last = segments[segments.length - 1];
+    if (last.startsWith(":")) {
+        return `/${segments.slice(0, -1).join("/")}`;
+    }
+    // Otherwise the path itself is a potential collection path
+    return `/${segments.join("/")}`;
+}
+function buildResource(basePath, paths) {
+    const operations = [];
+    let itemPath = "";
+    let idParam = "";
+    let schema;
+    for (const p of paths) {
+        const isCollection = p.path === basePath;
+        const isItem = !isCollection && p.path.startsWith(basePath);
+        if (isCollection) {
+            if (p.method === "GET") {
+                operations.push("list");
+                // Try to extract item schema from list response (array items)
+                const listSchema = getSuccessResponseSchema(p);
+                if (listSchema && listSchema.type === "array" && listSchema.items) {
+                    const items = Array.isArray(listSchema.items)
+                        ? listSchema.items[0]
+                        : listSchema.items;
+                    if (typeof items === "object" && items !== null) {
+                        schema = schema ?? items;
+                    }
+                }
+            }
+            else if (p.method === "POST") {
+                operations.push("create");
+            }
+        }
+        else if (isItem) {
+            // Extract ID param from the item path
+            const paramSegments = p.path
+                .slice(basePath.length)
+                .split("/")
+                .filter(Boolean);
+            if (paramSegments.length === 1 && paramSegments[0].startsWith(":")) {
+                const param = paramSegments[0].slice(1);
+                if (!idParam) {
+                    idParam = param;
+                    itemPath = p.path;
+                }
+                if (p.method === "GET") {
+                    operations.push("read");
+                    schema = schema ?? getSuccessResponseSchema(p);
+                }
+                else if (p.method === "PUT" || p.method === "PATCH") {
+                    if (!operations.includes("update")) {
+                        operations.push("update");
+                    }
+                }
+                else if (p.method === "DELETE") {
+                    operations.push("delete");
+                }
+            }
+        }
+    }
+    if (operations.length === 0)
+        return undefined;
+    // Require evidence of a genuine CRUD collection:
+    // either item-level operations (read/update/delete) exist,
+    // or both list AND create exist on the collection path.
+    // Single GET /health or POST /login don't qualify.
+    const hasItemOps = operations.some((op) => op === "read" || op === "update" || op === "delete");
+    const hasList = operations.includes("list");
+    const hasCreate = operations.includes("create");
+    if (!hasItemOps && !(hasList && hasCreate))
+        return undefined;
+    // If we only have collection operations, infer item path
+    if (!itemPath) {
+        const resourceName = basePath.split("/").filter(Boolean).pop() ?? "";
+        const singular = resourceName.endsWith("s")
+            ? resourceName.slice(0, -1)
+            : resourceName;
+        idParam = `${singular}Id`;
+        itemPath = `${basePath}/:${idParam}`;
+    }
+    const name = basePath.split("/").filter(Boolean).pop() ?? basePath;
+    return {
+        name,
+        basePath,
+        itemPath,
+        idParam,
+        operations,
+        schema,
+    };
+}
+function getSuccessResponseSchema(p) {
+    // Try 200, then 201, then first 2xx
+    for (const code of [200, 201]) {
+        const resp = p.responses.get(code);
+        if (resp?.schema)
+            return resp.schema;
+    }
+    for (const [code, resp] of p.responses) {
+        if (code >= 200 && code < 300 && resp.schema)
+            return resp.schema;
+    }
+    return undefined;
+}

package/dist/generators.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchema7 } from "json-schema";
+import type { CrudResource } from "./crud-detector.js";
+import type { ParsedPath } from "./parser.js";
+export declare function createListGenerator(resource: CrudResource): Schmock.GeneratorFunction;
+export declare function createCreateGenerator(resource: CrudResource): Schmock.GeneratorFunction;
+export declare function createReadGenerator(resource: CrudResource): Schmock.GeneratorFunction;
+export declare function createUpdateGenerator(resource: CrudResource): Schmock.GeneratorFunction;
+export declare function createDeleteGenerator(resource: CrudResource): Schmock.GeneratorFunction;
+export declare function createStaticGenerator(parsedPath: ParsedPath): Schmock.GeneratorFunction;
+/**
+ * Generate seed items for a resource using its schema.
+ */
+export declare function generateSeedItems(schema: JSONSchema7, count: number, idParam: string): unknown[];
+//# sourceMappingURL=generators.d.ts.map

package/dist/generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../src/generators.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA2C9C,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAK3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAkB3B;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAY3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAoB3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAa3B;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,iBAAiB,CA+B3B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,EAAE,CAWX"}

package/dist/generators.js

@@ -0,0 +1,158 @@
+/// <reference path="../../../types/schmock.d.ts" />
+import { generateFromSchema } from "@schmock/schema";
+const COLLECTION_STATE_PREFIX = "openapi:collections:";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toTuple(status, body) {
+    return [status, body];
+}
+function collectionKey(resourceName) {
+    return `${COLLECTION_STATE_PREFIX}${resourceName}`;
+}
+function getCollection(state, resourceName) {
+    const key = collectionKey(resourceName);
+    if (!Array.isArray(state[key])) {
+        state[key] = [];
+    }
+    const value = state[key];
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [];
+}
+function getNextId(state, resourceName) {
+    const counterKey = `openapi:counter:${resourceName}`;
+    const current = state[counterKey];
+    const base = typeof current === "number" ? current : 0;
+    const next = base + 1;
+    state[counterKey] = next;
+    return next;
+}
+export function createListGenerator(resource) {
+    return (ctx) => {
+        const collection = getCollection(ctx.state, resource.name);
+        return [...collection];
+    };
+}
+export function createCreateGenerator(resource) {
+    return (ctx) => {
+        const collection = getCollection(ctx.state, resource.name);
+        const id = getNextId(ctx.state, resource.name);
+        let item;
+        if (isRecord(ctx.body)) {
+            item = {
+                ...ctx.body,
+                [resource.idParam]: id,
+            };
+        }
+        else {
+            item = { [resource.idParam]: id };
+        }
+        collection.push(item);
+        return toTuple(201, item);
+    };
+}
+export function createReadGenerator(resource) {
+    return (ctx) => {
+        const collection = getCollection(ctx.state, resource.name);
+        const idValue = ctx.params[resource.idParam];
+        const item = findById(collection, resource.idParam, idValue);
+        if (!item) {
+            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+        }
+        return item;
+    };
+}
+export function createUpdateGenerator(resource) {
+    return (ctx) => {
+        const collection = getCollection(ctx.state, resource.name);
+        const idValue = ctx.params[resource.idParam];
+        const index = findIndexById(collection, resource.idParam, idValue);
+        if (index === -1) {
+            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+        }
+        const existingRaw = collection[index];
+        const existing = isRecord(existingRaw) ? existingRaw : {};
+        const updated = {
+            ...existing,
+            ...(isRecord(ctx.body) ? ctx.body : {}),
+            [resource.idParam]: existing[resource.idParam], // Preserve ID
+        };
+        collection[index] = updated;
+        return updated;
+    };
+}
+export function createDeleteGenerator(resource) {
+    return (ctx) => {
+        const collection = getCollection(ctx.state, resource.name);
+        const idValue = ctx.params[resource.idParam];
+        const index = findIndexById(collection, resource.idParam, idValue);
+        if (index === -1) {
+            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+        }
+        collection.splice(index, 1);
+        return toTuple(204, undefined);
+    };
+}
+export function createStaticGenerator(parsedPath) {
+    // Get the success response schema
+    let responseSchema;
+    for (const code of [200, 201]) {
+        const resp = parsedPath.responses.get(code);
+        if (resp?.schema) {
+            responseSchema = resp.schema;
+            break;
+        }
+    }
+    if (!responseSchema) {
+        for (const [code, resp] of parsedPath.responses) {
+            if (code >= 200 && code < 300 && resp.schema) {
+                responseSchema = resp.schema;
+                break;
+            }
+        }
+    }
+    return () => {
+        if (responseSchema) {
+            try {
+                return generateFromSchema({ schema: responseSchema });
+            }
+            catch {
+                // Complex schemas (deep anyOf, circular refs) may fail generation.
+                // Fall back to an empty object rather than crashing.
+                return {};
+            }
+        }
+        return toTuple(200, {});
+    };
+}
+/**
+ * Generate seed items for a resource using its schema.
+ */
+export function generateSeedItems(schema, count, idParam) {
+    const items = [];
+    for (let i = 0; i < count; i++) {
+        const generated = generateFromSchema({ schema });
+        const item = isRecord(generated)
+            ? generated
+            : { value: generated };
+        item[idParam] = i + 1;
+        items.push(item);
+    }
+    return items;
+}
+function findById(collection, idParam, idValue) {
+    return collection.find((item) => {
+        if (!isRecord(item))
+            return false;
+        return String(item[idParam]) === String(idValue);
+    });
+}
+function findIndexById(collection, idParam, idValue) {
+    return collection.findIndex((item) => {
+        if (!isRecord(item))
+            return false;
+        return String(item[idParam]) === String(idValue);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { OpenApiOptions, SeedConfig, SeedSource } from "./plugin.js";
+export { openapi } from "./plugin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}