@newmo/graphql-codegen-fake-server-client 0.23.3 → 0.24.1

package/dist/templates/method-generators.js

@@ -178,9 +178,9 @@ function generateCalledQuery(params) {
       };
     };
     response: {
-        statusCode: number;
+        status: number;
         headers: Record<string, unknown>;
-        body: ${params.name}Query;
+        body: { data: ${params.name}Query };
     };
   }[]            
 }`,
@@ -217,9 +217,9 @@ return result as {
             };
         };
         response: {
-            statusCode: number;
+            status: number;
             headers: Record<string, unknown>;
-            body: ${params.name}Query;
+            body: { data: ${params.name}Query };
         };
     }[];
 };`,
@@ -245,9 +245,9 @@ function generateCalledMutation(params) {
       };
     };
     response: {
-        statusCode: number;
+        status: number;
         headers: Record<string, unknown>;
-        body: ${params.name}Mutation;
+        body: { data: ${params.name}Mutation };
     };
   }[];
 }`,
@@ -284,9 +284,9 @@ return result as {
             };
         };
         response: {
-            statusCode: number;
+            status: number;
             headers: Record<string, unknown>;
-            body: ${params.name}Mutation;
+            body: { data: ${params.name}Mutation };
         };
     }[];
 };`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newmo/graphql-codegen-fake-server-client",
-  "version": "0.23.3",
+  "version": "0.24.1",
   "private": false,
   "description": "GraphQL Codegen plugin for generating a fake server client",
   "keywords": [
@@ -62,5 +62,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "fdb857dc72e010f59daa8b274d027d495ddba6f1"
+  "gitHead": "abbdbd8c0dd8eaf96a5b5dc3221a45e03e23aee6"
 }

package/src/templates/method-generators.ts

@@ -203,9 +203,9 @@ export function generateCalledQuery(params: {
       };
     };
     response: {
-        statusCode: number;
+        status: number;
         headers: Record<string, unknown>;
-        body: ${params.name}Query;
+        body: { data: ${params.name}Query };
     };
   }[]            
 }`,
@@ -242,9 +242,9 @@ return result as {
             };
         };
         response: {
-            statusCode: number;
+            status: number;
             headers: Record<string, unknown>;
-            body: ${params.name}Query;
+            body: { data: ${params.name}Query };
         };
     }[];
 };`,
@@ -275,9 +275,9 @@ export function generateCalledMutation(params: {
       };
     };
     response: {
-        statusCode: number;
+        status: number;
         headers: Record<string, unknown>;
-        body: ${params.name}Mutation;
+        body: { data: ${params.name}Mutation };
     };
   }[];
 }`,
@@ -314,9 +314,9 @@ return result as {
             };
         };
         response: {
-            statusCode: number;
+            status: number;
             headers: Record<string, unknown>;
-            body: ${params.name}Mutation;
+            body: { data: ${params.name}Mutation };
         };
     }[];
 };`,

package/dist/runtime/fake-client-runtime.js

@@ -1,141 +0,0 @@
-"use strict";
-// Runtime utilities for generated fake client
-// This file is embedded into the generated code
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestQueue = void 0;
-exports.fetchWithRetry = fetchWithRetry;
-// Request queue implementation for rate limiting
-class RequestQueue {
-    queue = [];
-    running = 0;
-    maxConcurrent = 5; // Reduced default for better stability
-    requestDelay = 10; // Small delay to prevent overwhelming the server
-    lastRequestTime = 0;
-    async add(fn) {
-        return new Promise((resolve, reject) => {
-            this.queue.push(async () => {
-                try {
-                    // Apply request delay if configured
-                    if (this.requestDelay > 0) {
-                        const now = Date.now();
-                        const timeSinceLastRequest = now - this.lastRequestTime;
-                        if (timeSinceLastRequest < this.requestDelay) {
-                            await new Promise(r => setTimeout(r, this.requestDelay - timeSinceLastRequest));
-                        }
-                        this.lastRequestTime = Date.now();
-                    }
-                    const result = await fn();
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            this.process();
-        });
-    }
-    async process() {
-        if (this.running >= this.maxConcurrent || this.queue.length === 0) {
-            return;
-        }
-        this.running++;
-        const fn = this.queue.shift();
-        if (fn) {
-            await fn();
-            this.running--;
-            this.process();
-        }
-    }
-}
-exports.RequestQueue = RequestQueue;
-// Retry helper function with exponential backoff
-async function fetchWithRetry(url, options) {
-    const maxAttempts = 3;
-    const initialDelay = 100;
-    const maxDelay = 2000;
-    const backoffFactor = 2;
-    // Apply HTTP options with sensible defaults
-    const fetchOptions = {
-        ...options,
-        // Enable keepalive for connection reuse
-        keepalive: true,
-        // Set a reasonable timeout (30 seconds)
-        signal: AbortSignal.timeout(30000),
-    };
-    let lastError;
-    let lastResponse;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        try {
-            const response = await fetch(url, fetchOptions);
-            lastResponse = response;
-            // Success (2xx) or client error (4xx) - don't retry
-            if (response.status < 500) {
-                return response;
-            }
-            // Server error (5xx) - should retry
-            if (attempt < maxAttempts - 1) {
-                const requestInfo = {
-                    url,
-                    status: response.status,
-                    statusText: response.statusText,
-                    attempt: attempt + 1,
-                    maxAttempts,
-                    operationName: JSON.parse(options.body)?.operationName,
-                    sequenceId: options.headers?.['sequence-id'],
-                };
-                console.error(`[FakeClient] Server error, will retry:`, requestInfo);
-                // Calculate delay with exponential backoff and jitter
-                const baseDelay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
-                const jitter = Math.random() * 0.1 * baseDelay; // 10% jitter
-                const delay = baseDelay + jitter;
-                console.log(`[FakeClient] Retrying in ${Math.round(delay)}ms...`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                continue;
-            }
-            // Last attempt and still server error
-            return response;
-        }
-        catch (error) {
-            lastError = error;
-            // Determine if error is retryable
-            let shouldRetry = false;
-            let errorType = 'unknown';
-            if (error instanceof TypeError) {
-                // Network errors from fetch (connection failures)
-                shouldRetry = true;
-                errorType = 'network';
-            }
-            else if (error instanceof Error && error.name === 'AbortError') {
-                // Timeout errors
-                shouldRetry = true;
-                errorType = 'timeout';
-            }
-            const requestInfo = {
-                url,
-                errorType,
-                error: error instanceof Error ? error.message : String(error),
-                attempt: attempt + 1,
-                maxAttempts,
-                operationName: JSON.parse(options.body)?.operationName,
-                sequenceId: options.headers?.['sequence-id'],
-            };
-            console.error(`[FakeClient] Request failed:`, requestInfo);
-            if (shouldRetry && attempt < maxAttempts - 1) {
-                // Calculate delay with exponential backoff and jitter
-                const baseDelay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
-                const jitter = Math.random() * 0.1 * baseDelay; // 10% jitter
-                const delay = baseDelay + jitter;
-                console.log(`[FakeClient] Retrying in ${Math.round(delay)}ms...`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                continue;
-            }
-            // Not retryable or max attempts reached
-            throw error;
-        }
-    }
-    // Should not reach here, but just in case
-    if (lastResponse) {
-        return lastResponse;
-    }
-    throw new Error('Max retry attempts reached', { cause: lastError });
-}

package/dist/runtime-template.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuntimeCode = getRuntimeCode;
-/**
- * Returns the runtime code as a string template
- * This is used to embed the runtime code in the generated client
- */
-function getRuntimeCode() {
-    return `// Runtime utilities for generated fake client
-export type CreateFakeClientOptions = {
-  /**
-   * The URL of the fake server
-   * @example 'http://localhost:4000/fake'
-   */
-  fakeServerEndpoint: string;
-};
-
-// Request queue implementation for rate limiting
-class RequestQueue {
-  private queue: Array<() => Promise<any>> = [];
-  private running = 0;
-  private maxConcurrent: number = 5; // Reduced default for better stability
-  private requestDelay: number = 10; // Small delay to prevent overwhelming the server
-  private lastRequestTime = 0;
-
-  async add<T>(fn: () => Promise<T>): Promise<T> {
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          // Apply request delay if configured
-          if (this.requestDelay > 0) {
-            const now = Date.now();
-            const timeSinceLastRequest = now - this.lastRequestTime;
-            if (timeSinceLastRequest < this.requestDelay) {
-              await new Promise(r => setTimeout(r, this.requestDelay - timeSinceLastRequest));
-            }
-            this.lastRequestTime = Date.now();
-          }
-
-          const result = await fn();
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      });
-      this.process();
-    });
-  }
-
-  private async process() {
-    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
-      return;
-    }
-
-    this.running++;
-    const fn = this.queue.shift();
-    if (fn) {
-      await fn();
-      this.running--;
-      this.process();
-    }
-  }
-}
-
-// Retry helper function with exponential backoff
-async function fetchWithRetry(
-  url: string,
-  options: RequestInit
-): Promise<Response> {
-  const maxAttempts = 3;
-  const initialDelay = 100;
-  const maxDelay = 2000;
-  const backoffFactor = 2;
-
-  // Apply HTTP options with sensible defaults
-  const fetchOptions: RequestInit = {
-    ...options,
-    // Enable keepalive for connection reuse
-    keepalive: true,
-    // Set a reasonable timeout (30 seconds)
-    signal: AbortSignal.timeout(30000),
-  };
-
-  let lastError: Error | undefined;
-  let lastResponse: Response | undefined;
-  
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const response = await fetch(url, fetchOptions);
-      lastResponse = response;
-      
-      // Success (2xx) or client error (4xx) - don't retry
-      if (response.status < 500) {
-        return response;
-      }
-      
-      // Server error (5xx) - should retry
-      if (attempt < maxAttempts - 1) {
-        const requestInfo = {
-          url,
-          status: response.status,
-          statusText: response.statusText,
-          attempt: attempt + 1,
-          maxAttempts,
-          operationName: JSON.parse(options.body as string)?.operationName,
-          sequenceId: (options.headers as any)?.['sequence-id'],
-        };
-        
-        console.error(\`[FakeClient] Server error, will retry:\`, requestInfo);
-        
-        // Calculate delay with exponential backoff and jitter
-        const baseDelay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
-        const jitter = Math.random() * 0.1 * baseDelay; // 10% jitter
-        const delay = baseDelay + jitter;
-        
-        console.log(\`[FakeClient] Retrying in \${Math.round(delay)}ms...\`);
-        await new Promise(resolve => setTimeout(resolve, delay));
-        continue;
-      }
-      
-      // Last attempt and still server error
-      return response;
-      
-    } catch (error) {
-      lastError = error as Error;
-      
-      // Determine if error is retryable
-      let shouldRetry = false;
-      let errorType = 'unknown';
-      
-      if (error instanceof TypeError) {
-        // Network errors from fetch (connection failures)
-        shouldRetry = true;
-        errorType = 'network';
-      } else if (error instanceof Error && error.name === 'AbortError') {
-        // Timeout errors
-        shouldRetry = true;
-        errorType = 'timeout';
-      }
-      
-      const requestInfo = {
-        url,
-        errorType,
-        error: error instanceof Error ? error.message : String(error),
-        attempt: attempt + 1,
-        maxAttempts,
-        operationName: JSON.parse(options.body as string)?.operationName,
-        sequenceId: (options.headers as any)?.['sequence-id'],
-      };
-      
-      console.error(\`[FakeClient] Request failed:\`, requestInfo);
-      
-      if (shouldRetry && attempt < maxAttempts - 1) {
-        // Calculate delay with exponential backoff and jitter
-        const baseDelay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
-        const jitter = Math.random() * 0.1 * baseDelay; // 10% jitter
-        const delay = baseDelay + jitter;
-        
-        console.log(\`[FakeClient] Retrying in \${Math.round(delay)}ms...\`);
-        await new Promise(resolve => setTimeout(resolve, delay));
-        continue;
-      }
-      
-      // Not retryable or max attempts reached
-      throw error;
-    }
-  }
-  
-  // Should not reach here, but just in case
-  if (lastResponse) {
-    return lastResponse;
-  }
-  throw new Error('Max retry attempts reached', { cause: lastError });
-}`;
-}

package/dist/template-helpers.js

@@ -1,291 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRegisterQuery = generateRegisterQuery;
-exports.generateRegisterQueryError = generateRegisterQueryError;
-exports.generateRegisterMutation = generateRegisterMutation;
-exports.generateRegisterMutationError = generateRegisterMutationError;
-exports.generateCalledQuery = generateCalledQuery;
-exports.generateCalledMutation = generateCalledMutation;
-/**
- * Helper to indent each line of a string
- */
-function indent(str, spaces = 4) {
-    const indentStr = ' '.repeat(spaces);
-    return str.split('\n').map(line => line ? indentStr + line : line).join('\n');
-}
-/**
- * Helper to create method templates with better readability
- */
-function createMethod(config) {
-    return `async ${config.name}(${config.params}): Promise<${config.returnType}> {
-${indent(config.body)}
-}`;
-}
-/**
- * Generate register query method template
- */
-function generateRegisterQuery(params) {
-    return createMethod({
-        name: `register${params.name}QueryResponse`,
-        params: `sequenceId:string, queryResponse: ${params.name}Query, sequenceOptions?: FakeClientRegisterSequenceOptions<${params.variablesType}>`,
-        returnType: params.responseType,
-        body: `const requestCondition = sequenceOptions?.requestCondition ?? { type: "always" };
-const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "operation",
-            operationName: "${params.name}",
-            data: queryResponse,
-            requestCondition: requestCondition
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to register fake response: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-return result as ${params.responseType};`
-    });
-}
-/**
- * Generate register query error method template
- */
-function generateRegisterQueryError(params) {
-    return createMethod({
-        name: `register${params.name}QueryErrorResponse`,
-        params: `sequenceId:string, { errors, responseStatusCode }: { errors: Record<string, unknown>[]; responseStatusCode: number }`,
-        returnType: params.responseType,
-        body: `const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "network-error",
-            operationName: "${params.name}",
-            responseStatusCode,
-            errors
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to register fake error response: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-return result as ${params.responseType};`
-    });
-}
-/**
- * Generate register mutation method template
- */
-function generateRegisterMutation(params) {
-    return createMethod({
-        name: `register${params.name}MutationResponse`,
-        params: `sequenceId:string, mutationResponse: ${params.name}Mutation, sequenceOptions?: FakeClientRegisterSequenceOptions<${params.variablesType}>`,
-        returnType: params.responseType,
-        body: `const requestCondition = sequenceOptions?.requestCondition ?? { type: "always" };
-const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "operation",
-            operationName: "${params.name}",
-            data: mutationResponse,
-            requestCondition: requestCondition
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to register fake response: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-return result as ${params.responseType};`
-    });
-}
-/**
- * Generate register mutation error method template
- */
-function generateRegisterMutationError(params) {
-    return createMethod({
-        name: `register${params.name}MutationErrorResponse`,
-        params: `sequenceId:string, { errors, responseStatusCode }: { errors: Record<string, unknown>[]; responseStatusCode: number }`,
-        returnType: params.responseType,
-        body: `const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "network-error",
-            operationName: "${params.name}",
-            responseStatusCode,
-            errors
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to register fake error response: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-return result as ${params.responseType};`
-    });
-}
-/**
- * Generate called query method template
- */
-function generateCalledQuery(params) {
-    return createMethod({
-        name: `called${params.name}Query`,
-        params: `sequenceId:string`,
-        returnType: `{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${params.variablesType};
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${params.name}Query;
-    };
-  }[]            
-}`,
-        body: `const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            operationName: "${params.name}"
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to get called data: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-
-return result as {
-    ok: true;
-    data: {
-        requestTimestamp: number;
-        request: {
-            headers: Record<string, unknown>;
-            body: {
-                operationName: string;
-                query: string;
-                variables: ${params.variablesType};
-            };
-        };
-        response: {
-            statusCode: number;
-            headers: Record<string, unknown>;
-            body: ${params.name}Query;
-        };
-    }[];
-};`
-    });
-}
-/**
- * Generate called mutation method template
- */
-function generateCalledMutation(params) {
-    return createMethod({
-        name: `called${params.name}Mutation`,
-        params: `sequenceId:string`,
-        returnType: `{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${params.variablesType};
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${params.name}Mutation;
-    };
-  }[];
-}`,
-        body: `const response = await requestQueue.add(() => fetchWithRetry(
-    ${params.endpoint},
-    {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            operationName: "${params.name}"
-        }),
-    }
-));
-
-const result = await response.json();
-if (!response.ok) {
-    const errorResult = result as { errors?: string[] };
-    throw new Error(\`Failed to get called data: \${response.status} \${response.statusText}\${errorResult.errors ? ' - ' + JSON.stringify(errorResult.errors) : ''}\`);
-}
-
-return result as {
-    ok: true;
-    data: {
-        requestTimestamp: number;
-        request: {
-            headers: Record<string, unknown>;
-            body: {
-                operationName: string;
-                query: string;
-                variables: ${params.variablesType};
-            };
-        };
-        response: {
-            statusCode: number;
-            headers: Record<string, unknown>;
-            body: ${params.name}Mutation;
-        };
-    }[];
-};`
-    });
-}