@soda-gql/codegen 0.0.1

package/dist/generator-t_NByvnv.cjs

@@ -0,0 +1,551 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let graphql = require("graphql");
+graphql = __toESM(graphql);
+
+//#region packages/codegen/src/generator.ts
+const builtinScalarTypes = new Map([
+	["ID", {
+		input: "string",
+		output: "string"
+	}],
+	["String", {
+		input: "string",
+		output: "string"
+	}],
+	["Int", {
+		input: "number",
+		output: "number"
+	}],
+	["Float", {
+		input: "number",
+		output: "number"
+	}],
+	["Boolean", {
+		input: "boolean",
+		output: "boolean"
+	}]
+]);
+const ensureRecord = (collection, key, factory) => {
+	const existing = collection.get(key);
+	if (existing) {
+		return existing;
+	}
+	const created = factory(key);
+	collection.set(key, created);
+	return created;
+};
+const addObjectFields = (target, fields) => {
+	if (!fields) {
+		return;
+	}
+	for (const field of fields) {
+		target.set(field.name.value, field);
+	}
+};
+const addInputFields = (target, fields) => {
+	if (!fields) {
+		return;
+	}
+	for (const field of fields) {
+		target.set(field.name.value, field);
+	}
+};
+const addEnumValues = (target, values) => {
+	if (!values) {
+		return;
+	}
+	for (const value of values) {
+		target.set(value.name.value, value);
+	}
+};
+const addUnionMembers = (target, members) => {
+	if (!members) {
+		return;
+	}
+	for (const member of members) {
+		target.set(member.name.value, member);
+	}
+};
+const mergeDirectives = (existing, incoming, precedence) => {
+	const current = existing ?? [];
+	const next = incoming ? Array.from(incoming) : [];
+	return precedence === "definition" ? [...next, ...current] : [...current, ...next];
+};
+const updateOperationTypes = (operationTypes, definition) => {
+	for (const operation of definition.operationTypes ?? []) {
+		const typeName = operation.type.name.value;
+		switch (operation.operation) {
+			case "query":
+				operationTypes.query = typeName;
+				break;
+			case "mutation":
+				operationTypes.mutation = typeName;
+				break;
+			case "subscription":
+				operationTypes.subscription = typeName;
+				break;
+			default: break;
+		}
+	}
+};
+const createSchemaIndex = (document) => {
+	const objects = new Map();
+	const inputs = new Map();
+	const enums = new Map();
+	const unions = new Map();
+	const scalars = new Map();
+	const operationTypes = {};
+	for (const definition of document.definitions) {
+		switch (definition.kind) {
+			case graphql.Kind.OBJECT_TYPE_DEFINITION:
+			case graphql.Kind.OBJECT_TYPE_EXTENSION: {
+				const precedence = definition.kind === graphql.Kind.OBJECT_TYPE_DEFINITION ? "definition" : "extension";
+				const record = ensureRecord(objects, definition.name.value, (name) => ({
+					name,
+					fields: new Map(),
+					directives: []
+				}));
+				addObjectFields(record.fields, definition.fields);
+				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
+				break;
+			}
+			case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+			case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
+				const precedence = definition.kind === graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION ? "definition" : "extension";
+				const record = ensureRecord(inputs, definition.name.value, (name) => ({
+					name,
+					fields: new Map(),
+					directives: []
+				}));
+				addInputFields(record.fields, definition.fields);
+				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
+				break;
+			}
+			case graphql.Kind.ENUM_TYPE_DEFINITION:
+			case graphql.Kind.ENUM_TYPE_EXTENSION: {
+				const precedence = definition.kind === graphql.Kind.ENUM_TYPE_DEFINITION ? "definition" : "extension";
+				const record = ensureRecord(enums, definition.name.value, (name) => ({
+					name,
+					values: new Map(),
+					directives: []
+				}));
+				addEnumValues(record.values, definition.values);
+				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
+				break;
+			}
+			case graphql.Kind.UNION_TYPE_DEFINITION:
+			case graphql.Kind.UNION_TYPE_EXTENSION: {
+				const precedence = definition.kind === graphql.Kind.UNION_TYPE_DEFINITION ? "definition" : "extension";
+				const record = ensureRecord(unions, definition.name.value, (name) => ({
+					name,
+					members: new Map(),
+					directives: []
+				}));
+				addUnionMembers(record.members, definition.types);
+				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
+				break;
+			}
+			case graphql.Kind.SCALAR_TYPE_DEFINITION:
+			case graphql.Kind.SCALAR_TYPE_EXTENSION: {
+				const precedence = definition.kind === graphql.Kind.SCALAR_TYPE_DEFINITION ? "definition" : "extension";
+				const record = ensureRecord(scalars, definition.name.value, (name) => ({
+					name,
+					directives: []
+				}));
+				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
+				break;
+			}
+			case graphql.Kind.SCHEMA_DEFINITION:
+			case graphql.Kind.SCHEMA_EXTENSION:
+				updateOperationTypes(operationTypes, definition);
+				break;
+			default: break;
+		}
+	}
+	if (!operationTypes.query && objects.has("Query")) {
+		operationTypes.query = "Query";
+	}
+	if (!operationTypes.mutation && objects.has("Mutation")) {
+		operationTypes.mutation = "Mutation";
+	}
+	if (!operationTypes.subscription && objects.has("Subscription")) {
+		operationTypes.subscription = "Subscription";
+	}
+	return {
+		objects,
+		inputs,
+		enums,
+		unions,
+		scalars,
+		operationTypes
+	};
+};
+const collectTypeLevels = (type, nonNull = false, levels = []) => {
+	if (type.kind === graphql.Kind.NON_NULL_TYPE) {
+		return collectTypeLevels(type.type, true, levels);
+	}
+	if (type.kind === graphql.Kind.LIST_TYPE) {
+		levels.push({
+			kind: "list",
+			nonNull
+		});
+		return collectTypeLevels(type.type, false, levels);
+	}
+	levels.push({
+		kind: "named",
+		nonNull
+	});
+	return {
+		name: type.name.value,
+		levels
+	};
+};
+const buildTypeModifier = (levels) => {
+	let modifier = "";
+	for (const level of levels.slice().reverse()) {
+		if (level.kind === "named") {
+			modifier = level.nonNull ? "!" : "";
+			continue;
+		}
+		const rest = modifier;
+		const base = rest.startsWith("!") ? `![]${rest.slice(1)}` : `[]${rest}`;
+		modifier = level.nonNull ? `${base}!` : base;
+	}
+	return modifier || "?";
+};
+const parseTypeReference = (type) => {
+	const { name, levels } = collectTypeLevels(type);
+	return {
+		name,
+		modifier: buildTypeModifier(levels)
+	};
+};
+const renderType = (name, modifier) => JSON.stringify(`${name}:${modifier}`);
+const isScalarName = (schema, name) => builtinScalarTypes.has(name) || schema.scalars.has(name);
+const isEnumName = (schema, name) => schema.enums.has(name);
+const _isInputName = (schema, name) => schema.inputs.has(name);
+const isUnionName = (schema, name) => schema.unions.has(name);
+const isObjectName = (schema, name) => schema.objects.has(name);
+const renderConstValue = (value) => {
+	switch (value.kind) {
+		case graphql.Kind.NULL: return "null";
+		case graphql.Kind.INT:
+		case graphql.Kind.FLOAT: return value.value;
+		case graphql.Kind.STRING:
+		case graphql.Kind.ENUM: return JSON.stringify(value.value);
+		case graphql.Kind.BOOLEAN: return value.value ? "true" : "false";
+		case graphql.Kind.LIST: return `[${value.values.map((item) => renderConstValue(item)).join(", ")}]`;
+		case graphql.Kind.OBJECT: {
+			if (value.fields.length === 0) {
+				return "{}";
+			}
+			const entries = value.fields.map((field) => `${field.name.value}: ${renderConstValue(field.value)}`);
+			return `{ ${entries.join(", ")} }`;
+		}
+	}
+};
+const renderConstArgumentMap = (args) => {
+	const entries = (args ?? []).map((arg) => `${arg.name.value}: ${renderConstValue(arg.value)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 8
+	});
+};
+const renderDirectives = (directives) => {
+	const entries = (directives ?? []).map((directive) => `${directive.name.value}: ${renderConstArgumentMap(directive.arguments)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 8
+	});
+};
+const renderDefaultValue = (value) => value ? `() => (${renderConstValue(value)})` : "null";
+const renderInputRef = (schema, definition) => {
+	const { name, modifier } = parseTypeReference(definition.type);
+	const tuple = renderType(name, modifier);
+	const defaultValue = renderDefaultValue(definition.defaultValue ?? null);
+	const directives = renderDirectives(definition.directives);
+	if (isScalarName(schema, name)) {
+		return `unsafeInputType.scalar(${tuple}, { default: ${defaultValue}, directives: ${directives} })`;
+	}
+	if (isEnumName(schema, name)) {
+		return `unsafeInputType.enum(${tuple}, { default: ${defaultValue}, directives: ${directives} })`;
+	}
+	return `unsafeInputType.input(${tuple}, { default: ${defaultValue}, directives: ${directives} })`;
+};
+const renderArgumentMap = (schema, args) => {
+	const entries = [...args ?? []].sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => `${arg.name.value}: ${renderInputRef(schema, arg)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 8
+	});
+};
+const renderOutputRef = (schema, type, args, directives) => {
+	const { name, modifier } = parseTypeReference(type);
+	const modifiedType = renderType(name, modifier);
+	const argumentMap = renderArgumentMap(schema, args);
+	const directiveMap = renderDirectives(directives);
+	if (isScalarName(schema, name)) {
+		return `unsafeOutputType.scalar(${modifiedType}, { arguments: ${argumentMap}, directives: ${directiveMap} })`;
+	}
+	if (isEnumName(schema, name)) {
+		return `unsafeOutputType.enum(${modifiedType}, { arguments: ${argumentMap}, directives: ${directiveMap} })`;
+	}
+	if (isUnionName(schema, name)) {
+		return `unsafeOutputType.union(${modifiedType}, { arguments: ${argumentMap}, directives: ${directiveMap} })`;
+	}
+	if (isObjectName(schema, name)) {
+		return `unsafeOutputType.object(${modifiedType}, { arguments: ${argumentMap}, directives: ${directiveMap} })`;
+	}
+	return `unsafeOutputType.scalar(${modifiedType}, { arguments: ${argumentMap}, directives: ${directiveMap} })`;
+};
+const renderPropertyLines = ({ entries, indentSize }) => {
+	if (entries.length === 0) {
+		return "{}";
+	}
+	const indent = " ".repeat(indentSize);
+	const lastIndent = " ".repeat(indentSize - 2);
+	return [
+		"{",
+		`${indent}${entries.join(`,\n${indent}`)},`,
+		`${lastIndent}}`
+	].join(`\n`);
+};
+const renderObjectFields = (schema, fields) => {
+	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderOutputRef(schema, field.type, field.arguments, field.directives)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 6
+	});
+};
+const renderInputFields = (schema, fields) => {
+	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderInputRef(schema, field)}`);
+	return renderPropertyLines({
+		entries,
+		indentSize: 6
+	});
+};
+const renderScalarDefinition = (record) => {
+	const typeInfo = builtinScalarTypes.get(record.name) ?? {
+		input: "string",
+		output: "string"
+	};
+	const scalarType = `type<{ input: ${typeInfo.input}; output: ${typeInfo.output} }>()`;
+	return `${record.name}: define("${record.name}").scalar(${scalarType}, ${renderDirectives(record.directives)})`;
+};
+const renderObjectDefinition = (schema, typeName) => {
+	const record = schema.objects.get(typeName);
+	if (!record) {
+		return "";
+	}
+	const fields = renderObjectFields(schema, record.fields);
+	return `${record.name}: define("${record.name}").object(${fields}, ${renderDirectives(record.directives)})`;
+};
+const renderInputDefinition = (schema, typeName) => {
+	const record = schema.inputs.get(typeName);
+	if (!record) {
+		return "";
+	}
+	const fields = renderInputFields(schema, record.fields);
+	return `${record.name}: define("${record.name}").input(${fields}, ${renderDirectives(record.directives)})`;
+};
+const renderEnumDefinition = (schema, typeName) => {
+	const record = schema.enums.get(typeName);
+	if (!record) {
+		return "";
+	}
+	const values = Array.from(record.values.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((value) => `${value.name.value}: true`).join(", ");
+	const body = values.length === 0 ? "{}" : `{ ${values} }`;
+	return `${record.name}: define("${record.name}").enum(${body}, ${renderDirectives(record.directives)})`;
+};
+const renderUnionDefinition = (schema, typeName) => {
+	const record = schema.unions.get(typeName);
+	if (!record) {
+		return "";
+	}
+	const members = Array.from(record.members.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((member) => `${member.name.value}: true`).join(", ");
+	const body = members.length === 0 ? "{}" : `{ ${members} }`;
+	return `${record.name}: define("${record.name}").union(${body}, ${renderDirectives(record.directives)})`;
+};
+const collectObjectTypeNames = (schema) => Array.from(schema.objects.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectInputTypeNames = (schema) => Array.from(schema.inputs.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectEnumTypeNames = (schema) => Array.from(schema.enums.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectUnionTypeNames = (schema) => Array.from(schema.unions.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const collectScalarNames = (schema) => Array.from(schema.scalars.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
+const multiRuntimeTemplate = ($$) => {
+	const imports = [];
+	const adapterAliases = new Map();
+	const scalarAliases = new Map();
+	if ($$.injection.mode === "inject") {
+		for (const [schemaName, injection] of $$.injection.perSchema) {
+			const adapterAlias = `adapter_${schemaName}`;
+			const scalarAlias = `scalar_${schemaName}`;
+			adapterAliases.set(schemaName, adapterAlias);
+			scalarAliases.set(schemaName, scalarAlias);
+			imports.push(`import { adapter as ${adapterAlias} } from "${injection.adapterImportPath}";`);
+			imports.push(`import { scalar as ${scalarAlias} } from "${injection.scalarImportPath}";`);
+		}
+	}
+	const extraImports = imports.length > 0 ? `${imports.join("\n")}\n` : "";
+	const schemaBlocks = [];
+	const gqlEntries = [];
+	for (const [name, config] of Object.entries($$.schemas)) {
+		const schemaVar = `${name}Schema`;
+		const adapterVar = $$.injection.mode === "inject" ? adapterAliases.get(name) : `adapter_${name}`;
+		const scalarBlock = $$.injection.mode === "inject" ? scalarAliases.get(name) : config.scalarBlock;
+		const adapterDefinition = $$.injection.mode === "inject" ? "" : `const ${adapterVar} = createRuntimeAdapter(({ type }) => ({\n  nonGraphqlErrorType: type<{ type: "non-graphql-error"; cause: unknown }>(),\n}));\n`;
+		schemaBlocks.push(`${adapterDefinition}
+const ${schemaVar} = {
+  operations: defineOperationRoots({
+    query: "${config.queryType}",
+    mutation: "${config.mutationType}",
+    subscription: "${config.subscriptionType}",
+  }),
+  scalar: ${scalarBlock},
+  enum: ${config.enumBlock},
+  input: ${config.inputBlock},
+  object: ${config.objectBlock},
+  union: ${config.unionBlock},
+} satisfies AnyGraphqlSchema;
+
+export type Schema_${name} = typeof ${schemaVar} & { _?: never };
+export type Adapter_${name} = typeof ${adapterVar} & { _?: never };`);
+		gqlEntries.push(`  ${name}: createGqlElementComposer<Schema_${name}, Adapter_${name}>(${schemaVar})`);
+	}
+	const runtimeImport = $$.injection.mode === "inline" ? "\nimport { createRuntimeAdapter } from \"@soda-gql/runtime\";" : "";
+	return `\
+import {
+  type AnyGraphqlSchema,
+  createGqlElementComposer,
+  define,
+  defineOperationRoots,
+  unsafeInputType,
+  unsafeOutputType,
+} from "@soda-gql/core";${runtimeImport}
+${extraImports}
+${schemaBlocks.join("\n")}
+
+export const gql = {
+${gqlEntries.join(",\n")}
+};
+`;
+};
+const generateMultiSchemaModule = (schemas, options) => {
+	const schemaConfigs = {};
+	const allStats = {
+		objects: 0,
+		enums: 0,
+		inputs: 0,
+		unions: 0
+	};
+	for (const [name, document] of schemas.entries()) {
+		const schema = createSchemaIndex(document);
+		const builtinScalarDefinitions = Array.from(builtinScalarTypes.keys()).map((name$1) => renderScalarDefinition(schema.scalars.get(name$1) ?? {
+			name: name$1,
+			directives: []
+		}));
+		const customScalarDefinitions = collectScalarNames(schema).filter((name$1) => !builtinScalarTypes.has(name$1)).map((name$1) => {
+			const record = schema.scalars.get(name$1);
+			return record ? renderScalarDefinition(record) : "";
+		}).filter((definition) => definition.length > 0);
+		const allScalarDefinitions = builtinScalarDefinitions.concat(customScalarDefinitions);
+		const objectTypeNames = collectObjectTypeNames(schema);
+		const enumTypeNames = collectEnumTypeNames(schema);
+		const inputTypeNames = collectInputTypeNames(schema);
+		const unionTypeNames = collectUnionTypeNames(schema);
+		const scalarBlock = renderPropertyLines({
+			entries: allScalarDefinitions,
+			indentSize: 4
+		});
+		const enumDefinitions = enumTypeNames.map((name$1) => renderEnumDefinition(schema, name$1)).filter((definition) => definition.length > 0);
+		const enumBlock = renderPropertyLines({
+			entries: enumDefinitions,
+			indentSize: 4
+		});
+		const inputDefinitions = inputTypeNames.map((name$1) => renderInputDefinition(schema, name$1)).filter((definition) => definition.length > 0);
+		const inputBlock = renderPropertyLines({
+			entries: inputDefinitions,
+			indentSize: 4
+		});
+		const objectDefinitions = objectTypeNames.map((name$1) => renderObjectDefinition(schema, name$1)).filter((definition) => definition.length > 0);
+		const objectBlock = renderPropertyLines({
+			entries: objectDefinitions,
+			indentSize: 4
+		});
+		const unionDefinitions = unionTypeNames.map((name$1) => renderUnionDefinition(schema, name$1)).filter((definition) => definition.length > 0);
+		const unionBlock = renderPropertyLines({
+			entries: unionDefinitions,
+			indentSize: 4
+		});
+		const queryType = schema.operationTypes.query ?? "Query";
+		const mutationType = schema.operationTypes.mutation ?? "Mutation";
+		const subscriptionType = schema.operationTypes.subscription ?? "Subscription";
+		schemaConfigs[name] = {
+			queryType,
+			mutationType,
+			subscriptionType,
+			scalarBlock,
+			enumBlock,
+			inputBlock,
+			objectBlock,
+			unionBlock
+		};
+		allStats.objects += objectDefinitions.length;
+		allStats.enums += enumDefinitions.length;
+		allStats.inputs += inputDefinitions.length;
+		allStats.unions += unionDefinitions.length;
+	}
+	const injection = options?.injection ? {
+		mode: "inject",
+		perSchema: options.injection
+	} : { mode: "inline" };
+	const code = multiRuntimeTemplate({
+		schemas: schemaConfigs,
+		injection
+	});
+	return {
+		code,
+		stats: allStats
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'createSchemaIndex', {
+  enumerable: true,
+  get: function () {
+    return createSchemaIndex;
+  }
+});
+Object.defineProperty(exports, 'generateMultiSchemaModule', {
+  enumerable: true,
+  get: function () {
+    return generateMultiSchemaModule;
+  }
+});