@schmock/faker 2.3.0 → 2.3.1

package/src/integration.test.ts

@@ -1,634 +0,0 @@
-import { schmock } from "@schmock/core";
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { fakerPlugin, generateFromSchema } from "./index";
-import { generate, schemas, validators } from "./test-utils";
-
-describe("Schema Generator Integration Tests", () => {
-  describe("End-to-End Scenarios", () => {
-    it("generates complete mock API response with relationships", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          user: {
-            type: "object",
-            properties: {
-              id: { type: "string", format: "uuid" },
-              username: { type: "string", pattern: "^[a-z0-9_]{3,20}$" },
-              email: { type: "string", format: "email" },
-              profile: {
-                type: "object",
-                properties: {
-                  firstName: { type: "string" },
-                  lastName: { type: "string" },
-                  avatar: { type: "string", format: "uri" },
-                  bio: { type: "string", maxLength: 500 },
-                },
-              },
-              posts: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    id: { type: "string", format: "uuid" },
-                    title: { type: "string", minLength: 1, maxLength: 200 },
-                    content: { type: "string" },
-                    tags: {
-                      type: "array",
-                      items: { type: "string" },
-                      maxItems: 5,
-                    },
-                    publishedAt: { type: "string", format: "date-time" },
-                    comments: {
-                      type: "array",
-                      items: {
-                        type: "object",
-                        properties: {
-                          id: { type: "string", format: "uuid" },
-                          author: { type: "string" },
-                          text: { type: "string" },
-                          createdAt: { type: "string", format: "date-time" },
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      // Verify complete structure
-      expect(result.user).toBeDefined();
-      expect(validators.appearsToBeFromCategory([result.user.id], "uuid")).toBe(
-        true,
-      );
-      expect(result.user.username).toMatch(/^[a-z0-9_]{3,20}$/);
-      expect(
-        validators.appearsToBeFromCategory([result.user.email], "email"),
-      ).toBe(true);
-
-      expect(result.user.profile).toBeDefined();
-      expect(typeof result.user.profile.firstName).toBe("string");
-      expect(result.user.profile.firstName.length).toBeGreaterThan(0);
-
-      if (result.user.posts && result.user.posts.length > 0) {
-        const post = result.user.posts[0];
-        expect(validators.appearsToBeFromCategory([post.id], "uuid")).toBe(
-          true,
-        );
-        expect(post.title.length).toBeGreaterThan(0);
-        expect(
-          validators.appearsToBeFromCategory([post.publishedAt], "date"),
-        ).toBe(true);
-      }
-    });
-
-    it("generates consistent data across related fields", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: {
-            order: {
-              type: "object",
-              properties: {
-                id: { type: "string", format: "uuid" },
-                customerId: { type: "string", format: "uuid" },
-                items: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    properties: {
-                      productId: { type: "string", format: "uuid" },
-                      quantity: { type: "integer", minimum: 1 },
-                      unitPrice: { type: "number", minimum: 0 },
-                      totalPrice: { type: "number", minimum: 0 },
-                    },
-                  },
-                },
-                subtotal: { type: "number", minimum: 0 },
-                tax: { type: "number", minimum: 0 },
-                total: { type: "number", minimum: 0 },
-                createdAt: { type: "string", format: "date-time" },
-                updatedAt: { type: "string", format: "date-time" },
-              },
-            },
-          },
-        },
-        overrides: {
-          "order.customerId": "{{params.customerId}}",
-          "order.createdAt": "{{state.timestamp}}",
-          "order.updatedAt": "{{state.timestamp}}",
-        },
-      });
-
-      const context = {
-        method: "GET",
-        path: "/api/orders/123",
-        params: { orderId: "123", customerId: "customer-456" },
-        query: {},
-        state: new Map(),
-        routeState: { timestamp: "2024-01-01T10:00:00Z" },
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const result = await plugin.process(context);
-
-      expect(result.response.order.customerId).toBe("customer-456");
-      expect(result.response.order.createdAt).toBe("2024-01-01T10:00:00Z");
-      expect(result.response.order.updatedAt).toBe("2024-01-01T10:00:00Z");
-
-      // All IDs should be valid UUIDs
-      expect(
-        validators.appearsToBeFromCategory([result.response.order.id], "uuid"),
-      ).toBe(true);
-
-      if (
-        result.response.order.items &&
-        result.response.order.items.length > 0
-      ) {
-        result.response.order.items.forEach((item) => {
-          expect(
-            validators.appearsToBeFromCategory([item.productId], "uuid"),
-          ).toBe(true);
-          expect(item.quantity).toBeGreaterThanOrEqual(1);
-          expect(item.unitPrice).toBeGreaterThanOrEqual(0);
-        });
-      }
-    });
-  });
-
-  describe("Cross-Package Integration", () => {
-    it("works with complex nested schemas from multiple sources", async () => {
-      const addressSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          street: { type: "string" },
-          city: { type: "string" },
-          state: { type: "string", pattern: "^[A-Z]{2}$" },
-          zipCode: { type: "string", pattern: "^\\d{5}(-\\d{4})?$" },
-          country: { type: "string", enum: ["US", "CA", "MX"] },
-        },
-        required: ["street", "city", "state", "zipCode", "country"],
-      };
-
-      const customerSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uuid" },
-          name: { type: "string" },
-          email: { type: "string", format: "email" },
-          phone: { type: "string" },
-          billingAddress: addressSchema,
-          shippingAddress: addressSchema,
-          sameAsBilling: { type: "boolean" },
-        },
-      };
-
-      const result = await generateFromSchema({ schema: customerSchema });
-
-      // Both addresses should be valid structures
-      expect(result.billingAddress.street).toBeDefined();
-      expect(typeof result.billingAddress.street).toBe("string");
-      expect(result.billingAddress.state).toMatch(/^[A-Z]{2}$/);
-      expect(result.billingAddress.zipCode).toMatch(/^\d{5}(-\d{4})?$/);
-
-      expect(result.shippingAddress.street).toBeDefined();
-      expect(typeof result.shippingAddress.street).toBe("string");
-      expect(["US", "CA", "MX"]).toContain(result.shippingAddress.country);
-    });
-
-    it("handles schema composition with allOf, anyOf, oneOf", async () => {
-      const baseSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uuid" },
-          createdAt: { type: "string", format: "date-time" },
-        },
-        required: ["id", "createdAt"],
-      };
-
-      const documentSchema: JSONSchema7 = {
-        allOf: [
-          baseSchema,
-          {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              content: {
-                anyOf: [
-                  { type: "string" },
-                  {
-                    type: "object",
-                    properties: {
-                      html: { type: "string" },
-                      markdown: { type: "string" },
-                    },
-                  },
-                ],
-              },
-              status: {
-                oneOf: [
-                  { const: "draft" },
-                  { const: "published" },
-                  { const: "archived" },
-                ],
-              },
-            },
-            required: ["title", "content", "status"],
-          },
-        ],
-      };
-
-      const results = await generate.samples<any>(documentSchema, 10);
-
-      results.forEach((result) => {
-        // Should have base properties
-        expect(validators.appearsToBeFromCategory([result.id], "uuid")).toBe(
-          true,
-        );
-        expect(
-          validators.appearsToBeFromCategory([result.createdAt], "date"),
-        ).toBe(true);
-
-        // Should have document properties
-        expect(result).toHaveProperty("title");
-        expect(result).toHaveProperty("content");
-        expect(["draft", "published", "archived"]).toContain(result.status);
-      });
-    });
-  });
-
-  describe("State Management Integration", () => {
-    it("maintains state across multiple generations", async () => {
-      const _callCount = 0;
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: {
-            requestNumber: { type: "integer" },
-            sessionId: { type: "string" },
-            timestamp: { type: "string", format: "date-time" },
-          },
-        },
-        overrides: {
-          requestNumber: "{{state.requestCount}}",
-          sessionId: "{{state.sessionId}}",
-        },
-      });
-
-      const baseContext = {
-        method: "GET",
-        path: "/api/track",
-        params: {},
-        query: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      // Simulate multiple requests with evolving state
-      const results: any[] = [];
-      for (let i = 0; i < 5; i++) {
-        const context = {
-          ...baseContext,
-          state: new Map(),
-          routeState: {
-            requestCount: i + 1,
-            sessionId: "session-123",
-          },
-        };
-        const r = await plugin.process(context);
-        results.push(r.response);
-      }
-
-      // Request numbers should increment
-      results.forEach((result, i) => {
-        expect(result.requestNumber).toBe(i + 1);
-        expect(result.sessionId).toBe("session-123");
-      });
-    });
-
-    it("generates stateful mock data", async () => {
-      const cartSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uuid" },
-          userId: { type: "string", format: "uuid" },
-          items: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                productId: { type: "string", format: "uuid" },
-                quantity: { type: "integer", minimum: 1 },
-                addedAt: { type: "string", format: "date-time" },
-              },
-            },
-          },
-          lastModified: { type: "string", format: "date-time" },
-        },
-      };
-
-      // Generate initial cart
-      const cart1 = await generateFromSchema({ schema: cartSchema });
-
-      // Simulate adding items (would be done through state in real usage)
-      const cart2 = await generateFromSchema({
-        schema: cartSchema,
-        overrides: {
-          id: cart1.id, // Keep same cart ID
-          userId: cart1.userId, // Keep same user
-          lastModified: new Date().toISOString(),
-        },
-      });
-
-      expect(cart2.id).toBe(cart1.id);
-      expect(cart2.userId).toBe(cart1.userId);
-    });
-  });
-
-  describe("Performance at Scale", () => {
-    it("generates large datasets efficiently", async () => {
-      const schema: JSONSchema7 = {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "integer" },
-            uuid: { type: "string", format: "uuid" },
-            name: { type: "string" },
-            email: { type: "string", format: "email" },
-            active: { type: "boolean" },
-            score: { type: "number", minimum: 0, maximum: 100 },
-            tags: {
-              type: "array",
-              items: { type: "string" },
-              maxItems: 3,
-            },
-          },
-        },
-      };
-
-      const startTime = Date.now();
-      const result = await generateFromSchema({ schema, count: 100 });
-      const duration = Date.now() - startTime;
-
-      expect(result).toHaveLength(100);
-      expect(duration).toBeLessThan(1000); // Should complete in under 1 second
-
-      // Verify data quality at scale
-      const emails = result.map((item) => item.email);
-      const uniqueEmails = new Set(emails);
-      expect(uniqueEmails.size / emails.length).toBeGreaterThan(0.9); // High uniqueness
-    });
-
-    it("handles concurrent plugin processing", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.complex.user(),
-      });
-
-      const context = {
-        method: "GET",
-        path: "/api/user",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      // Simulate concurrent requests
-      const promises = Array.from({ length: 20 }, () =>
-        plugin.process(context),
-      );
-
-      const results = await Promise.all(promises);
-
-      // All should complete successfully
-      expect(results).toHaveLength(20);
-
-      // Each should generate unique data
-      const emails = results.map((r) => r.response.email);
-      const uniqueEmails = new Set(emails);
-      expect(uniqueEmails.size).toBeGreaterThan(15); // Most should be unique
-    });
-  });
-
-  describe("Error Recovery and Resilience", () => {
-    it("recovers from validation errors gracefully", async () => {
-      // First, try invalid schema
-      try {
-        await generateFromSchema({
-          schema: {
-            type: "object",
-            properties: {
-              bad: { type: "invalid" as any },
-            },
-          },
-        });
-      } catch (_e) {
-        // Expected
-      }
-
-      // Should still work with valid schema
-      const result = await generateFromSchema({
-        schema: schemas.simple.object({ id: schemas.simple.number() }),
-      });
-
-      expect(result).toHaveProperty("id");
-    });
-
-    it("handles partial template failures", async () => {
-      const plugin = fakerPlugin({
-        schema: {
-          type: "object",
-          properties: {
-            field1: { type: "string" },
-            field2: { type: "string" },
-            field3: { type: "string" },
-            field4: { type: "string" },
-          },
-        },
-        overrides: {
-          field1: "{{params.value1}}",
-          field2: "{{state.missing.nested.value}}",
-          field3: "static",
-          field4: "{{query.value4}}",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/test",
-        params: { value1: "success" },
-        query: { value4: "works" },
-        state: new Map(),
-        routeState: {},
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      // Successful templates should work
-      expect(result.response.field1).toBe("success");
-      expect(result.response.field3).toBe("static");
-      expect(result.response.field4).toBe("works");
-
-      // Failed template returns original
-      expect(result.response.field2).toBe("{{state.missing.nested.value}}");
-    });
-  });
-
-  describe("Advanced Integration Patterns", () => {
-    it("supports pagination patterns", async () => {
-      const paginatedSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          items: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                id: { type: "string", format: "uuid" },
-                name: { type: "string" },
-              },
-            },
-          },
-          pagination: {
-            type: "object",
-            properties: {
-              page: { type: "integer", minimum: 1 },
-              pageSize: { type: "integer", minimum: 1, maximum: 100 },
-              total: { type: "integer", minimum: 0 },
-              hasNext: { type: "boolean" },
-              hasPrev: { type: "boolean" },
-            },
-          },
-        },
-      };
-
-      const plugin = fakerPlugin({
-        schema: paginatedSchema,
-        overrides: {
-          "pagination.page": "{{query.page}}",
-          "pagination.pageSize": "{{query.limit}}",
-          "pagination.total": 150,
-          "pagination.hasNext": "{{state.hasNext}}",
-          "pagination.hasPrev": "{{state.hasPrev}}",
-        },
-      });
-
-      const result = await plugin.process({
-        method: "GET",
-        path: "/api/items",
-        params: {},
-        query: { page: "2", limit: "20" },
-        state: new Map(),
-        routeState: { hasNext: true, hasPrev: true },
-        headers: {},
-        body: null,
-        route: {},
-      });
-
-      expect(result.response.pagination.page).toBe("2");
-      expect(result.response.pagination.pageSize).toBe("20");
-      expect(result.response.pagination.total).toBe(150);
-      expect(result.response.pagination.hasNext).toBe(true);
-    });
-
-    it("supports versioned API responses", async () => {
-      const v1Schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          version: { const: "1.0" },
-          data: {
-            type: "object",
-            properties: {
-              id: { type: "number" },
-              name: { type: "string" },
-            },
-          },
-        },
-      };
-
-      const v2Schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          version: { const: "2.0" },
-          data: {
-            type: "object",
-            properties: {
-              id: { type: "string", format: "uuid" },
-              name: { type: "string" },
-              metadata: { type: "object" },
-            },
-          },
-        },
-      };
-
-      const v1Result = await generateFromSchema({ schema: v1Schema });
-      const v2Result = await generateFromSchema({ schema: v2Schema });
-
-      expect(v1Result.version).toBe("1.0");
-      expect(typeof v1Result.data.id).toBe("number");
-
-      expect(v2Result.version).toBe("2.0");
-      expect(
-        validators.appearsToBeFromCategory([v2Result.data.id], "uuid"),
-      ).toBe(true);
-      expect(v2Result.data).toHaveProperty("metadata");
-    });
-  });
-
-  describe("Schmock Handle Integration", () => {
-    it("resolves state overrides when using schmock.handle() with global state", async () => {
-      // This test verifies that state-driven template overrides work correctly
-      // when the schema plugin is used through schmock.handle() with global state
-      const userState = {
-        currentUser: {
-          id: "user-123",
-          name: "Test User",
-        },
-        settings: {
-          theme: "dark",
-        },
-      };
-
-      const mock = schmock({ state: userState });
-
-      const responseSchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          userId: { type: "string" },
-          userName: { type: "string" },
-          theme: { type: "string" },
-          timestamp: { type: "string" },
-        },
-      };
-
-      mock("GET /profile", null).pipe(
-        fakerPlugin({
-          schema: responseSchema,
-          overrides: {
-            userId: "{{state.currentUser.id}}",
-            userName: "{{state.currentUser.name}}",
-            theme: "{{state.settings.theme}}",
-          },
-        }),
-      );
-
-      const response = await mock.handle("GET", "/profile");
-
-      expect(response.body.userId).toBe("user-123");
-      expect(response.body.userName).toBe("Test User");
-      expect(response.body.theme).toBe("dark");
-    });
-  });
-});

package/src/jsf-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsf-config.d.ts","sourceRoot":"","sources":["jsf-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,GAAG,MAAM,mBAAmB,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,SAMhD;AAoBD,wBAAgB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,CAuBhD"}

package/src/jsf-config.test.ts

@@ -1,65 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { normalizeSchemaForJsf } from "./jsf-config.js";
-
-const tuple: JSONSchema7 = {
-  type: "array",
-  items: [{ type: "string" }, { type: "integer" }],
-  minItems: 2,
-  maxItems: 2,
-  additionalItems: false,
-};
-
-function expectNormalizedTuple(value: unknown): void {
-  expect(value).toMatchObject({
-    type: "array",
-    prefixItems: [{ type: "string" }, { type: "integer" }],
-    items: false,
-  });
-  expect(value).not.toHaveProperty("additionalItems");
-}
-
-describe("normalizeSchemaForJsf", () => {
-  it("recurses through Draft-7 schema-bearing keywords", () => {
-    const normalized = normalizeSchemaForJsf({
-      type: "object",
-      definitions: { legacy: tuple },
-      $defs: { modern: tuple },
-      patternProperties: { "^tuple$": tuple },
-      contains: tuple,
-      not: tuple,
-      if: tuple,
-      // biome-ignore lint/suspicious/noThenProperty: JSON Schema's conditional keyword is named "then"
-      then: tuple,
-      else: tuple,
-    });
-
-    const record: Record<string, unknown> = normalized;
-    const definitions = record.definitions;
-    const defs = record.$defs;
-    const patternProperties = record.patternProperties;
-
-    expect(definitions).toBeTypeOf("object");
-    expect(defs).toBeTypeOf("object");
-    expect(patternProperties).toBeTypeOf("object");
-    if (
-      definitions === null ||
-      typeof definitions !== "object" ||
-      defs === null ||
-      typeof defs !== "object" ||
-      patternProperties === null ||
-      typeof patternProperties !== "object"
-    ) {
-      throw new Error("Expected normalized schema maps");
-    }
-
-    expectNormalizedTuple(Reflect.get(definitions, "legacy"));
-    expectNormalizedTuple(Reflect.get(defs, "modern"));
-    expectNormalizedTuple(Reflect.get(patternProperties, "^tuple$"));
-    expectNormalizedTuple(record.contains);
-    expectNormalizedTuple(record.not);
-    expectNormalizedTuple(record.if);
-    expectNormalizedTuple(record.then);
-    expectNormalizedTuple(record.else);
-  });
-});