@tikoci/centrs 0.1.1 → 0.1.3

package/src/retrieve.ts

@@ -6,6 +6,15 @@ import type {
 	SettingSource as CoreSettingSource,
 	EnvelopeValidationMeta,
 } from "./core/envelope.ts";
+import {
+	extractCompletionNames,
+	inspectChildren,
+	inspectChildrenOrEmpty,
+	inspectCompletions,
+	isArgumentNode,
+	isCommandNode,
+	pathTokens,
+} from "./core/inspect.ts";
 import { CentrsError, serializeCentrsError } from "./errors.ts";
 import {
 	createProtocolAdapter,
@@ -19,6 +28,7 @@ import {
 import {
 	type CdbResolution,
 	isIpTransport,
+	loadEnvFileDefaults,
 	parseDuration,
 	parseResolvePolicy,
 	type ResolvedAuth,
@@ -101,20 +111,6 @@ export type RetrieveSuccessEnvelope = CentrsSuccessEnvelope<
 >;
 export type RetrieveErrorEnvelope = CentrsErrorEnvelope<RetrieveOperationMeta>;
 
-interface InspectChildItem {
-	type?: string;
-	name?: string;
-	"node-type"?: string;
-}
-
-interface InspectCompletionItem {
-	type?: string;
-	name?: string;
-	completion?: string;
-	value?: string;
-	text?: string;
-}
-
 interface RetrieveInspection {
 	command: "get" | "print";
 }
@@ -623,9 +619,10 @@ export function buildResolvedRetrieve(
 	cdbResolution: CdbResolution | undefined,
 	attributeSelections: readonly string[],
 	macResolution?: { mac: string; ip: string },
+	config: Record<string, string | undefined> = {},
 ): ResolvedRetrieveRequest {
-	const via = resolveProtocol(request, env, cdbResolution);
-	const format = resolveFormat(request, env);
+	const via = resolveProtocol(request, env, cdbResolution, config);
+	const format = resolveFormat(request, env, config);
 	const validate = resolveBooleanSetting(
 		request.validate,
 		env,
@@ -633,18 +630,22 @@ export function buildResolvedRetrieve(
 		true,
 		"validate",
 		cdbResolution?.overrides.validate,
+		config,
 	);
 	const timeoutMs = resolveTimeoutSetting(
 		request.timeout,
 		env,
 		via.value,
 		cdbResolution?.overrides.timeoutMs,
+		config,
 	);
 	const maxResultsBytes = resolveOptionalIntegerSetting(
 		request.maxResultsBytes,
 		env,
 		"CENTRS_MAX_RESULTS",
 		"max-results",
+		undefined,
+		config,
 	);
 	const target = resolveTarget(
 		{
@@ -696,22 +697,33 @@ export function resolveRetrieveGlobalContext(
 	request: RetrieveRequest,
 	env: Record<string, string | undefined>,
 	attributeSelections: readonly string[],
+	config: Record<string, string | undefined> = {},
 ): RetrieveGlobalContext {
-	const via = resolveProtocol(request, env);
-	const format = resolveFormat(request, env);
+	const via = resolveProtocol(request, env, undefined, config);
+	const format = resolveFormat(request, env, config);
 	const validate = resolveBooleanSetting(
 		request.validate,
 		env,
 		"CENTRS_VALIDATE",
 		true,
 		"validate",
+		undefined,
+		config,
+	);
+	const timeoutMs = resolveTimeoutSetting(
+		request.timeout,
+		env,
+		via.value,
+		undefined,
+		config,
 	);
-	const timeoutMs = resolveTimeoutSetting(request.timeout, env, via.value);
 	const maxResultsBytes = resolveOptionalIntegerSetting(
 		request.maxResultsBytes,
 		env,
 		"CENTRS_MAX_RESULTS",
 		"max-results",
+		undefined,
+		config,
 	);
 
 	return {
@@ -744,6 +756,7 @@ export async function resolveRetrieveRequest(
 	env: Record<string, string | undefined>,
 ): Promise<ResolvedRetrieveRequest> {
 	const attributeSelections = validateRetrieveRequestShape(request);
+	const config = await loadEnvFileDefaults(env);
 
 	const cdbResolution = await resolveCdb(
 		{
@@ -752,12 +765,14 @@ export async function resolveRetrieveRequest(
 			cdbPassword: request.cdbPassword,
 		},
 		env,
+		config,
 	);
 
 	const macResolution = await resolveMacForRetrieve(
 		request,
 		env,
 		cdbResolution,
+		config,
 	);
 
 	return buildResolvedRetrieve(
@@ -766,6 +781,7 @@ export async function resolveRetrieveRequest(
 		cdbResolution,
 		attributeSelections,
 		macResolution,
+		config,
 	);
 }
 
@@ -779,8 +795,9 @@ export async function resolveMacForRetrieve(
 	request: RetrieveRequest,
 	env: Record<string, string | undefined>,
 	cdb?: CdbResolution,
+	config: Record<string, string | undefined> = {},
 ): Promise<{ mac: string; ip: string } | undefined> {
-	if (!isIpTransport(resolveProtocol(request, env, cdb).value)) {
+	if (!isIpTransport(resolveProtocol(request, env, cdb, config).value)) {
 		return undefined;
 	}
 	return resolveMacTarget({
@@ -788,7 +805,10 @@ export async function resolveMacForRetrieve(
 		targetInput: request.targetInput,
 		cdbTarget: cdb?.target,
 		env,
-		policy: parseResolvePolicy(request.resolve ?? env["CENTRS_RESOLVE"]),
+		config,
+		policy: parseResolvePolicy(
+			request.resolve ?? env["CENTRS_RESOLVE"] ?? config["CENTRS_RESOLVE"],
+		),
 		operation: "retrieve",
 	});
 }
@@ -797,6 +817,7 @@ function resolveProtocol(
 	request: RetrieveRequest,
 	env: Record<string, string | undefined>,
 	cdb?: CdbResolution,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<RouterOsProtocol> {
 	const via = resolveStringSetting(
 		request.via,
@@ -806,6 +827,7 @@ function resolveProtocol(
 		"via",
 		undefined,
 		cdb?.overrides.via,
+		config,
 	);
 	if (!via) {
 		throw new CentrsError({
@@ -864,6 +886,7 @@ function resolveProtocol(
 function resolveFormat(
 	request: RetrieveRequest,
 	env: Record<string, string | undefined>,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<RetrieveOutputFormat> {
 	return resolveStringSetting(
 		request.format,
@@ -872,45 +895,25 @@ function resolveFormat(
 		"text",
 		"format",
 		parseOutputFormat,
+		undefined,
+		config,
 	) as ResolvedSetting<RetrieveOutputFormat>;
 }
 
 /**
- * Path-existence probe. An invalid path raises a native trap that
- * {@link mapRouterOsError} normalizes to `routeros/unknown-path` (REST instead
- * returns an empty child list). Both the legacy `routeros/api-trap` catch-all
- * and the grounded `routeros/unknown-path` classification are flattened to an
- * empty list so the orchestrator surfaces a single `validation/unknown-path`.
- * Traps during attribute/completion discovery do NOT use this probe — they
- * surface as-is.
+ * Resolve the read command (`print` vs `get`) for a path via a `request=child`
+ * existence probe. Uses {@link inspectChildrenOrEmpty} so an invalid path (a
+ * native trap, or REST's empty child list) flattens to no children and surfaces
+ * as a single `validation/unknown-path` here rather than leaking a transport
+ * trap. Attribute/completion discovery does NOT use the swallowing probe — traps
+ * there surface as-is.
  */
-async function inspectChildrenForProbe(
-	backend: ProtocolAdapter,
-	path: string,
-): Promise<unknown[]> {
-	try {
-		return await backend.inspect("child", path);
-	} catch (error) {
-		if (
-			error instanceof CentrsError &&
-			(error.code === "routeros/api-trap" ||
-				error.code === "routeros/unknown-path")
-		) {
-			return [];
-		}
-		throw error;
-	}
-}
-
 async function inspectRetrievePath(
 	resolved: ResolvedRetrieveRequest,
 	backend: ProtocolAdapter,
 ): Promise<RetrieveInspection> {
-	const pathTokens = pathTokensForInspect(resolved.path);
-	const rootChildren = (await inspectChildrenForProbe(
-		backend,
-		pathToInspectString(pathTokens),
-	)) as InspectChildItem[];
+	const tokens = pathTokens(resolved.path);
+	const rootChildren = await inspectChildrenOrEmpty(backend, tokens);
 
 	const supportsPrint = rootChildren.some((child) =>
 		isCommandNode(child, "print"),
@@ -943,21 +946,24 @@ async function inspectAttributes(
 	inspection: RetrieveInspection,
 	backend: ProtocolAdapter,
 ): Promise<string[]> {
-	const pathTokens = pathTokensForInspect(resolved.path);
+	const tokens = pathTokens(resolved.path);
 	const argument = inspection.command === "get" ? "value-name" : "proplist";
-	const completionRows = (await backend.inspect(
-		"completion",
-		pathToInspectString([...pathTokens, inspection.command, argument]),
-	)) as InspectCompletionItem[];
-	const completions = extractCompletionNames(completionRows);
+	const completionRows = await inspectCompletions(backend, [
+		...tokens,
+		inspection.command,
+		argument,
+	]);
+	const completions = [
+		...new Set(extractCompletionNames(completionRows)),
+	].sort();
 	if (completions.length > 0) {
 		return completions;
 	}
 
-	const commandChildren = (await backend.inspect(
-		"child",
-		pathToInspectString([...pathTokens, inspection.command]),
-	)) as InspectChildItem[];
+	const commandChildren = await inspectChildren(backend, [
+		...tokens,
+		inspection.command,
+	]);
 	return commandChildren
 		.filter(isArgumentNode)
 		.map((child) => child.name)
@@ -985,35 +991,6 @@ async function executeRetrieve(
 	});
 }
 
-function pathTokensForInspect(path: string): string[] {
-	return path.split("/").filter(Boolean);
-}
-
-function isCommandNode(
-	child: InspectChildItem,
-	name: "get" | "print",
-): boolean {
-	return (
-		child.name === name &&
-		(child.type === "cmd" || child["node-type"] === "cmd")
-	);
-}
-
-function isArgumentNode(child: InspectChildItem): boolean {
-	return child.type === "arg" || child["node-type"] === "arg";
-}
-
-function extractCompletionNames(
-	rows: readonly InspectCompletionItem[],
-): string[] {
-	const names = rows
-		.flatMap((row) => [row.completion, row.name, row.value, row.text])
-		.filter((value): value is string => typeof value === "string")
-		.map((value) => value.replace(/=.*$/, "").trim())
-		.filter((value) => value.length > 0);
-	return [...new Set(names)].sort();
-}
-
 function isKnownSingletonPath(path: string): boolean {
 	return ["/system/resource", "/system/identity"].includes(
 		path.replace(/\/$/, ""),
@@ -1043,6 +1020,7 @@ function resolveTimeoutSetting(
 	env: Record<string, string | undefined>,
 	via: RouterOsProtocol,
 	commentKv?: ResolvedSetting<number>,
+	config: Record<string, string | undefined> = {},
 ): ResolvedSetting<number> {
 	const resolved = resolveStringSetting(
 		timeout === undefined ? undefined : String(timeout),
@@ -1063,6 +1041,7 @@ function resolveTimeoutSetting(
 			return parsed;
 		},
 		commentKv,
+		config,
 	);
 	if (!resolved) {
 		throw new Error("timeout resolution produced no value");
@@ -1122,10 +1101,6 @@ function parseOutputFormat(value: string): RetrieveOutputFormat {
 	});
 }
 
-function pathToInspectString(path: readonly string[]): string {
-	return path.join(",");
-}
-
 function countResultObjects(data: unknown): number {
 	if (Array.isArray(data)) {
 		return data.length;