@soda-gql/babel-plugin 0.1.0

package/dist/index.cjs

@@ -0,0 +1,664 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+//#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 __babel_core = require("@babel/core");
+let __soda_gql_plugin_common = require("@soda-gql/plugin-common");
+let __soda_gql_builder = require("@soda-gql/builder");
+let neverthrow = require("neverthrow");
+let __babel_types = require("@babel/types");
+__babel_types = __toESM(__babel_types);
+
+//#region packages/babel-plugin/src/ast/imports.ts
+const RUNTIME_MODULE = "@soda-gql/runtime";
+/**
+* Ensure that the gqlRuntime import exists in the program.
+* gqlRuntime is always imported from @soda-gql/runtime.
+*/
+const ensureGqlRuntimeImport = (programPath) => {
+	const existing = programPath.node.body.find((statement) => statement.type === "ImportDeclaration" && statement.source.value === RUNTIME_MODULE);
+	if (existing && __babel_core.types.isImportDeclaration(existing)) {
+		if (!existing.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "gqlRuntime")) existing.specifiers = [...existing.specifiers, __babel_core.types.importSpecifier(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("gqlRuntime"))];
+		return;
+	}
+	programPath.node.body.unshift(__babel_core.types.importDeclaration([__babel_core.types.importSpecifier(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("gqlRuntime"))], __babel_core.types.stringLiteral(RUNTIME_MODULE)));
+};
+/**
+* Remove the graphql-system import (runtimeModule) and gql-related exports from the program.
+* After transformation, gqlRuntime is imported from @soda-gql/runtime instead,
+* so the original graphql-system import should be completely removed.
+*
+* This handles both ESM imports and CommonJS require() statements.
+*/
+const removeGraphqlSystemImports = (programPath, graphqlSystemIdentifyHelper, filename) => {
+	const toRemove = [];
+	programPath.traverse({
+		ImportDeclaration(path) {
+			if (__babel_core.types.isStringLiteral(path.node.source)) {
+				if (graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+					filePath: filename,
+					specifier: path.node.source.value
+				})) toRemove.push(path);
+			}
+		},
+		VariableDeclaration(path) {
+			if (path.node.declarations.every((decl) => {
+				const specifier = extractRequireTargetSpecifier(decl.init);
+				if (!specifier) return false;
+				return graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+					filePath: filename,
+					specifier
+				});
+			})) toRemove.push(path);
+		}
+	});
+	for (const path of toRemove) path.remove();
+};
+/**
+* Check if an expression is a require() call and extract its target specifier.
+* Handles multiple patterns:
+* - require("@/graphql-system")
+* - Object(require("@/graphql-system")) (interop helper pattern)
+*/
+const extractRequireTargetSpecifier = (expr) => {
+	if (!expr) return;
+	if (__babel_core.types.isCallExpression(expr)) {
+		if (__babel_core.types.isIdentifier(expr.callee) && expr.callee.name === "require") {
+			const arg = expr.arguments[0];
+			if (arg && __babel_core.types.isStringLiteral(arg)) return arg.value;
+		}
+		if (__babel_core.types.isIdentifier(expr.callee) && (expr.callee.name === "Object" || expr.callee.name.startsWith("__import"))) {
+			const arg = expr.arguments[0];
+			if (arg && __babel_core.types.isCallExpression(arg)) {
+				if (__babel_core.types.isIdentifier(arg.callee) && arg.callee.name === "require") {
+					const requireArg = arg.arguments[0];
+					if (requireArg && __babel_core.types.isStringLiteral(requireArg)) return requireArg.value;
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region packages/babel-plugin/src/ast/metadata.ts
+const collectGqlDefinitionMetadata = ({ programPath, filename, createTracker }) => {
+	const exportBindings = collectExportBindings(programPath.node);
+	const tracker = (createTracker ?? __soda_gql_builder.createCanonicalTracker)({
+		filePath: filename,
+		getExportName: (localName) => exportBindings.get(localName)
+	});
+	const getAnonymousName = createAnonymousNameFactory();
+	const scopeHandles = /* @__PURE__ */ new WeakMap();
+	const metadata = /* @__PURE__ */ new WeakMap();
+	programPath.traverse({
+		enter(path) {
+			if (path.isCallExpression() && isGqlDefinitionCall(path.node)) {
+				const depthBeforeRegister = tracker.currentDepth();
+				const { astPath } = tracker.registerDefinition();
+				const isTopLevel = depthBeforeRegister <= 1;
+				const exportInfo = isTopLevel ? resolveTopLevelExport(path, exportBindings) : null;
+				metadata.set(path.node, {
+					astPath,
+					isTopLevel,
+					isExported: exportInfo?.isExported ?? false,
+					exportBinding: exportInfo?.exportBinding
+				});
+				path.skip();
+				return;
+			}
+			const handle = maybeEnterScope(path, tracker, getAnonymousName);
+			if (handle) scopeHandles.set(path, handle);
+		},
+		exit(path) {
+			const handle = scopeHandles.get(path);
+			if (handle) {
+				tracker.exitScope(handle);
+				scopeHandles.delete(path);
+			}
+		}
+	});
+	return metadata;
+};
+const collectExportBindings = (program) => {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (__babel_core.types.isExportNamedDeclaration(statement) && statement.declaration) {
+			const { declaration } = statement;
+			if (__babel_core.types.isVariableDeclaration(declaration)) {
+				for (const declarator of declaration.declarations) if (__babel_core.types.isIdentifier(declarator.id)) bindings.set(declarator.id.name, declarator.id.name);
+				continue;
+			}
+			if ((__babel_core.types.isFunctionDeclaration(declaration) || __babel_core.types.isClassDeclaration(declaration)) && declaration.id) bindings.set(declaration.id.name, declaration.id.name);
+			continue;
+		}
+		if (__babel_core.types.isExpressionStatement(statement) && __babel_core.types.isAssignmentExpression(statement.expression)) {
+			const exportName = getCommonJsExportName(statement.expression.left);
+			if (exportName) bindings.set(exportName, exportName);
+		}
+	}
+	return bindings;
+};
+const getCommonJsExportName = (node) => {
+	if (!__babel_core.types.isMemberExpression(node) || node.computed) return null;
+	const isExports = __babel_core.types.isIdentifier(node.object, { name: "exports" });
+	const isModuleExports = __babel_core.types.isMemberExpression(node.object) && __babel_core.types.isIdentifier(node.object.object, { name: "module" }) && __babel_core.types.isIdentifier(node.object.property, { name: "exports" });
+	if (!isExports && !isModuleExports) return null;
+	if (__babel_core.types.isIdentifier(node.property)) return node.property.name;
+	if (__babel_core.types.isStringLiteral(node.property)) return node.property.value;
+	return null;
+};
+const createAnonymousNameFactory = () => {
+	const counters = /* @__PURE__ */ new Map();
+	return (kind) => {
+		const count = counters.get(kind) ?? 0;
+		counters.set(kind, count + 1);
+		return `${kind}#${count}`;
+	};
+};
+const isGqlDefinitionCall = (node) => __babel_core.types.isCallExpression(node) && __babel_core.types.isMemberExpression(node.callee) && isGqlReference$1(node.callee.object) && node.arguments.length > 0 && __babel_core.types.isArrowFunctionExpression(node.arguments[0]);
+const isGqlReference$1 = (expr) => {
+	if (__babel_core.types.isIdentifier(expr, { name: "gql" })) return true;
+	if (!__babel_core.types.isMemberExpression(expr) || expr.computed) return false;
+	if (__babel_core.types.isIdentifier(expr.property) && expr.property.name === "gql" || __babel_core.types.isStringLiteral(expr.property) && expr.property.value === "gql") return true;
+	return isGqlReference$1(expr.object);
+};
+const resolveTopLevelExport = (callPath, exportBindings) => {
+	const declarator = callPath.parentPath;
+	if (declarator?.isVariableDeclarator()) {
+		const { id } = declarator.node;
+		if (__babel_core.types.isIdentifier(id)) {
+			const exportBinding = exportBindings.get(id.name);
+			if (exportBinding) return {
+				isExported: true,
+				exportBinding
+			};
+		}
+	}
+	const assignment = callPath.parentPath;
+	if (assignment?.isAssignmentExpression()) {
+		const exportName = getCommonJsExportName(assignment.node.left);
+		if (exportName && exportBindings.has(exportName)) return {
+			isExported: true,
+			exportBinding: exportName
+		};
+	}
+	return null;
+};
+const maybeEnterScope = (path, tracker, getAnonymousName) => {
+	if (path.isAssignmentExpression()) {
+		const exportName = getCommonJsExportName(path.node.left);
+		if (exportName) return tracker.enterScope({
+			segment: exportName,
+			kind: "variable",
+			stableKey: `var:${exportName}`
+		});
+	}
+	if (path.isVariableDeclarator() && __babel_core.types.isIdentifier(path.node.id)) {
+		const name = path.node.id.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "variable",
+			stableKey: `var:${name}`
+		});
+	}
+	if (path.isArrowFunctionExpression()) {
+		const name = getAnonymousName("arrow");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: "arrow"
+		});
+	}
+	if (path.isFunctionDeclaration() || path.isFunctionExpression()) {
+		const name = path.node.id?.name ?? getAnonymousName("function");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: `func:${name}`
+		});
+	}
+	if (path.isClassDeclaration()) {
+		const name = path.node.id?.name ?? getAnonymousName("class");
+		return tracker.enterScope({
+			segment: name,
+			kind: "class",
+			stableKey: `class:${name}`
+		});
+	}
+	if (path.isClassMethod() && __babel_core.types.isIdentifier(path.node.key)) {
+		const name = path.node.key.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "method",
+			stableKey: `member:${name}`
+		});
+	}
+	if (path.isClassProperty() && __babel_core.types.isIdentifier(path.node.key)) {
+		const name = path.node.key.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `member:${name}`
+		});
+	}
+	if (path.isObjectProperty()) {
+		const key = path.node.key;
+		const name = __babel_core.types.isIdentifier(key) ? key.name : __babel_core.types.isStringLiteral(key) ? key.value : null;
+		if (name) return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `prop:${name}`
+		});
+	}
+	return null;
+};
+
+//#endregion
+//#region packages/babel-plugin/src/ast/analysis.ts
+const extractGqlCall = ({ nodePath, filename, metadata, builderCall, getArtifact }) => {
+	const callExpression = nodePath.node;
+	const meta = metadata.get(callExpression);
+	if (!meta) return (0, neverthrow.err)(createMetadataMissingError({ filename }));
+	const canonicalId = (0, __soda_gql_plugin_common.resolveCanonicalId)(filename, meta.astPath);
+	const artifact = getArtifact(canonicalId);
+	if (!artifact) return (0, neverthrow.err)(createArtifactMissingError({
+		filename,
+		canonicalId
+	}));
+	if (artifact.type === "model") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		builderCall,
+		type: "model",
+		artifact
+	});
+	if (artifact.type === "slice") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		builderCall,
+		type: "slice",
+		artifact
+	});
+	if (artifact.type === "operation") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		builderCall,
+		type: "operation",
+		artifact
+	});
+	if (artifact.type === "inlineOperation") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		builderCall,
+		type: "inlineOperation",
+		artifact
+	});
+	return (0, neverthrow.err)(createUnsupportedArtifactTypeError({
+		filename,
+		canonicalId,
+		artifactType: artifact.type
+	}));
+};
+const createMetadataMissingError = ({ filename }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_METADATA_NOT_FOUND",
+	message: `No GraphQL metadata found for ${filename}`,
+	cause: { filename },
+	filename
+});
+const createArtifactMissingError = ({ filename, canonicalId }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_ANALYSIS_ARTIFACT_NOT_FOUND",
+	message: `No builder artifact found for canonical ID ${canonicalId}`,
+	cause: {
+		filename,
+		canonicalId
+	},
+	filename,
+	canonicalId
+});
+const createUnsupportedArtifactTypeError = ({ filename, canonicalId, artifactType }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_UNSUPPORTED_ARTIFACT_TYPE",
+	message: `Unsupported builder artifact type "${artifactType}" for canonical ID ${canonicalId}`,
+	cause: {
+		filename,
+		canonicalId,
+		artifactType
+	},
+	filename,
+	canonicalId,
+	artifactType
+});
+const findGqlBuilderCall = (callPath) => resolveBuilderCall(callPath.node);
+const resolveBuilderCall = (call) => {
+	if (!isGqlMemberExpression(call.callee)) return null;
+	if (call.arguments.length !== 1) return null;
+	const factoryArg = call.arguments[0];
+	if (!__babel_core.types.isArrowFunctionExpression(factoryArg)) return null;
+	return extractBuilderCall(factoryArg);
+};
+const isGqlMemberExpression = (callee) => {
+	return __babel_core.types.isMemberExpression(callee) && isSimpleProperty(callee.property) && isGqlReference(callee.object);
+};
+const isSimpleProperty = (property) => __babel_core.types.isIdentifier(property) || __babel_core.types.isStringLiteral(property) && property.value.length > 0;
+const isGqlReference = (expr) => {
+	if (__babel_core.types.isIdentifier(expr, { name: "gql" })) return true;
+	if (!__babel_core.types.isMemberExpression(expr) || expr.computed) return false;
+	if (__babel_core.types.isIdentifier(expr.property) && expr.property.name === "gql" || __babel_core.types.isStringLiteral(expr.property) && expr.property.value === "gql") return true;
+	return isGqlReference(expr.object);
+};
+const extractBuilderCall = (factory) => {
+	if (__babel_core.types.isCallExpression(factory.body)) return factory.body;
+	if (!__babel_core.types.isBlockStatement(factory.body)) return null;
+	for (const statement of factory.body.body) if (__babel_core.types.isReturnStatement(statement) && statement.argument && __babel_core.types.isCallExpression(statement.argument)) return statement.argument;
+	return null;
+};
+
+//#endregion
+//#region packages/babel-plugin/src/ast/ast.ts
+const clone = (node) => __babel_types.cloneNode(node, true);
+const buildObjectExpression = (properties) => __babel_types.objectExpression(Object.entries(properties).map(([key, value]) => __babel_types.objectProperty(__babel_types.identifier(key), value)));
+
+//#endregion
+//#region packages/babel-plugin/src/ast/runtime.ts
+const createMissingBuilderArgError = ({ filename, builderType, argName }) => ({
+	type: "PluginError",
+	stage: "transform",
+	code: "SODA_GQL_TRANSFORM_MISSING_BUILDER_ARG",
+	message: `${builderType} requires a ${argName} argument`,
+	cause: {
+		filename,
+		builderType,
+		argName
+	},
+	filename,
+	builderType,
+	argName
+});
+const buildModelRuntimeCall = ({ artifact, builderCall, filename }) => {
+	const [, , normalize] = builderCall.arguments;
+	if (!normalize || !__babel_core.types.isExpression(normalize)) return (0, neverthrow.err)(createMissingBuilderArgError({
+		filename,
+		builderType: "model",
+		argName: "normalize"
+	}));
+	return (0, neverthrow.ok)(__babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("model")), [buildObjectExpression({
+		prebuild: buildObjectExpression({ typename: __babel_core.types.stringLiteral(artifact.prebuild.typename) }),
+		runtime: buildObjectExpression({ normalize: clone(normalize) })
+	})]));
+};
+const buildSliceRuntimeCall = ({ artifact, builderCall, filename }) => {
+	const [, , projectionBuilder] = builderCall.arguments;
+	if (!projectionBuilder || !__babel_core.types.isExpression(projectionBuilder)) return (0, neverthrow.err)(createMissingBuilderArgError({
+		filename,
+		builderType: "slice",
+		argName: "projectionBuilder"
+	}));
+	return (0, neverthrow.ok)(__babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("slice")), [buildObjectExpression({
+		prebuild: buildObjectExpression({ operationType: __babel_core.types.stringLiteral(artifact.prebuild.operationType) }),
+		runtime: buildObjectExpression({ buildProjection: clone(projectionBuilder) })
+	})]));
+};
+const buildComposedOperationRuntimeComponents = ({ artifact, builderCall, filename }) => {
+	const [, slicesBuilder] = builderCall.arguments;
+	if (!slicesBuilder || !__babel_core.types.isExpression(slicesBuilder)) return (0, neverthrow.err)(createMissingBuilderArgError({
+		filename,
+		builderType: "composed operation",
+		argName: "slicesBuilder"
+	}));
+	const runtimeCall = __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("composedOperation")), [buildObjectExpression({
+		prebuild: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("JSON"), __babel_core.types.identifier("parse")), [__babel_core.types.stringLiteral(JSON.stringify(artifact.prebuild))]),
+		runtime: buildObjectExpression({ getSlices: clone(slicesBuilder) })
+	})]);
+	return (0, neverthrow.ok)({
+		referenceCall: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("getComposedOperation")), [__babel_core.types.stringLiteral(artifact.prebuild.operationName)]),
+		runtimeCall
+	});
+};
+const buildInlineOperationRuntimeComponents = ({ artifact }) => {
+	const runtimeCall = __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("inlineOperation")), [buildObjectExpression({
+		prebuild: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("JSON"), __babel_core.types.identifier("parse")), [__babel_core.types.stringLiteral(JSON.stringify(artifact.prebuild))]),
+		runtime: buildObjectExpression({})
+	})]);
+	return (0, neverthrow.ok)({
+		referenceCall: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("getInlineOperation")), [__babel_core.types.stringLiteral(artifact.prebuild.operationName)]),
+		runtimeCall
+	});
+};
+
+//#endregion
+//#region packages/babel-plugin/src/ast/transformer.ts
+const transformCallExpression = ({ callPath, filename, metadata, getArtifact }) => {
+	const builderCall = findGqlBuilderCall(callPath);
+	if (!builderCall) return (0, neverthrow.ok)({ transformed: false });
+	const gqlCallResult = extractGqlCall({
+		nodePath: callPath,
+		filename,
+		metadata,
+		builderCall,
+		getArtifact
+	});
+	if (gqlCallResult.isErr()) return (0, neverthrow.err)(gqlCallResult.error);
+	const gqlCall = gqlCallResult.value;
+	return replaceWithRuntimeCall(callPath, gqlCall, filename);
+};
+const replaceWithRuntimeCall = (callPath, gqlCall, filename) => {
+	if (gqlCall.type === "model") {
+		const result = buildModelRuntimeCall({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		callPath.replaceWith(result.value);
+		return (0, neverthrow.ok)({ transformed: true });
+	}
+	if (gqlCall.type === "slice") {
+		const result = buildSliceRuntimeCall({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		callPath.replaceWith(result.value);
+		return (0, neverthrow.ok)({ transformed: true });
+	}
+	if (gqlCall.type === "operation") {
+		const result = buildComposedOperationRuntimeComponents({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		const { referenceCall, runtimeCall } = result.value;
+		callPath.replaceWith(referenceCall);
+		return (0, neverthrow.ok)({
+			transformed: true,
+			runtimeCall
+		});
+	}
+	if (gqlCall.type === "inlineOperation") {
+		const result = buildInlineOperationRuntimeComponents({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		const { referenceCall, runtimeCall } = result.value;
+		callPath.replaceWith(referenceCall);
+		return (0, neverthrow.ok)({
+			transformed: true,
+			runtimeCall
+		});
+	}
+	return (0, neverthrow.ok)({ transformed: false });
+};
+
+//#endregion
+//#region packages/babel-plugin/src/transformer.ts
+/**
+* Creates a Babel transformer with a single transform() method.
+* This matches the pattern used in the TypeScript plugin.
+*/
+const createTransformer = ({ programPath, types, config }) => {
+	const graphqlSystemIdentifyHelper = (0, __soda_gql_builder.createGraphqlSystemIdentifyHelper)(config);
+	/**
+	* Check if a node is a require() or __webpack_require__() call.
+	*/
+	const isRequireCall = (node) => {
+		if (!types.isCallExpression(node)) return false;
+		const callee = node.callee;
+		return types.isIdentifier(callee) && (callee.name === "require" || callee.name === "__webpack_require__");
+	};
+	/**
+	* Find the last statement that loads a module (import or require).
+	* Handles both ESM imports and CommonJS require() calls.
+	*/
+	const findLastModuleLoader = () => {
+		const bodyPaths = programPath.get("body");
+		let lastLoader = null;
+		for (const path of bodyPaths) {
+			if (path.isImportDeclaration()) {
+				lastLoader = path;
+				continue;
+			}
+			if (path.isVariableDeclaration()) {
+				for (const declarator of path.node.declarations) if (declarator.init && isRequireCall(declarator.init)) {
+					lastLoader = path;
+					break;
+				}
+				continue;
+			}
+			if (path.isExpressionStatement()) {
+				if (isRequireCall(path.node.expression)) lastLoader = path;
+			}
+		}
+		return lastLoader;
+	};
+	return { transform: (context) => {
+		const metadata = collectGqlDefinitionMetadata({
+			programPath,
+			filename: context.filename
+		});
+		const runtimeCalls = [];
+		let transformed = false;
+		programPath.traverse({ CallExpression: (callPath) => {
+			const result = transformCallExpression({
+				callPath,
+				filename: context.filename,
+				metadata,
+				getArtifact: context.artifactLookup
+			});
+			if (result.isErr()) {
+				console.error(`[@soda-gql/babel-plugin] ${(0, __soda_gql_plugin_common.formatPluginError)(result.error)}`);
+				return;
+			}
+			const transformResult = result.value;
+			if (transformResult.transformed) {
+				transformed = true;
+				if (transformResult.runtimeCall) runtimeCalls.push(transformResult.runtimeCall);
+			}
+		} });
+		if (!transformed) return {
+			transformed: false,
+			runtimeArtifacts: void 0
+		};
+		ensureGqlRuntimeImport(programPath);
+		if (runtimeCalls.length > 0) {
+			const statements = runtimeCalls.map((expr) => types.expressionStatement(expr));
+			const lastLoaderPath = findLastModuleLoader();
+			if (lastLoaderPath) lastLoaderPath.insertAfter(statements);
+			else programPath.unshiftContainer("body", statements);
+		}
+		programPath.scope.crawl();
+		removeGraphqlSystemImports(programPath, graphqlSystemIdentifyHelper, context.filename);
+		return {
+			transformed: true,
+			runtimeArtifacts: void 0
+		};
+	} };
+};
+
+//#endregion
+//#region packages/babel-plugin/src/plugin.ts
+const fallbackPlugin = () => ({
+	name: "@soda-gql/babel-plugin",
+	visitor: { Program() {} }
+});
+const createPlugin = ({ pluginSession }) => ({
+	name: "@soda-gql/babel-plugin",
+	async pre() {
+		this._artifact = await pluginSession.getArtifactAsync();
+	},
+	visitor: { Program(programPath, state) {
+		const filename = state.file?.opts?.filename;
+		if (!filename) return;
+		const artifact = state._artifact;
+		if (!artifact) return;
+		createTransformer({
+			programPath,
+			types: __babel_core.types,
+			config: pluginSession.config
+		}).transform({
+			filename,
+			artifactLookup: (canonicalId) => artifact.elements[canonicalId]
+		});
+	} }
+});
+const createSodaGqlPlugin = (_babel, options = {}) => {
+	const pluginSession = (0, __soda_gql_plugin_common.createPluginSession)(options, "@soda-gql/babel-plugin");
+	return pluginSession ? createPlugin({ pluginSession }) : fallbackPlugin();
+};
+/**
+* Create a Babel plugin with an already-built artifact.
+* Use this when the artifact is pre-built (e.g., by a bundler plugin).
+*/
+const createPluginWithArtifact = ({ artifact, config }) => ({
+	name: "@soda-gql/babel-plugin",
+	visitor: { Program(programPath, state) {
+		const filename = state.file?.opts?.filename;
+		if (!filename) return;
+		createTransformer({
+			programPath,
+			types: __babel_core.types,
+			config
+		}).transform({
+			filename,
+			artifactLookup: (canonicalId) => artifact.elements[canonicalId]
+		});
+	} }
+});
+
+//#endregion
+//#region packages/babel-plugin/src/index.ts
+var src_default = createSodaGqlPlugin;
+
+//#endregion
+exports.createPlugin = createPlugin;
+exports.createPluginWithArtifact = createPluginWithArtifact;
+exports.createSodaGqlPlugin = createSodaGqlPlugin;
+exports.default = src_default;

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+import { PluginObj, PluginPass } from "@babel/core";
+import { BuilderArtifact } from "@soda-gql/builder";
+import { ResolvedSodaGqlConfig } from "@soda-gql/config";
+import { PluginOptions, PluginSession } from "@soda-gql/plugin-common";
+
+//#region packages/babel-plugin/src/plugin.d.ts
+type PluginPassState = PluginPass & {
+  _artifact?: BuilderArtifact | null;
+};
+declare const createPlugin: ({
+  pluginSession
+}: {
+  pluginSession: PluginSession;
+}) => PluginObj<PluginPassState>;
+declare const createSodaGqlPlugin: (_babel: unknown, options?: PluginOptions) => PluginObj;
+/**
+ * Create a Babel plugin with an already-built artifact.
+ * Use this when the artifact is pre-built (e.g., by a bundler plugin).
+ */
+declare const createPluginWithArtifact: ({
+  artifact,
+  config
+}: {
+  artifact: BuilderArtifact;
+  config: ResolvedSodaGqlConfig;
+}) => PluginObj;
+//#endregion
+export { createPlugin, createPluginWithArtifact, createSodaGqlPlugin, createSodaGqlPlugin as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/plugin.ts"],"sourcesContent":[],"mappings":";;;;;;KAQK,eAAA,GAAkB;cACT;AAJwF,CAAA;AAgBzF,cAAA,YAiCX,EAAA,CAAA;EAAA;CAAA,EAAA;EAjC2B,aAAA,EAAoC,aAApC;CAAoC,EAAA,GAAkB,SAAlB,CAA4B,eAA5B,CAAA;AAA4B,cAmChF,mBAnCgF,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,OAAA,CAAA,EAmC/B,aAnC+B,EAAA,GAmCV,SAnCU;;;AAmC7F;AAWA;AAAyC,cAA5B,wBAA4B,EAAA,CAAA;EAAA,QAAA;EAAA;CAAA,EAAA;EAAA,QAAA,EAI7B,eAJ6B;EAI7B,MAAA,EACF,qBADE;CACF,EAAA,GACN,SADM"}