@schmock/faker 2.3.0 → 2.3.1

package/src/steps/faker-plugin.steps.ts

@@ -1,301 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { generateFromSchema } from "../index";
-import { isJSONSchema7 } from "../validation";
-
-const feature = await loadFeature("../../features/faker-plugin.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let generated: unknown;
-
-  function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-
-  function isUnknownArray(value: unknown): value is unknown[] {
-    return Array.isArray(value);
-  }
-
-  function parseSchema(
-    docString: string,
-  ): Schmock.SchemaGenerationContext["schema"] {
-    const parsed: unknown = JSON.parse(docString);
-    if (!isJSONSchema7(parsed)) {
-      throw new Error("Expected feature DocString to contain a JSON Schema");
-    }
-    return parsed;
-  }
-
-  Scenario(
-    "Generate object from simple schema",
-    ({ Given, When, Then, And }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-
-      Given("I create a schema plugin with:", (_, docString: string) => {
-        schema = parseSchema(docString);
-      });
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema });
-      });
-
-      Then(
-        "the generated data should have property {string} of type {string}",
-        (_, prop: string, type: string) => {
-          if (!isRecord(generated)) {
-            throw new Error("Expected generated data to be an object");
-          }
-          expect(generated).toHaveProperty(prop);
-          expect(typeof generated[prop]).toBe(type);
-        },
-      );
-
-      And(
-        "the generated data should have property {string} of type {string}",
-        (_, prop: string, type: string) => {
-          if (!isRecord(generated)) {
-            throw new Error("Expected generated data to be an object");
-          }
-          expect(generated).toHaveProperty(prop);
-          expect(typeof generated[prop]).toBe(type);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Generate array of items with explicit count",
-    ({ Given, When, Then }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-      let count: number;
-
-      Given(
-        "I create a schema plugin for array with count {int}:",
-        (_, cnt: number, docString: string) => {
-          schema = parseSchema(docString);
-          count = cnt;
-        },
-      );
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema, count });
-      });
-
-      Then(
-        "the generated data should be an array of length {int}",
-        (_, length: number) => {
-          expect(Array.isArray(generated)).toBe(true);
-          expect(generated).toHaveLength(length);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Template preserves string values for mixed templates",
-    ({ Given, When, Then }) => {
-      let template: string;
-      let result: unknown;
-
-      Given(
-        "I create a schema plugin with template override {string}",
-        (_, tmpl: string) => {
-          template = tmpl;
-        },
-      );
-
-      When(
-        "I generate data with param {string} set to {string}",
-        async (_, paramName: string, paramValue: string) => {
-          const schema = {
-            type: "object" as const,
-            properties: {
-              value: { type: "string" as const },
-            },
-          };
-          result = await generateFromSchema({
-            schema,
-            overrides: { value: template },
-            params: { [paramName]: paramValue },
-          });
-        },
-      );
-
-      Then(
-        "the template result should be the string {string}",
-        (_, expected: string) => {
-          if (!isRecord(result)) {
-            throw new Error("Expected generated data to be an object");
-          }
-          expect(result.value).toBe(expected);
-          expect(typeof result.value).toBe("string");
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Generate tuple positions from their respective schemas",
-    ({ Given, When, Then }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-
-      Given(
-        "I create a tuple schema with string, integer, and boolean positions",
-        () => {
-          schema = {
-            type: "array",
-            items: [
-              { type: "string" },
-              { type: "integer" },
-              { type: "boolean" },
-            ],
-            minItems: 3,
-            maxItems: 3,
-          };
-        },
-      );
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema, seed: 42 });
-      });
-
-      Then(
-        "the generated tuple should contain string, number, and boolean values in order",
-        () => {
-          if (!isUnknownArray(generated)) {
-            throw new Error("Expected generated tuple data to be an array");
-          }
-          expect(generated).toHaveLength(3);
-          expect(typeof generated[0]).toBe("string");
-          expect(typeof generated[1]).toBe("number");
-          expect(typeof generated[2]).toBe("boolean");
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Generate a nested tuple through a schema reference",
-    ({ Given, When, Then }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-
-      Given(
-        "I create an object schema whose payload references a tuple definition",
-        () => {
-          schema = {
-            type: "object",
-            properties: {
-              payload: { $ref: "#/definitions/payloadTuple" },
-            },
-            required: ["payload"],
-            definitions: {
-              payloadTuple: {
-                type: "array",
-                items: [
-                  { type: "string" },
-                  { type: "integer" },
-                  { type: "boolean" },
-                ],
-                minItems: 3,
-                maxItems: 3,
-                additionalItems: false,
-              },
-            },
-          };
-        },
-      );
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema, seed: 42 });
-      });
-
-      Then(
-        "the generated payload tuple should contain string, number, and boolean values in order",
-        () => {
-          if (!isRecord(generated) || !Array.isArray(generated.payload)) {
-            throw new Error("Expected generated payload to be a tuple");
-          }
-          expect(generated.payload).toHaveLength(3);
-          expect(typeof generated.payload[0]).toBe("string");
-          expect(typeof generated.payload[1]).toBe("number");
-          expect(typeof generated.payload[2]).toBe("boolean");
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Apply overrides to every generated array item",
-    ({ Given, When, Then }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-      let count = 0;
-      let name = "";
-
-      Given(
-        "I create an object array schema with count {int} and override name {string}",
-        (_, requestedCount: number, overrideName: string) => {
-          count = requestedCount;
-          name = overrideName;
-          schema = {
-            type: "array",
-            items: {
-              type: "object",
-              properties: { name: { type: "string" } },
-              required: ["name"],
-            },
-          };
-        },
-      );
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({
-          schema,
-          count,
-          overrides: { name },
-          seed: 42,
-        });
-      });
-
-      Then(
-        "every generated array item should have name {string}",
-        (_, expectedName: string) => {
-          if (!isUnknownArray(generated)) {
-            throw new Error(
-              "Expected generated collection data to be an array",
-            );
-          }
-          for (const item of generated) {
-            expect(item).toMatchObject({ name: expectedName });
-          }
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Generate useful text for an unconstrained string",
-    ({ Given, When, Then }) => {
-      let schema: Schmock.SchemaGenerationContext["schema"];
-
-      Given("I create a schema plugin with:", (_, docString: string) => {
-        schema = parseSchema(docString);
-      });
-
-      When("I generate data from the schema", async () => {
-        generated = await generateFromSchema({ schema, seed: 42 });
-      });
-
-      Then(
-        "the generated data should have a non-empty {string}",
-        (_, property: string) => {
-          if (!isRecord(generated)) {
-            throw new Error("Expected generated data to be an object");
-          }
-          const value = generated[property];
-          expect(typeof value).toBe("string");
-          expect(value).not.toBe("");
-        },
-      );
-    },
-  );
-});

package/src/test-utils.ts

@@ -1,385 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { expect } from "vitest";
-import { generateFromSchema } from "./index";
-
-interface FakerSchema extends JSONSchema7 {
-  faker?: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// Schema Factory Functions
-export const schemas = {
-  simple: {
-    string: (): JSONSchema7 => ({
-      type: "string",
-    }),
-
-    number: (): JSONSchema7 => ({
-      type: "number",
-    }),
-
-    object: (properties: Record<string, JSONSchema7> = {}): JSONSchema7 => ({
-      type: "object",
-      properties,
-    }),
-
-    array: (
-      items: JSONSchema7,
-      constraints?: { minItems?: number; maxItems?: number },
-    ): JSONSchema7 => ({
-      type: "array",
-      items,
-      ...constraints,
-    }),
-  },
-
-  withFaker: (type: JSONSchema7["type"], fakerMethod: string): FakerSchema => ({
-    type,
-    faker: fakerMethod,
-  }),
-
-  nested: {
-    deep: (
-      depth: number,
-      leafSchema: JSONSchema7 = schemas.simple.string(),
-    ): JSONSchema7 => {
-      if (depth <= 0) return leafSchema;
-      return {
-        type: "object",
-        properties: {
-          nested: schemas.nested.deep(depth - 1, leafSchema),
-        },
-      };
-    },
-
-    wide: (
-      width: number,
-      propertySchema: JSONSchema7 = schemas.simple.string(),
-    ): JSONSchema7 => ({
-      type: "object",
-      properties: Object.fromEntries(
-        Array.from({ length: width }, (_, i) => [`prop${i}`, propertySchema]),
-      ),
-    }),
-  },
-
-  complex: {
-    user: (): JSONSchema7 => ({
-      type: "object",
-      properties: {
-        id: { type: "string", format: "uuid" },
-        email: { type: "string" },
-        firstName: { type: "string" },
-        lastName: { type: "string" },
-        createdAt: { type: "string" },
-      },
-      required: ["id", "email"],
-    }),
-
-    apiResponse: (): JSONSchema7 => ({
-      type: "object",
-      properties: {
-        success: { type: "boolean" },
-        data: {
-          type: "array",
-          items: schemas.complex.user(),
-        },
-        meta: {
-          type: "object",
-          properties: {
-            page: { type: "number" },
-            total: { type: "number" },
-          },
-        },
-      },
-    }),
-  },
-};
-
-// Validation Helpers
-export const validators = {
-  // Check if a field was mapped to a faker method by comparing with unmapped behavior
-  isFieldMapped: async (
-    fieldName: string,
-    fieldType: JSONSchema7["type"] = "string",
-  ): Promise<boolean> => {
-    const mappedSchema: JSONSchema7 = {
-      type: "object",
-      properties: {
-        [fieldName]: { type: fieldType },
-      },
-    };
-
-    const unmappedSchema: JSONSchema7 = {
-      type: "object",
-      properties: {
-        unmappedRandomField12345: { type: fieldType },
-      },
-    };
-
-    // Generate multiple samples to check for patterns
-    const mappedSamples: unknown[] = [];
-    for (let i = 0; i < 10; i++) {
-      const result = await generateFromSchema({
-        schema: mappedSchema,
-      });
-      if (!isRecord(result)) {
-        throw new Error(
-          "Expected mapped schema generation to return an object",
-        );
-      }
-      mappedSamples.push(result[fieldName]);
-    }
-
-    const unmappedSamples: unknown[] = [];
-    for (let i = 0; i < 10; i++) {
-      const result = await generateFromSchema({
-        schema: unmappedSchema,
-      });
-      if (!isRecord(result)) {
-        throw new Error(
-          "Expected unmapped schema generation to return an object",
-        );
-      }
-      unmappedSamples.push(result.unmappedRandomField12345);
-    }
-
-    // If field is mapped to a specific faker method, it should have different characteristics
-    // than the generic unmapped field
-    return (
-      analyzeDataCharacteristics(mappedSamples) !==
-      analyzeDataCharacteristics(unmappedSamples)
-    );
-  },
-
-  // Analyze uniqueness of generated data
-  uniquenessRatio: (samples: unknown[]): number => {
-    const unique = new Set(samples);
-    return unique.size / samples.length;
-  },
-
-  // Check if all samples match a basic pattern without being too specific
-  allMatch: <T>(samples: T[], validator: (sample: T) => boolean): boolean => {
-    return samples.every(validator);
-  },
-
-  // Check if data appears to be from a specific faker category
-  appearsToBeFromCategory: (
-    samples: string[],
-    category: "email" | "name" | "phone" | "address" | "uuid" | "date",
-  ): boolean => {
-    switch (category) {
-      case "email":
-        return validators.allMatch(
-          samples,
-          (s) => typeof s === "string" && s.includes("@") && s.includes("."),
-        );
-      case "name":
-        return validators.allMatch(
-          samples,
-          (s) =>
-            typeof s === "string" &&
-            s.length > 1 &&
-            s.length < 50 &&
-            /^[A-Z]/.test(s),
-        );
-      case "phone":
-        return validators.allMatch(
-          samples,
-          (s) => typeof s === "string" && /\d/.test(s) && s.length > 10,
-        );
-      case "address":
-        return validators.allMatch(
-          samples,
-          (s) =>
-            typeof s === "string" &&
-            s.length > 10 &&
-            /\d/.test(s) &&
-            /[A-Z]/.test(s),
-        );
-      case "uuid":
-        return validators.allMatch(
-          samples,
-          (s) =>
-            typeof s === "string" &&
-            /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
-              s,
-            ),
-        );
-      case "date":
-        return validators.allMatch(
-          samples,
-          (s) => typeof s === "string" && !Number.isNaN(Date.parse(s)),
-        );
-      default:
-        return false;
-    }
-  },
-};
-
-// Performance Testing Utilities
-export const performance = {
-  measure: async <T>(
-    fn: () => T | Promise<T>,
-  ): Promise<{ result: T; duration: number }> => {
-    const start = Date.now();
-    const result = await fn();
-    const duration = Date.now() - start;
-    return { result, duration };
-  },
-
-  measureMemory: (fn: () => void): number => {
-    if (globalThis.gc) {
-      globalThis.gc();
-    }
-    const before = process.memoryUsage().heapUsed;
-    fn();
-    const after = process.memoryUsage().heapUsed;
-    return after - before;
-  },
-
-  benchmark: async (
-    _name: string,
-    fn: () => unknown | Promise<unknown>,
-    iterations = 100,
-  ): Promise<{ mean: number; min: number; max: number }> => {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = Date.now();
-      await fn();
-      const duration = Date.now() - start;
-      times.push(duration);
-    }
-
-    return {
-      mean: times.reduce((a, b) => a + b, 0) / times.length,
-      min: Math.min(...times),
-      max: Math.max(...times),
-    };
-  },
-};
-
-// Test Data Generators
-export const generate = {
-  samples: async (
-    schema: JSONSchema7,
-    count = 10,
-    options?: Omit<Schmock.SchemaGenerationContext, "schema">,
-  ): Promise<unknown[]> => {
-    const results: unknown[] = [];
-    for (let i = 0; i < count; i++) {
-      results.push(await generateFromSchema({ schema, ...options }));
-    }
-    return results;
-  },
-
-  withSeed: async (schema: JSONSchema7, seed?: number): Promise<unknown> => {
-    return await generateFromSchema({ schema, seed });
-  },
-};
-
-// Statistical Analysis
-export const stats = {
-  distribution: (samples: unknown[]): Map<string, number> => {
-    const dist = new Map<string, number>();
-    for (const sample of samples) {
-      const key = JSON.stringify(sample) ?? "undefined";
-      dist.set(key, (dist.get(key) || 0) + 1);
-    }
-    return dist;
-  },
-
-  entropy: (samples: unknown[]): number => {
-    const dist = stats.distribution(samples);
-    const total = samples.length;
-    let entropy = 0;
-
-    for (const count of dist.values()) {
-      const p = count / total;
-      if (p > 0) {
-        entropy -= p * Math.log2(p);
-      }
-    }
-
-    return entropy;
-  },
-};
-
-// Schema Validation Test Helpers
-export const schemaTests = {
-  expectValid: async (schema: JSONSchema7): Promise<void> => {
-    await expect(generateFromSchema({ schema })).resolves.not.toThrow();
-  },
-
-  expectInvalid: async (
-    schema: JSONSchema7,
-    errorMessage?: string | RegExp,
-  ): Promise<void> => {
-    if (errorMessage) {
-      await expect(generateFromSchema({ schema })).rejects.toThrow(
-        errorMessage,
-      );
-    } else {
-      await expect(generateFromSchema({ schema })).rejects.toThrow();
-    }
-  },
-
-  expectSchemaError: async (
-    schema: JSONSchema7,
-    path: string,
-    issue?: string,
-  ): Promise<void> => {
-    try {
-      await generateFromSchema({ schema });
-      throw new Error("Expected schema validation to fail");
-    } catch (error: unknown) {
-      expect(error).toBeInstanceOf(Error);
-      if (!(error instanceof Error)) {
-        throw new Error("Expected schema validation to throw an Error");
-      }
-      expect(error.name).toBe("SchemaValidationError");
-      // The schemaPath is in the context
-      if (
-        "context" in error &&
-        isRecord(error.context) &&
-        error.context.schemaPath
-      ) {
-        expect(error.context.schemaPath).toBe(path);
-      }
-      if (issue) {
-        expect(error.message).toContain(issue);
-      }
-    }
-  },
-};
-
-// Helper to analyze data characteristics without hardcoding patterns
-function analyzeDataCharacteristics(samples: unknown[]): string {
-  if (samples.length === 0) return "empty";
-
-  const first = samples[0];
-  const type = typeof first;
-
-  if (!samples.every((sample) => typeof sample === "string")) return type;
-
-  // Analyze string characteristics
-  const characteristics: string[] = [type];
-
-  // Check common patterns without being too specific
-  if (samples.every((s) => s.includes("@"))) characteristics.push("has-at");
-  if (samples.every((s) => /^\d+$/.test(s))) characteristics.push("numeric");
-  if (samples.every((s) => /^[0-9a-f-]+$/i.test(s)))
-    characteristics.push("hex-like");
-  if (samples.every((s) => s.length > 50)) characteristics.push("long");
-  if (samples.every((s) => s.length < 10)) characteristics.push("short");
-  if (validators.uniquenessRatio(samples) > 0.8)
-    characteristics.push("high-entropy");
-  if (validators.uniquenessRatio(samples) < 0.2)
-    characteristics.push("low-entropy");
-
-  return characteristics.join("-");
-}

package/src/validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAY/C,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,SAAM,GAAG,IAAI,CAiJpE;AAwMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAmC7D"}