@salesforce/graphiti 10.10.2

package/src/lib/__tests__/session.spec.ts

@@ -0,0 +1,292 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { describe, expect, it } from "vitest";
+import { makeSession } from "../../__tests__/helpers/schema.js";
+import { renderQuery } from "../query-builder.js";
+import {
+	addVariable,
+	appendListElement,
+	buildRuntimeVariables,
+	cloneSession,
+	createSiblingFieldInstance,
+	deepGetArg,
+	deepRemoveArg,
+	deepSetArg,
+	deepSetVariableValue,
+	getArgsFieldPath,
+	getInputSubPath,
+	getNavigationContext,
+	isInArgsContext,
+	loadSession,
+	parseVariablePath,
+	queryNavToSchemaPath,
+	removeListElement,
+	saveSession,
+	selectLeaf,
+	setAliasOnPath,
+	setArg,
+} from "../session.js";
+
+describe("session", () => {
+	describe("navigation context helpers", () => {
+		it("getNavigationContext returns correct contexts", () => {
+			expect(getNavigationContext([])).toBe("root");
+			expect(getNavigationContext(["query"])).toBe("query");
+			expect(getNavigationContext(["query", "uiapi"])).toBe("query");
+			expect(getNavigationContext(["variables"])).toBe("variables");
+			expect(getNavigationContext(["variables", "$filter"])).toBe("variables");
+		});
+
+		it("isInArgsContext detects @args segment", () => {
+			expect(isInArgsContext(["query", "accounts", "@args"])).toBe(true);
+			expect(isInArgsContext(["query", "accounts", "@args", "where"])).toBe(true);
+			expect(isInArgsContext(["query", "accounts"])).toBe(false);
+			expect(isInArgsContext([])).toBe(false);
+		});
+
+		it("getArgsFieldPath extracts field path before @args", () => {
+			expect(getArgsFieldPath(["query", "accounts", "@args", "where"])).toEqual(["accounts"]);
+			expect(getArgsFieldPath(["query", "viewer", "@args"])).toEqual(["viewer"]);
+			expect(getArgsFieldPath([])).toEqual([]);
+		});
+
+		it("getInputSubPath extracts path after @args", () => {
+			expect(getInputSubPath(["query", "accounts", "@args", "where", "name"])).toEqual([
+				"where",
+				"name",
+			]);
+			expect(getInputSubPath(["query", "accounts", "@args"])).toEqual([]);
+			expect(getInputSubPath([])).toEqual([]);
+		});
+
+		it("queryNavToSchemaPath strips query prefix and stops at @args", () => {
+			expect(queryNavToSchemaPath(["query", "accounts"])).toEqual(["accounts"]);
+			expect(queryNavToSchemaPath(["query", "accounts", "@args", "where"])).toEqual(["accounts"]);
+			expect(queryNavToSchemaPath([])).toEqual([]);
+			expect(queryNavToSchemaPath(["variables"])).toEqual([]);
+		});
+
+		it("parseVariablePath extracts variable name and sub-path", () => {
+			const result = parseVariablePath(["variables", "$filter", "name"]);
+			expect(result).not.toBeNull();
+			expect(result!.varName).toBe("filter");
+			expect(result!.inputSubPath).toEqual(["name"]);
+
+			expect(parseVariablePath(["query"])).toBeNull();
+			expect(parseVariablePath(["variables"])).toBeNull();
+		});
+	});
+
+	describe("deep set/get helpers", () => {
+		it("deepSetArg creates nested JSON structure", () => {
+			const session = makeSession();
+			session.navigationPath = ["query", "accounts"];
+
+			setArg(session, ["accounts"], "first", "10");
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+
+			deepSetArg(session, ["accounts"], "where", ["name", "like"], '"Acme%"');
+
+			const raw = session.nodes.find((n) => n.kind === "field" && n.fieldName === "accounts")!;
+			expect(raw.kind).toBe("field");
+			if (raw.kind !== "field") throw new Error("unreachable");
+			const parsed = JSON.parse(raw.args["where"]);
+			expect(parsed).toEqual({ name: { like: "Acme%" } });
+		});
+
+		it("deepSetArg merges with existing values", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+			deepSetArg(session, ["accounts"], "where", ["name", "like"], '"Acme%"');
+			deepSetArg(session, ["accounts"], "where", ["minRevenue"], "1000");
+
+			const raw = session.nodes.find((n) => n.kind === "field" && n.fieldName === "accounts")!;
+			expect(raw.kind).toBe("field");
+			if (raw.kind !== "field") throw new Error("unreachable");
+			const parsed = JSON.parse(raw.args["where"]);
+			expect(parsed).toEqual({ name: { like: "Acme%" }, minRevenue: 1000 });
+		});
+
+		it("deepSetArg with empty inputPath sets top-level arg directly", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+			deepSetArg(session, ["accounts"], "first", [], "10");
+
+			const raw = session.nodes.find((n) => n.kind === "field" && n.fieldName === "accounts")!;
+			expect(raw.kind).toBe("field");
+			if (raw.kind !== "field") throw new Error("unreachable");
+			expect(raw.args["first"]).toBe("10");
+		});
+
+		it("deepGetArg retrieves nested values", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+			deepSetArg(session, ["accounts"], "where", ["name", "like"], '"Acme%"');
+
+			const value = deepGetArg(session, ["accounts"], "where", ["name", "like"]);
+			expect(value).toBe("Acme%");
+
+			const whole = deepGetArg(session, ["accounts"], "where", []);
+			expect(typeof whole).toBe("string");
+		});
+
+		it("deepRemoveArg removes nested values", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+			deepSetArg(session, ["accounts"], "where", ["name", "like"], '"Acme%"');
+			deepSetArg(session, ["accounts"], "where", ["minRevenue"], "100");
+
+			const removed = deepRemoveArg(session, ["accounts"], "where", ["name", "like"]);
+			expect(removed).toBe(true);
+
+			const remaining = deepGetArg(session, ["accounts"], "where", ["minRevenue"]);
+			expect(remaining).toBe(100);
+		});
+
+		it("deepSetVariableValue builds nested variable runtime values", () => {
+			const session = makeSession();
+			addVariable(session, "filter", "AccountFilter");
+
+			deepSetVariableValue(session, "filter", ["name", "like"], '"Test%"');
+
+			const variable = session.variables.find((v) => v.name === "filter")!;
+			expect(variable.runtimeValue).toBeDefined();
+			const parsed = JSON.parse(variable.runtimeValue!);
+			expect(parsed).toEqual({ name: { like: "Test%" } });
+		});
+	});
+
+	describe("list element management", () => {
+		it("appendListElement creates array elements", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+
+			const idx0 = appendListElement(session, ["accounts"], "orderBy", []);
+			expect(idx0).toBe(0);
+
+			const idx1 = appendListElement(session, ["accounts"], "orderBy", []);
+			expect(idx1).toBe(1);
+
+			const raw = session.nodes.find((n) => n.kind === "field" && n.fieldName === "accounts")!;
+			expect(raw.kind).toBe("field");
+			if (raw.kind !== "field") throw new Error("unreachable");
+			const parsed = JSON.parse(raw.args["orderBy"]);
+			expect(Array.isArray(parsed)).toBe(true);
+			expect(parsed).toHaveLength(2);
+		});
+
+		it("removeListElement splices array", () => {
+			const session = makeSession();
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+
+			appendListElement(session, ["accounts"], "orderBy", []);
+			appendListElement(session, ["accounts"], "orderBy", []);
+
+			const removed = removeListElement(session, ["accounts"], "orderBy", [], 0);
+			expect(removed).toBe(true);
+
+			const raw = session.nodes.find((n) => n.kind === "field" && n.fieldName === "accounts")!;
+			expect(raw.kind).toBe("field");
+			if (raw.kind !== "field") throw new Error("unreachable");
+			const parsed = JSON.parse(raw.args["orderBy"]);
+			expect(parsed).toHaveLength(1);
+		});
+	});
+
+	describe("session migration", () => {
+		it("loadSession auto-migrates old navigation paths", () => {
+			const session = makeSession();
+			session.navigationPath = ["accounts"]; // old-style path without "query" prefix
+			saveSession(session);
+
+			const loaded = loadSession(session.id);
+			expect(loaded.navigationPath).toEqual(["query", "accounts"]);
+		});
+
+		it("loadSession does not double-prefix already-migrated paths", () => {
+			const session = makeSession();
+			session.navigationPath = ["query", "accounts"];
+			saveSession(session);
+
+			const loaded = loadSession(session.id);
+			expect(loaded.navigationPath).toEqual(["query", "accounts"]);
+		});
+	});
+
+	describe("aliasing & cloning", () => {
+		it("supports multiple instances of the same field with different variables", () => {
+			const session = makeSession();
+
+			addVariable(session, "$limit", "Int");
+			addVariable(session, "$otherLimit", "Int");
+			addVariable(session, "$accountFilter", "AccountFilter");
+			addVariable(session, "$otherFilter", "AccountFilter");
+
+			session.navigationPath = ["query", "accounts"];
+			setAliasOnPath(session, ["accounts"], "highRevenueAccounts");
+			setArg(session, ["accounts"], "first", "$limit");
+			setArg(session, ["accounts"], "where", "$accountFilter");
+
+			session.navigationPath = ["query", "accounts", "edges", "node"];
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+
+			session.navigationPath = ["query", "accounts"];
+			createSiblingFieldInstance(session, ["accounts"], "regionalAccounts");
+			setArg(session, ["accounts"], "first", "$otherLimit");
+			setArg(session, ["accounts"], "where", "$otherFilter");
+
+			session.navigationPath = ["query", "accounts", "edges", "node"];
+			selectLeaf(session, ["accounts", "edges", "node", "id"]);
+
+			// Assertion lives in query-builder.spec.ts; here we only verify session state changes.
+			const aliased = session.nodes.filter((n) => n.kind === "field" && n.fieldName === "accounts");
+			expect(aliased.length).toBeGreaterThanOrEqual(2);
+		});
+
+		it("cloneSession produces a deep copy with a new id", () => {
+			const session = makeSession();
+			addVariable(session, "limit", "Int", "10");
+			session.navigationPath = ["query", "accounts"];
+			setAliasOnPath(session, ["accounts"], "myAccounts");
+			setArg(session, ["accounts"], "first", "5");
+
+			session.navigationPath = ["query", "accounts", "edges", "node"];
+			selectLeaf(session, ["accounts", "edges", "node", "name"]);
+
+			const cloned = cloneSession(session, "my-clone");
+
+			expect(cloned.id).not.toBe(session.id);
+			expect(cloned.name).toBe("my-clone");
+			expect(cloned.variables).toHaveLength(session.variables.length);
+			expect(cloned.nodes).toHaveLength(session.nodes.length);
+			expect(renderQuery(cloned)).toBe(renderQuery(session));
+
+			addVariable(cloned, "extra", "String");
+			expect(cloned.variables.length).not.toBe(session.variables.length);
+		});
+	});
+
+	describe("runtime variable building", () => {
+		it("runtime variables are built from runtime values and defaults", () => {
+			const session = makeSession();
+
+			addVariable(session, "$limit", "Int", "10");
+			addVariable(session, "$filters", "AccountFilter");
+			addVariable(session, "$isActive", "Boolean");
+
+			session.variables.find((variable) => variable.name === "filters")!.runtimeValue =
+				'{"minRevenue":1000}';
+			session.variables.find((variable) => variable.name === "isActive")!.runtimeValue = "true";
+
+			expect(buildRuntimeVariables(session)).toEqual({
+				limit: 10,
+				filters: { minRevenue: 1000 },
+				isActive: true,
+			});
+		});
+	});
+});

package/src/lib/__tests__/tokenize.spec.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { describe, expect, it } from "vitest";
+import { tokenizeCommand } from "../tokenize.js";
+
+describe("lib/tokenize", () => {
+	it("splits on unquoted spaces", () => {
+		expect(tokenizeCommand("select Id Name")).toEqual(["select", "Id", "Name"]);
+	});
+
+	it("keeps single-quoted segments intact", () => {
+		expect(tokenizeCommand('set where=\'{"Status":{"eq":"New"}}\'')).toEqual([
+			"set",
+			'where=\'{"Status":{"eq":"New"}}\'',
+		]);
+	});
+
+	it("keeps double-quoted segments intact", () => {
+		expect(tokenizeCommand('set @args/where/Name/like "Acme%"')).toEqual([
+			"set",
+			"@args/where/Name/like",
+			"Acme%",
+		]);
+	});
+
+	it("returns empty array for blank input", () => {
+		expect(tokenizeCommand("   ")).toEqual([]);
+	});
+});

package/src/lib/__tests__/uiapi.spec.ts

@@ -0,0 +1,192 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { buildSchema } from "graphql";
+import { describe, expect, it } from "vitest";
+import {
+	aggregatePath,
+	connectionNodePath,
+	connectionPath,
+	createInputTypeName,
+	filterTypeName,
+	isValueWrapperType,
+	mutationFieldPath,
+	mutationRecordPath,
+	nodePath,
+	orderByTypeName,
+	pageInfoPath,
+	resolveScalarSelectionPath,
+	updateInputTypeName,
+} from "../uiapi.js";
+
+describe("uiapi", () => {
+	describe("path constructors", () => {
+		it("connectionPath builds the uiapi.query.<Object> path", () => {
+			expect(connectionPath("Account")).toEqual(["uiapi", "query", "Account"]);
+		});
+
+		it("nodePath descends through edges/node from the connection", () => {
+			expect(nodePath("Account")).toEqual(["uiapi", "query", "Account", "edges", "node"]);
+		});
+
+		it("connectionNodePath works on any connection path (incl. nested children)", () => {
+			const nestedConnection = ["uiapi", "query", "Account", "edges", "node", "Cases"];
+			expect(connectionNodePath(nestedConnection)).toEqual([
+				"uiapi",
+				"query",
+				"Account",
+				"edges",
+				"node",
+				"Cases",
+				"edges",
+				"node",
+			]);
+		});
+
+		it("pageInfoPath sits at the connection root", () => {
+			expect(pageInfoPath(["uiapi", "query", "Account"])).toEqual([
+				"uiapi",
+				"query",
+				"Account",
+				"pageInfo",
+			]);
+		});
+
+		it("mutationFieldPath builds uiapi.<Object><Op> for each mutation kind", () => {
+			expect(mutationFieldPath("Account", "Create")).toEqual(["uiapi", "AccountCreate"]);
+			expect(mutationFieldPath("Account", "Update")).toEqual(["uiapi", "AccountUpdate"]);
+			expect(mutationFieldPath("Account", "Delete")).toEqual(["uiapi", "AccountDelete"]);
+		});
+
+		it("mutationRecordPath descends into the Record selection scope", () => {
+			expect(mutationRecordPath("Account", "Create")).toEqual(["uiapi", "AccountCreate", "Record"]);
+		});
+
+		it("aggregatePath builds the aggregate root", () => {
+			expect(aggregatePath("Account")).toEqual(["uiapi", "aggregate", "Account"]);
+		});
+	});
+
+	describe("naming conventions", () => {
+		it("filterTypeName / orderByTypeName / *InputTypeName follow Salesforce conventions", () => {
+			expect(filterTypeName("Account")).toBe("Account_Filter");
+			expect(orderByTypeName("Account")).toBe("Account_OrderBy");
+			expect(createInputTypeName("Account")).toBe("AccountCreateInput");
+			expect(updateInputTypeName("Account")).toBe("AccountUpdateInput");
+		});
+	});
+
+	describe("isValueWrapperType", () => {
+		const wrapperSchema = buildSchema(`
+			type Query {
+				any: Holder
+			}
+
+			type Holder {
+				Id: ID!
+				Name: StringValue
+				Status: PicklistValue
+				# A *Value-named type that does NOT have a value field — the
+				# detection helper must reject this to avoid false positives.
+				ImpostorValue: Impostor
+			}
+
+			type StringValue { value: String }
+			type PicklistValue { value: String }
+			type Impostor { other: String }
+		`);
+
+		it("detects StringValue and PicklistValue", () => {
+			expect(isValueWrapperType(wrapperSchema, "StringValue")).toBe(true);
+			expect(isValueWrapperType(wrapperSchema, "PicklistValue")).toBe(true);
+		});
+
+		it("rejects *Value types that don't expose a `value` field", () => {
+			expect(isValueWrapperType(wrapperSchema, "Impostor")).toBe(false);
+		});
+
+		it("returns false for unknown / non-object types", () => {
+			expect(isValueWrapperType(wrapperSchema, "DoesNotExist")).toBe(false);
+			expect(isValueWrapperType(wrapperSchema, "ID")).toBe(false);
+		});
+	});
+
+	describe("resolveScalarSelectionPath", () => {
+		const sobjectSchema = buildSchema(`
+			type Query {
+				uiapi: UIAPI!
+			}
+
+			type UIAPI {
+				query: RecordQuery!
+			}
+
+			type RecordQuery {
+				Account: AccountConnection!
+			}
+
+			type AccountConnection { edges: [AccountEdge!]! }
+			type AccountEdge { node: Account! }
+
+			type Account {
+				Id: ID!
+				Name: StringValue
+				Industry: StringValue
+				Owner: OwnerUnion
+			}
+
+			union OwnerUnion = User | Group
+			type User { Id: ID! }
+			type Group { Id: ID! }
+
+			type StringValue { value: String }
+		`);
+
+		const accountNodePath = ["uiapi", "query", "Account", "edges", "node"];
+
+		it("returns the leaf path for Id (no value wrapper)", () => {
+			expect(resolveScalarSelectionPath(sobjectSchema, "query", accountNodePath, "Id")).toEqual([
+				"uiapi",
+				"query",
+				"Account",
+				"edges",
+				"node",
+				"Id",
+			]);
+		});
+
+		it("appends 'value' for value-wrapper fields", () => {
+			expect(resolveScalarSelectionPath(sobjectSchema, "query", accountNodePath, "Name")).toEqual([
+				"uiapi",
+				"query",
+				"Account",
+				"edges",
+				"node",
+				"Name",
+				"value",
+			]);
+		});
+
+		it("returns the field path for non-leaf, non-wrapper types", () => {
+			// Owner is a union — the helper returns the bare path; callers that
+			// need union expansion use selectDottedFieldPath from path-selection.ts.
+			expect(resolveScalarSelectionPath(sobjectSchema, "query", accountNodePath, "Owner")).toEqual([
+				"uiapi",
+				"query",
+				"Account",
+				"edges",
+				"node",
+				"Owner",
+			]);
+		});
+
+		it("returns null when the field can't be resolved", () => {
+			expect(
+				resolveScalarSelectionPath(sobjectSchema, "query", accountNodePath, "NotARealField"),
+			).toBeNull();
+		});
+	});
+});