@manot40/genql-cli 1.0.0 → 1.0.2

package/dist/main-BVWRj669.mjs

@@ -1,798 +0,0 @@
-import { Listr } from "listr2";
-import fsx from "fs-extra";
-import url from "node:url";
-import path, { resolve } from "node:path";
-import { assertValidSchema, buildClientSchema, getIntrospectionQuery, getNamedType, isEnumType, isInputObjectType, isInterfaceType, isListType, isNamedType, isNonNullType, isObjectType, isScalarType, isUnionType, lexicographicSortSchema, printSchema } from "graphql";
-import lodashCamelCase from "lodash-es/camelCase.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { mkdirp } from "mkdirp";
-import { rimraf } from "rimraf";
-import path$1 from "path";
-import uniq from "lodash-es/uniq.js";
-import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
-import { stringifyQuery } from "ufo";
-import { loadSchema } from "@graphql-tools/load";
-
-//#region src/utils.ts
-function camelCase(str) {
-	if (!str) return str;
-	if (str.startsWith("_")) {
-		const leadingChars = str.match(/^_+/);
-		return leadingChars[0] + lodashCamelCase(str.slice(leadingChars[0].length));
-	}
-	if (str.endsWith("_")) {
-		const leadingChars = str.match(/_+$/);
-		return lodashCamelCase(str.slice(0, str.length - leadingChars[0].length)) + leadingChars[0];
-	}
-	return lodashCamelCase(str);
-}
-function capitalize(str) {
-	if (!str) return str;
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-//#endregion
-//#region src/helpers/files.ts
-const ensurePath = async (path$2, clear = false) => {
-	if (clear) await rimraf(resolve(...path$2));
-	await mkdirp(resolve(...path$2));
-};
-const writeFileToPath = async (path$2, content) => {
-	await mkdir(resolve(...path$2, ".."), { recursive: true });
-	await writeFile(resolve(...path$2), content, "utf-8");
-};
-
-//#endregion
-//#region src/config.ts
-const RUNTIME_LIB_NAME = "./runtime";
-
-//#endregion
-//#region src/render/requestTypes/requestTypeName.ts
-const requestTypeName = (type) => {
-	if (!type) return "";
-	return `${type.name}GenqlSelection`;
-};
-
-//#endregion
-//#region src/render/client/renderClient.ts
-const renderClientCode = (ctx) => {
-	const url$1 = ctx.config?.endpoint ? `"${ctx.config.endpoint}"` : "undefined";
-	const fetchImport = ctx.config?.fetchImport;
-	return `
-function(options${url$1 ? "?" : ""}: ClientOptions): Client {
-  return createClientOriginal({
-      url: ${url$1},
-      ${fetchImport ? `fetch,` : ""}
-      ...options,
-      queryRoot: typeMap.Query!,
-      mutationRoot: typeMap.Mutation!,
-      subscriptionRoot: typeMap.Subscription!,
-  }) as any
-}`;
-};
-const renderClientEsm = (schema, ctx) => {
-	const queryType = schema.getQueryType();
-	const mutationType = schema.getMutationType();
-	const subscriptionType = schema.getSubscriptionType();
-	const fetchImport = ctx.config?.fetchImport || "";
-	ctx.addCodeBlock(`
-${fetchImport}
-${renderClientTypesImports({
-		mutationType,
-		queryType,
-		subscriptionType
-	})}
-  import {
-      linkTypeMap,
-      createClient as createClientOriginal,
-      generateGraphqlOperation,
-      type FieldsSelection, type GraphqlOperation, type ClientOptions, GenqlError
-  } from '${RUNTIME_LIB_NAME}'
-  export type { FieldsSelection } from '${RUNTIME_LIB_NAME}'
-  export { GenqlError }
-
-  import types from './types'
-  export * from './schema'
-  const typeMap = linkTypeMap(types as any)
-
-  ${renderClientType({
-		mutationType,
-		queryType,
-		subscriptionType
-	})}
-
-  export const createClient = ${renderClientCode(ctx)}
-
-  export const everything = {
-    __scalar: true
-  }
-  `);
-	if (queryType) ctx.addCodeBlock(`
-        export type QueryResult<fields extends ${requestTypeName(queryType)}> = FieldsSelection<${queryType.name}, fields>
-        export const generateQueryOp: (fields: ${requestTypeName(queryType)} & { __name?: string }) => GraphqlOperation = function(fields) {
-        return generateGraphqlOperation('query', typeMap.Query!, fields as any)
-      }
-    `);
-	if (mutationType) ctx.addCodeBlock(`
-        export type MutationResult<fields extends ${requestTypeName(mutationType)}> = FieldsSelection<${mutationType.name}, fields>
-        export const generateMutationOp: (fields: ${requestTypeName(mutationType)} & { __name?: string }) => GraphqlOperation = function(fields) {
-        return generateGraphqlOperation('mutation', typeMap.Mutation!, fields as any)
-      }
-    `);
-	if (subscriptionType) ctx.addCodeBlock(`
-        export type SubscriptionResult<fields extends ${requestTypeName(subscriptionType)}> = FieldsSelection<${subscriptionType.name}, fields>
-        export const generateSubscriptionOp: (fields: ${requestTypeName(subscriptionType)} & { __name?: string }) => GraphqlOperation = function(fields) {
-        return generateGraphqlOperation('subscription', typeMap.Subscription!, fields as any)
-      }
-    `);
-};
-function renderClientTypesImports({ queryType, mutationType, subscriptionType }) {
-	const imports = [];
-	if (queryType) imports.push(requestTypeName(queryType), queryType.name);
-	if (mutationType) imports.push(requestTypeName(mutationType), mutationType.name);
-	if (subscriptionType) imports.push(requestTypeName(subscriptionType), subscriptionType.name);
-	if (imports.length > 0) return `import type {${imports.join(",")}} from './schema'`;
-	return "";
-}
-function renderClientType({ queryType, mutationType, subscriptionType }) {
-	let interfaceContent = "";
-	if (queryType) interfaceContent += `
-      query<R extends ${requestTypeName(queryType)}>(
-          request: R & { __name?: string },
-      ): Promise<FieldsSelection<${queryType.name}, R>>
-      `;
-	if (mutationType) interfaceContent += `
-      mutation<R extends ${requestTypeName(mutationType)}>(
-          request: R & { __name?: string },
-      ): Promise<FieldsSelection<${mutationType.name}, R>>
-      `;
-	return `
-  export interface Client {
-      ${interfaceContent}
-  }
-  `;
-}
-
-//#endregion
-//#region src/render/common/excludedTypes.ts
-const excludedTypes = [
-	"__Schema",
-	"__Type",
-	"__TypeKind",
-	"__Field",
-	"__InputValue",
-	"__EnumValue",
-	"__Directive",
-	"__DirectiveLocation"
-];
-
-//#endregion
-//#region src/helpers/prettify.ts
-function prettify(code, parser) {
-	const hasPrettier = import.meta.resolve("prettier");
-	if (parser === "skip" || !hasPrettier) return code;
-	return new Promise(async (resolve$1, reject) => {
-		try {
-			const prettier = await import("prettier/standalone.js").then(({ default: mod }) => mod);
-			const parserTS = await import("prettier/plugins/typescript.js").then(({ default: mod }) => mod);
-			const parserEstree = await import("prettier/plugins/estree.js").then(({ default: mod }) => mod);
-			const parserGraphQL = await import("prettier/plugins/graphql.js").then(({ default: mod }) => mod);
-			resolve$1(await prettier.format(code, {
-				parser,
-				plugins: [
-					parserGraphQL,
-					parserTS,
-					parserEstree
-				],
-				semi: false,
-				singleQuote: true,
-				trailingComma: "all",
-				printWidth: 80
-			}));
-		} catch (e) {
-			reject(e);
-		}
-	});
-}
-
-//#endregion
-//#region src/render/common/relativeImportPath.ts
-const relativeImportPath = (from, to) => {
-	const fromResolved = path$1.relative(from, to);
-	return fromResolved[0] === "." ? fromResolved : `./${fromResolved}`;
-};
-
-//#endregion
-//#region src/render/common/RenderContext.ts
-var RenderContext = class {
-	codeBlocks = [];
-	imports = {};
-	importAliasCounter = 0;
-	constructor(schema, config) {
-		this.schema = schema;
-		this.config = config;
-	}
-	addCodeBlock(block) {
-		if (block) this.codeBlocks.push(block);
-	}
-	addImport(from, isDefault, module, fromAbsolute, noAlias) {
-		if (this.config && this.config.output) from = fromAbsolute ? from : relativeImportPath(this.config.output, from);
-		if (!this.imports[from]) this.imports[from] = [];
-		const imports = this.imports[from];
-		const existing = imports.find((i) => isDefault && i.isDefault || !isDefault && i.module === module);
-		if (existing) return existing.alias;
-		this.importAliasCounter++;
-		const alias = noAlias ? void 0 : `a${this.importAliasCounter}`;
-		imports.push({
-			isDefault,
-			module,
-			alias
-		});
-		return alias;
-	}
-	getImportBlock() {
-		const imports = [];
-		Object.keys(this.imports).forEach((from) => {
-			let defaultImport = this.imports[from].find((i) => i.isDefault);
-			const namedImports = this.imports[from].filter((i) => !i.isDefault);
-			const statements = [];
-			if (defaultImport) statements.push(defaultImport.alias || "");
-			if (namedImports.length > 0) statements.push(`{${namedImports.map((i) => i.alias ? `${i.module} as ${i.alias}` : i.module).join(",")}}`);
-			imports.push(`import ${statements.join(",")} from '${from}'`);
-		});
-		if (imports.length > 0) return imports.join("\n");
-		else return;
-	}
-	toCode(parser, pretty = false) {
-		const blocks = [...this.codeBlocks];
-		if (parser && (parser === "typescript" || parser === "babel")) {
-			const importBlock = this.getImportBlock();
-			if (importBlock) blocks.unshift(importBlock);
-		}
-		if (parser) {
-			const whiteSpaced = blocks.join("\n\n");
-			if (pretty && parser !== "skip") return prettify(whiteSpaced, parser);
-			return whiteSpaced;
-		}
-		return blocks.join("");
-	}
-};
-
-//#endregion
-//#region src/render/common/comment.ts
-const comment = (comment$1) => {
-	const lines = [];
-	if (comment$1.deprecated) lines.push(`@deprecated ${comment$1.deprecated.replace(/\s/g, " ")}`);
-	if (comment$1.text) lines.push(...comment$1.text.split("\n"));
-	return lines.length > 0 ? lines.length === 1 ? `\n/** ${lines[0]} */\n` : `\n/**\n${lines.map((l) => ` * ${l}`).join("\n")}\n */\n` : "";
-};
-const typeComment = (type) => comment({ text: type.description });
-const fieldComment = (field) => comment({
-	deprecated: field.deprecationReason,
-	text: field.description
-});
-const argumentComment = (arg) => comment({ text: arg.description });
-
-//#endregion
-//#region src/render/common/renderTyping.ts
-const renderTyping = (type, nonNull = false, wrap = (x) => x) => {
-	if (isNamedType(type)) {
-		let typeName = type.name;
-		if (isScalarType(type)) typeName = `Scalars['${typeName}']`;
-		const typing = wrap(typeName);
-		return nonNull ? typing : `(${typing} | null)`;
-	}
-	if (isListType(type)) {
-		const typing = `${renderTyping(type.ofType, false, wrap)}[]`;
-		return nonNull ? typing : `(${typing} | null)`;
-	}
-	return renderTyping(type.ofType, true, wrap);
-};
-
-//#endregion
-//#region src/render/common/support.ts
-function sortKeys(obj) {
-	obj = obj || {};
-	const ordered = {};
-	Object.keys(obj).sort().forEach(function(key) {
-		ordered[key] = obj[key];
-	});
-	return ordered;
-}
-
-//#endregion
-//#region src/render/requestTypes/inputObjectType.ts
-const inputObjectType = (type, ctx) => {
-	let fields = type.getFields();
-	if (ctx.config?.sortProperties) fields = sortKeys(fields);
-	const fieldStrings = Object.keys(fields).map((fieldName) => {
-		const field = fields[fieldName];
-		return `${argumentComment(field)}${field.name}${isNonNullType(field.type) && field.defaultValue == null ? ":" : "?:"} ${renderTyping(field.type)}`;
-	});
-	ctx.addCodeBlock(`${typeComment(type)}export interface ${type.name} {${fieldStrings.join(",")}}`);
-};
-
-//#endregion
-//#region src/render/requestTypes/objectType.ts
-const INDENTATION$1 = "    ";
-const objectType$2 = (type, ctx) => {
-	let fields = type.getFields();
-	if (ctx.config?.sortProperties) fields = sortKeys(fields);
-	let fieldStrings = Object.keys(fields).map((fieldName) => {
-		const field = fields[fieldName];
-		const types = [];
-		const resolvedType = getNamedType(field.type);
-		const resolvable = !(isEnumType(resolvedType) || isScalarType(resolvedType));
-		const argsPresent = field.args.length > 0;
-		const argsString = toArgsString(field);
-		const argsOptional = !argsString.match(/[^?]:/);
-		if (argsPresent) if (resolvable) types.push(`(${requestTypeName(resolvedType)} & { __args${argsOptional ? "?" : ""}: ${argsString} })`);
-		else types.push(`{ __args: ${argsString} }`);
-		if (argsOptional && !resolvable) types.push("boolean | number");
-		if (!argsPresent && resolvable) types.push(requestTypeName(resolvedType));
-		return `${fieldComment(field)}${field.name}?: ${types.join(" | ")}`;
-	});
-	if (isInterfaceType(type) && ctx.schema) {
-		let interfaceProperties = ctx.schema.getPossibleTypes(type).map((t) => `on_${t.name}?: ${requestTypeName(t)}`);
-		if (ctx.config?.sortProperties) interfaceProperties = interfaceProperties.sort();
-		fieldStrings = fieldStrings.concat(interfaceProperties);
-	}
-	fieldStrings.push("__typename?: boolean | number");
-	fieldStrings.push("__scalar?: boolean | number");
-	fieldStrings = fieldStrings.map((x) => x.split("\n").filter(Boolean).map((l) => INDENTATION$1 + l).join("\n"));
-	ctx.addCodeBlock(`${typeComment(type)}export interface ${requestTypeName(type)}{\n${fieldStrings.join("\n")}\n}`);
-};
-const toArgsString = (field) => {
-	return `{${field.args.map((a) => `${argumentComment(a)}${a.name}${isNonNullType(a.type) && a.defaultValue == null ? ":" : "?:"} ${renderTyping(a.type)}`).join(", ")}}`;
-};
-
-//#endregion
-//#region src/render/requestTypes/unionType.ts
-const unionType$2 = (type, ctx) => {
-	let types = [...type.getTypes()];
-	if (ctx.config?.sortProperties) types = types.sort();
-	const fieldStrings = types.map((t) => `on_${t.name}?:${requestTypeName(t)}`);
-	const commonInterfaces = uniq(types.map((x) => x.getInterfaces()).flat());
-	fieldStrings.push(...commonInterfaces.map((type$1) => {
-		return `on_${type$1.name}?: ${requestTypeName(type$1)}`;
-	}));
-	fieldStrings.push("__typename?: boolean | number");
-	ctx.addCodeBlock(`${typeComment(type)}export interface ${requestTypeName(type)}{\n${fieldStrings.map((x) => "    " + x).join(",\n")}\n}`);
-};
-
-//#endregion
-//#region src/render/requestTypes/renderRequestTypes.ts
-const renderRequestTypes = (schema, ctx) => {
-	let typeMap = schema.getTypeMap();
-	if (ctx.config?.sortProperties) typeMap = sortKeys(typeMap);
-	for (const name in typeMap) {
-		if (excludedTypes.includes(name)) continue;
-		const type = typeMap[name];
-		if (isObjectType(type) || isInterfaceType(type)) objectType$2(type, ctx);
-		if (isInputObjectType(type)) inputObjectType(type, ctx);
-		if (isUnionType(type)) unionType$2(type, ctx);
-	}
-	const aliases = [
-		{
-			type: schema.getQueryType(),
-			name: "QueryGenqlSelection"
-		},
-		{
-			type: schema.getMutationType(),
-			name: "MutationGenqlSelection"
-		},
-		{
-			type: schema.getSubscriptionType(),
-			name: "SubscriptionGenqlSelection"
-		}
-	].map(renderAlias$1).filter(Boolean).join("\n");
-	ctx.addCodeBlock(aliases);
-};
-function renderAlias$1({ type, name }) {
-	if (type && requestTypeName(type) !== name) return `export type ${name} = ${requestTypeName(type)}`;
-	return "";
-}
-
-//#endregion
-//#region src/render/responseTypes/enumType.ts
-const enumType = (type, ctx) => {
-	const values = type.getValues().map((v) => `'${v.name}'`);
-	ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = ${values.join(" | ")}`);
-};
-
-//#endregion
-//#region src/render/responseTypes/objectType.ts
-const INDENTATION = "    ";
-const objectType$1 = (type, ctx) => {
-	let fieldsMap = type.getFields();
-	if (ctx.config?.sortProperties) fieldsMap = sortKeys(fieldsMap);
-	const fields = Object.keys(fieldsMap).map((fieldName) => fieldsMap[fieldName]);
-	if (!ctx.schema) throw new Error("no schema provided");
-	const typeNames = isObjectType(type) ? [type.name] : ctx.schema.getPossibleTypes(type).map((t) => t.name);
-	let fieldStrings = fields.map((f) => {
-		return `${fieldComment(f)}${f.name}: ${renderTyping(f.type)}`;
-	}).concat([`__typename: ${typeNames.length > 0 ? typeNames.map((t) => `'${t}'`).join("|") : "string"}`]);
-	fieldStrings = fieldStrings.map((x) => x.split("\n").filter(Boolean).map((l) => INDENTATION + l).join("\n"));
-	ctx.addCodeBlock(`${typeComment(type)}export interface ${type.name} {\n${fieldStrings.join("\n")}\n}`);
-};
-
-//#endregion
-//#region src/render/responseTypes/typeMappedAlias.ts
-const knownTypes = {
-	Int: "number",
-	Float: "number",
-	String: "string",
-	Boolean: "boolean",
-	ID: "string"
-};
-const getTypeMappedAlias = (type, ctx) => {
-	return {
-		...knownTypes,
-		...ctx?.config?.scalarTypes || {}
-	}?.[type.name] || "any";
-};
-
-//#endregion
-//#region src/render/responseTypes/scalarType.ts
-function renderScalarTypes(ctx, types) {
-	let content = "";
-	types.forEach((type) => {
-		content += `    ${type.name}: ${getTypeMappedAlias(type, ctx)},\n`;
-	});
-	return `export type Scalars = {\n${content}}`;
-}
-
-//#endregion
-//#region src/render/responseTypes/unionType.ts
-const unionType$1 = (type, ctx) => {
-	let typeNames = type.getTypes().map((t) => t.name);
-	if (ctx.config?.sortProperties) typeNames = typeNames.sort();
-	ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = (${typeNames.join(" | ")}) & { __isUnion?: true }`);
-};
-
-//#endregion
-//#region src/render/responseTypes/interfaceType.ts
-const interfaceType = (type, ctx) => {
-	if (!ctx.schema) throw new Error("schema is required to render unionType");
-	const typeNames = ctx.schema.getPossibleTypes(type).map((t) => t.name);
-	if (!typeNames.length) objectType$1(type, ctx);
-	else ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = (${typeNames.join(" | ")}) & { __isUnion?: true }`);
-};
-
-//#endregion
-//#region src/render/responseTypes/renderResponseTypes.ts
-const renderResponseTypes = (schema, ctx) => {
-	let typeMap = schema.getTypeMap();
-	if (ctx.config?.sortProperties) typeMap = sortKeys(typeMap);
-	ctx.addCodeBlock(renderScalarTypes(ctx, Object.values(typeMap).filter((type) => isScalarType(type))));
-	for (const name in typeMap) {
-		if (excludedTypes.includes(name)) continue;
-		const type = typeMap[name];
-		if (isEnumType(type)) enumType(type, ctx);
-		if (isUnionType(type)) unionType$1(type, ctx);
-		if (isObjectType(type)) objectType$1(type, ctx);
-		if (isInterfaceType(type)) interfaceType(type, ctx);
-	}
-	const aliases = [
-		{
-			type: schema.getQueryType(),
-			name: "Query"
-		},
-		{
-			type: schema.getMutationType(),
-			name: "Mutation"
-		},
-		{
-			type: schema.getSubscriptionType(),
-			name: "Subscription"
-		}
-	].map(renderAlias).filter(Boolean).join("\n");
-	ctx.addCodeBlock(aliases);
-};
-function renderAlias({ type, name }) {
-	if (type && type.name !== name) return `export type ${name} = ${type.name}`;
-	return "";
-}
-
-//#endregion
-//#region src/render/schema/renderSchema.ts
-const renderSchema = (schema, ctx) => {
-	ctx.addCodeBlock(printSchema(schema));
-};
-
-//#endregion
-//#region src/render/typeGuards/renderTypeGuards.ts
-const renderTypeGuard = (target, possible) => {
-	return `
-    const ${target}_possibleTypes: string[] = [${possible.map((t) => `'${t}'`).join(",")}]
-    export const is${target} = (obj?: { __typename?: any } | null): obj is ${target} => {
-      if (!obj?.__typename) throw new Error('__typename is missing in "is${target}"')
-      return ${target}_possibleTypes.includes(obj.__typename)
-    }
-    `;
-};
-const renderTypeGuards = (schema, ctx) => {
-	const typeMap = schema.getTypeMap();
-	for (const name in typeMap) {
-		if (excludedTypes.includes(name)) continue;
-		const type = typeMap[name];
-		if (isUnionType(type)) {
-			const types = type.getTypes().map((t) => t.name);
-			ctx.addCodeBlock(renderTypeGuard(type.name, types));
-		} else if (isInterfaceType(type)) {
-			const types = schema.getPossibleTypes(type).map((t) => t.name);
-			ctx.addCodeBlock(renderTypeGuard(type.name, types));
-		} else if (isObjectType(type)) ctx.addCodeBlock(renderTypeGuard(type.name, [type.name]));
-	}
-};
-
-//#endregion
-//#region src/render/typeMap/support.ts
-function isEmpty(x) {
-	if (!x) return true;
-	return Object.keys(x).length === 0;
-}
-
-//#endregion
-//#region src/render/typeMap/objectType.ts
-const objectType = (type, ctx) => {
-	const typeObj = Object.keys(type.getFields()).reduce((r, f) => {
-		const field = type.getFields()[f];
-		const fieldObj = { type: getNamedType(field.type).name };
-		r[f] = fieldObj;
-		const args = field.args || [];
-		if (args.length > 0) fieldObj.args = args.reduce((r$1, a) => {
-			const concreteType = a.type.toString();
-			const typename = getNamedType(a.type).name;
-			r$1[a.name] = [typename];
-			if (typename !== concreteType) r$1[a.name]?.push(concreteType);
-			return r$1;
-		}, {});
-		return r;
-	}, {});
-	if (isInterfaceType(type) && ctx.schema) ctx.schema.getPossibleTypes(type).map((t) => {
-		if (!isEmpty(typeObj)) typeObj[`on_${t.name}`] = { type: t.name };
-	});
-	if (!isEmpty(typeObj)) typeObj.__typename = { type: "String" };
-	return typeObj;
-};
-
-//#endregion
-//#region src/render/typeMap/unionType.ts
-const unionType = (type, _) => {
-	const types = type.getTypes();
-	const typeObj = types.reduce((r, t) => {
-		r[`on_${t.name}`] = { type: t.name };
-		return r;
-	}, {});
-	uniq(types.map((x) => x.getInterfaces()).flat()).forEach((t) => {
-		typeObj[`on_${t.name}`] = { type: t.name };
-	});
-	typeObj.__typename = { type: "String" };
-	return typeObj;
-};
-
-//#endregion
-//#region src/render/typeMap/renderTypeMap.ts
-const renderTypeMap = (schema, ctx) => {
-	const result = {
-		scalars: [],
-		types: {}
-	};
-	Object.keys(schema.getTypeMap()).filter((t) => !excludedTypes.includes(t)).map((t) => schema.getTypeMap()[t]).map((t) => {
-		if (isObjectType(t) || isInterfaceType(t) || isInputObjectType(t)) result.types[t.name] = objectType(t, ctx);
-		else if (isUnionType(t)) result.types[t.name] = unionType(t, ctx);
-		else if (isScalarType(t) || isEnumType(t)) {
-			result.scalars.push(t.name);
-			result.types[t.name] = {};
-		}
-	});
-	const q = schema.getQueryType();
-	if (q?.name && q?.name !== "Query") {
-		delete result.types[q.name];
-		result.types.Query = objectType(q, ctx);
-	}
-	const m = schema.getMutationType();
-	if (m?.name && m.name !== "Mutation") {
-		delete result.types[m.name];
-		result.types.Mutation = objectType(m, ctx);
-	}
-	const s = schema.getSubscriptionType();
-	if (s?.name && s.name !== "Subscription") {
-		delete result.types[s.name];
-		result.types.Subscription = objectType(s, ctx);
-	}
-	ctx.addCodeBlock(JSON.stringify(replaceTypeNamesWithIndexes(result), null, 4));
-};
-function replaceTypeNamesWithIndexes(typeMap) {
-	const nameToIndex = Object.assign({}, ...Object.keys(typeMap.types).map((k, i) => ({ [k]: i })));
-	return {
-		scalars: typeMap.scalars.map((x) => nameToIndex[x]),
-		types: Object.assign({}, ...Object.keys(typeMap.types || {}).map((k) => {
-			const fieldsMap = typeMap.types[k] || {};
-			const fields = Object.assign({}, ...Object.keys(fieldsMap).map((f) => {
-				const content = fieldsMap[f];
-				if (!content) throw new Error("no content in field " + f);
-				const [typeName, args] = [content.type, content.args];
-				const res = [typeName ? nameToIndex[typeName] : -1];
-				if (args) res[1] = Object.assign({}, ...Object.keys(args || {}).map((k$1) => {
-					const arg = args?.[k$1];
-					if (!arg) throw new Error("replaceTypeNamesWithIndexes: no arg for " + k$1);
-					return { [k$1]: [nameToIndex[arg[0]], ...arg.slice(1)] };
-				}));
-				return { [f]: res };
-			}));
-			return { [k]: { ...fields } };
-		}))
-	};
-}
-
-//#endregion
-//#region src/tasks/clientTasks.ts
-const typeMapFileEsm = "types.ts";
-const schemaTypesFile = "schema.ts";
-const schemaGqlFile = "schema.graphql";
-const cliRoot = path.dirname(url.fileURLToPath(import.meta.url));
-const runtimeFolderPath = path.resolve(cliRoot, "runtime");
-const clientTasks = (config) => {
-	const clientFileEsm = "index.ts";
-	if (!config.output) throw new Error("`output` must be defined in the config");
-	const output = config.output;
-	const tasks = [
-		{
-			title: `writing ${schemaGqlFile}`,
-			async task(ctx) {
-				const renderCtx = new RenderContext(ctx.schema, config);
-				renderSchema(ctx.schema, renderCtx);
-				await writeFileToPath([output, schemaGqlFile], await renderCtx.toCode("graphql"));
-			}
-		},
-		{
-			title: `copy runtime files`,
-			async task() {
-				await fsx.ensureDir(path.resolve(output, "runtime"));
-				let files = await fsx.readdir(runtimeFolderPath);
-				for (let file of files) {
-					let contents = await fsx.readFile(path.resolve(runtimeFolderPath, file), "utf-8");
-					contents = "// @ts-nocheck\n" + contents;
-					await fsx.writeFile(path.resolve(output, "runtime", file), contents);
-				}
-			}
-		},
-		{
-			title: `writing ${schemaTypesFile}`,
-			async task(ctx) {
-				const renderCtx = new RenderContext(ctx.schema, config);
-				renderResponseTypes(ctx.schema, renderCtx);
-				renderRequestTypes(ctx.schema, renderCtx);
-				renderTypeGuards(ctx.schema, renderCtx);
-				renderEnumsMaps(ctx.schema, renderCtx);
-				const code = await renderCtx.toCode("typescript");
-				await writeFileToPath([output, schemaTypesFile], "// @ts-nocheck\n/* istanbul ignore file */\n/* tslint:disable */\n/* eslint-disable */\n\n" + code);
-			}
-		},
-		{
-			title: `writing types map`,
-			async task(ctx) {
-				const renderCtx = new RenderContext(ctx.schema, config);
-				renderTypeMap(ctx.schema, renderCtx);
-				const code = await renderCtx.toCode();
-				await writeFileToPath([output, typeMapFileEsm], `export default ${code}`);
-			}
-		},
-		{
-			title: `writing ${clientFileEsm}`,
-			async task(ctx) {
-				const renderCtx = new RenderContext(ctx.schema, config);
-				renderClientEsm(ctx.schema, renderCtx);
-				const code = await renderCtx.toCode("typescript", true);
-				await writeFileToPath([output, clientFileEsm], "// @ts-nocheck\n" + code);
-			}
-		}
-	];
-	return [{
-		title: "preparing client directory",
-		task: () => ensurePath([output], true)
-	}, {
-		title: `writing files`,
-		task() {
-			return new Listr(tasks.filter((x) => Boolean(x)), { concurrent: true });
-		}
-	}];
-};
-function renderEnumsMaps(schema, ctx) {
-	let typeMap = schema.getTypeMap();
-	const enums = [];
-	for (const name in typeMap) {
-		if (excludedTypes.includes(name)) continue;
-		const type = typeMap[name];
-		if (isEnumType(type)) enums.push(type);
-	}
-	if (enums.length === 0) return;
-	ctx.addCodeBlock(enums.map((type) => `export const ${"enum" + capitalize(camelCase(type.name))} = {\n` + type.getValues().map((v) => {
-		if (!v?.name) return "";
-		return `   ${v.name}: '${v.name}' as const`;
-	}).join(",\n") + `\n}\n`).join("\n"));
-}
-
-//#endregion
-//#region src/schema/fetchSchema.ts
-const fetchSchema = async ({ endpoint, usePost = true, headers, timeout = 20 * 1e3, options }) => {
-	let controller = new AbortController();
-	let id = setTimeout(() => {
-		controller.abort();
-	}, timeout);
-	const response = await fetch(usePost ? endpoint : `${endpoint}?${stringifyQuery({ query: getIntrospectionQuery() })}`, {
-		signal: controller.signal,
-		...usePost ? {
-			method: usePost ? "POST" : "GET",
-			body: JSON.stringify({ query: getIntrospectionQuery() }),
-			headers: {
-				...headers,
-				"Content-Type": "application/json"
-			}
-		} : { headers }
-	});
-	clearTimeout(id);
-	if (!response.ok) throw new Error(`introspection for ${endpoint} failed, ${response.status} ${response.statusText}`);
-	const result = await response.json().catch((e) => {
-		const contentType = response.headers.get("Content-Type");
-		throw new Error(`endpoint '${endpoint}' did not return valid json, content type is ${contentType}, check that your endpoint points to a valid graphql api`);
-	});
-	if (!result.data) throw new Error(`introspection for ${endpoint} failed: ${JSON.stringify(result).slice(0, 400)}...`);
-	return buildClientSchema(result.data, options);
-};
-
-//#endregion
-//#region src/tasks/schemaTask.ts
-const schemaTask = (config) => {
-	const processSchema = (schema) => {
-		if (config.sortProperties) return lexicographicSortSchema(schema);
-		return schema;
-	};
-	if (config.endpoint) {
-		const endpoint = config.endpoint;
-		return {
-			title: `fetching schema using ${config.useGet ? "GET" : "POST"} ${endpoint} and headers ${JSON.stringify(config.headers)}`,
-			task: async (ctx) => {
-				ctx.schema = processSchema(await fetchSchema({
-					endpoint,
-					usePost: !config.useGet,
-					headers: config.headers
-				}));
-			}
-		};
-	} else if (config.schema) {
-		const schema = config.schema;
-		return {
-			title: "loading schema",
-			task: async (ctx) => {
-				ctx.schema = processSchema(await loadSchema(schema, { loaders: [new GraphQLFileLoader()] }));
-				try {
-					assertValidSchema(ctx.schema);
-				} catch (e) {
-					if (e["message"] === "Query root type must be provided.") return;
-					throw e;
-				}
-			}
-		};
-	} else throw new Error("either `endpoint`, `fetcher` or `schema` must be defined in the config");
-};
-
-//#endregion
-//#region src/main.ts
-const generate = (config) => {
-	if (!config.output) throw new Error("`output` must be defined in the config");
-	return new Listr([{
-		title: `generating the client in \`${config.output}\``,
-		task: () => new Listr([schemaTask(config), ...clientTasks(config)])
-	}], {
-		renderer: config.verbose ? "verbose" : "default",
-		exitOnError: true
-	}).run().catch((e) => {
-		throw e?.errors?.[0];
-	});
-};
-
-//#endregion
-export { generate as t };