@soda-gql/tsc-transformer 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,570 @@
+import { createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
+import { formatPluginError, resolveCanonicalId } from "@soda-gql/plugin-common";
+import * as ts$1 from "typescript";
+import ts from "typescript";
+import { createCanonicalTracker } from "@soda-gql/common";
+import { err, ok } from "neverthrow";
+
+//#region packages/tsc-transformer/src/ast/imports.ts
+const RUNTIME_MODULE = "@soda-gql/runtime";
+/**
+* Ensure that the gqlRuntime require exists in the source file for CJS output.
+* Injects: const __soda_gql_runtime = require("@soda-gql/runtime");
+* Returns an updated source file with the require added if needed.
+*/
+const ensureGqlRuntimeRequire = ({ sourceFile, factory }) => {
+	if (sourceFile.statements.find((statement) => ts.isVariableStatement(statement) && statement.declarationList.declarations.some((decl) => {
+		if (!ts.isIdentifier(decl.name) || decl.name.text !== "__soda_gql_runtime") return false;
+		if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return false;
+		const callExpr = decl.initializer;
+		if (!ts.isIdentifier(callExpr.expression) || callExpr.expression.text !== "require") return false;
+		const arg = callExpr.arguments[0];
+		return arg && ts.isStringLiteral(arg) && arg.text === RUNTIME_MODULE;
+	}))) return sourceFile;
+	const requireCall = factory.createCallExpression(factory.createIdentifier("require"), void 0, [factory.createStringLiteral(RUNTIME_MODULE)]);
+	const variableDeclaration = factory.createVariableDeclaration(factory.createIdentifier("__soda_gql_runtime"), void 0, void 0, requireCall);
+	const newStatements = [factory.createVariableStatement(void 0, factory.createVariableDeclarationList([variableDeclaration], ts.NodeFlags.Const)), ...sourceFile.statements];
+	return factory.updateSourceFile(sourceFile, newStatements);
+};
+/**
+* Ensure that the gqlRuntime import exists in the source file.
+* gqlRuntime is always imported from @soda-gql/runtime.
+* Returns an updated source file with the import added or merged.
+*/
+const ensureGqlRuntimeImport = ({ sourceFile, factory }) => {
+	const existing = sourceFile.statements.find((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === RUNTIME_MODULE);
+	if (existing?.importClause?.namedBindings && ts.isNamedImports(existing.importClause.namedBindings)) {
+		if (existing.importClause.namedBindings.elements.some((element) => ts.isIdentifier(element.name) && element.name.text === "gqlRuntime")) return sourceFile;
+		const newElements = [...existing.importClause.namedBindings.elements, factory.createImportSpecifier(false, void 0, factory.createIdentifier("gqlRuntime"))];
+		const newNamedBindings = factory.createNamedImports(newElements);
+		const newImportClause = factory.createImportClause(false, void 0, newNamedBindings);
+		const newImportDeclaration = factory.createImportDeclaration(void 0, newImportClause, factory.createStringLiteral(RUNTIME_MODULE), void 0);
+		const newStatements$1 = sourceFile.statements.map((stmt) => stmt === existing ? newImportDeclaration : stmt);
+		return factory.updateSourceFile(sourceFile, newStatements$1);
+	}
+	const newStatements = [factory.createImportDeclaration(void 0, factory.createImportClause(false, void 0, factory.createNamedImports([factory.createImportSpecifier(false, void 0, factory.createIdentifier("gqlRuntime"))])), factory.createStringLiteral(RUNTIME_MODULE), void 0), ...sourceFile.statements];
+	return factory.updateSourceFile(sourceFile, newStatements);
+};
+/**
+* Remove the graphql-system import (runtimeModule) and gql-related exports from the source file.
+* 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 (including interop helpers).
+*/
+const removeGraphqlSystemImports = ({ sourceFile, factory, graphqlSystemIdentifyHelper }) => {
+	const updatedStatements = Array.from(sourceFile.statements).filter((statement) => {
+		if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) return !graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+			filePath: sourceFile.fileName,
+			specifier: statement.moduleSpecifier.text
+		});
+		if (ts.isVariableStatement(statement)) return !statement.declarationList.declarations.every((decl) => {
+			const specifier = extractRequireTargetSpecifier(decl.initializer);
+			if (!specifier) return false;
+			return graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+				filePath: sourceFile.fileName,
+				specifier
+			});
+		});
+		return true;
+	});
+	if (updatedStatements.length === sourceFile.statements.length) return sourceFile;
+	return factory.updateSourceFile(sourceFile, updatedStatements);
+};
+/**
+* Create an "after" transformer that stubs out require() calls for the runtimeModule.
+* This runs after TypeScript's own transformers (including CommonJS down-leveling),
+* so we can replace `const X = require("@/graphql-system")` with a lightweight stub.
+*
+* This prevents the heavy graphql-system module from being loaded at runtime.
+*/
+const createAfterStubTransformer = ({ sourceFile, graphqlSystemIdentifyHelper }) => {
+	return (context) => {
+		const factory = context.factory;
+		const visitor = (node) => {
+			if (ts.isVariableStatement(node)) {
+				let transformed = false;
+				const newDeclarations = node.declarationList.declarations.map((decl) => {
+					const specifier = extractRequireTargetSpecifier(decl.initializer);
+					if (!specifier) return decl;
+					if (!graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+						filePath: sourceFile.fileName,
+						specifier
+					})) return decl;
+					const stub = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "create"), void 0, [factory.createNull()]);
+					ts.addSyntheticLeadingComment(stub, ts.SyntaxKind.MultiLineCommentTrivia, "#__PURE__", false);
+					transformed = true;
+					return factory.updateVariableDeclaration(decl, decl.name, decl.exclamationToken, decl.type, stub);
+				});
+				if (transformed) return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(node.declarationList, newDeclarations));
+			}
+			return ts.visitEachChild(node, visitor, context);
+		};
+		return (sourceFile$1) => ts.visitNode(sourceFile$1, visitor);
+	};
+};
+/**
+* Check if an expression is a require() call for the runtimeModule.
+* Handles multiple patterns:
+* - require("@/graphql-system")
+* - __importDefault(require("@/graphql-system"))
+* - __importStar(require("@/graphql-system"))
+*/
+const extractRequireTargetSpecifier = (expr) => {
+	if (!expr) return;
+	if (ts.isCallExpression(expr)) {
+		if (ts.isIdentifier(expr.expression) && expr.expression.text === "require") {
+			const arg = expr.arguments[0];
+			if (arg && ts.isStringLiteral(arg)) return arg.text;
+		}
+		if (ts.isIdentifier(expr.expression)) {
+			const helperName = expr.expression.text;
+			if (helperName === "__importDefault" || helperName === "__importStar") {
+				const arg = expr.arguments[0];
+				if (arg && ts.isCallExpression(arg)) {
+					if (ts.isIdentifier(arg.expression) && arg.expression.text === "require") {
+						const requireArg = arg.arguments[0];
+						if (requireArg && ts.isStringLiteral(requireArg)) return requireArg.text;
+					}
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region packages/tsc-transformer/src/ast/metadata.ts
+const collectGqlDefinitionMetadata = ({ sourceFile, filename, createTracker }) => {
+	const exportBindings = collectExportBindings(sourceFile);
+	const tracker = (createTracker ?? createCanonicalTracker)({
+		filePath: filename,
+		getExportName: (localName) => exportBindings.get(localName)
+	});
+	const getAnonymousName = createAnonymousNameFactory();
+	const scopeHandles = /* @__PURE__ */ new WeakMap();
+	const metadata = /* @__PURE__ */ new WeakMap();
+	const visit = (node) => {
+		if (ts$1.isCallExpression(node) && isGqlDefinitionCall(node, ts$1)) {
+			const depthBeforeRegister = tracker.currentDepth();
+			const { astPath } = tracker.registerDefinition();
+			const isTopLevel = depthBeforeRegister <= 1;
+			const exportInfo = isTopLevel ? resolveTopLevelExport(node, exportBindings, ts$1) : null;
+			metadata.set(node, {
+				astPath,
+				isTopLevel,
+				isExported: exportInfo?.isExported ?? false,
+				exportBinding: exportInfo?.exportBinding
+			});
+			return;
+		}
+		const handle = maybeEnterScope(node, tracker, getAnonymousName, ts$1);
+		if (handle) scopeHandles.set(node, handle);
+		ts$1.forEachChild(node, visit);
+		const scopeHandle = scopeHandles.get(node);
+		if (scopeHandle) {
+			tracker.exitScope(scopeHandle);
+			scopeHandles.delete(node);
+		}
+	};
+	visit(sourceFile);
+	return metadata;
+};
+const collectExportBindings = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts$1.isExportDeclaration(statement) && statement.exportClause && ts$1.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				const name = element.name.text;
+				bindings.set(name, name);
+			}
+			continue;
+		}
+		if (ts$1.isVariableStatement(statement) && statement.modifiers?.some((m) => m.kind === ts$1.SyntaxKind.ExportKeyword)) {
+			for (const declaration of statement.declarationList.declarations) if (ts$1.isIdentifier(declaration.name)) bindings.set(declaration.name.text, declaration.name.text);
+			continue;
+		}
+		if ((ts$1.isFunctionDeclaration(statement) || ts$1.isClassDeclaration(statement)) && statement.modifiers?.some((m) => m.kind === ts$1.SyntaxKind.ExportKeyword) && statement.name) {
+			bindings.set(statement.name.text, statement.name.text);
+			continue;
+		}
+		if (ts$1.isExpressionStatement(statement) && ts$1.isBinaryExpression(statement.expression)) {
+			const exportName = getCommonJsExportName(statement.expression.left);
+			if (exportName) bindings.set(exportName, exportName);
+		}
+	}
+	return bindings;
+};
+const getCommonJsExportName = (node) => {
+	if (!ts$1.isPropertyAccessExpression(node)) return null;
+	const isExports = ts$1.isIdentifier(node.expression) && node.expression.text === "exports";
+	const isModuleExports = ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "module" && ts$1.isIdentifier(node.expression.name) && node.expression.name.text === "exports";
+	if (!isExports && !isModuleExports) return null;
+	if (ts$1.isIdentifier(node.name)) return node.name.text;
+	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, typescript) => {
+	if (!typescript.isCallExpression(node)) return false;
+	if (!typescript.isPropertyAccessExpression(node.expression)) return false;
+	if (!isGqlReference(node.expression.expression, typescript)) return false;
+	if (node.arguments.length === 0) return false;
+	const firstArg = node.arguments[0];
+	if (firstArg === void 0) return false;
+	return typescript.isArrowFunction(firstArg);
+};
+const isGqlReference = (expr, typescript) => {
+	if (typescript.isIdentifier(expr) && expr.text === "gql") return true;
+	if (!typescript.isPropertyAccessExpression(expr)) return false;
+	if (typescript.isIdentifier(expr.name) && expr.name.text === "gql") return true;
+	return isGqlReference(expr.expression, typescript);
+};
+const resolveTopLevelExport = (callNode, exportBindings, typescript) => {
+	const parent = callNode.parent;
+	if (!parent) return null;
+	if (typescript.isVariableDeclaration(parent)) {
+		const { name } = parent;
+		if (typescript.isIdentifier(name)) {
+			const exportBinding = exportBindings.get(name.text);
+			if (exportBinding) return {
+				isExported: true,
+				exportBinding
+			};
+		}
+	}
+	if (typescript.isBinaryExpression(parent)) {
+		const exportName = getCommonJsExportName(parent.left);
+		if (exportName && exportBindings.has(exportName)) return {
+			isExported: true,
+			exportBinding: exportName
+		};
+	}
+	return null;
+};
+const maybeEnterScope = (node, tracker, getAnonymousName, typescript) => {
+	if (typescript.isBinaryExpression(node)) {
+		const exportName = getCommonJsExportName(node.left);
+		if (exportName) return tracker.enterScope({
+			segment: exportName,
+			kind: "variable",
+			stableKey: `var:${exportName}`
+		});
+	}
+	if (typescript.isVariableDeclaration(node) && typescript.isIdentifier(node.name)) {
+		const name = node.name.text;
+		return tracker.enterScope({
+			segment: name,
+			kind: "variable",
+			stableKey: `var:${name}`
+		});
+	}
+	if (typescript.isArrowFunction(node)) {
+		const name = getAnonymousName("arrow");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: "arrow"
+		});
+	}
+	if (typescript.isFunctionDeclaration(node) || typescript.isFunctionExpression(node)) {
+		const name = node.name?.text ?? getAnonymousName("function");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: `func:${name}`
+		});
+	}
+	if (typescript.isClassDeclaration(node)) {
+		const name = node.name?.text ?? getAnonymousName("class");
+		return tracker.enterScope({
+			segment: name,
+			kind: "class",
+			stableKey: `class:${name}`
+		});
+	}
+	if (typescript.isMethodDeclaration(node) && typescript.isIdentifier(node.name)) {
+		const name = node.name.text;
+		return tracker.enterScope({
+			segment: name,
+			kind: "method",
+			stableKey: `member:${name}`
+		});
+	}
+	if (typescript.isPropertyDeclaration(node) && typescript.isIdentifier(node.name)) {
+		const name = node.name.text;
+		return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `member:${name}`
+		});
+	}
+	if (typescript.isPropertyAssignment(node)) {
+		const key = node.name;
+		const name = typescript.isIdentifier(key) ? key.text : typescript.isStringLiteral(key) ? key.text : null;
+		if (name) return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `prop:${name}`
+		});
+	}
+	return null;
+};
+
+//#endregion
+//#region packages/tsc-transformer/src/ast/analysis.ts
+const extractGqlCall = ({ callNode, filename, metadata, getArtifact }) => {
+	const meta = metadata.get(callNode);
+	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 === "fragment") return ok({
+		callNode,
+		canonicalId,
+		type: "fragment",
+		artifact
+	});
+	if (artifact.type === "operation") return ok({
+		callNode,
+		canonicalId,
+		type: "operation",
+		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
+});
+
+//#endregion
+//#region packages/tsc-transformer/src/ast/ast.ts
+/**
+* Build an object literal expression from a record of properties.
+*/
+const buildObjectExpression = (factory, properties) => {
+	const propertyAssignments = Object.entries(properties).map(([key, value]) => factory.createPropertyAssignment(factory.createIdentifier(key), value));
+	return factory.createObjectLiteralExpression(propertyAssignments);
+};
+/**
+* Build a JSON.parse expression from an object value.
+* This is used to emit large objects as JSON strings to reduce the calculation cost of both the compiler and the runtime.
+*/
+const buildJsonParseExpression = (factory, value) => factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("JSON"), factory.createIdentifier("parse")), void 0, [factory.createStringLiteral(JSON.stringify(value))]);
+
+//#endregion
+//#region packages/tsc-transformer/src/ast/runtime.ts
+const createRuntimeAccessor = ({ isCJS, factory }) => isCJS ? factory.createPropertyAccessExpression(factory.createIdentifier("__soda_gql_runtime"), factory.createIdentifier("gqlRuntime")) : factory.createIdentifier("gqlRuntime");
+const buildFragmentRuntimeCall = ({ gqlCall, factory, isCJS }) => {
+	return ok(factory.createCallExpression(factory.createPropertyAccessExpression(createRuntimeAccessor({
+		isCJS,
+		factory
+	}), factory.createIdentifier("fragment")), void 0, [buildObjectExpression(factory, { prebuild: buildObjectExpression(factory, { typename: factory.createStringLiteral(gqlCall.artifact.prebuild.typename) }) })]));
+};
+const buildOperationRuntimeComponents = ({ gqlCall, factory, isCJS }) => {
+	const runtimeCall = factory.createCallExpression(factory.createPropertyAccessExpression(createRuntimeAccessor({
+		isCJS,
+		factory
+	}), factory.createIdentifier("operation")), void 0, [buildObjectExpression(factory, {
+		prebuild: buildJsonParseExpression(factory, gqlCall.artifact.prebuild),
+		runtime: buildObjectExpression(factory, {})
+	})]);
+	return ok({
+		referenceCall: factory.createCallExpression(factory.createPropertyAccessExpression(createRuntimeAccessor({
+			isCJS,
+			factory
+		}), factory.createIdentifier("getOperation")), void 0, [factory.createStringLiteral(gqlCall.artifact.prebuild.operationName)]),
+		runtimeCall
+	});
+};
+
+//#endregion
+//#region packages/tsc-transformer/src/ast/transformer.ts
+const transformCallExpression = ({ callNode, filename, metadata, getArtifact, factory, isCJS }) => {
+	if (!metadata.has(callNode)) return ok({ transformed: false });
+	const gqlCallResult = extractGqlCall({
+		callNode,
+		filename,
+		metadata,
+		getArtifact
+	});
+	if (gqlCallResult.isErr()) return err(gqlCallResult.error);
+	const gqlCall = gqlCallResult.value;
+	return replaceWithRuntimeCall({
+		gqlCall,
+		factory,
+		isCJS,
+		filename
+	});
+};
+const replaceWithRuntimeCall = ({ gqlCall, factory, isCJS, filename }) => {
+	if (gqlCall.type === "fragment") {
+		const result = buildFragmentRuntimeCall({
+			gqlCall,
+			factory,
+			isCJS,
+			filename
+		});
+		if (result.isErr()) return err(result.error);
+		return ok({
+			transformed: true,
+			replacement: result.value
+		});
+	}
+	if (gqlCall.type === "operation") {
+		const result = buildOperationRuntimeComponents({
+			gqlCall,
+			factory,
+			isCJS
+		});
+		if (result.isErr()) return err(result.error);
+		const { referenceCall, runtimeCall } = result.value;
+		return ok({
+			transformed: true,
+			replacement: referenceCall,
+			runtimeCall
+		});
+	}
+	return ok({ transformed: false });
+};
+
+//#endregion
+//#region packages/tsc-transformer/src/transformer.ts
+const findLastImportIndex = ({ sourceFile }) => {
+	let lastIndex = -1;
+	const statements = sourceFile.statements;
+	for (let i = 0; i < statements.length; i++) {
+		const statement = statements[i];
+		if (statement && ts$1.isImportDeclaration(statement)) lastIndex = i;
+	}
+	return lastIndex;
+};
+const createTransformer = ({ compilerOptions, config, artifact }) => {
+	const isCJS = compilerOptions.module === ts$1.ModuleKind.CommonJS || compilerOptions.target === ts$1.ScriptTarget.ES5;
+	const graphqlSystemIdentifyHelper = createGraphqlSystemIdentifyHelper(config);
+	const makeSourceFileEmpty = ({ factory, sourceFile }) => {
+		return factory.updateSourceFile(sourceFile, [factory.createExportDeclaration(void 0, false, factory.createNamedExports([]), void 0)]);
+	};
+	const transformGqlCalls = ({ sourceFile, context }) => {
+		let transformed = false;
+		const metadata = collectGqlDefinitionMetadata({
+			sourceFile,
+			filename: sourceFile.fileName
+		});
+		const runtimeCallsFromLastTransform = [];
+		const visitor = (node) => {
+			if (ts$1.isCallExpression(node)) {
+				const result = transformCallExpression({
+					callNode: node,
+					filename: sourceFile.fileName,
+					metadata,
+					getArtifact: (canonicalId) => artifact.elements[canonicalId],
+					factory: context.factory,
+					isCJS
+				});
+				if (result.isErr()) {
+					console.error(`[@soda-gql/tsc-plugin] ${formatPluginError(result.error)}`);
+					return node;
+				}
+				const transformResult = result.value;
+				if (transformResult.transformed) {
+					transformed = true;
+					if (transformResult.runtimeCall) runtimeCallsFromLastTransform.push(transformResult.runtimeCall);
+					return transformResult.replacement;
+				}
+			}
+			return ts$1.visitEachChild(node, visitor, context);
+		};
+		const visitedNode = ts$1.visitNode(sourceFile, visitor);
+		if (!visitedNode || !ts$1.isSourceFile(visitedNode)) {
+			console.error(`[@soda-gql/tsc-plugin] Failed to transform source file: ${sourceFile.fileName}`);
+			return sourceFile;
+		}
+		if (!transformed) return sourceFile;
+		if (runtimeCallsFromLastTransform.length === 0) return visitedNode;
+		const lastImportIndex = findLastImportIndex({ sourceFile });
+		return context.factory.updateSourceFile(visitedNode, [
+			...visitedNode.statements.slice(0, lastImportIndex + 1),
+			...runtimeCallsFromLastTransform.map((expr) => context.factory.createExpressionStatement(expr)),
+			...visitedNode.statements.slice(lastImportIndex + 1)
+		]);
+	};
+	return { transform: ({ sourceFile, context }) => {
+		if (graphqlSystemIdentifyHelper.isGraphqlSystemFile({ filePath: sourceFile.fileName })) return {
+			transformed: true,
+			sourceFile: makeSourceFileEmpty({
+				factory: context.factory,
+				sourceFile
+			})
+		};
+		const original = sourceFile;
+		let current = sourceFile;
+		current = transformGqlCalls({
+			sourceFile: current,
+			context
+		});
+		if (current !== sourceFile) current = isCJS ? ensureGqlRuntimeRequire({
+			sourceFile: current,
+			factory: context.factory
+		}) : ensureGqlRuntimeImport({
+			sourceFile: current,
+			factory: context.factory
+		});
+		current = removeGraphqlSystemImports({
+			sourceFile: current,
+			factory: context.factory,
+			graphqlSystemIdentifyHelper
+		});
+		return {
+			transformed: current !== original,
+			sourceFile: current
+		};
+	} };
+};
+
+//#endregion
+export { createAfterStubTransformer, createTransformer };
+//# sourceMappingURL=index.mjs.map