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

package/src/graphql-codegen-fake-server-client.ts

@@ -1,12 +1,25 @@
 import type { CodegenPlugin } from "@graphql-codegen/plugin-helpers";
 import { normalizeConfig, type RawPluginConfig } from "./config";
 import { convertName } from "./convertName";
+import {
+    generateCalledMutation,
+    generateCalledQuery,
+    generateRegisterMutation,
+    generateRegisterMutationError,
+    generateRegisterQuery,
+    generateRegisterQueryError,
+} from "./templates/method-generators";
+import { getRuntimeCode } from "./templates/runtime";
 
 const plugin: CodegenPlugin<RawPluginConfig> = {
     plugin(_schema, documents, rawConfig, _info) {
         const config = 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 = 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 };
@@ -24,318 +37,221 @@ export type FakeClientRegisterSequenceOptions<TVariables = Record<string, any>>
         const indentEachLine = (indent: string, text: string) => {
             return text
                 .split("\n")
-                .map((line) => `${indent}${line}`)
+                .map((line) => indent + line)
                 .join("\n");
         };
         const generateFakeClient = (exportsFunctions: GenerateFakeFunction[]) => {
             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: string,
             fakeEndpointVariableName: string,
         ) => {
             const variablesType = `${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 generateRegisterQuery({
+                name,
+                variablesType,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterOperationErrorMethod = (
             name: string,
             fakeEndpointVariableName: string,
         ) => {
-            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 generateRegisterQueryError({
+                name,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterMutationMethod = (name: string, fakeEndpointVariableName: string) => {
             const variablesType = `${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 generateRegisterMutation({
+                name,
+                variablesType,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
         const generateRegisterMutationErrorMethod = (
             name: string,
             fakeEndpointVariableName: string,
         ) => {
-            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 generateRegisterMutationError({
+                name,
+                responseType: registerOperationResponseType,
+                endpoint: fakeEndpointVariableName,
+            });
         };
-        const generateCalledQuery = (name: string, calledEndpoint: string) => {
-            return `async called${name}Query(sequenceId:string): Promise<{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${convertName(name, config)}QueryVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${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: ${convertName(name, config)}QueryVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${convertName(name, config)}Query;
-    };
-  }[];
-};
-}`;
+        const generateCalledQueryMethod = (name: string, calledEndpoint: string) => {
+            const variablesType = `${convertName(name, config)}QueryVariables`;
+            return generateCalledQuery({
+                name: convertName(name, config),
+                variablesType,
+                endpoint: calledEndpoint,
+            });
         };
 
-        const generateCalledMutation = (name: string, calledEndpoint: string) => {
-            return `async called${name}Mutation(sequenceId:string): Promise<{
-  ok: true;
-  data: {
-    requestTimestamp: number;
-    request: {
-      headers: Record<string, unknown>;
-      body: {
-        operationName: string;
-        query: string;
-        variables: ${convertName(name, config)}MutationVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${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: ${convertName(name, config)}MutationVariables;
-      };
-    };
-    response: {
-        statusCode: number;
-        headers: Record<string, unknown>;
-        body: ${convertName(name, config)}Mutation;
-    };
-  }[];
-}
-}`;
+        const generateCalledMutationMethod = (name: string, calledEndpoint: string) => {
+            const variablesType = `${convertName(name, config)}MutationVariables`;
+            return generateCalledMutation({
+                name: convertName(name, config),
+                variablesType,
+                endpoint: calledEndpoint,
+            });
         };
 
         const importQueryIdentifierName = (documentName: string) => {
             return `import type { ${convertName(
                 documentName,
                 config,
-            )}Query, ${convertName(documentName, config)}QueryVariables } from '${config.typesFile}';`;
+            )}Query, ${convertName(documentName, config)}QueryVariables } from \'${config.typesFile}\';`;
         };
         const importMutationIdentifierName = (documentName: string) => {
             return `import type { ${convertName(documentName, config)}Mutation, ${convertName(
                 documentName,
                 config,
-            )}MutationVariables } from '${config.typesFile}';`;
+            )}MutationVariables } from \'${config.typesFile}\';`;
         };
-        return `/* eslint-disable */
-// This file was generated by a @newmo/graphql-codegen-fake-server-operation
-${documents
-    .flatMap((document) => {
-        return document.document?.definitions?.map((definition) => {
-            // query
-            if (
-                definition.kind === "OperationDefinition" &&
-                definition.operation === "query" &&
-                definition.name
-            ) {
-                return importQueryIdentifierName(definition.name.value);
-            }
-            if (
-                definition.kind === "OperationDefinition" &&
-                definition.operation === "mutation" &&
-                definition.name
-            ) {
-                return importMutationIdentifierName(definition.name.value);
-            }
-            return [];
-        });
-    })
-    .join("\n")}
-${conditionRuleTypes}
-${generateFakeClient(
-    documents.flatMap((document) => {
-        const flatMap =
-            document.document?.definitions?.flatMap((definition) => {
-                if (
-                    definition.kind === "OperationDefinition" &&
-                    definition.operation === "query" &&
-                    definition.name
-                ) {
-                    return [
-                        {
-                            name: convertName(definition.name.value, config),
-                            type: "query",
-                        },
-                    ] satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
-                }
-                if (
-                    definition.kind === "OperationDefinition" &&
-                    definition.operation === "mutation" &&
-                    definition.name
-                ) {
-                    return [
-                        {
-                            name: convertName(definition.name.value, config),
-                            type: "mutation",
-                        },
-                    ] satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
-                }
-                return [];
-            }) ?? [];
-        return flatMap satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
-    }),
-)}
-`;
+        const importsSection = documents
+            .flatMap((document) => {
+                return document.document?.definitions?.map((definition) => {
+                    // query
+                    if (
+                        definition.kind === "OperationDefinition" &&
+                        definition.operation === "query" &&
+                        definition.name
+                    ) {
+                        return importQueryIdentifierName(definition.name.value);
+                    }
+                    if (
+                        definition.kind === "OperationDefinition" &&
+                        definition.operation === "mutation" &&
+                        definition.name
+                    ) {
+                        return importMutationIdentifierName(definition.name.value);
+                    }
+                    return [];
+                });
+            })
+            .join("\n");
+
+        const functionsSection = generateFakeClient(
+            documents.flatMap((document) => {
+                const flatMap =
+                    document.document?.definitions?.flatMap((definition) => {
+                        if (
+                            definition.kind === "OperationDefinition" &&
+                            definition.operation === "query" &&
+                            definition.name
+                        ) {
+                            return [
+                                {
+                                    name: convertName(definition.name.value, config),
+                                    type: "query",
+                                },
+                            ] satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
+                        }
+                        if (
+                            definition.kind === "OperationDefinition" &&
+                            definition.operation === "mutation" &&
+                            definition.name
+                        ) {
+                            return [
+                                {
+                                    name: convertName(definition.name.value, config),
+                                    type: "mutation",
+                                },
+                            ] satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
+                        }
+                        return [];
+                    }) ?? [];
+                return flatMap satisfies GenerateFakeFunction[] as GenerateFakeFunction[];
+            }),
+        );
+
+        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