@salesforce/graphiti 10.10.2

package/src/commands/session-mgmt.ts

@@ -0,0 +1,256 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { CommandError, getSessionSchema, printQuery } from "./query-helpers.js";
+import { getOrgAuth } from "../lib/auth.js";
+import { formatNavigationPath } from "../lib/formatter.js";
+import { schemaExists } from "../lib/introspect.js";
+import { renderQuery } from "../lib/query-builder.js";
+import {
+	createSession,
+	cloneSession,
+	loadSession,
+	saveSession,
+	deleteSession,
+	listSessions,
+	type QuerySession,
+} from "../lib/session.js";
+import { validateQuery } from "../lib/validator.js";
+import { getRootFields } from "../lib/walker.js";
+
+export interface NewSessionOpts {
+	mutation?: boolean;
+	aggregate?: boolean;
+	name?: string;
+	force?: boolean;
+}
+
+export async function queryNew(orgAlias: string, opts: NewSessionOpts): Promise<QuerySession> {
+	if (opts.mutation && opts.aggregate) {
+		throw new CommandError("Cannot use --mutation and --aggregate together. Choose one.");
+	}
+
+	const { instanceUrl } = await getOrgAuth(orgAlias);
+
+	if (!schemaExists(instanceUrl)) {
+		throw new CommandError(
+			`No cached schema for "${orgAlias}". Run \`graphiti connect ${orgAlias}\` first.`,
+		);
+	}
+
+	const operation = opts.mutation
+		? ("mutation" as const)
+		: opts.aggregate
+			? ("aggregate" as const)
+			: ("query" as const);
+
+	if (opts.name) {
+		const existing = listSessions().find((s) => s.name === opts.name);
+		if (existing) {
+			if (opts.force) {
+				deleteSession(existing.id);
+			} else {
+				throw new CommandError(
+					`A session named "${opts.name}" already exists (${existing.id}). ` +
+						`Remove it first with \`graphiti query sessions rm ${opts.name}\`, use --force to replace it, or choose a different name.`,
+				);
+			}
+		}
+	}
+
+	const session = createSession(orgAlias, operation, instanceUrl, opts.name);
+	saveSession(session);
+
+	const schema = getSessionSchema(session);
+	const rootFields = getRootFields(schema, operation);
+
+	console.log(`Session: ${session.id}${session.name ? ` (${session.name})` : ""}`);
+	if (session.name) {
+		console.log(`Use "${session.id}" or "${session.name}" in subsequent commands.`);
+	}
+	console.log(formatNavigationPath(session.navigationPath));
+	console.log("  query/");
+	console.log("  variables/");
+	console.log("");
+	console.log(`Schema root (query/): ${rootFields.length} fields`);
+	for (const field of rootFields.slice(0, 10)) {
+		console.log(
+			`  ${field.name}${field.typeKind === "SCALAR" || field.typeKind === "ENUM" ? "" : "/"}`,
+		);
+	}
+	if (rootFields.length > 10) {
+		console.log(`  ... ${rootFields.length - 10} more (use \`cd query\` then \`ls\` to browse)`);
+	}
+	console.log("");
+	printQuery(session);
+
+	return session;
+}
+
+export function queryClone(
+	sessionId: string,
+	newName?: string,
+	opts?: { force?: boolean },
+): { id: string; name?: string } {
+	const source = loadSession(sessionId);
+	if (newName) {
+		const existing = listSessions().find((s) => s.name === newName);
+		if (existing) {
+			if (opts?.force) {
+				deleteSession(existing.id);
+			} else {
+				throw new CommandError(
+					`A session named "${newName}" already exists (${existing.id}). ` +
+						`Remove it first, use --force to replace it, or choose a different name.`,
+				);
+			}
+		}
+	}
+	const cloned = cloneSession(source, newName);
+	saveSession(cloned);
+	console.log(
+		`Cloned session ${source.id}${source.name ? ` (${source.name})` : ""} → ${cloned.id}${cloned.name ? ` (${cloned.name})` : ""}`,
+	);
+	if (cloned.name) {
+		console.log(`Use "${cloned.id}" or "${cloned.name}" in subsequent commands.`);
+	}
+	console.log("");
+	printQuery(cloned);
+	return { id: cloned.id, name: cloned.name };
+}
+
+export function querySessionsList(): void {
+	const sessions = listSessions().sort(
+		(a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+	);
+
+	if (sessions.length === 0) {
+		console.log("No sessions found. Run `graphiti query new <org>` to create one.");
+		return;
+	}
+
+	console.log(`${sessions.length} session${sessions.length === 1 ? "" : "s"}:`);
+	console.log("");
+	const maxIdNameLen = Math.max(
+		...sessions.map((s) => {
+			const nameDisplay = s.name ? ` (${s.name})` : "";
+			return (s.id + nameDisplay).length;
+		}),
+	);
+	for (const s of sessions) {
+		const age = formatAge(new Date(s.createdAt));
+		const nameDisplay = s.name ? ` (${s.name})` : "";
+		const idCol = (s.id + nameDisplay).padEnd(maxIdNameLen + 2);
+		console.log(`  ${idCol}${s.operation.padEnd(10)}${s.orgAlias.padEnd(20)} ${age}`);
+	}
+	console.log("");
+	console.log("Resume a session (by ID or name):");
+	if (sessions.length > 0) {
+		const s = sessions[0];
+		const identifier = s.name ?? s.id;
+		console.log(`  graphiti query ${identifier} ls`);
+		console.log(`  graphiti query ${identifier} interactive`);
+	}
+}
+
+export function querySessionsRm(sessionIdOrName: string): void {
+	if (sessionIdOrName === "--all") {
+		const sessions = listSessions();
+		if (sessions.length === 0) {
+			console.log("No sessions to delete.");
+			return;
+		}
+		for (const s of sessions) {
+			deleteSession(s.id);
+		}
+		console.log(`Deleted ${sessions.length} session${sessions.length === 1 ? "" : "s"}.`);
+		return;
+	}
+
+	const deleted = deleteSession(sessionIdOrName);
+	if (!deleted) {
+		throw new CommandError(`Session "${sessionIdOrName}" not found.`);
+	}
+	console.log(`Deleted session "${sessionIdOrName}".`);
+}
+
+export function parseDuration(str: string): number {
+	const match = str.match(/^(\d+)\s*(s|m|h|d|w)$/);
+	if (!match)
+		throw new CommandError(`Invalid duration "${str}". Use format: 1d, 12h, 30m, 7w, etc.`);
+	const value = parseInt(match[1], 10);
+	const unit = match[2];
+	const multipliers: Record<string, number> = {
+		s: 1000,
+		m: 60_000,
+		h: 3_600_000,
+		d: 86_400_000,
+		w: 604_800_000,
+	};
+	return value * multipliers[unit];
+}
+
+export function querySessionsClean(): void {
+	const sessions = listSessions();
+	if (sessions.length === 0) {
+		console.log("No sessions found.");
+		return;
+	}
+
+	let cleaned = 0;
+
+	for (const sessionMeta of sessions) {
+		const identifier = sessionMeta.name ?? sessionMeta.id;
+		try {
+			const session = loadSession(sessionMeta.id);
+			const schema = getSessionSchema(session);
+			const queryString = renderQuery(session);
+			const errors = validateQuery(schema, queryString);
+			if (errors.length > 0) {
+				deleteSession(sessionMeta.id);
+				console.log(
+					`  Removed ${identifier} (${errors.length} error${errors.length !== 1 ? "s" : ""})`,
+				);
+				cleaned++;
+			}
+		} catch {
+			deleteSession(sessionMeta.id);
+			console.log(`  Removed ${identifier} (load/schema error)`);
+			cleaned++;
+		}
+	}
+
+	if (cleaned === 0) {
+		console.log("All sessions are valid. Nothing to clean.");
+	} else {
+		console.log(`\nCleaned ${cleaned} invalid session${cleaned !== 1 ? "s" : ""}.`);
+	}
+}
+
+export function querySessionsPrune(olderThan: string): void {
+	const maxAgeMs = parseDuration(olderThan);
+	const sessions = listSessions();
+	const cutoff = Date.now() - maxAgeMs;
+	let count = 0;
+	for (const s of sessions) {
+		if (new Date(s.createdAt).getTime() < cutoff) {
+			deleteSession(s.id);
+			count++;
+		}
+	}
+	console.log(`Pruned ${count} session${count === 1 ? "" : "s"} older than ${olderThan}.`);
+}
+
+export function formatAge(date: Date): string {
+	const diffMs = Date.now() - date.getTime();
+	const diffSec = Math.floor(diffMs / 1000);
+	if (diffSec < 60) return `${diffSec}s ago`;
+	const diffMin = Math.floor(diffSec / 60);
+	if (diffMin < 60) return `${diffMin}m ago`;
+	const diffHr = Math.floor(diffMin / 60);
+	if (diffHr < 24) return `${diffHr}h ago`;
+	return `${Math.floor(diffHr / 24)}d ago`;
+}

package/src/commands/type.ts

@@ -0,0 +1,437 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { type GraphQLSchema, isInputObjectType } from "graphql";
+import { getOrgAuth } from "../lib/auth.js";
+import { formatTypeInfo, type TypeAnnotations } from "../lib/formatter.js";
+import {
+	getObjectInfo,
+	getCachedObjectInfo,
+	type ObjectInfoResult,
+	type FieldMetadata,
+} from "../lib/object-info.js";
+import { getSchema, inspectType, type TypeInfo } from "../lib/walker.js";
+
+export async function typeCommand(orgAlias: string, typeName: string): Promise<void> {
+	const auth = await getOrgAuth(orgAlias);
+	const schema = getSchema(auth.instanceUrl);
+	const info = inspectType(schema, typeName);
+	const annotations = await buildAnnotations(schema, orgAlias, typeName, info);
+	console.log(formatTypeInfo(info, annotations));
+}
+
+// ── Annotation builders ───────────────────────────────────────────────────────
+
+async function buildAnnotations(
+	schema: GraphQLSchema,
+	orgAlias: string,
+	typeName: string,
+	info: TypeInfo,
+): Promise<TypeAnnotations> {
+	const ann: TypeAnnotations = {};
+
+	switch (info.kind) {
+		case "OBJECT":
+		case "INTERFACE":
+			annotateObjectFields(schema, info, ann);
+			await annotateObjectWithObjectInfo(schema, orgAlias, typeName, info, ann);
+			break;
+
+		case "INPUT_OBJECT":
+			await annotateInputObject(schema, orgAlias, typeName, info, ann);
+			break;
+	}
+
+	return ann;
+}
+
+/**
+ * For OBJECT/INTERFACE types: annotate fields with wrapper-type leaf fields
+ * (e.g. StringValue → { value, displayValue, label }) and child relationship args.
+ */
+function annotateObjectFields(schema: GraphQLSchema, info: TypeInfo, ann: TypeAnnotations): void {
+	ann.fieldComments = ann.fieldComments ?? new Map();
+
+	for (const field of info.fields) {
+		const comments: string[] = [];
+
+		if (field.args.length > 0) {
+			const argSummary = field.args
+				.map((a) => {
+					if (a.enumValues) return `${a.name}: ${a.enumValues.join(" | ")}`;
+					return `${a.name}: ${a.typeName}`;
+				})
+				.join(", ");
+			comments.push(`child: ${argSummary}`);
+		}
+
+		if (comments.length > 0) {
+			ann.fieldComments.set(field.name, comments);
+		}
+	}
+}
+
+/**
+ * Enrich OBJECT types with ObjectInfo data: parent references, child
+ * relationship targets, picklist values.
+ */
+async function annotateObjectWithObjectInfo(
+	schema: GraphQLSchema,
+	orgAlias: string,
+	typeName: string,
+	info: TypeInfo,
+	ann: TypeAnnotations,
+): Promise<void> {
+	const sObjectName = detectSObjectFromObjectType(typeName);
+	if (!sObjectName) return;
+
+	const objInfo = await fetchObjectInfoQuietly(orgAlias, sObjectName);
+	if (!objInfo) return;
+
+	ann.fieldComments = ann.fieldComments ?? new Map();
+	const fieldMap = new Map(objInfo.fields.map((f) => [f.apiName, f]));
+	const relNameMap = new Map(
+		objInfo.fields.filter((f) => f.relationshipName).map((f) => [f.relationshipName!, f]),
+	);
+
+	for (const field of info.fields) {
+		const existing = ann.fieldComments.get(field.name) ?? [];
+
+		const meta = fieldMap.get(field.name);
+		if (meta) {
+			if (meta.reference && meta.referenceToInfos.length > 0) {
+				const targets = meta.referenceToInfos.map((r) => r.apiName).join(", ");
+				existing.unshift(`-> ${targets}`);
+			}
+
+			addPicklistComment(objInfo, meta.apiName, existing);
+		}
+
+		const relMeta = relNameMap.get(field.name);
+		if (relMeta && relMeta.reference && relMeta.referenceToInfos.length > 0) {
+			const targets = relMeta.referenceToInfos.map((r) => r.apiName).join(", ");
+			if (!existing.some((c) => c.startsWith("->"))) {
+				existing.unshift(`-> ${targets}`);
+			}
+		}
+
+		if (existing.length > 0) {
+			ann.fieldComments.set(field.name, existing);
+		}
+	}
+
+	const childRelMap = new Map(
+		objInfo.childRelationships
+			.filter((cr) => cr.relationshipName)
+			.map((cr) => [cr.relationshipName!, cr]),
+	);
+	for (const field of info.fields) {
+		const cr = childRelMap.get(field.name);
+		if (cr) {
+			const existing = ann.fieldComments.get(field.name) ?? [];
+			if (!existing.some((c) => c.startsWith("child:"))) {
+				existing.unshift(`child -> ${cr.childObjectApiName}.${cr.fieldName}`);
+			}
+			ann.fieldComments.set(field.name, existing);
+		}
+	}
+}
+
+/**
+ * For INPUT_OBJECT types: detect whether it's a mutation input, filter, or
+ * orderBy and annotate accordingly.
+ */
+async function annotateInputObject(
+	schema: GraphQLSchema,
+	orgAlias: string,
+	typeName: string,
+	info: TypeInfo,
+	ann: TypeAnnotations,
+): Promise<void> {
+	ann.fieldComments = ann.fieldComments ?? new Map();
+
+	if (isFilterType(typeName)) {
+		annotateFilterFields(schema, info, ann);
+		ann.filterExamples = buildFilterExamples(typeName, info, schema);
+		return;
+	}
+
+	if (isOrderByType(typeName)) {
+		annotateOrderByFields(schema, info, ann);
+		return;
+	}
+
+	const mutationMatch = typeName.match(/^(\w+?)(Create|Update)(?:Input|Representation)$/);
+	if (mutationMatch) {
+		await annotateMutationInput(
+			schema,
+			orgAlias,
+			typeName,
+			info,
+			ann,
+			mutationMatch[1],
+			mutationMatch[2],
+		);
+	}
+}
+
+// ── Filter annotation ─────────────────────────────────────────────────────────
+
+function annotateFilterFields(schema: GraphQLSchema, info: TypeInfo, ann: TypeAnnotations): void {
+	for (const field of info.inputFields) {
+		const comments: string[] = [];
+		const namedType = schema.getType(stripWrapping(field.typeName));
+
+		if (namedType && isInputObjectType(namedType)) {
+			if (field.typeName.endsWith("Operators")) {
+				const ops = Object.keys(namedType.getFields()).join(", ");
+				comments.push(`${namedType.name}: ${ops}`);
+			} else if (field.name === "and" || field.name === "or" || field.name === "not") {
+				// combinators — no extra comment needed
+			} else {
+				comments.push("nested filter");
+			}
+		}
+
+		if (comments.length > 0) {
+			ann.fieldComments!.set(field.name, comments);
+		}
+	}
+}
+
+function buildFilterExamples(typeName: string, info: TypeInfo, schema: GraphQLSchema): string[] {
+	const examples: string[] = [];
+	const _sObject = typeName.replace(/_Filter$/, "");
+
+	const simpleField = info.inputFields.find(
+		(f) => f.typeName.endsWith("Operators") && !["and", "or", "not"].includes(f.name),
+	);
+	if (simpleField) {
+		const namedType = schema.getType(stripWrapping(simpleField.typeName));
+		if (namedType && isInputObjectType(namedType)) {
+			const ops = Object.keys(namedType.getFields());
+			const op = ops.includes("gt") ? "gt" : ops.includes("eq") ? "eq" : ops[0];
+			examples.push(`{ "${simpleField.name}": { "${op}": <value> } }`);
+		}
+	}
+
+	const twoFilterable = info.inputFields
+		.filter((f) => f.typeName.endsWith("Operators") && !["and", "or", "not"].includes(f.name))
+		.slice(0, 2);
+	if (twoFilterable.length === 2) {
+		examples.push(
+			`{ "and": [{ "${twoFilterable[0].name}": { "eq": <value> } }, { "${twoFilterable[1].name}": { "gt": <value> } }] }`,
+		);
+	}
+
+	return examples;
+}
+
+// ── OrderBy annotation ────────────────────────────────────────────────────────
+
+function annotateOrderByFields(schema: GraphQLSchema, info: TypeInfo, ann: TypeAnnotations): void {
+	let shownClause = false;
+	for (const field of info.inputFields) {
+		const comments: string[] = [];
+		const namedType = schema.getType(stripWrapping(field.typeName));
+
+		if (namedType && isInputObjectType(namedType)) {
+			const _fieldNames = Object.keys(namedType.getFields());
+			if (!shownClause && field.typeName === "OrderByClause") {
+				comments.push(`{ order: ASC | DESC, nulls: FIRST | LAST }`);
+				shownClause = true;
+			} else if (field.typeName !== "OrderByClause") {
+				comments.push(`nested: ${namedType.name}`);
+			}
+		}
+
+		if (comments.length > 0) {
+			ann.fieldComments!.set(field.name, comments);
+		}
+	}
+}
+
+// ── Mutation input annotation ─────────────────────────────────────────────────
+
+async function annotateMutationInput(
+	schema: GraphQLSchema,
+	orgAlias: string,
+	typeName: string,
+	info: TypeInfo,
+	ann: TypeAnnotations,
+	sObjectName: string,
+	_operation: string,
+): Promise<void> {
+	const objInfo = await fetchObjectInfoQuietly(orgAlias, sObjectName);
+
+	if (objInfo) {
+		const fieldMap = new Map(objInfo.fields.map((f) => [f.apiName, f]));
+
+		for (const field of info.inputFields) {
+			const comments: string[] = [];
+			const meta = fieldMap.get(field.name);
+			if (meta) {
+				addMutationFieldTags(meta, comments);
+				addPicklistComment(objInfo, meta.apiName, comments);
+				if (meta.reference && meta.referenceToInfos.length > 0) {
+					const targets = meta.referenceToInfos.map((r) => r.apiName).join(", ");
+					comments.push(`-> ${targets}`);
+				}
+			}
+			if (comments.length > 0) {
+				ann.fieldComments!.set(field.name, comments);
+			}
+		}
+	}
+
+	const nestedInput = info.inputFields.find((f) => {
+		const t = schema.getType(stripWrapping(f.typeName));
+		return t && isInputObjectType(t);
+	});
+	if (nestedInput) {
+		const nestedType = schema.getType(stripWrapping(nestedInput.typeName));
+		if (nestedType && isInputObjectType(nestedType)) {
+			const nestedInfo = inspectType(schema, nestedType.name);
+			ann.inlinedInputs = ann.inlinedInputs ?? [];
+			const nestedAnn: TypeAnnotations = { fieldComments: new Map() };
+
+			if (objInfo) {
+				const fieldMap = new Map(objInfo.fields.map((f) => [f.apiName, f]));
+				for (const field of nestedInfo.inputFields) {
+					const comments: string[] = [];
+					const meta = fieldMap.get(field.name);
+					if (meta) {
+						addMutationFieldTags(meta, comments);
+						addPicklistComment(objInfo, meta.apiName, comments);
+						if (meta.reference && meta.referenceToInfos.length > 0) {
+							const targets = meta.referenceToInfos.map((r) => r.apiName).join(", ");
+							comments.push(`-> ${targets}`);
+						}
+					}
+					if (comments.length > 0) {
+						nestedAnn.fieldComments!.set(field.name, comments);
+					}
+				}
+
+				nestedAnn.sampleInput = buildSampleInput(sObjectName, objInfo, nestedInfo);
+			}
+
+			ann.inlinedInputs.push({ info: nestedInfo, annotations: nestedAnn });
+		}
+	}
+}
+
+function addMutationFieldTags(meta: FieldMetadata, comments: string[]): void {
+	const tags: string[] = [];
+	if (meta.required && meta.createable && !meta.defaultedOnCreate) tags.push("required");
+	if (meta.defaultedOnCreate) tags.push("has default");
+	if (!meta.createable && !meta.updateable) tags.push("read-only");
+	if (tags.length > 0) comments.push(tags.join(" | "));
+}
+
+function buildSampleInput(
+	sObjectName: string,
+	objInfo: ObjectInfoResult,
+	nestedInfo: TypeInfo,
+): string {
+	const requiredFields = objInfo.fields.filter(
+		(f) => f.required && f.createable && !f.defaultedOnCreate,
+	);
+	const nestedFieldNames = new Set(nestedInfo.inputFields.map((f) => f.name));
+	const relevant = requiredFields.filter((f) => nestedFieldNames.has(f.apiName));
+
+	const entries: Record<string, string> = {};
+	for (const f of relevant) {
+		const picklist = objInfo.picklists.find((p) => p.apiName === f.apiName);
+		if (picklist && picklist.values.length > 0) {
+			entries[f.apiName] = JSON.stringify(picklist.values[0].value);
+		} else if (f.dataType === "STRING" || f.dataType === "TEXTAREA") {
+			entries[f.apiName] = `"<${f.label ?? f.apiName}>"`;
+		} else if (
+			f.dataType === "CURRENCY" ||
+			f.dataType === "DOUBLE" ||
+			f.dataType === "INT" ||
+			f.dataType === "PERCENT"
+		) {
+			entries[f.apiName] = "0";
+		} else if (f.dataType === "DATE") {
+			entries[f.apiName] = `"${new Date().toISOString().split("T")[0]}"`;
+		} else if (f.dataType === "DATETIME") {
+			entries[f.apiName] = `"${new Date().toISOString()}"`;
+		} else if (f.dataType === "BOOLEAN") {
+			entries[f.apiName] = "false";
+		} else if (f.dataType === "REFERENCE") {
+			entries[f.apiName] = '"<record-id>"';
+		} else {
+			entries[f.apiName] = `"<${f.apiName}>"`;
+		}
+	}
+
+	const inner = Object.entries(entries)
+		.map(([k, v]) => `    ${JSON.stringify(k)}: ${v}`)
+		.join(",\n");
+	return `{ "${sObjectName}": {\n${inner}\n  } }`;
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function addPicklistComment(
+	objInfo: ObjectInfoResult,
+	fieldName: string,
+	comments: string[],
+): void {
+	const picklist = objInfo.picklists.find((p) => p.apiName === fieldName);
+	if (picklist && picklist.values.length > 0) {
+		const vals = picklist.values.map((v) => v.value).join(", ");
+		comments.push(`picklist: [${vals}]`);
+	}
+}
+
+function stripWrapping(typeName: string): string {
+	return typeName.replace(/[[\]!]/g, "");
+}
+
+function isFilterType(name: string): boolean {
+	return /_Filter$/.test(name);
+}
+
+function isOrderByType(name: string): boolean {
+	return /_OrderBy$/.test(name);
+}
+
+function detectSObjectFromObjectType(typeName: string): string | null {
+	if (typeName.endsWith("Connection")) {
+		return typeName.replace(/Connection$/, "");
+	}
+	if (typeName.endsWith("Edge")) {
+		return typeName.replace(/Edge$/, "");
+	}
+	const schemaOnlyTypes = new Set([
+		"UIAPI",
+		"RecordQuery",
+		"RecordQueryAggregate",
+		"PageInfo",
+		"UIAPIMutations",
+		"FieldValue",
+	]);
+	if (schemaOnlyTypes.has(typeName)) return null;
+	return typeName;
+}
+
+async function fetchObjectInfoQuietly(
+	orgAlias: string,
+	sObjectName: string,
+): Promise<ObjectInfoResult | null> {
+	let info = getCachedObjectInfo(orgAlias, sObjectName);
+	if (info) return info;
+	try {
+		const auth = await getOrgAuth(orgAlias);
+		info = await getObjectInfo(auth, orgAlias, sObjectName);
+		return info;
+	} catch {
+		return null;
+	}
+}