@graphql-codegen/typescript-jit-sdk/cjs/visitor.js

GraphQL Code Generator plugin for generating a ready-to-use SDK that uses GraphQL JIT

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.JitSdkVisitor = void 0;
const tslib_1 = require("tslib");
const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
const graphql_1 = require("graphql");
const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
class JitSdkVisitor extends visitor_plugin_common_1.ClientSideBaseVisitor {
    constructor(schema, fragments, rawConfig) {
        super(schema, fragments, rawConfig, {});
        this._operationsToInclude = [];
        (0, auto_bind_1.default)(this);
        const importType = this.config.useTypeImports ? 'import type' : 'import';
        this._additionalImports.push(`${importType} { GraphQLSchema, ExecutionResult } from 'graphql';`);
        if (this.config.documentMode !== visitor_plugin_common_1.DocumentMode.string &&
            this.config.documentMode !== visitor_plugin_common_1.DocumentMode.graphQLTag) {
            this._additionalImports.push(`${importType} { DocumentNode } from 'graphql';`);
        }
        if (this.config.documentMode === visitor_plugin_common_1.DocumentMode.string) {
            this._additionalImports.push(`import { parse } from 'graphql';`);
        }
        this._additionalImports.push(`import { compileQuery, isCompiledQuery, CompilerOptions } from 'graphql-jit';`);
        this._additionalImports.push(`import { AggregateError, isAsyncIterable, mapAsyncIterator } from '@graphql-tools/utils';`);
    }
    buildOperation(node, documentVariableName, operationType, operationResultType, operationVariablesTypes) {
        if (node.name == null) {
            throw new Error("Plugin 'Jit-sdk' cannot generate SDK for unnamed operation.\n\n" + (0, graphql_1.print)(node));
        }
        else {
            this._operationsToInclude.push({
                node,
                documentVariableName,
                operationType,
                operationResultType,
                operationVariablesTypes,
            });
        }
        return null;
    }
    get sdkContent() {
        const compiledQueries = [];
        const sdkMethods = [];
        let hasSubscription = false;
        for (const o of this._operationsToInclude) {
            const operationName = o.node.name.value;
            const compiledQueryVariableName = `${operationName}Compiled`;
            compiledQueries.push((0, visitor_plugin_common_1.indentMultiline)(`const ${compiledQueryVariableName} = compileQuery(schema, ${this.config.documentMode === visitor_plugin_common_1.DocumentMode.string
                ? `parse(${o.documentVariableName})`
                : o.documentVariableName}, '${operationName}', jitOptions);
if(!(isCompiledQuery(${compiledQueryVariableName}))) {
  const originalErrors = ${compiledQueryVariableName}?.errors?.map(error => error.originalError || error) || [];
  throw new AggregateError(originalErrors, \`Failed to compile ${operationName}: \\n\\t\${originalErrors.join('\\n\\t')}\`);
}`, 2));
            const optionalVariables = !o.node.variableDefinitions ||
                o.node.variableDefinitions.length === 0 ||
                o.node.variableDefinitions.every(v => v.type.kind !== graphql_1.Kind.NON_NULL_TYPE || v.defaultValue);
            const methodName = o.operationType === 'Subscription' ? 'subscribe!' : 'query';
            const handlerName = o.operationType === 'Subscription' ? 'handleSubscriptionResult' : 'handleExecutionResult';
            const returnType = o.operationType === 'Subscription'
                ? `AsyncIterableIterator<${o.operationResultType}> | ${o.operationResultType}`
                : o.operationResultType;
            if (o.operationType === 'Subscription') {
                hasSubscription = true;
            }
            sdkMethods.push((0, visitor_plugin_common_1.indentMultiline)(`async ${operationName}(variables${optionalVariables ? '?' : ''}: ${o.operationVariablesTypes}, context?: TOperationContext, root?: TOperationRoot): Promise<${returnType}> {
  const result = await ${compiledQueryVariableName}.${methodName}({
    ...globalRoot,
    ...root
  }, {
    ...globalContext,
    ...context
  }, variables);
  return ${handlerName}(result, '${operationName}');
}`, 2));
        }
        return `${hasSubscription
            ? `async function handleSubscriptionResult<T>(resultIterator: AsyncIterableIterator<ExecutionResult> | ExecutionResult, operationName: string) {
  if (isAsyncIterable(resultIterator)) {
    return mapAsyncIterator<any, T>(resultIterator, result => handleExecutionResult(result, operationName));
  } else {
    return handleExecutionResult<T>(resultIterator, operationName);
  }
}
`
            : ``}function handleExecutionResult<T>(result: ExecutionResult, operationName: string) {
  if (result.errors) {
    const originalErrors = result.errors.map(error => error.originalError|| error);
    throw new AggregateError(originalErrors, \`Failed to execute \${operationName}: \\n\\t\${originalErrors.join('\\n\\t')}\`);
  }
  return result.data as unknown as T;
}
export interface SdkOptions<TGlobalContext = any, TGlobalRoot = any> {
  globalContext?: TGlobalContext;
  globalRoot?: TGlobalRoot;
  jitOptions?: Partial<CompilerOptions>;
}
export function getSdk<TGlobalContext = any, TGlobalRoot = any, TOperationContext = any, TOperationRoot = any>(schema: GraphQLSchema, { globalContext, globalRoot, jitOptions = {} }: SdkOptions<TGlobalContext, TGlobalRoot> = {}) {
${compiledQueries.join('\n\n')}

  return {
${sdkMethods.join(',\n')}
  };
}
export type Sdk = ReturnType<typeof getSdk>;`;
    }
}
exports.JitSdkVisitor = JitSdkVisitor;