@soda-gql/builder 0.8.0 → 0.8.2

package/dist/index.cjs

@@ -1804,25 +1804,41 @@ const collectAllDefinitions$1 = ({ module: module$1, gqlIdentifiers, imports: _i
 		if (node.type === "CallExpression") {
 			const gqlCall = unwrapMethodChains$1(gqlIdentifiers, node);
 			if (gqlCall) {
-				const { astPath } = tracker.registerDefinition();
-				const isTopLevel = stack.length === 1;
-				let isExported = false;
-				let exportBinding;
-				if (isTopLevel && stack[0]) {
-					const topLevelName = stack[0].nameSegment;
-					if (exportBindings.has(topLevelName)) {
-						isExported = true;
-						exportBinding = exportBindings.get(topLevelName);
+				const needsAnonymousScope = tracker.currentDepth() === 0;
+				let anonymousScopeHandle;
+				if (needsAnonymousScope) {
+					const anonymousName = getAnonymousName("anonymous");
+					anonymousScopeHandle = tracker.enterScope({
+						segment: anonymousName,
+						kind: "expression",
+						stableKey: "anonymous"
+					});
+				}
+				try {
+					const { astPath } = tracker.registerDefinition();
+					const isTopLevel = stack.length === 1;
+					let isExported = false;
+					let exportBinding;
+					if (isTopLevel && stack[0]) {
+						const topLevelName = stack[0].nameSegment;
+						if (exportBindings.has(topLevelName)) {
+							isExported = true;
+							exportBinding = exportBindings.get(topLevelName);
+						}
+					}
+					handledCalls.push(node);
+					pending.push({
+						astPath,
+						isTopLevel,
+						isExported,
+						exportBinding,
+						expression: expressionFromCall(gqlCall)
+					});
+				} finally {
+					if (anonymousScopeHandle) {
+						tracker.exitScope(anonymousScopeHandle);
 					}
 				}
-				handledCalls.push(node);
-				pending.push({
-					astPath,
-					isTopLevel,
-					isExported,
-					exportBinding,
-					expression: expressionFromCall(gqlCall)
-				});
 				return;
 			}
 		}
@@ -1835,6 +1851,8 @@ const collectAllDefinitions$1 = ({ module: module$1, gqlIdentifiers, imports: _i
 							visit(decl.init, newStack);
 						});
 					}
+				} else if (decl.init) {
+					visit(decl.init, stack);
 				}
 			});
 			return;
@@ -2186,25 +2204,41 @@ const collectAllDefinitions = ({ sourceFile, identifiers, exports: exports$1 })
 		if (typescript.default.isCallExpression(node)) {
 			const gqlCall = unwrapMethodChains(identifiers, node);
 			if (gqlCall) {
-				const { astPath } = tracker.registerDefinition();
-				const isTopLevel = stack.length === 1;
-				let isExported = false;
-				let exportBinding;
-				if (isTopLevel && stack[0]) {
-					const topLevelName = stack[0].nameSegment;
-					if (exportBindings.has(topLevelName)) {
-						isExported = true;
-						exportBinding = exportBindings.get(topLevelName);
+				const needsAnonymousScope = tracker.currentDepth() === 0;
+				let anonymousScopeHandle;
+				if (needsAnonymousScope) {
+					const anonymousName = getAnonymousName("anonymous");
+					anonymousScopeHandle = tracker.enterScope({
+						segment: anonymousName,
+						kind: "expression",
+						stableKey: "anonymous"
+					});
+				}
+				try {
+					const { astPath } = tracker.registerDefinition();
+					const isTopLevel = stack.length === 1;
+					let isExported = false;
+					let exportBinding;
+					if (isTopLevel && stack[0]) {
+						const topLevelName = stack[0].nameSegment;
+						if (exportBindings.has(topLevelName)) {
+							isExported = true;
+							exportBinding = exportBindings.get(topLevelName);
+						}
+					}
+					handledCalls.push(node);
+					pending.push({
+						astPath,
+						isTopLevel,
+						isExported,
+						exportBinding,
+						expression: gqlCall.getText(sourceFile)
+					});
+				} finally {
+					if (anonymousScopeHandle) {
+						tracker.exitScope(anonymousScopeHandle);
 					}
 				}
-				handledCalls.push(node);
-				pending.push({
-					astPath,
-					isTopLevel,
-					isExported,
-					exportBinding,
-					expression: gqlCall.getText(sourceFile)
-				});
 				return;
 			}
 		}
@@ -2377,20 +2411,58 @@ const toEntryKey = (key) => {
 	return hasher.hash(key, "xxhash");
 };
 const PERSISTENCE_VERSION = "v1";
+/**
+* Validate persisted data structure.
+* Uses simple validation to detect corruption without strict schema.
+*/
+const isValidPersistedData = (data) => {
+	if (typeof data !== "object" || data === null) return false;
+	const record = data;
+	if (typeof record.version !== "string") return false;
+	if (typeof record.storage !== "object" || record.storage === null) return false;
+	for (const value of Object.values(record.storage)) {
+		if (!Array.isArray(value)) return false;
+		for (const entry of value) {
+			if (!Array.isArray(entry) || entry.length !== 2) return false;
+			if (typeof entry[0] !== "string") return false;
+			const envelope = entry[1];
+			if (typeof envelope !== "object" || envelope === null) return false;
+			const env = envelope;
+			if (typeof env.key !== "string" || typeof env.version !== "string") return false;
+		}
+	}
+	return true;
+};
 const createMemoryCache = ({ prefix = [], persistence } = {}) => {
 	const storage = new Map();
 	if (persistence?.enabled) {
 		try {
 			if ((0, node_fs.existsSync)(persistence.filePath)) {
 				const content = (0, node_fs.readFileSync)(persistence.filePath, "utf-8");
-				const data = JSON.parse(content);
-				if (data.version === PERSISTENCE_VERSION && data.storage) {
-					for (const [namespaceKey, entries] of Object.entries(data.storage)) {
-						const namespaceMap = new Map();
-						for (const [hashedKey, envelope] of entries) {
-							namespaceMap.set(hashedKey, envelope);
+				let parsed;
+				try {
+					parsed = JSON.parse(content);
+				} catch {
+					console.warn(`[cache] Corrupt cache file (invalid JSON), starting fresh: ${persistence.filePath}`);
+					try {
+						(0, node_fs.unlinkSync)(persistence.filePath);
+					} catch {}
+					parsed = null;
+				}
+				if (parsed) {
+					if (!isValidPersistedData(parsed)) {
+						console.warn(`[cache] Corrupt cache file (invalid structure), starting fresh: ${persistence.filePath}`);
+						try {
+							(0, node_fs.unlinkSync)(persistence.filePath);
+						} catch {}
+					} else if (parsed.version === PERSISTENCE_VERSION) {
+						for (const [namespaceKey, entries] of Object.entries(parsed.storage)) {
+							const namespaceMap = new Map();
+							for (const [hashedKey, envelope] of entries) {
+								namespaceMap.set(hashedKey, envelope);
+							}
+							storage.set(namespaceKey, namespaceMap);
 						}
-						storage.set(namespaceKey, namespaceMap);
 					}
 				}
 			}
@@ -2511,11 +2583,8 @@ const createMemoryCache = ({ prefix = [], persistence } = {}) => {
 					version: PERSISTENCE_VERSION,
 					storage: serialized
 				};
-				const dir = (0, node_path.dirname)(persistence.filePath);
-				if (!(0, node_fs.existsSync)(dir)) {
-					(0, node_fs.mkdirSync)(dir, { recursive: true });
-				}
-				(0, node_fs.writeFileSync)(persistence.filePath, JSON.stringify(data), "utf-8");
+				const fs = (0, __soda_gql_common.getPortableFS)();
+				fs.writeFileSyncAtomic(persistence.filePath, JSON.stringify(data));
 			} catch (error) {
 				console.warn(`[cache] Failed to save cache to ${persistence.filePath}:`, error);
 			}
@@ -3244,6 +3313,43 @@ const collectAffectedFiles = (input) => {
 //#endregion
 //#region packages/builder/src/session/builder-session.ts
 /**
+* Singleton state for beforeExit handler registration.
+* Ensures only one handler is registered regardless of how many sessions are created.
+*/
+const exitHandlerState = {
+	registered: false,
+	factories: new Set()
+};
+/**
+* Register a cache factory for save on process exit.
+* Uses singleton pattern to prevent multiple handler registrations.
+*/
+const registerExitHandler = (cacheFactory) => {
+	exitHandlerState.factories.add(cacheFactory);
+	if (!exitHandlerState.registered) {
+		exitHandlerState.registered = true;
+		process.on("beforeExit", () => {
+			for (const factory of exitHandlerState.factories) {
+				factory.save();
+			}
+		});
+	}
+};
+/**
+* Unregister a cache factory from the exit handler.
+*/
+const unregisterExitHandler = (cacheFactory) => {
+	exitHandlerState.factories.delete(cacheFactory);
+};
+/**
+* Reset exit handler state for testing.
+* @internal
+*/
+const __resetExitHandlerForTests = () => {
+	exitHandlerState.registered = false;
+	exitHandlerState.factories.clear();
+};
+/**
 * Create a new builder session.
 *
 * The session maintains in-memory state across builds to enable incremental processing.
@@ -3266,9 +3372,7 @@ const createBuilderSession = (options) => {
 			filePath: (0, node_path.join)(process.cwd(), "node_modules", ".cache", "soda-gql", "builder", "cache.json")
 		}
 	});
-	process.on("beforeExit", () => {
-		cacheFactory.save();
-	});
+	registerExitHandler(cacheFactory);
 	const graphqlHelper = createGraphqlSystemIdentifyHelper(config);
 	const ensureAstAnalyzer = (0, __soda_gql_common.cachedFn)(() => createAstAnalyzer({
 		analyzer: config.analyzer,
@@ -3412,6 +3516,7 @@ const createBuilderSession = (options) => {
 		getCurrentArtifact: () => state.lastArtifact,
 		dispose: () => {
 			cacheFactory.save();
+			unregisterExitHandler(cacheFactory);
 		}
 	};
 };