@schmock/schema 1.0.0 → 1.0.2

package/dist/steps/schema-plugin.steps.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema-plugin.steps.d.ts.map

package/dist/steps/schema-plugin.steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-plugin.steps.d.ts","sourceRoot":"","sources":["../../src/steps/schema-plugin.steps.ts"],"names":[],"mappings":""}

package/dist/steps/schema-plugin.steps.js

@@ -0,0 +1,139 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { expect } from "vitest";
+import { generateFromSchema, schemaPlugin } from "../index";
+const feature = await loadFeature("../../features/schema-plugin.feature");
+describeFeature(feature, ({ Scenario }) => {
+    let generated;
+    let error = null;
+    Scenario("Generate object from simple schema", ({ Given, When, Then, And }) => {
+        let schema;
+        Given("I create a schema plugin with:", (_, docString) => {
+            schema = JSON.parse(docString);
+        });
+        When("I generate data from the schema", () => {
+            generated = generateFromSchema({ schema });
+        });
+        Then("the generated data should have property {string} of type {string}", (_, prop, type) => {
+            expect(generated).toHaveProperty(prop);
+            expect(typeof generated[prop]).toBe(type);
+        });
+        And("the generated data should have property {string} of type {string}", (_, prop, type) => {
+            expect(generated).toHaveProperty(prop);
+            expect(typeof generated[prop]).toBe(type);
+        });
+    });
+    Scenario("Generate array of items with explicit count", ({ Given, When, Then }) => {
+        let schema;
+        let count;
+        Given("I create a schema plugin for array with count {int}:", (_, cnt, docString) => {
+            schema = JSON.parse(docString);
+            count = cnt;
+        });
+        When("I generate data from the schema", () => {
+            generated = generateFromSchema({ schema, count });
+        });
+        Then("the generated data should be an array of length {int}", (_, length) => {
+            expect(Array.isArray(generated)).toBe(true);
+            expect(generated).toHaveLength(length);
+        });
+    });
+    Scenario("Template preserves string values for mixed templates", ({ Given, When, Then }) => {
+        let template;
+        let result;
+        Given("I create a schema plugin with template override {string}", (_, tmpl) => {
+            template = tmpl;
+        });
+        When("I generate data with param {string} set to {string}", (_, paramName, paramValue) => {
+            const schema = {
+                type: "object",
+                properties: {
+                    value: { type: "string" },
+                },
+            };
+            result = generateFromSchema({
+                schema,
+                overrides: { value: template },
+                params: { [paramName]: paramValue },
+            });
+        });
+        Then("the template result should be the string {string}", (_, expected) => {
+            expect(result.value).toBe(expected);
+            expect(typeof result.value).toBe("string");
+        });
+    });
+    Scenario("Multiple schema plugin instances do not share state", ({ Given, When, Then }) => {
+        let plugin1;
+        let plugin2;
+        let data1;
+        let data2;
+        Given("I create two separate schema plugin instances", () => {
+            const schema = {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                },
+                required: ["name"],
+            };
+            plugin1 = schemaPlugin({ schema });
+            plugin2 = schemaPlugin({ schema });
+        });
+        When("I generate data from both instances", async () => {
+            const ctx = {
+                path: "/test",
+                route: {},
+                method: "GET",
+                params: {},
+                query: {},
+                headers: {},
+                state: new Map(),
+            };
+            const result1 = await plugin1.process(ctx);
+            const result2 = await plugin2.process(ctx);
+            data1 = result1.response;
+            data2 = result2.response;
+        });
+        Then("the data from each instance should be independently generated", () => {
+            expect(data1).toBeDefined();
+            expect(data2).toBeDefined();
+            expect(typeof data1.name).toBe("string");
+            expect(typeof data2.name).toBe("string");
+        });
+    });
+    Scenario("Invalid schema is rejected at plugin creation time", ({ Given, Then }) => {
+        Given("I attempt to create a schema plugin with invalid schema", () => {
+            error = null;
+            try {
+                schemaPlugin({ schema: {} });
+            }
+            catch (e) {
+                error = e;
+            }
+        });
+        Then("it should throw a SchemaValidationError", () => {
+            expect(error).not.toBeNull();
+            expect(error.constructor.name).toBe("SchemaValidationError");
+        });
+    });
+    Scenario("Faker method validation checks actual method existence", ({ Given, Then }) => {
+        Given("I attempt to create a schema with faker method {string}", (_, fakerMethod) => {
+            error = null;
+            try {
+                const schema = {
+                    type: "object",
+                    properties: {
+                        field: { type: "string", faker: fakerMethod },
+                    },
+                };
+                schemaPlugin({ schema: schema });
+            }
+            catch (e) {
+                error = e;
+            }
+        });
+        Then("it should throw a SchemaValidationError with message {string}", (_, message) => {
+            expect(error).not.toBeNull();
+            expect(error.constructor.name).toBe("SchemaValidationError");
+            expect(error.message).toContain(message);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/schema",
   "description": "JSON Schema-based automatic data generation for Schmock",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,17 +23,23 @@
     "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"
+    "lint:fix": "biome check --write --unsafe src/*.ts",
+    "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",
   "dependencies": {
     "json-schema-faker": "^0.5.6",
-    "@faker-js/faker": "^10.1.0"
+    "@faker-js/faker": "^10.2.0"
+  },
+  "peerDependencies": {
+    "@schmock/core": "^1.0.0"
   },
   "devDependencies": {
+    "@amiceli/vitest-cucumber": "^6.2.0",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^24.9.1",
+    "@types/node": "^25.1.0",
     "vitest": "^4.0.15"
   }
-}
+}

package/src/data-quality.test.ts

@@ -299,7 +299,7 @@ describe("Data Quality and Statistical Properties", () => {
         // Street addresses should have numbers and street names
         expect(sample.street).toMatch(/\d/);
         expect(sample.street).toMatch(/[A-Z]/);
-        expect(sample.street.length).toBeGreaterThanOrEqual(10); // Allow exactly 10
+        expect(sample.street.length).toBeGreaterThanOrEqual(5); // Allow short addresses like "9 Ave."
 
         // Cities should be properly formatted
         expect(sample.city).toMatch(/^[A-Z]/);

package/src/error-handling.test.ts

@@ -84,9 +84,8 @@ describe("Schema Error Handling", () => {
         });
         expect.fail("Should have thrown");
       } catch (error: any) {
-        expect(error.message).toContain("Unknown faker namespace");
-        expect(error.message).toContain("badnamespace");
-        expect(error.message).toContain("Valid namespaces include");
+        expect(error.message).toContain("Invalid faker method");
+        expect(error.message).toContain("badnamespace.method");
       }
     });
 

package/src/index.test.ts

@@ -404,7 +404,7 @@ describe("Schema Generator", () => {
           field: schemas.withFaker("string", "invalidnamespace.method"),
         });
 
-        schemaTests.expectInvalid(schema, /Unknown faker namespace/);
+        schemaTests.expectInvalid(schema, /Invalid faker method/);
       });
 
       it("handles all common field mapping categories", () => {
@@ -765,7 +765,7 @@ describe("Schema Generator", () => {
       });
 
       expect(plugin).toHaveProperty("name", "schema");
-      expect(plugin).toHaveProperty("version", "1.0.0");
+      expect(plugin).toHaveProperty("version", "1.0.1");
       expect(plugin).toHaveProperty("process");
       expect(typeof plugin.process).toBe("function");
     });
@@ -905,9 +905,8 @@ describe("Schema Generator", () => {
         });
         expect.fail("Should have thrown");
       } catch (error: any) {
-        expect(error.message).toContain("Unknown faker namespace");
-        expect(error.context?.schemaPath).toContain("nested");
-        expect(error.context?.schemaPath).toContain("field");
+        expect(error.message).toContain("Invalid faker method");
+        expect(error.message).toContain("invalid.namespace.method");
       }
     });
 

package/src/index.ts

@@ -1,6 +1,5 @@
-/// <reference path="../../../types/schmock.d.ts" />
-
 import { en, Faker } from "@faker-js/faker";
+import type { Plugin, PluginContext } from "@schmock/core";
 import {
   ResourceLimitError,
   SchemaGenerationError,
@@ -18,18 +17,23 @@ function createFakerInstance() {
   return new Faker({ locale: [en] });
 }
 
-// Configure json-schema-faker with a function that creates fresh faker instances
-jsf.extend("faker", () => createFakerInstance());
-
-// Configure json-schema-faker options
-jsf.option({
-  requiredOnly: false,
-  alwaysFakeOptionals: true,
-  useDefaultValue: true,
-  ignoreMissingRefs: true,
-  failOnInvalidTypes: false,
-  failOnInvalidFormat: false,
-});
+let jsfConfigured = false;
+
+function getJsf() {
+  if (!jsfConfigured) {
+    jsf.extend("faker", () => createFakerInstance());
+    jsf.option({
+      requiredOnly: false,
+      alwaysFakeOptionals: true,
+      useDefaultValue: true,
+      ignoreMissingRefs: true,
+      failOnInvalidTypes: false,
+      failOnInvalidFormat: false,
+    });
+    jsfConfigured = true;
+  }
+  return jsf;
+}
 
 // Resource limits for safety
 const MAX_ARRAY_SIZE = 10000;
@@ -53,15 +57,15 @@ interface SchemaPluginOptions {
   overrides?: Record<string, any>;
 }
 
-export function schemaPlugin(options: SchemaPluginOptions): Schmock.Plugin {
+export function schemaPlugin(options: SchemaPluginOptions): Plugin {
   // Validate schema immediately when plugin is created
   validateSchema(options.schema);
 
   return {
     name: "schema",
-    version: "1.0.0",
+    version: "1.0.1",
 
-    process(context: Schmock.PluginContext, response?: any) {
+    process(context: PluginContext, response?: any) {
       // If response already exists, pass it through
       if (response !== undefined && response !== null) {
         return { context, response };
@@ -131,7 +135,7 @@ export function generateFromSchema(options: SchemaGenerationContext): any {
 
     generated = [];
     for (let i = 0; i < itemCount; i++) {
-      let item = jsf.generate(
+      let item = getJsf().generate(
         enhanceSchemaWithSmartMapping(itemSchema as JSONSchema7),
       );
       item = applyOverrides(item, overrides, params, state, query);
@@ -140,7 +144,7 @@ export function generateFromSchema(options: SchemaGenerationContext): any {
   } else {
     // Handle object schemas
     const enhancedSchema = enhanceSchemaWithSmartMapping(schema);
-    generated = jsf.generate(enhancedSchema);
+    generated = getJsf().generate(enhancedSchema);
     generated = applyOverrides(generated, overrides, params, state, query);
   }
 
@@ -687,16 +691,6 @@ function processTemplate(
     },
   );
 
-  // Try to convert to number if it's a numeric string
-  if (typeof processed === "string") {
-    if (/^\d+$/.test(processed)) {
-      return Number.parseInt(processed, 10);
-    }
-    if (/^\d+\.\d+$/.test(processed)) {
-      return Number.parseFloat(processed);
-    }
-  }
-
   return processed;
 }
 
@@ -707,31 +701,6 @@ function processTemplate(
  * @throws {SchemaValidationError} When faker method format or namespace is invalid
  */
 function validateFakerMethod(fakerMethod: string): void {
-  // List of known faker namespaces and common methods
-  const validFakerNamespaces = [
-    "person",
-    "internet",
-    "phone",
-    "location",
-    "string",
-    "date",
-    "company",
-    "commerce",
-    "color",
-    "database",
-    "finance",
-    "git",
-    "hacker",
-    "helpers",
-    "image",
-    "lorem",
-    "music",
-    "number",
-    "science",
-    "vehicle",
-    "word",
-  ];
-
   // Check if faker method follows valid format (namespace.method)
   const parts = fakerMethod.split(".");
   if (parts.length < 2) {
@@ -742,20 +711,24 @@ function validateFakerMethod(fakerMethod: string): void {
     );
   }
 
-  const [namespace] = parts;
-  if (!validFakerNamespaces.includes(namespace)) {
-    throw new SchemaValidationError(
-      "$.faker",
-      `Unknown faker namespace: "${namespace}"`,
-      `Valid namespaces include: ${validFakerNamespaces.slice(0, 5).join(", ")}, etc.`,
-    );
+  // Validate by resolving the method path on a real faker instance
+  const faker = createFakerInstance();
+  let current: any = faker;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      throw new SchemaValidationError(
+        "$.faker",
+        `Invalid faker method: "${fakerMethod}"`,
+        "Check faker.js documentation for valid methods",
+      );
+    }
   }
-
-  // Check for obviously invalid method names
-  if (fakerMethod.includes("nonexistent") || fakerMethod.includes("invalid")) {
+  if (typeof current !== "function") {
     throw new SchemaValidationError(
       "$.faker",
-      `Invalid faker method: "${fakerMethod}"`,
+      `Invalid faker method: "${fakerMethod}" is not a function`,
       "Check faker.js documentation for valid methods",
     );
   }

package/src/plugin-integration.test.ts

@@ -11,7 +11,7 @@ describe("Schema Plugin Integration", () => {
       });
       expect(validPlugin).toBeDefined();
       expect(validPlugin.name).toBe("schema");
-      expect(validPlugin.version).toBe("1.0.0");
+      expect(validPlugin.version).toBe("1.0.1");
 
       // Invalid schema should throw immediately
       expect(() => {

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

@@ -0,0 +1,160 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { expect } from "vitest";
+import { generateFromSchema, schemaPlugin } from "../index";
+
+const feature = await loadFeature("../../features/schema-plugin.feature");
+
+describeFeature(feature, ({ Scenario }) => {
+  let generated: any;
+  let error: Error | null = null;
+
+  Scenario("Generate object from simple schema", ({ Given, When, Then, And }) => {
+    let schema: any;
+
+    Given("I create a schema plugin with:", (_, docString: string) => {
+      schema = JSON.parse(docString);
+    });
+
+    When("I generate data from the schema", () => {
+      generated = generateFromSchema({ schema });
+    });
+
+    Then("the generated data should have property {string} of type {string}", (_, prop: string, type: string) => {
+      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) => {
+      expect(generated).toHaveProperty(prop);
+      expect(typeof generated[prop]).toBe(type);
+    });
+  });
+
+  Scenario("Generate array of items with explicit count", ({ Given, When, Then }) => {
+    let schema: any;
+    let count: number;
+
+    Given("I create a schema plugin for array with count {int}:", (_, cnt: number, docString: string) => {
+      schema = JSON.parse(docString);
+      count = cnt;
+    });
+
+    When("I generate data from the schema", () => {
+      generated = 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: any;
+
+    Given("I create a schema plugin with template override {string}", (_, tmpl: string) => {
+      template = tmpl;
+    });
+
+    When("I generate data with param {string} set to {string}", (_, paramName: string, paramValue: string) => {
+      const schema = {
+        type: "object" as const,
+        properties: {
+          value: { type: "string" as const },
+        },
+      };
+      result = generateFromSchema({
+        schema,
+        overrides: { value: template },
+        params: { [paramName]: paramValue },
+      });
+    });
+
+    Then("the template result should be the string {string}", (_, expected: string) => {
+      expect(result.value).toBe(expected);
+      expect(typeof result.value).toBe("string");
+    });
+  });
+
+  Scenario("Multiple schema plugin instances do not share state", ({ Given, When, Then }) => {
+    let plugin1: any;
+    let plugin2: any;
+    let data1: any;
+    let data2: any;
+
+    Given("I create two separate schema plugin instances", () => {
+      const schema = {
+        type: "object" as const,
+        properties: {
+          name: { type: "string" as const },
+        },
+        required: ["name"],
+      };
+      plugin1 = schemaPlugin({ schema });
+      plugin2 = schemaPlugin({ schema });
+    });
+
+    When("I generate data from both instances", async () => {
+      const ctx = {
+        path: "/test",
+        route: {},
+        method: "GET" as const,
+        params: {},
+        query: {},
+        headers: {},
+        state: new Map(),
+      };
+      const result1 = await plugin1.process(ctx);
+      const result2 = await plugin2.process(ctx);
+      data1 = result1.response;
+      data2 = result2.response;
+    });
+
+    Then("the data from each instance should be independently generated", () => {
+      expect(data1).toBeDefined();
+      expect(data2).toBeDefined();
+      expect(typeof data1.name).toBe("string");
+      expect(typeof data2.name).toBe("string");
+    });
+  });
+
+  Scenario("Invalid schema is rejected at plugin creation time", ({ Given, Then }) => {
+    Given("I attempt to create a schema plugin with invalid schema", () => {
+      error = null;
+      try {
+        schemaPlugin({ schema: {} as any });
+      } catch (e) {
+        error = e as Error;
+      }
+    });
+
+    Then("it should throw a SchemaValidationError", () => {
+      expect(error).not.toBeNull();
+      expect(error!.constructor.name).toBe("SchemaValidationError");
+    });
+  });
+
+  Scenario("Faker method validation checks actual method existence", ({ Given, Then }) => {
+    Given("I attempt to create a schema with faker method {string}", (_, fakerMethod: string) => {
+      error = null;
+      try {
+        const schema = {
+          type: "object" as const,
+          properties: {
+            field: { type: "string" as const, faker: fakerMethod },
+          },
+        };
+        schemaPlugin({ schema: schema as any });
+      } catch (e) {
+        error = e as Error;
+      }
+    });
+
+    Then("it should throw a SchemaValidationError with message {string}", (_, message: string) => {
+      expect(error).not.toBeNull();
+      expect(error!.constructor.name).toBe("SchemaValidationError");
+      expect(error!.message).toContain(message);
+    });
+  });
+});