@newmo/graphql-codegen-fake-server-client 0.22.0 → 0.23.0

package/dist/graphql-codegen-fake-server-client.js

@@ -2,11 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = require("./config");
 const convertName_1 = require("./convertName");
+const method_generators_1 = require("./templates/method-generators");
+const runtime_1 = require("./templates/runtime");
 const plugin = {
     plugin(_schema, documents, rawConfig, _info) {
         const config = (0, config_1.normalizeConfig)(rawConfig);
-        const _fakeEndpoint = config.fakeServerEndpoint;
-        const registerOperationResponseType = "{ ok: true } | { ok: false; errors: string[] }"; // Conditional fake types with generic Variables
+        const registerOperationResponseType = "{ ok: true }";
+        // Get runtime code from template function
+        const runtimeCode = (0, runtime_1.getRuntimeCode)();
+        // Conditional fake types with generic Variables
         const conditionRuleTypes = `
 export type FakeClientAlwaysConditionRule = { type: "always" };
 export type FakeClientVariablesConditionRule<TVariables = Record<string, any>> = { type: "variables"; value: TVariables };
@@ -15,227 +19,99 @@ export type FakeClientRegisterSequenceOptions<TVariables = Record<string, any>>
         const indentEachLine = (indent, text) => {
             return text
                 .split("\n")
-                .map((line) => `${indent}${line}`)
+                .map((line) => indent + line)
                 .join("\n");
         };
         const generateFakeClient = (exportsFunctions) => {
             const indent = "  ";
-            return `\
-export type CreateFakeClientOptions = {
-  /** 
-   * The URL of the fake server
-   * @example 'http://localhost:4000/fake'
-   */
-  fakeServerEndpoint: string;
-};
-export function createFakeClient(options: CreateFakeClientOptions) {
-  if(!options.fakeServerEndpoint.endsWith('/fake')) {
-    throw new Error('fakeServerEndpoint must end with "/fake"');
-  }
-  return {
-${exportsFunctions
-                .flatMap((fn) => {
-                if (fn.type === "query") {
-                    return [
-                        indentEachLine(`${indent}${indent}`, generateRegisterOperationMethod(fn.name, "options.fakeServerEndpoint")),
-                        indentEachLine(`${indent}${indent}`, generateRegisterOperationErrorMethod(fn.name, "options.fakeServerEndpoint")),
-                        indentEachLine(`${indent}${indent}`, generateCalledQuery(fn.name, `options.fakeServerEndpoint + "/called"`)),
-                    ];
-                }
-                if (fn.type === "mutation") {
-                    return [
-                        indentEachLine(`${indent}${indent}`, generateRegisterMutationMethod(fn.name, "options.fakeServerEndpoint")),
-                        indentEachLine(`${indent}${indent}`, generateRegisterMutationErrorMethod(fn.name, "options.fakeServerEndpoint")),
-                        indentEachLine(`${indent}${indent}`, generateCalledMutation(fn.name, `options.fakeServerEndpoint + "/called"`)),
-                    ];
-                }
-                throw new Error(`Unknown type${fn}`);
-            })
-                .join(",\n")}
-  };
-}`;
+            // Use runtime code from template
+            return (runtimeCode +
+                "\n\n" +
+                "export function createFakeClient(options: CreateFakeClientOptions) {\n" +
+                "  if(!options.fakeServerEndpoint.endsWith('/fake')) {\n" +
+                "    throw new Error('fakeServerEndpoint must end with \"/fake\"');\n" +
+                "  }\n" +
+                "  \n" +
+                "  // Create request queue for rate limiting\n" +
+                "  const requestQueue = new RequestQueue();\n" +
+                "  \n" +
+                "  return {\n" +
+                exportsFunctions
+                    .flatMap((fn) => {
+                    if (fn.type === "query") {
+                        return [
+                            indentEachLine(indent + indent, generateRegisterOperationMethod(fn.name, "options.fakeServerEndpoint")),
+                            indentEachLine(indent + indent, generateRegisterOperationErrorMethod(fn.name, "options.fakeServerEndpoint")),
+                            indentEachLine(indent + indent, generateCalledQueryMethod(fn.name, 'options.fakeServerEndpoint + "/called"')),
+                        ];
+                    }
+                    if (fn.type === "mutation") {
+                        return [
+                            indentEachLine(indent + indent, generateRegisterMutationMethod(fn.name, "options.fakeServerEndpoint")),
+                            indentEachLine(indent + indent, generateRegisterMutationErrorMethod(fn.name, "options.fakeServerEndpoint")),
+                            indentEachLine(indent + indent, generateCalledMutationMethod(fn.name, 'options.fakeServerEndpoint + "/called"')),
+                        ];
+                    }
+                    throw new Error(`Unknown type${fn}`);
+                })
+                    .join(",\n") +
+                "\n  };\n}");
         };
         const generateRegisterOperationMethod = (name, fakeEndpointVariableName) => {
             const variablesType = `${(0, convertName_1.convertName)(name, config)}QueryVariables`;
-            return `async register${name}QueryResponse(sequenceId:string, queryResponse: ${name}Query, sequenceOptions?: FakeClientRegisterSequenceOptions<${variablesType}>): Promise<${registerOperationResponseType}> {
-    const requestCondition = sequenceOptions?.requestCondition ?? { type: "always" };
-    return await fetch(${fakeEndpointVariableName}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "operation",
-            operationName: "${name}",
-            data: queryResponse,
-            requestCondition: requestCondition
-        }),
-    }).then((res) => res.json()) as ${registerOperationResponseType};
-}`;
+            return (0, method_generators_1.generateRegisterQuery)({
+                name,
+                variablesType,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterOperationErrorMethod = (name, fakeEndpointVariableName) => {
-            return `async register${name}QueryErrorResponse(sequenceId:string, { errors, responseStatusCode }: { errors: Record<string, unknown>[]; responseStatusCode: number }): Promise<${registerOperationResponseType}> {
-    return await fetch(${fakeEndpointVariableName}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "network-error",
-            operationName: "${name}",
-            responseStatusCode,
-            errors
-        }),
-    }).then((res) => res.json()) as ${registerOperationResponseType};
-}`;
+            return (0, method_generators_1.generateRegisterQueryError)({
+                name,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterMutationMethod = (name, fakeEndpointVariableName) => {
             const variablesType = `${(0, convertName_1.convertName)(name, config)}MutationVariables`;
-            return `async register${name}MutationResponse(sequenceId:string, mutationResponse: ${name}Mutation, sequenceOptions?: FakeClientRegisterSequenceOptions<${variablesType}>): Promise<${registerOperationResponseType}> {
-    const requestCondition = sequenceOptions?.requestCondition ?? { type: "always" };
-    return await fetch(${fakeEndpointVariableName}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "operation",
-            operationName: "${name}",
-            data: mutationResponse,
-            requestCondition: requestCondition
-        }),
-    }).then((res) => res.json()) as ${registerOperationResponseType};
-}`;
+            return (0, method_generators_1.generateRegisterMutation)({
+                name,
+                variablesType,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterMutationErrorMethod = (name, fakeEndpointVariableName) => {
-            return `async register${name}MutationErrorResponse(sequenceId:string, { errors, responseStatusCode }: { errors: Record<string, unknown>[]; responseStatusCode: number }): Promise<${registerOperationResponseType}> {
-    return await fetch(${fakeEndpointVariableName}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            type: "network-error",
-            operationName: "${name}",
-            responseStatusCode,
-            errors
-        }),
-    }).then((res) => res.json()) as ${registerOperationResponseType};
-}`;
+            return (0, method_generators_1.generateRegisterMutationError)({
+                name,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
-        const generateCalledQuery = (name, calledEndpoint) => {
-            return `async called${name}Query(sequenceId:string): Promise<{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${(0, convertName_1.convertName)(name, config)}QueryVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${(0, convertName_1.convertName)(name, config)}Query;
-    };
-  }[]            
-}> {
-    return await fetch(${calledEndpoint}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            operationName: "${name}"
-        }),
-    }).then((res) => res.json()) as {
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${(0, convertName_1.convertName)(name, config)}QueryVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${(0, convertName_1.convertName)(name, config)}Query;
-    };
-  }[];
-};
-}`;
+        const generateCalledQueryMethod = (name, calledEndpoint) => {
+            const variablesType = `${(0, convertName_1.convertName)(name, config)}QueryVariables`;
+            return (0, method_generators_1.generateCalledQuery)({
+                name: (0, convertName_1.convertName)(name, config),
+                variablesType,
+                endpoint: calledEndpoint,
+            });
         };
-        const generateCalledMutation = (name, calledEndpoint) => {
-            return `async called${name}Mutation(sequenceId:string): Promise<{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${(0, convertName_1.convertName)(name, config)}MutationVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${(0, convertName_1.convertName)(name, config)}Mutation;
-    };
-  }[];
-}> {
-    return await fetch(${calledEndpoint}, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'sequence-id': sequenceId
-        },
-        body: JSON.stringify({
-            operationName: "${name}"
-        }),
-    }).then((res) => res.json()) as {
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${(0, convertName_1.convertName)(name, config)}MutationVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${(0, convertName_1.convertName)(name, config)}Mutation;
-    };
-  }[];
-}
-}`;
+        const generateCalledMutationMethod = (name, calledEndpoint) => {
+            const variablesType = `${(0, convertName_1.convertName)(name, config)}MutationVariables`;
+            return (0, method_generators_1.generateCalledMutation)({
+                name: (0, convertName_1.convertName)(name, config),
+                variablesType,
+                endpoint: calledEndpoint,
+            });
         };
         const importQueryIdentifierName = (documentName) => {
-            return `import type { ${(0, convertName_1.convertName)(documentName, config)}Query, ${(0, convertName_1.convertName)(documentName, config)}QueryVariables } from '${config.typesFile}';`;
+            return `import type { ${(0, convertName_1.convertName)(documentName, config)}Query, ${(0, convertName_1.convertName)(documentName, config)}QueryVariables } from \'${config.typesFile}\';`;
         };
         const importMutationIdentifierName = (documentName) => {
-            return `import type { ${(0, convertName_1.convertName)(documentName, config)}Mutation, ${(0, convertName_1.convertName)(documentName, config)}MutationVariables } from '${config.typesFile}';`;
+            return `import type { ${(0, convertName_1.convertName)(documentName, config)}Mutation, ${(0, convertName_1.convertName)(documentName, config)}MutationVariables } from \'${config.typesFile}\';`;
         };
-        return `/* eslint-disable */
-// This file was generated by a @newmo/graphql-codegen-fake-server-operation
-${documents
+        const importsSection = documents
             .flatMap((document) => {
             return document.document?.definitions?.map((definition) => {
                 // query
@@ -252,9 +128,8 @@ ${documents
                 return [];
             });
         })
-            .join("\n")}
-${conditionRuleTypes}
-${generateFakeClient(documents.flatMap((document) => {
+            .join("\n");
+        const functionsSection = generateFakeClient(documents.flatMap((document) => {
             const flatMap = document.document?.definitions?.flatMap((definition) => {
                 if (definition.kind === "OperationDefinition" &&
                     definition.operation === "query" &&
@@ -279,8 +154,15 @@ ${generateFakeClient(documents.flatMap((document) => {
                 return [];
             }) ?? [];
             return flatMap;
-        }))}
-`;
+        }));
+        return ("/* eslint-disable */\n" +
+            "// This file was generated by a @newmo/graphql-codegen-fake-server-operation\n" +
+            importsSection +
+            "\n" +
+            conditionRuleTypes +
+            "\n" +
+            functionsSection +
+            "\n");
     },
 };
 // GraphQL Codegen Plugin requires CommonJS export

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

@@ -0,0 +1,141 @@
+"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

@@ -0,0 +1,175 @@
+"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 });
+}`;
+}