@schmock/core 1.0.0

package/src/errors.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, it } from "vitest";
+import {
+  PluginError,
+  ResourceLimitError,
+  ResponseGenerationError,
+  RouteDefinitionError,
+  RouteNotFoundError,
+  RouteParseError,
+  SchemaGenerationError,
+  SchemaValidationError,
+  SchmockError,
+} from "./errors";
+
+describe("error classes", () => {
+  describe("SchmockError", () => {
+    it("creates base error with code and context", () => {
+      const error = new SchmockError("test message", "TEST_CODE", {
+        data: "test",
+      });
+
+      expect(error.message).toBe("test message");
+      expect(error.code).toBe("TEST_CODE");
+      expect(error.context).toEqual({ data: "test" });
+      expect(error.name).toBe("SchmockError");
+      expect(error).toBeInstanceOf(Error);
+    });
+
+    it("creates error without context", () => {
+      const error = new SchmockError("test message", "TEST_CODE");
+
+      expect(error.context).toBeUndefined();
+    });
+
+    it("captures stack trace", () => {
+      const error = new SchmockError("test", "TEST");
+
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain("SchmockError");
+    });
+  });
+
+  describe("RouteNotFoundError", () => {
+    it("formats message with method and path", () => {
+      const error = new RouteNotFoundError("GET", "/users/123");
+
+      expect(error.message).toBe("Route not found: GET /users/123");
+      expect(error.code).toBe("ROUTE_NOT_FOUND");
+      expect(error.context).toEqual({ method: "GET", path: "/users/123" });
+      expect(error.name).toBe("RouteNotFoundError");
+    });
+  });
+
+  describe("RouteParseError", () => {
+    it("includes route key and reason in message", () => {
+      const error = new RouteParseError("INVALID /test", "Missing method");
+
+      expect(error.message).toBe(
+        'Invalid route key format: "INVALID /test". Missing method',
+      );
+      expect(error.code).toBe("ROUTE_PARSE_ERROR");
+      expect(error.context).toEqual({
+        routeKey: "INVALID /test",
+        reason: "Missing method",
+      });
+    });
+  });
+
+  describe("ResponseGenerationError", () => {
+    it("wraps original error", () => {
+      const originalError = new Error("Original failure");
+      const error = new ResponseGenerationError("GET /users", originalError);
+
+      expect(error.message).toBe(
+        "Failed to generate response for route GET /users: Original failure",
+      );
+      expect(error.code).toBe("RESPONSE_GENERATION_ERROR");
+      expect(error.context).toEqual({
+        route: "GET /users",
+        originalError,
+      });
+    });
+  });
+
+  describe("PluginError", () => {
+    it("includes plugin name and wraps error", () => {
+      const originalError = new Error("Plugin failed");
+      const error = new PluginError("test-plugin", originalError);
+
+      expect(error.message).toBe('Plugin "test-plugin" failed: Plugin failed');
+      expect(error.code).toBe("PLUGIN_ERROR");
+      expect(error.context).toEqual({
+        pluginName: "test-plugin",
+        originalError,
+      });
+    });
+  });
+
+  describe("RouteDefinitionError", () => {
+    it("includes route key and reason", () => {
+      const error = new RouteDefinitionError(
+        "GET /test",
+        "Missing response function",
+      );
+
+      expect(error.message).toBe(
+        'Invalid route definition for "GET /test": Missing response function',
+      );
+      expect(error.code).toBe("ROUTE_DEFINITION_ERROR");
+      expect(error.context).toEqual({
+        routeKey: "GET /test",
+        reason: "Missing response function",
+      });
+    });
+  });
+
+  describe("SchemaValidationError", () => {
+    it("includes path and issue", () => {
+      const error = new SchemaValidationError(
+        "users.name",
+        "Required field missing",
+      );
+
+      expect(error.message).toBe(
+        "Schema validation failed at users.name: Required field missing",
+      );
+      expect(error.code).toBe("SCHEMA_VALIDATION_ERROR");
+      expect(error.context).toEqual({
+        schemaPath: "users.name",
+        issue: "Required field missing",
+        suggestion: undefined,
+      });
+    });
+
+    it("includes suggestion when provided", () => {
+      const error = new SchemaValidationError(
+        "users.age",
+        "Invalid type",
+        "Use number instead of string",
+      );
+
+      expect(error.message).toBe(
+        "Schema validation failed at users.age: Invalid type. Use number instead of string",
+      );
+      expect(error.context?.suggestion).toBe("Use number instead of string");
+    });
+  });
+
+  describe("SchemaGenerationError", () => {
+    it("wraps schema generation failure", () => {
+      const originalError = new Error("Invalid schema");
+      const schema = { type: "object" };
+      const error = new SchemaGenerationError(
+        "GET /users",
+        originalError,
+        schema,
+      );
+
+      expect(error.message).toBe(
+        "Schema generation failed for route GET /users: Invalid schema",
+      );
+      expect(error.code).toBe("SCHEMA_GENERATION_ERROR");
+      expect(error.context).toEqual({
+        route: "GET /users",
+        originalError,
+        schema,
+      });
+    });
+
+    it("works without schema context", () => {
+      const originalError = new Error("Invalid schema");
+      const error = new SchemaGenerationError("GET /users", originalError);
+
+      expect(error.context?.schema).toBeUndefined();
+    });
+  });
+
+  describe("ResourceLimitError", () => {
+    it("includes resource and limit", () => {
+      const error = new ResourceLimitError("memory", 1024);
+
+      expect(error.message).toBe(
+        "Resource limit exceeded for memory: limit=1024",
+      );
+      expect(error.code).toBe("RESOURCE_LIMIT_ERROR");
+      expect(error.context).toEqual({
+        resource: "memory",
+        limit: 1024,
+        actual: undefined,
+      });
+    });
+
+    it("includes actual value when provided", () => {
+      const error = new ResourceLimitError("connections", 100, 150);
+
+      expect(error.message).toBe(
+        "Resource limit exceeded for connections: limit=100, actual=150",
+      );
+      expect(error.context?.actual).toBe(150);
+    });
+  });
+
+  describe("error inheritance", () => {
+    it("all custom errors inherit from SchmockError", () => {
+      const errors = [
+        new RouteNotFoundError("GET", "/test"),
+        new RouteParseError("invalid", "reason"),
+        new ResponseGenerationError("route", new Error("test")),
+        new PluginError("plugin", new Error("test")),
+        new RouteDefinitionError("route", "reason"),
+        new SchemaValidationError("path", "issue"),
+        new SchemaGenerationError("route", new Error("test")),
+        new ResourceLimitError("resource", 100),
+      ];
+
+      for (const error of errors) {
+        expect(error).toBeInstanceOf(SchmockError);
+        expect(error).toBeInstanceOf(Error);
+        expect(error.code).toBeDefined();
+        expect(error.name).toBeDefined();
+      }
+    });
+  });
+});

package/src/errors.ts

@@ -0,0 +1,124 @@
+/**
+ * Base error class for all Schmock errors
+ */
+export class SchmockError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly context?: unknown,
+  ) {
+    super(message);
+    this.name = "SchmockError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Error thrown when a route is not found
+ */
+export class RouteNotFoundError extends SchmockError {
+  constructor(method: string, path: string) {
+    super(`Route not found: ${method} ${path}`, "ROUTE_NOT_FOUND", {
+      method,
+      path,
+    });
+    this.name = "RouteNotFoundError";
+  }
+}
+
+/**
+ * Error thrown when route parsing fails
+ */
+export class RouteParseError extends SchmockError {
+  constructor(routeKey: string, reason: string) {
+    super(
+      `Invalid route key format: "${routeKey}". ${reason}`,
+      "ROUTE_PARSE_ERROR",
+      { routeKey, reason },
+    );
+    this.name = "RouteParseError";
+  }
+}
+
+/**
+ * Error thrown when response generation fails
+ */
+export class ResponseGenerationError extends SchmockError {
+  constructor(route: string, error: Error) {
+    super(
+      `Failed to generate response for route ${route}: ${error.message}`,
+      "RESPONSE_GENERATION_ERROR",
+      { route, originalError: error },
+    );
+    this.name = "ResponseGenerationError";
+  }
+}
+
+/**
+ * Error thrown when a plugin fails
+ */
+export class PluginError extends SchmockError {
+  constructor(pluginName: string, error: Error) {
+    super(`Plugin "${pluginName}" failed: ${error.message}`, "PLUGIN_ERROR", {
+      pluginName,
+      originalError: error,
+    });
+    this.name = "PluginError";
+  }
+}
+
+/**
+ * Error thrown when route definition is invalid
+ */
+export class RouteDefinitionError extends SchmockError {
+  constructor(routeKey: string, reason: string) {
+    super(
+      `Invalid route definition for "${routeKey}": ${reason}`,
+      "ROUTE_DEFINITION_ERROR",
+      { routeKey, reason },
+    );
+    this.name = "RouteDefinitionError";
+  }
+}
+
+/**
+ * Error thrown when schema validation fails
+ */
+export class SchemaValidationError extends SchmockError {
+  constructor(schemaPath: string, issue: string, suggestion?: string) {
+    super(
+      `Schema validation failed at ${schemaPath}: ${issue}${suggestion ? `. ${suggestion}` : ""}`,
+      "SCHEMA_VALIDATION_ERROR",
+      { schemaPath, issue, suggestion },
+    );
+    this.name = "SchemaValidationError";
+  }
+}
+
+/**
+ * Error thrown when schema generation fails
+ */
+export class SchemaGenerationError extends SchmockError {
+  constructor(route: string, error: Error, schema?: unknown) {
+    super(
+      `Schema generation failed for route ${route}: ${error.message}`,
+      "SCHEMA_GENERATION_ERROR",
+      { route, originalError: error, schema },
+    );
+    this.name = "SchemaGenerationError";
+  }
+}
+
+/**
+ * Error thrown when resource limits are exceeded
+ */
+export class ResourceLimitError extends SchmockError {
+  constructor(resource: string, limit: number, actual?: number) {
+    super(
+      `Resource limit exceeded for ${resource}: limit=${limit}${actual ? `, actual=${actual}` : ""}`,
+      "RESOURCE_LIMIT_ERROR",
+      { resource, limit, actual },
+    );
+    this.name = "ResourceLimitError";
+  }
+}

package/src/factory.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import { schmock } from "./index";
+
+describe("schmock factory function", () => {
+  describe("factory behavior", () => {
+    it("creates callable mock instance with no config", () => {
+      const mock = schmock();
+
+      expect(typeof mock).toBe("function");
+      expect(typeof mock.handle).toBe("function");
+      expect(typeof mock.pipe).toBe("function");
+    });
+
+    it("creates callable mock instance with config", () => {
+      const config = { debug: true, namespace: "/api" };
+      const mock = schmock(config);
+
+      expect(typeof mock).toBe("function");
+      expect(typeof mock.handle).toBe("function");
+      expect(typeof mock.pipe).toBe("function");
+    });
+
+    it("supports method chaining from factory call", () => {
+      const mock = schmock();
+      const result = mock("GET /test", "response");
+
+      expect(result).toBe(mock); // Should return same instance for chaining
+    });
+
+    it("supports plugin chaining", () => {
+      const mock = schmock();
+      const plugin = {
+        name: "test",
+        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
+      };
+      const result = mock.pipe(plugin);
+
+      expect(result).toBe(mock); // Should return same instance for chaining
+    });
+  });
+
+  describe("callable instance behavior", () => {
+    it("defines routes when called as function", async () => {
+      const mock = schmock();
+      mock("GET /test", "hello");
+
+      const response = await mock.handle("GET", "/test");
+      expect(response.body).toBe("hello");
+    });
+
+    it("allows method chaining after route definition", async () => {
+      const mock = schmock();
+      const plugin = {
+        name: "test",
+        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
+      };
+
+      mock("GET /test", "hello").pipe(plugin);
+
+      const response = await mock.handle("GET", "/test");
+      expect(response.body).toBe("hello");
+    });
+
+    it("passes config to route definition", async () => {
+      const mock = schmock();
+      mock("GET /test", { data: "test" }, { contentType: "text/plain" });
+
+      const response = await mock.handle("GET", "/test");
+      expect(response.headers["content-type"]).toBe("text/plain");
+      expect(response.body).toBe('{"data":"test"}'); // Stringified because contentType is text/plain
+    });
+  });
+
+  describe("binding and method preservation", () => {
+    it("preserves handle method binding", async () => {
+      const mock = schmock();
+      mock("GET /test", "response");
+
+      const handleMethod = mock.handle;
+      const response = await handleMethod("GET", "/test");
+
+      expect(response.body).toBe("response");
+    });
+
+    it("allows destructuring of methods", async () => {
+      const mock = schmock();
+      mock("GET /test", "response");
+
+      const { handle } = mock;
+      const response = await handle("GET", "/test");
+
+      expect(response.body).toBe("response");
+    });
+
+    it("pipes maintain chain references", () => {
+      const mock = schmock();
+      const plugin1 = {
+        name: "plugin1",
+        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
+      };
+      const plugin2 = {
+        name: "plugin2",
+        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
+      };
+
+      const chain = mock.pipe(plugin1).pipe(plugin2);
+
+      expect(chain).toBe(mock);
+    });
+  });
+
+  describe("type compatibility", () => {
+    it("works with TypeScript function signature", () => {
+      // Test that the factory function matches expected TypeScript types
+      const mock = schmock({ debug: false });
+      mock("GET /users", () => [{ id: 1 }], {
+        contentType: "application/json",
+      });
+
+      expect(typeof mock).toBe("function");
+    });
+
+    it("handles optional config parameter", () => {
+      const mock1 = schmock();
+      const mock2 = schmock({});
+      const mock3 = schmock({ debug: true });
+
+      expect(typeof mock1).toBe("function");
+      expect(typeof mock2).toBe("function");
+      expect(typeof mock3).toBe("function");
+    });
+  });
+});

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAEjC;AAGD,YAAY,EACV,OAAO,EACP,aAAa,EACb,UAAU,EACV,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,QAAQ,EACR,MAAM,GACP,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,WAAW,EACX,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,UAAU,CAAC"}

package/src/index.ts

@@ -0,0 +1,80 @@
+import { CallableMockInstance } from "./builder";
+
+/**
+ * Create a new Schmock mock instance with callable API.
+ *
+ * @example
+ * ```typescript
+ * // New callable API (default)
+ * const mock = schmock({ debug: true })
+ * mock('GET /users', () => [{ id: 1, name: 'John' }])
+ *   .pipe(authPlugin())
+ *
+ * const response = await mock.handle('GET', '/users')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with defaults
+ * const mock = schmock()
+ * mock('GET /users', [{ id: 1, name: 'John' }])
+ * ```
+ *
+ * @param config Optional global configuration
+ * @returns A callable mock instance
+ */
+export function schmock(
+  config?: Schmock.GlobalConfig,
+): Schmock.CallableMockInstance {
+  // Always use new callable API
+  const instance = new CallableMockInstance(config || {});
+
+  // Create a callable function that wraps the instance
+  const callableInstance = ((
+    route: Schmock.RouteKey,
+    generator: Schmock.Generator,
+    config: Schmock.RouteConfig = {},
+  ) => {
+    instance.defineRoute(route, generator, config);
+    return callableInstance; // Return the callable function for chaining
+  }) as any;
+
+  // Manually bind all instance methods to the callable function with proper return values
+  callableInstance.pipe = (plugin: Schmock.Plugin) => {
+    instance.pipe(plugin);
+    return callableInstance; // Return callable function for chaining
+  };
+  callableInstance.handle = instance.handle.bind(instance);
+
+  return callableInstance as Schmock.CallableMockInstance;
+}
+
+// Re-export errors
+export {
+  PluginError,
+  ResourceLimitError,
+  ResponseGenerationError,
+  RouteDefinitionError,
+  RouteNotFoundError,
+  RouteParseError,
+  SchemaGenerationError,
+  SchemaValidationError,
+  SchmockError,
+} from "./errors";
+// Re-export types
+export type {
+  CallableMockInstance,
+  Generator,
+  GeneratorFunction,
+  GlobalConfig,
+  HttpMethod,
+  Plugin,
+  PluginContext,
+  PluginResult,
+  RequestContext,
+  RequestOptions,
+  Response,
+  ResponseResult,
+  RouteConfig,
+  RouteKey,
+} from "./types";