@soda-gql/babel-plugin 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,580 +1,7 @@
 import { types } from "@babel/core";
-import { createPluginSession, formatPluginError, resolveCanonicalId } from "@soda-gql/plugin-common";
-import { createCanonicalTracker, createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
-import { err, ok } from "neverthrow";
-import * as t from "@babel/types";
+import { createTransformer } from "@soda-gql/babel-transformer";
+import { createPluginSession } from "@soda-gql/plugin-common";
 
-//#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 && types.isImportDeclaration(existing)) {
-		if (!existing.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "gqlRuntime")) existing.specifiers = [...existing.specifiers, types.importSpecifier(types.identifier("gqlRuntime"), types.identifier("gqlRuntime"))];
-		return;
-	}
-	programPath.node.body.unshift(types.importDeclaration([types.importSpecifier(types.identifier("gqlRuntime"), types.identifier("gqlRuntime"))], 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 (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 (types.isCallExpression(expr)) {
-		if (types.isIdentifier(expr.callee) && expr.callee.name === "require") {
-			const arg = expr.arguments[0];
-			if (arg && types.isStringLiteral(arg)) return arg.value;
-		}
-		if (types.isIdentifier(expr.callee) && (expr.callee.name === "Object" || expr.callee.name.startsWith("__import"))) {
-			const arg = expr.arguments[0];
-			if (arg && types.isCallExpression(arg)) {
-				if (types.isIdentifier(arg.callee) && arg.callee.name === "require") {
-					const requireArg = arg.arguments[0];
-					if (requireArg && 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 ?? 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 (types.isExportNamedDeclaration(statement) && statement.declaration) {
-			const { declaration } = statement;
-			if (types.isVariableDeclaration(declaration)) {
-				for (const declarator of declaration.declarations) if (types.isIdentifier(declarator.id)) bindings.set(declarator.id.name, declarator.id.name);
-				continue;
-			}
-			if ((types.isFunctionDeclaration(declaration) || types.isClassDeclaration(declaration)) && declaration.id) bindings.set(declaration.id.name, declaration.id.name);
-			continue;
-		}
-		if (types.isExpressionStatement(statement) && types.isAssignmentExpression(statement.expression)) {
-			const exportName = getCommonJsExportName(statement.expression.left);
-			if (exportName) bindings.set(exportName, exportName);
-		}
-	}
-	return bindings;
-};
-const getCommonJsExportName = (node) => {
-	if (!types.isMemberExpression(node) || node.computed) return null;
-	const isExports = types.isIdentifier(node.object, { name: "exports" });
-	const isModuleExports = types.isMemberExpression(node.object) && types.isIdentifier(node.object.object, { name: "module" }) && types.isIdentifier(node.object.property, { name: "exports" });
-	if (!isExports && !isModuleExports) return null;
-	if (types.isIdentifier(node.property)) return node.property.name;
-	if (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) => types.isCallExpression(node) && types.isMemberExpression(node.callee) && isGqlReference$1(node.callee.object) && node.arguments.length > 0 && types.isArrowFunctionExpression(node.arguments[0]);
-const isGqlReference$1 = (expr) => {
-	if (types.isIdentifier(expr, { name: "gql" })) return true;
-	if (!types.isMemberExpression(expr) || expr.computed) return false;
-	if (types.isIdentifier(expr.property) && expr.property.name === "gql" || 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 (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() && 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() && types.isIdentifier(path.node.key)) {
-		const name = path.node.key.name;
-		return tracker.enterScope({
-			segment: name,
-			kind: "method",
-			stableKey: `member:${name}`
-		});
-	}
-	if (path.isClassProperty() && 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 = types.isIdentifier(key) ? key.name : 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 err(createMetadataMissingError({ filename }));
-	const canonicalId = resolveCanonicalId(filename, meta.astPath);
-	const artifact = getArtifact(canonicalId);
-	if (!artifact) return err(createArtifactMissingError({
-		filename,
-		canonicalId
-	}));
-	if (artifact.type === "model") return ok({
-		nodePath,
-		canonicalId,
-		builderCall,
-		type: "model",
-		artifact
-	});
-	if (artifact.type === "slice") return ok({
-		nodePath,
-		canonicalId,
-		builderCall,
-		type: "slice",
-		artifact
-	});
-	if (artifact.type === "operation") return ok({
-		nodePath,
-		canonicalId,
-		builderCall,
-		type: "operation",
-		artifact
-	});
-	if (artifact.type === "inlineOperation") return ok({
-		nodePath,
-		canonicalId,
-		builderCall,
-		type: "inlineOperation",
-		artifact
-	});
-	return 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 (!types.isArrowFunctionExpression(factoryArg)) return null;
-	return extractBuilderCall(factoryArg);
-};
-const isGqlMemberExpression = (callee) => {
-	return types.isMemberExpression(callee) && isSimpleProperty(callee.property) && isGqlReference(callee.object);
-};
-const isSimpleProperty = (property) => types.isIdentifier(property) || types.isStringLiteral(property) && property.value.length > 0;
-const isGqlReference = (expr) => {
-	if (types.isIdentifier(expr, { name: "gql" })) return true;
-	if (!types.isMemberExpression(expr) || expr.computed) return false;
-	if (types.isIdentifier(expr.property) && expr.property.name === "gql" || types.isStringLiteral(expr.property) && expr.property.value === "gql") return true;
-	return isGqlReference(expr.object);
-};
-const extractBuilderCall = (factory) => {
-	if (types.isCallExpression(factory.body)) return factory.body;
-	if (!types.isBlockStatement(factory.body)) return null;
-	for (const statement of factory.body.body) if (types.isReturnStatement(statement) && statement.argument && types.isCallExpression(statement.argument)) return statement.argument;
-	return null;
-};
-
-//#endregion
-//#region packages/babel-plugin/src/ast/ast.ts
-const clone = (node) => t.cloneNode(node, true);
-const buildObjectExpression = (properties) => t.objectExpression(Object.entries(properties).map(([key, value]) => t.objectProperty(t.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 || !types.isExpression(normalize)) return err(createMissingBuilderArgError({
-		filename,
-		builderType: "model",
-		argName: "normalize"
-	}));
-	return ok(types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("model")), [buildObjectExpression({
-		prebuild: buildObjectExpression({ typename: types.stringLiteral(artifact.prebuild.typename) }),
-		runtime: buildObjectExpression({ normalize: clone(normalize) })
-	})]));
-};
-const buildSliceRuntimeCall = ({ artifact, builderCall, filename }) => {
-	const [, , projectionBuilder] = builderCall.arguments;
-	if (!projectionBuilder || !types.isExpression(projectionBuilder)) return err(createMissingBuilderArgError({
-		filename,
-		builderType: "slice",
-		argName: "projectionBuilder"
-	}));
-	return ok(types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("slice")), [buildObjectExpression({
-		prebuild: buildObjectExpression({ operationType: types.stringLiteral(artifact.prebuild.operationType) }),
-		runtime: buildObjectExpression({ buildProjection: clone(projectionBuilder) })
-	})]));
-};
-const buildComposedOperationRuntimeComponents = ({ artifact, builderCall, filename }) => {
-	const [, slicesBuilder] = builderCall.arguments;
-	if (!slicesBuilder || !types.isExpression(slicesBuilder)) return err(createMissingBuilderArgError({
-		filename,
-		builderType: "composed operation",
-		argName: "slicesBuilder"
-	}));
-	const runtimeCall = types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("composedOperation")), [buildObjectExpression({
-		prebuild: types.callExpression(types.memberExpression(types.identifier("JSON"), types.identifier("parse")), [types.stringLiteral(JSON.stringify(artifact.prebuild))]),
-		runtime: buildObjectExpression({ getSlices: clone(slicesBuilder) })
-	})]);
-	return ok({
-		referenceCall: types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("getComposedOperation")), [types.stringLiteral(artifact.prebuild.operationName)]),
-		runtimeCall
-	});
-};
-const buildInlineOperationRuntimeComponents = ({ artifact }) => {
-	const runtimeCall = types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("inlineOperation")), [buildObjectExpression({
-		prebuild: types.callExpression(types.memberExpression(types.identifier("JSON"), types.identifier("parse")), [types.stringLiteral(JSON.stringify(artifact.prebuild))]),
-		runtime: buildObjectExpression({})
-	})]);
-	return ok({
-		referenceCall: types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("getInlineOperation")), [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 ok({ transformed: false });
-	const gqlCallResult = extractGqlCall({
-		nodePath: callPath,
-		filename,
-		metadata,
-		builderCall,
-		getArtifact
-	});
-	if (gqlCallResult.isErr()) return 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 err(result.error);
-		callPath.replaceWith(result.value);
-		return ok({ transformed: true });
-	}
-	if (gqlCall.type === "slice") {
-		const result = buildSliceRuntimeCall({
-			...gqlCall,
-			filename
-		});
-		if (result.isErr()) return err(result.error);
-		callPath.replaceWith(result.value);
-		return ok({ transformed: true });
-	}
-	if (gqlCall.type === "operation") {
-		const result = buildComposedOperationRuntimeComponents({
-			...gqlCall,
-			filename
-		});
-		if (result.isErr()) return err(result.error);
-		const { referenceCall, runtimeCall } = result.value;
-		callPath.replaceWith(referenceCall);
-		return ok({
-			transformed: true,
-			runtimeCall
-		});
-	}
-	if (gqlCall.type === "inlineOperation") {
-		const result = buildInlineOperationRuntimeComponents({
-			...gqlCall,
-			filename
-		});
-		if (result.isErr()) return err(result.error);
-		const { referenceCall, runtimeCall } = result.value;
-		callPath.replaceWith(referenceCall);
-		return ok({
-			transformed: true,
-			runtimeCall
-		});
-	}
-	return 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: types$1, config }) => {
-	const graphqlSystemIdentifyHelper = createGraphqlSystemIdentifyHelper(config);
-	/**
-	* Check if a node is a require() or __webpack_require__() call.
-	*/
-	const isRequireCall = (node) => {
-		if (!types$1.isCallExpression(node)) return false;
-		const callee = node.callee;
-		return types$1.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] ${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$1.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",
@@ -625,9 +52,5 @@ const createPluginWithArtifact = ({ artifact, config }) => ({
 });
 
 //#endregion
-//#region packages/babel-plugin/src/index.ts
-var src_default = createSodaGqlPlugin;
-
-//#endregion
-export { createPlugin, createPluginWithArtifact, createSodaGqlPlugin, src_default as default };
+export { createPlugin, createPluginWithArtifact, createSodaGqlPlugin };
 //# sourceMappingURL=index.mjs.map