@schmock/openapi 1.1.0

package/src/crud-detector.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { detectCrudResources } from "./crud-detector";
+import type { ParsedPath } from "./parser";
+
+function makePath(
+  method: Schmock.HttpMethod,
+  path: string,
+  responseSchema?: Record<string, unknown>,
+): ParsedPath {
+  const responses = new Map<number, { schema?: any; description: string }>();
+  if (responseSchema) {
+    responses.set(200, { schema: responseSchema, description: "OK" });
+  }
+  return {
+    path,
+    method,
+    parameters: [],
+    responses,
+    tags: [],
+  };
+}
+
+describe("detectCrudResources", () => {
+  it("detects a standard CRUD resource", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/pets", {
+        type: "array",
+        items: { type: "object", properties: { petId: { type: "integer" } } },
+      }),
+      makePath("POST", "/pets"),
+      makePath("GET", "/pets/:petId", {
+        type: "object",
+        properties: { petId: { type: "integer" } },
+      }),
+      makePath("PUT", "/pets/:petId"),
+      makePath("DELETE", "/pets/:petId"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(1);
+    expect(result.nonCrudPaths).toHaveLength(0);
+
+    const resource = result.resources[0];
+    expect(resource.name).toBe("pets");
+    expect(resource.basePath).toBe("/pets");
+    expect(resource.itemPath).toBe("/pets/:petId");
+    expect(resource.idParam).toBe("petId");
+    expect(resource.operations).toContain("list");
+    expect(resource.operations).toContain("create");
+    expect(resource.operations).toContain("read");
+    expect(resource.operations).toContain("update");
+    expect(resource.operations).toContain("delete");
+  });
+
+  it("detects a read-only API", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/articles", {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { articleId: { type: "integer" } },
+        },
+      }),
+      makePath("GET", "/articles/:articleId"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(1);
+    expect(result.resources[0].operations).toEqual(["list", "read"]);
+  });
+
+  it("handles non-CRUD endpoints", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/health"),
+      makePath("POST", "/login"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(0);
+    expect(result.nonCrudPaths).toHaveLength(2);
+  });
+
+  it("handles mixed CRUD and non-CRUD endpoints", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/pets"),
+      makePath("POST", "/pets"),
+      makePath("GET", "/health"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(1);
+    expect(result.resources[0].name).toBe("pets");
+    expect(result.nonCrudPaths).toHaveLength(1);
+    expect(result.nonCrudPaths[0].path).toBe("/health");
+  });
+
+  it("handles nested resources", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/owners/:ownerId/pets"),
+      makePath("POST", "/owners/:ownerId/pets"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(1);
+    expect(result.resources[0].name).toBe("pets");
+    expect(result.resources[0].basePath).toBe("/owners/:ownerId/pets");
+  });
+
+  it("extracts schema from list response items", () => {
+    const itemSchema = {
+      type: "object",
+      properties: {
+        petId: { type: "integer" },
+        name: { type: "string" },
+      },
+    };
+
+    const paths: ParsedPath[] = [
+      makePath("GET", "/pets", {
+        type: "array",
+        items: itemSchema,
+      }),
+      makePath("POST", "/pets"),
+    ];
+
+    const result = detectCrudResources(paths);
+
+    expect(result.resources).toHaveLength(1);
+    expect(result.resources[0].schema).toEqual(itemSchema);
+  });
+
+  it("does not duplicate update operation for PUT and PATCH", () => {
+    const paths: ParsedPath[] = [
+      makePath("GET", "/pets"),
+      makePath("PUT", "/pets/:petId"),
+      makePath("PATCH", "/pets/:petId"),
+    ];
+
+    const result = detectCrudResources(paths);
+    const updateCount = result.resources[0].operations.filter(
+      (op) => op === "update",
+    ).length;
+    expect(updateCount).toBe(1);
+  });
+});

package/src/crud-detector.ts

@@ -0,0 +1,194 @@
+/// <reference path="../../../types/schmock.d.ts" />
+
+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 function detectCrudResources(paths: ParsedPath[]): DetectionResult {
+  // Group paths by their base path (strip trailing /:param)
+  const groups = new Map<string, ParsedPath[]>();
+  const nonCrudPaths: ParsedPath[] = [];
+
+  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: CrudResource[] = [];
+
+  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: string): string | undefined {
+  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: string,
+  paths: ParsedPath[],
+): CrudResource | undefined {
+  const operations: CrudOperation[] = [];
+  let itemPath = "";
+  let idParam = "";
+  let schema: JSONSchema7 | undefined;
+
+  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 as JSONSchema7);
+          }
+        }
+      } 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: ParsedPath): JSONSchema7 | undefined {
+  // 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/src/generators.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from "vitest";
+import type { CrudResource } from "./crud-detector";
+import {
+  createCreateGenerator,
+  createDeleteGenerator,
+  createListGenerator,
+  createReadGenerator,
+  createUpdateGenerator,
+  generateSeedItems,
+} from "./generators";
+
+function makeResource(overrides?: Partial<CrudResource>): CrudResource {
+  return {
+    name: "pets",
+    basePath: "/pets",
+    itemPath: "/pets/:petId",
+    idParam: "petId",
+    operations: ["list", "create", "read", "update", "delete"],
+    schema: {
+      type: "object",
+      properties: {
+        petId: { type: "integer" },
+        name: { type: "string" },
+      },
+      required: ["petId", "name"],
+    },
+    ...overrides,
+  };
+}
+
+function makeContext(
+  overrides?: Partial<Schmock.RequestContext>,
+): Schmock.RequestContext {
+  return {
+    method: "GET",
+    path: "/pets",
+    params: {},
+    query: {},
+    headers: {},
+    state: {},
+    ...overrides,
+  };
+}
+
+describe("generators", () => {
+  describe("CRUD lifecycle", () => {
+    it("creates, reads, updates, lists, and deletes", () => {
+      const resource = makeResource();
+      const state: Record<string, unknown> = {};
+
+      // Seed the collection
+      state["openapi:collections:pets"] = [];
+      state["openapi:counter:pets"] = 0;
+
+      const create = createCreateGenerator(resource);
+      const read = createReadGenerator(resource);
+      const update = createUpdateGenerator(resource);
+      const list = createListGenerator(resource);
+      const del = createDeleteGenerator(resource);
+
+      // Create
+      const createResult = create(
+        makeContext({
+          method: "POST",
+          path: "/pets",
+          body: { name: "Buddy" },
+          state,
+        }),
+      );
+      expect(createResult).toEqual([201, { name: "Buddy", petId: 1 }]);
+
+      // Read
+      const readResult = read(
+        makeContext({
+          path: "/pets/1",
+          params: { petId: "1" },
+          state,
+        }),
+      );
+      expect(readResult).toEqual({ name: "Buddy", petId: 1 });
+
+      // Update
+      const updateResult = update(
+        makeContext({
+          method: "PUT",
+          path: "/pets/1",
+          params: { petId: "1" },
+          body: { name: "Max" },
+          state,
+        }),
+      );
+      expect(updateResult).toEqual({ name: "Max", petId: 1 });
+
+      // List
+      const listResult = list(makeContext({ state }));
+      expect(listResult).toEqual([{ name: "Max", petId: 1 }]);
+
+      // Delete
+      const deleteResult = del(
+        makeContext({
+          method: "DELETE",
+          path: "/pets/1",
+          params: { petId: "1" },
+          state,
+        }),
+      );
+      expect(deleteResult).toEqual([204, undefined]);
+
+      // Verify deletion
+      const afterDelete = list(makeContext({ state }));
+      expect(afterDelete).toEqual([]);
+    });
+  });
+
+  describe("read generator", () => {
+    it("returns 404 for missing resources", () => {
+      const resource = makeResource();
+      const state: Record<string, unknown> = {
+        "openapi:collections:pets": [],
+      };
+
+      const read = createReadGenerator(resource);
+      const result = read(
+        makeContext({
+          path: "/pets/999",
+          params: { petId: "999" },
+          state,
+        }),
+      );
+      expect(result).toEqual([404, { error: "Not found", code: "NOT_FOUND" }]);
+    });
+  });
+
+  describe("update generator", () => {
+    it("returns 404 for missing resources", () => {
+      const resource = makeResource();
+      const state: Record<string, unknown> = {
+        "openapi:collections:pets": [],
+      };
+
+      const update = createUpdateGenerator(resource);
+      const result = update(
+        makeContext({
+          method: "PUT",
+          path: "/pets/999",
+          params: { petId: "999" },
+          body: { name: "Ghost" },
+          state,
+        }),
+      );
+      expect(result).toEqual([404, { error: "Not found", code: "NOT_FOUND" }]);
+    });
+  });
+
+  describe("delete generator", () => {
+    it("returns 404 for missing resources", () => {
+      const resource = makeResource();
+      const state: Record<string, unknown> = {
+        "openapi:collections:pets": [],
+      };
+
+      const del = createDeleteGenerator(resource);
+      const result = del(
+        makeContext({
+          method: "DELETE",
+          path: "/pets/999",
+          params: { petId: "999" },
+          state,
+        }),
+      );
+      expect(result).toEqual([404, { error: "Not found", code: "NOT_FOUND" }]);
+    });
+  });
+
+  describe("create generator", () => {
+    it("auto-increments IDs", () => {
+      const resource = makeResource();
+      const state: Record<string, unknown> = {
+        "openapi:collections:pets": [],
+        "openapi:counter:pets": 0,
+      };
+
+      const create = createCreateGenerator(resource);
+      create(makeContext({ method: "POST", body: { name: "A" }, state }));
+      create(makeContext({ method: "POST", body: { name: "B" }, state }));
+
+      const collection = state["openapi:collections:pets"] as Record<
+        string,
+        unknown
+      >[];
+      expect(collection[0].petId).toBe(1);
+      expect(collection[1].petId).toBe(2);
+    });
+  });
+
+  describe("generateSeedItems", () => {
+    it("generates items with auto-assigned IDs", () => {
+      const schema = {
+        type: "object" as const,
+        properties: {
+          name: { type: "string" as const },
+        },
+        required: ["name" as const],
+      };
+
+      const items = generateSeedItems(schema, 3, "petId");
+      expect(items).toHaveLength(3);
+      for (let i = 0; i < 3; i++) {
+        const item = items[i] as Record<string, unknown>;
+        expect(item.petId).toBe(i + 1);
+      }
+    });
+  });
+});