@schmock/core 1.0.3 → 1.1.0

package/src/steps/stateful-workflows.steps.ts

@@ -1,12 +1,31 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
 import { schmock } from "../index";
-import type { MockInstance } from "../types";
+import type { CallableMockInstance } from "../types";
+
+interface CartItem {
+  id: number;
+  name: string;
+  price: number;
+  quantity: number;
+}
+
+interface UserRecord {
+  username: string;
+  password: string;
+  profile: { name: string; role: string };
+}
+
+interface SessionRecord {
+  user: string;
+  profile: { name: string; role: string };
+  loginTime: string;
+}
 
 const feature = await loadFeature("../../features/stateful-workflows.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let mock: MockInstance<any>;
+  let mock: CallableMockInstance;
   let response: any;
   let sessionToken: string;
   let addedItemIds: number[] = [];
@@ -14,73 +33,65 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Shopping cart workflow", ({ Given, When, Then, And }) => {
     addedItemIds = [];
 
-    Given("I create a stateful shopping cart mock:", (_, docString: string) => {
-      // Create stateful shopping cart mock with new callable API
-      const sharedState = { items: [], total: 0 };
-      mock = schmock({ state: sharedState });
-      
-      mock('GET /cart', ({ state }) => ({
-        items: state.items,
-        total: state.total,
-        count: state.items.length
+    Given("I create a stateful shopping cart mock", () => {
+      const items: CartItem[] = [];
+      let total = 0;
+
+      mock = schmock();
+      mock("GET /cart", () => ({
+        items,
+        total,
+        count: items.length,
       }));
-      
-      mock('POST /cart/add', ({ state, body }) => {
-        const item = { 
-          id: Date.now(), 
-          name: body.name, 
-          price: body.price, 
-          quantity: body.quantity || 1 
+      mock("POST /cart/add", ({ body }) => {
+        const b = body as Record<string, unknown>;
+        const item: CartItem = {
+          id: Date.now(),
+          name: b.name as string,
+          price: b.price as number,
+          quantity: (b.quantity as number) || 1,
         };
-        
-        state.items.push(item);
-        state.total += item.price * item.quantity;
-        
+        items.push(item);
+        total += item.price * item.quantity;
         return {
-          message: 'Item added to cart',
+          message: "Item added to cart",
           added: item,
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
-      
-      mock('DELETE /cart/:id', ({ state, params }) => {
+      mock("DELETE /cart/:id", ({ params }) => {
         const itemId = parseInt(params.id);
-        const itemIndex = state.items.findIndex(item => item.id === itemId);
-        
+        const itemIndex = items.findIndex((item) => item.id === itemId);
         if (itemIndex === -1) {
-          return [404, { error: 'Item not found in cart' }];
+          return [404, { error: "Item not found in cart" }];
         }
-        
-        const removedItem = state.items[itemIndex];
-        state.total -= removedItem.price * removedItem.quantity;
-        state.items.splice(itemIndex, 1);
-        
+        const removedItem = items[itemIndex];
+        total -= removedItem.price * removedItem.quantity;
+        items.splice(itemIndex, 1);
         return {
-          message: 'Item removed from cart',
+          message: "Item removed from cart",
           item: removedItem,
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
-      
-      mock('POST /cart/clear', ({ state }) => {
-        state.items = [];
-        state.total = 0;
-        
+      mock("POST /cart/clear", () => {
+        items.length = 0;
+        total = 0;
         return {
-          message: 'Cart cleared',
+          message: "Cart cleared",
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
     });
@@ -114,29 +125,34 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("the cart should contain {int} items", async (_, expectedCount: number) => {
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.count).toBe(expectedCount);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     Then("the cart should contain {int} item", async (_, expectedCount: number) => {
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.count).toBe(expectedCount);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("the initial cart total should be {string}", async (_, expectedTotalStr: string) => {
       const expectedTotal = parseFloat(expectedTotalStr);
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.total).toBe(expectedTotal);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.total).toBe(expectedTotal);
     });
 
     And("the final cart total should be {string}", async (_, expectedTotalStr: string) => {
       const expectedTotal = parseFloat(expectedTotalStr);
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.total).toBe(expectedTotal);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.total).toBe(expectedTotal);
     });
 
     When("I remove the first item from the cart", async () => {
       const cartResponse = await mock.handle("GET", "/cart");
-      const firstItemId = cartResponse.body.items[0].id;
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      const firstItemId = body.items[0].id;
       response = await mock.handle("DELETE", `/cart/${firstItemId}`);
     });
   });
@@ -144,66 +160,54 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("User session simulation", ({ Given, When, Then, And }) => {
     sessionToken = "";
 
-    Given("I create a session-based mock:", (_, docString: string) => {
-      // Create session-based mock with new callable API
-      const sharedState = { 
-        users: [
-          { username: 'admin', password: 'secret', profile: { name: 'Admin User', role: 'administrator' } },
-          { username: 'user1', password: 'pass123', profile: { name: 'Regular User', role: 'user' } }
-        ],
-        sessions: {} 
-      };
-      
-      mock = schmock({ state: sharedState });
-      
-      mock('POST /auth/login', ({ state, body }) => {
-        const user = state.users.find(u => u.username === body.username && u.password === body.password);
-        
+    Given("I create a session-based authentication mock", () => {
+      const users: UserRecord[] = [
+        { username: "admin", password: "secret", profile: { name: "Admin User", role: "administrator" } },
+        { username: "user1", password: "pass123", profile: { name: "Regular User", role: "user" } },
+      ];
+      const sessions: Record<string, SessionRecord> = {};
+
+      mock = schmock();
+      mock("POST /auth/login", ({ body }) => {
+        const b = body as Record<string, unknown>;
+        const user = users.find((u) => u.username === b.username && u.password === b.password);
         if (!user) {
-          return [401, { error: 'Invalid credentials' }];
+          return [401, { error: "Invalid credentials" }];
         }
-        
-        const token = `token-${user.username}-${Date.now()}`;
-        state.sessions[token] = {
+        const token = "token-" + user.username + "-" + Date.now();
+        sessions[token] = {
           user: user.username,
           profile: user.profile,
-          loginTime: new Date().toISOString()
+          loginTime: new Date().toISOString(),
         };
-        
         return {
-          message: 'Login successful',
-          token: token,
-          user: user.profile
+          message: "Login successful",
+          token,
+          user: user.profile,
         };
       });
-      
-      mock('GET /profile', ({ state, headers }) => {
-        const token = headers.authorization?.replace('Bearer ', '');
-        
-        if (!token || !state.sessions[token]) {
-          return [401, { error: 'Unauthorized' }];
+      mock("GET /profile", ({ headers }) => {
+        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
+        if (!token || !sessions[token]) {
+          return [401, { error: "Unauthorized" }];
         }
-        
-        const session = state.sessions[token];
+        const session = sessions[token];
         return {
           user: session.user,
           profile: session.profile,
           loginTime: session.loginTime,
           session: {
-            active: true
-          }
+            active: true,
+          },
         };
       });
-      
-      mock('POST /auth/logout', ({ state, headers }) => {
-        const token = headers.authorization?.replace('Bearer ', '');
-        
-        if (!token || !state.sessions[token]) {
-          return [401, { error: 'Unauthorized' }];
+      mock("POST /auth/logout", ({ headers }) => {
+        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
+        if (!token || !sessions[token]) {
+          return [401, { error: "Unauthorized" }];
         }
-        
-        delete state.sessions[token];
-        return { message: 'Logged out successfully' };
+        delete sessions[token];
+        return { message: "Logged out successfully" };
       });
     });
 
@@ -264,45 +268,37 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Multi-user state isolation", ({ Given, When, Then, And }) => {
-    Given("I create a multi-user counter mock:", (_, docString: string) => {
-      // Create multi-user counter mock with new callable API
-      const sharedState = { counters: {} };
-      mock = schmock({ state: sharedState });
-      
-      mock('POST /counter/:userId/increment', ({ state, params }) => {
+    Given("I create a multi-user counter mock", () => {
+      const counters: Record<string, number> = {};
+
+      mock = schmock();
+      mock("POST /counter/:userId/increment", ({ params }) => {
         const userId = params.userId;
-        
-        if (!state.counters[userId]) {
-          state.counters[userId] = 0;
+        if (!counters[userId]) {
+          counters[userId] = 0;
         }
-        
-        state.counters[userId]++;
-        
+        counters[userId]++;
         return {
-          userId: userId,
-          count: state.counters[userId],
-          message: `Counter incremented for user ${userId}`
+          userId,
+          count: counters[userId],
+          message: "Counter incremented for user " + userId,
         };
       });
-      
-      mock('GET /counter/:userId', ({ state, params }) => {
+      mock("GET /counter/:userId", ({ params }) => {
         const userId = params.userId;
-        const count = state.counters[userId] || 0;
-        
+        const count = counters[userId] || 0;
         return {
-          userId: userId,
-          count: count
+          userId,
+          count,
         };
       });
-      
-      mock('GET /counters/summary', ({ state }) => {
-        const totalCount = Object.values(state.counters).reduce((sum: number, count: number) => sum + count, 0);
-        const userCount = Object.keys(state.counters).length;
-        
+      mock("GET /counters/summary", () => {
+        const totalCount = Object.values(counters).reduce((sum, count) => sum + count, 0);
+        const userCount = Object.keys(counters).length;
         return {
           totalCounts: totalCount,
           totalUsers: userCount,
-          counters: state.counters
+          counters,
         };
       });
     });
@@ -321,31 +317,37 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
       const response = await mock.handle("GET", `/counter/${userId}`);
-      expect(response.body.count).toBe(expectedCount);
+      const body = response.body as { userId: string; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
       const response = await mock.handle("GET", `/counter/${userId}`);
-      expect(response.body.count).toBe(expectedCount);
+      const body = response.body as { userId: string; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("the summary should show {int} total users", async (_, expectedUsers: number) => {
       const response = await mock.handle("GET", "/counters/summary");
-      expect(response.body.totalUsers).toBe(expectedUsers);
+      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
+      expect(body.totalUsers).toBe(expectedUsers);
     });
 
     And("the summary should show total counts of {int}", async (_, expectedTotal: number) => {
       const response = await mock.handle("GET", "/counters/summary");
-      expect(response.body.totalCounts).toBe(expectedTotal);
+      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
+      expect(body.totalCounts).toBe(expectedTotal);
     });
 
     And("each user's state should be independent", async () => {
       const aliceResponse = await mock.handle("GET", "/counter/alice");
       const bobResponse = await mock.handle("GET", "/counter/bob");
-      
-      expect(aliceResponse.body.count).toBe(3);
-      expect(bobResponse.body.count).toBe(2);
-      expect(aliceResponse.body.count).not.toBe(bobResponse.body.count);
+      const aliceBody = aliceResponse.body as { userId: string; count: number };
+      const bobBody = bobResponse.body as { userId: string; count: number };
+
+      expect(aliceBody.count).toBe(3);
+      expect(bobBody.count).toBe(2);
+      expect(aliceBody.count).not.toBe(bobBody.count);
     });
   });
-});
+});

package/src/types.ts

@@ -1,259 +1,20 @@
-/**
- * JSON Schema type (simplified for core package)
- * Full schema support available via @schmock/schema
- */
-export interface JSONSchema {
-  type?: string | string[];
-  properties?: Record<string, JSONSchema>;
-  items?: JSONSchema | JSONSchema[];
-  required?: string[];
-  enum?: any[];
-  const?: any;
-  [key: string]: any;
-}
-
-/**
- * HTTP methods supported by Schmock
- */
-export type HttpMethod =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "DELETE"
-  | "PATCH"
-  | "HEAD"
-  | "OPTIONS";
-
-/**
- * Route key format: 'METHOD /path'
- *
- * @example
- * 'GET /users'
- * 'POST /users/:id'
- * 'DELETE /api/posts/:postId/comments/:commentId'
- */
-export type RouteKey = `${HttpMethod} ${string}`;
-
-/**
- * Plugin interface for extending Schmock functionality
- */
-export interface Plugin {
-  /** Unique plugin identifier */
-  name: string;
-  /** Plugin version (semver) */
-  version?: string;
-
-  /**
-   * Process the request through this plugin
-   * First plugin to set response becomes the generator, others transform
-   * @param context - Plugin context with request details
-   * @param response - Response from previous plugin (if any)
-   * @returns Updated context and response
-   */
-  process(
-    context: PluginContext,
-    response?: any,
-  ): PluginResult | Promise<PluginResult>;
-
-  /**
-   * Called when an error occurs
-   * Can handle, transform, or suppress errors
-   * @param error - The error that occurred
-   * @param context - Plugin context
-   * @returns Modified error, response data, or void to continue error propagation
-   */
-  onError?(
-    error: Error,
-    context: PluginContext,
-  ):
-    | Error
-    | ResponseResult
-    | undefined
-    | Promise<Error | ResponseResult | undefined>;
-}
-
-/**
- * Result returned by plugin process method
- */
-export interface PluginResult {
-  /** Updated context */
-  context: PluginContext;
-  /** Response data (if generated/modified) */
-  response?: any;
-}
-
-/**
- * Context passed through plugin pipeline
- */
-export interface PluginContext {
-  /** Request path */
-  path: string;
-  /** Matched route configuration */
-  route: any;
-  /** HTTP method */
-  method: HttpMethod;
-  /** Route parameters */
-  params: Record<string, string>;
-  /** Query parameters */
-  query: Record<string, string>;
-  /** Request headers */
-  headers: Record<string, string>;
-  /** Request body */
-  body?: any;
-  /** Shared state between plugins for this request */
-  state: Map<string, any>;
-  /** Route-specific state */
-  routeState?: any;
-}
-
-/**
- * Global configuration options for the mock instance
- */
-export interface GlobalConfig {
-  /** Base path prefix for all routes */
-  namespace?: string;
-  /** Response delay in ms, or [min, max] for random delay */
-  delay?: number | [number, number];
-  /** Enable debug mode for detailed logging */
-  debug?: boolean;
-  /** Initial shared state object */
-  state?: any;
-}
-
-/**
- * Route-specific configuration options
- */
-export interface RouteConfig {
-  /** MIME type for content type validation (auto-detected if not provided) */
-  contentType?: string;
-  /** Additional route-specific options */
-  [key: string]: any;
-}
-
-/**
- * Generator types that can be passed to route definitions
- */
-export type Generator = GeneratorFunction | StaticData | JSONSchema;
-
-/**
- * Function that generates responses
- */
-export type GeneratorFunction = (
-  context: RequestContext,
-) => ResponseResult | Promise<ResponseResult>;
-
-/**
- * Static data (non-function) that gets returned as-is
- */
-export type StaticData = any;
-
-/**
- * Context passed to generator functions
- */
-export interface RequestContext {
-  /** HTTP method */
-  method: HttpMethod;
-  /** Request path */
-  path: string;
-  /** Route parameters (e.g., :id) */
-  params: Record<string, string>;
-  /** Query string parameters */
-  query: Record<string, string>;
-  /** Request headers */
-  headers: Record<string, string>;
-  /** Request body (for POST, PUT, PATCH) */
-  body?: any;
-  /** Shared mutable state */
-  state: any;
-}
-
-/**
- * Response result types:
- * - Any value: returns as 200 OK
- * - [status, body]: custom status with body
- * - [status, body, headers]: custom status, body, and headers
- */
-export type ResponseResult =
-  | any
-  | [number, any]
-  | [number, any, Record<string, string>];
-
-/**
- * Response object returned by handle method
- */
-export interface Response {
-  status: number;
-  body: any;
-  headers: Record<string, string>;
-}
-
-/**
- * Options for handle method
- */
-export interface RequestOptions {
-  headers?: Record<string, string>;
-  body?: any;
-  query?: Record<string, string>;
-}
-
-/**
- * Main callable mock instance interface
- */
-export interface CallableMockInstance {
-  /**
-   * Define a route by calling the instance directly
-   *
-   * @param route - Route pattern in format 'METHOD /path'
-   * @param generator - Response generator (function, static data, or schema)
-   * @param config - Route-specific configuration
-   * @returns The same instance for method chaining
-   *
-   * @example
-   * ```typescript
-   * const mock = schmock()
-   * mock('GET /users', () => [...users], { contentType: 'application/json' })
-   * mock('POST /users', userData, { contentType: 'application/json' })
-   * ```
-   */
-  (
-    route: RouteKey,
-    generator: Generator,
-    config?: RouteConfig,
-  ): CallableMockInstance;
-
-  /**
-   * Add a plugin to the pipeline
-   *
-   * @param plugin - Plugin to add to the pipeline
-   * @returns The same instance for method chaining
-   *
-   * @example
-   * ```typescript
-   * mock('GET /users', generator, config)
-   *   .pipe(authPlugin())
-   *   .pipe(corsPlugin())
-   * ```
-   */
-  pipe(plugin: Plugin): CallableMockInstance;
-
-  /**
-   * Handle a request and return a response
-   *
-   * @param method - HTTP method
-   * @param path - Request path
-   * @param options - Request options (headers, body, query)
-   * @returns Promise resolving to response object
-   *
-   * @example
-   * ```typescript
-   * const response = await mock.handle('GET', '/users', {
-   *   headers: { 'Authorization': 'Bearer token' }
-   * })
-   * ```
-   */
-  handle(
-    method: HttpMethod,
-    path: string,
-    options?: RequestOptions,
-  ): Promise<Response>;
-}
+/// <reference path="../../../types/schmock.d.ts" />
+
+// Re-export types for internal use
+export type HttpMethod = Schmock.HttpMethod;
+export type RouteKey = Schmock.RouteKey;
+export type ResponseBody = Schmock.ResponseBody;
+export type ResponseResult = Schmock.ResponseResult;
+export type RequestContext = Schmock.RequestContext;
+export type Response = Schmock.Response;
+export type RequestOptions = Schmock.RequestOptions;
+export type GlobalConfig = Schmock.GlobalConfig;
+export type RouteConfig = Schmock.RouteConfig;
+export type Generator = Schmock.Generator;
+export type GeneratorFunction = Schmock.GeneratorFunction;
+export type CallableMockInstance = Schmock.CallableMockInstance;
+export type Plugin = Schmock.Plugin;
+export type PluginContext = Schmock.PluginContext;
+export type PluginResult = Schmock.PluginResult;
+export type StaticData = Schmock.StaticData;
+export type RequestRecord = Schmock.RequestRecord;