@constructive-io/graphql-codegen 2.17.11

package/esm/codegen.js

@@ -0,0 +1,227 @@
+import { promises as fs } from 'fs';
+import { join, dirname, isAbsolute, resolve } from 'path';
+import { buildSchema, buildClientSchema, graphql, getIntrospectionQuery, print } from 'graphql';
+const inflection = require('inflection');
+import { generate as generateGql } from './gql';
+import { parseGraphQuery } from 'introspectron';
+import { defaultGraphQLCodegenOptions, mergeGraphQLCodegenOptions } from './options';
+import { codegen as runCoreCodegen } from '@graphql-codegen/core';
+import * as typescriptPlugin from '@graphql-codegen/typescript';
+import * as typescriptOperationsPlugin from '@graphql-codegen/typescript-operations';
+import * as typescriptGraphqlRequestPlugin from '@graphql-codegen/typescript-graphql-request';
+import * as typescriptReactQueryPlugin from '@graphql-codegen/typescript-react-query';
+import { GraphQLClient } from 'graphql-request';
+import { parse } from '@babel/parser';
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+function addDocumentNodeImport(code) {
+    const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['typescript']
+    });
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('DocumentNode'), t.identifier('DocumentNode'))], t.stringLiteral('graphql'));
+    importDecl.importKind = 'type';
+    ast.program.body.unshift(importDecl);
+    const output = generate(ast, {}, code);
+    return output.code;
+}
+function getFilename(key, convention) {
+    if (convention === 'underscore')
+        return inflection.underscore(key);
+    if (convention === 'dashed')
+        return inflection.underscore(key).replace(/_/g, '-');
+    if (convention === 'camelUpper')
+        return inflection.camelize(key, false);
+    return key;
+}
+async function ensureDir(p) {
+    await fs.mkdir(p, { recursive: true });
+}
+async function readFileUTF8(p) {
+    return fs.readFile(p, 'utf8');
+}
+async function writeFileUTF8(p, content) {
+    await ensureDir(dirname(p));
+    await fs.writeFile(p, content, 'utf8');
+}
+async function getIntrospectionFromSDL(schemaPath) {
+    const sdl = await readFileUTF8(schemaPath);
+    const schema = buildSchema(sdl);
+    const q = getIntrospectionQuery();
+    const res = await graphql({ schema, source: q });
+    return res.data;
+}
+async function getIntrospectionFromEndpoint(endpoint, headers) {
+    const client = new GraphQLClient(endpoint, { headers });
+    const q = getIntrospectionQuery();
+    const res = await client.request(q);
+    return res;
+}
+function generateKeyedObjFromGqlMap(gqlMap) {
+    const gen = generateGql(gqlMap);
+    return Object.entries(gen).reduce((acc, [key, val]) => {
+        if (val?.ast)
+            acc[key] = print(val.ast);
+        return acc;
+    }, {});
+}
+function applyQueryFilters(map, docs) {
+    const allow = (docs.allowQueries || []).filter(Boolean);
+    const exclude = (docs.excludeQueries || []).filter(Boolean);
+    const patterns = (docs.excludePatterns || []).filter(Boolean);
+    let keys = Object.keys(map);
+    if (allow.length > 0)
+        keys = keys.filter((k) => allow.includes(k));
+    if (exclude.length > 0)
+        keys = keys.filter((k) => !exclude.includes(k));
+    if (patterns.length > 0) {
+        const regs = patterns.map((p) => {
+            try {
+                return new RegExp(p);
+            }
+            catch {
+                return null;
+            }
+        }).filter((r) => !!r);
+        keys = keys.filter((k) => !regs.some((r) => r.test(k)));
+    }
+    return keys.reduce((acc, k) => {
+        acc[k] = map[k];
+        return acc;
+    }, {});
+}
+async function writeOperationsDocuments(docs, dir, format, convention) {
+    await ensureDir(dir);
+    const index = [];
+    for (const key of Object.keys(docs)) {
+        const filename = getFilename(key, convention) + (format === 'ts' ? '.ts' : '.gql');
+        if (format === 'ts') {
+            const code = `import gql from 'graphql-tag'\nexport const ${key} = gql\`\n${docs[key]}\n\``;
+            await writeFileUTF8(join(dir, filename), code);
+            index.push(`export * from './${filename}'`);
+        }
+        else {
+            await writeFileUTF8(join(dir, filename), docs[key]);
+        }
+    }
+    if (format === 'ts')
+        await writeFileUTF8(join(dir, 'index.ts'), index.sort().join('\n'));
+}
+export async function runCodegen(opts, cwd) {
+    const options = {
+        input: { ...(defaultGraphQLCodegenOptions.input), ...(opts.input || {}) },
+        output: { ...(defaultGraphQLCodegenOptions.output), ...(opts.output || {}) },
+        documents: { ...(defaultGraphQLCodegenOptions.documents), ...(opts.documents || {}) },
+        features: { ...(defaultGraphQLCodegenOptions.features), ...(opts.features || {}) }
+    };
+    const root = join(cwd, options.output.root);
+    const typesFile = join(root, options.output.typesFile);
+    const operationsDir = join(root, options.output.operationsDir);
+    const sdkFile = join(root, options.output.sdkFile);
+    const reactQueryFile = join(root, options.output.reactQueryFile || 'react-query.ts');
+    const hasSchemaPath = !!options.input.schema && options.input.schema.trim() !== '';
+    const hasEndpoint = !!options.input.endpoint && options.input.endpoint.trim() !== '';
+    const schemaPath = hasSchemaPath ? (isAbsolute(options.input.schema) ? options.input.schema : resolve(cwd, options.input.schema)) : '';
+    const introspection = hasEndpoint
+        ? await getIntrospectionFromEndpoint(options.input.endpoint, options.input.headers || {})
+        : await getIntrospectionFromSDL(schemaPath);
+    const { queries, mutations } = parseGraphQuery(introspection);
+    const gqlMap = applyQueryFilters({ ...queries, ...mutations }, options.documents);
+    let docs = {};
+    const schema = hasEndpoint
+        ? buildClientSchema(introspection)
+        : buildSchema(await readFileUTF8(schemaPath));
+    if (options.features.emitOperations || options.features.emitSdk || options.features.emitReactQuery) {
+        docs = generateKeyedObjFromGqlMap(gqlMap);
+    }
+    if (options.features.emitOperations) {
+        await writeOperationsDocuments(docs, operationsDir, options.documents.format, options.documents.convention);
+    }
+    if (options.features.emitTypes) {
+        const typesContent = await runCoreCodegen({
+            filename: typesFile,
+            schema: schema,
+            documents: [],
+            config: {},
+            plugins: [{ typescript: {} }],
+            pluginMap: { typescript: typescriptPlugin }
+        });
+        await writeFileUTF8(typesFile, typesContent);
+    }
+    if (options.features.emitSdk) {
+        const documents = [];
+        for (const [name, content] of Object.entries(docs)) {
+            try {
+                const doc = require('graphql').parse(content);
+                documents.push({ location: name, document: doc });
+            }
+            catch (e) { }
+        }
+        const sdkContent = await runCoreCodegen({
+            filename: sdkFile,
+            schema: schema,
+            documents,
+            config: {},
+            plugins: [
+                { typescript: {} },
+                { 'typescript-operations': {} },
+                { 'typescript-graphql-request': {} }
+            ],
+            pluginMap: {
+                typescript: typescriptPlugin,
+                'typescript-operations': typescriptOperationsPlugin,
+                'typescript-graphql-request': typescriptGraphqlRequestPlugin
+            }
+        });
+        // Fix TS2742: Add missing DocumentNode import using Babel AST
+        const sdkContentWithImport = addDocumentNodeImport(sdkContent);
+        await writeFileUTF8(sdkFile, sdkContentWithImport);
+    }
+    if (options.features.emitReactQuery) {
+        const documents = [];
+        for (const [name, content] of Object.entries(docs)) {
+            try {
+                const doc = require('graphql').parse(content);
+                documents.push({ location: name, document: doc });
+            }
+            catch (e) { }
+        }
+        const rqConfig = {
+            fetcher: options.reactQuery?.fetcher || 'graphql-request',
+            legacyMode: options.reactQuery?.legacyMode || false,
+            exposeDocument: options.reactQuery?.exposeDocument || false,
+            addInfiniteQuery: options.reactQuery?.addInfiniteQuery || false
+        };
+        const rqContent = await runCoreCodegen({
+            filename: reactQueryFile,
+            schema: schema,
+            documents,
+            config: rqConfig,
+            plugins: [
+                { typescript: {} },
+                { 'typescript-operations': {} },
+                { 'typescript-react-query': rqConfig }
+            ],
+            pluginMap: {
+                typescript: typescriptPlugin,
+                'typescript-operations': typescriptOperationsPlugin,
+                'typescript-react-query': typescriptReactQueryPlugin
+            }
+        });
+        await writeFileUTF8(reactQueryFile, rqContent);
+    }
+    return { root, typesFile, operationsDir, sdkFile };
+}
+export async function runCodegenFromJSONConfig(configPath, cwd) {
+    const path = isAbsolute(configPath) ? configPath : resolve(cwd, configPath);
+    const content = await readFileUTF8(path);
+    let overrides = {};
+    try {
+        overrides = JSON.parse(content);
+    }
+    catch (e) {
+        throw new Error('Invalid JSON config: ' + e);
+    }
+    const merged = mergeGraphQLCodegenOptions(defaultGraphQLCodegenOptions, overrides);
+    return runCodegen(merged, cwd);
+}