@mysten-incubation/devstack 0.1.1 → 0.3.0

package/dist/plugins/dashboard/domain.mjs

@@ -58,78 +58,57 @@ const causeDetail = (cause) => {
 };
 const faucetCauseDetail = causeDetail;
 const fundingCauseDetail = causeDetail;
-const str = (v) => typeof v === "string" ? v : null;
-const strReq = (v) => typeof v === "string" ? v : "";
-const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+const newFaults = () => [];
+/** Collapse accumulated faults into a single nullable detail string for the
+*  GraphQL-visible result. `null` when nothing drifted. */
+const faultDetail = (faults) => faults.length === 0 ? null : faults.join("; ");
+/** Describe why a value failed to narrow to the expected type — distinguishing
+*  'absent' from 'present but wrong type'. */
+const typeFault = (field, expected, v) => {
+	if (v === void 0 || v === null) return `${field}: missing (expected ${expected})`;
+	return `${field}: expected ${expected}, got ${typeof v}`;
+};
+/** Required string. On mismatch records a fault and returns '' so the panel
+*  still renders a (degraded) cell. */
+const reqStr = (v, field, faults) => {
+	if (typeof v === "string") return v;
+	faults.push(typeFault(field, "string", v));
+	return "";
+};
+/** Required finite number. On mismatch records a fault and returns the safe
+*  display fallback (`fallback`, default 0). */
+const reqNum = (v, field, faults, fallback = 0) => {
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+	faults.push(typeFault(field, "number", v));
+	return fallback;
+};
+/** Allow-list enum narrow. Records a fault for an out-of-enum value while
+*  still returning a safe display fallback so the panel renders. */
+const narrowEnum = (raw, allowed, field, faults, fallback) => {
+	if (typeof raw === "string" && allowed.includes(raw)) return raw;
+	faults.push(raw === void 0 || raw === null ? `${field}: missing (expected one of ${allowed.join("|")})` : `${field}: '${String(raw)}' not in ${allowed.join("|")}`);
+	return fallback;
+};
+/** Required string-or-numeric coerced to a string. Pyth feed prices arrive as a
+*  `bigint` on the resolved value (string in the cached/known shape); accept any
+*  of string/number/bigint and record a fault otherwise. Returns '0' on
+*  mismatch so the panel still renders a (degraded) cell. */
+const reqNumericStr = (v, field, faults) => {
+	if (typeof v === "string") return v;
+	if (typeof v === "bigint") return v.toString();
+	if (typeof v === "number" && Number.isFinite(v)) return String(v);
+	faults.push(typeFault(field, "string|number|bigint", v));
+	return "0";
+};
+const optStr = (v) => typeof v === "string" ? v : null;
+const optNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
 const bool = (v) => v === true;
 /** Filter the generic resolved values down to those whose resource id
 *  matches a predicate, in graph order. Returns the `{ pluginKey, value }`
 *  the shaping functions consume. */
 const matching = (values, matches) => values.filter((v) => matches(v.id));
-/** SQL that emits a single line of JSON the dashboard can parse without a
-*  PG client. Keeps the round trip to one exec. */
-const PG_STATS_SQL = `SELECT json_build_object(
-  'db_bytes', pg_database_size(current_database()),
-  'connections', (SELECT count(*) FROM pg_stat_activity WHERE datname = current_database()),
-  'tables', COALESCE((
-    SELECT json_agg(t) FROM (
-      SELECT schemaname AS schema, relname AS name,
-             n_live_tup AS row_estimate,
-             pg_total_relation_size(relid) AS total_bytes
-      FROM pg_stat_user_tables
-      ORDER BY pg_total_relation_size(relid) DESC
-      LIMIT 200
-    ) t
-  ), '[]'::json)
-)`;
-const parsePgStats = (pluginKey, pg, stdout) => {
-	const base = {
-		pluginKey,
-		database: strReq((pg.databases ?? [])[0]) || "postgres",
-		plainUrl: `postgres://${str(pg.networkAlias) ?? "postgres"}:${num(pg.port) ?? 5432}`
-	};
-	try {
-		const trimmed = stdout.trim();
-		const parsed = JSON.parse(trimmed);
-		const tables = (parsed.tables ?? []).map((t) => ({
-			schema: t.schema ?? "public",
-			name: t.name ?? "",
-			rowEstimate: num(t.row_estimate) ?? 0,
-			totalBytes: num(t.total_bytes) ?? 0
-		}));
-		return {
-			...base,
-			databaseBytes: num(parsed.db_bytes) ?? 0,
-			connectionCount: num(parsed.connections) ?? 0,
-			tables,
-			available: true,
-			detail: null
-		};
-	} catch (cause) {
-		return {
-			...base,
-			databaseBytes: 0,
-			connectionCount: 0,
-			tables: [],
-			available: false,
-			detail: `failed to parse psql output: ${String(cause)}`
-		};
-	}
-};
-const unavailablePgStats = (pluginKey, pg, detail) => {
-	return {
-		pluginKey,
-		database: strReq((pg.databases ?? [])[0]) || "postgres",
-		plainUrl: `postgres://${str(pg.networkAlias) ?? "postgres"}:${num(pg.port) ?? 5432}`,
-		databaseBytes: 0,
-		connectionCount: 0,
-		tables: [],
-		available: false,
-		detail
-	};
-};
 const buildDashboardDomain = (deps) => {
-	const { control, identity, containerRuntime, strategyRegistry } = deps;
+	const { control, strategyRegistry } = deps;
 	const mode = control.resolvedValues.pipe(Effect.map((values) => {
 		const sui = matching(values, (id) => id === "sui")[0];
 		if (sui === void 0) return null;
@@ -143,55 +122,78 @@ const buildDashboardDomain = (deps) => {
 	}));
 	const deepbook = control.resolvedValues.pipe(Effect.map((values) => matching(values, (id) => id.startsWith("deepbook/")).map(({ pluginKey, value }) => {
 		const v = value;
-		const modeRaw = v.mode;
-		const dbMode = modeRaw === "override" ? "override" : modeRaw === "known" ? "known" : "local";
+		const faults = newFaults();
+		const dbMode = narrowEnum(v.mode, [
+			"local",
+			"override",
+			"known"
+		], "deepbook.mode", faults, "local");
 		return {
 			pluginKey,
 			name: pluginKey.replace(/^deepbook:/, ""),
 			mode: dbMode,
-			chain: strReq(v.chain),
-			packageId: strReq(v.packageId),
-			registryId: strReq(v.registryId),
-			adminCapId: str(v.adminCapId),
-			deepTreasuryId: str(v.deepTreasuryId),
-			pools: (v.pools ?? []).map((p) => ({
-				name: strReq(p.name),
-				poolId: strReq(p.poolId),
-				baseCoinType: strReq(p.baseCoinType),
-				quoteCoinType: strReq(p.quoteCoinType)
+			network: reqStr(v.network, "deepbook.network", faults),
+			packageId: reqStr(v.packageId, "deepbook.packageId", faults),
+			registryId: reqStr(v.registryId, "deepbook.registryId", faults),
+			adminCapId: optStr(v.adminCapId),
+			deepTreasuryId: optStr(v.deepTreasuryId),
+			pools: (v.pools ?? []).map((p, i) => ({
+				name: reqStr(p.name, `deepbook.pools[${i}].name`, faults),
+				poolId: reqStr(p.poolId, `deepbook.pools[${i}].poolId`, faults),
+				baseCoinType: reqStr(p.baseCoinType, `deepbook.pools[${i}].baseCoinType`, faults),
+				quoteCoinType: reqStr(p.quoteCoinType, `deepbook.pools[${i}].quoteCoinType`, faults)
+			})),
+			pythFeeds: (v.pyth?.feeds ?? []).map((f, i) => ({
+				symbol: reqStr(f.symbol, `deepbook.pyth.feeds[${i}].symbol`, faults),
+				priceInfoObjectId: reqStr(f.priceInfoObjectId, `deepbook.pyth.feeds[${i}].priceInfoObjectId`, faults),
+				price: reqNumericStr(f.price, `deepbook.pyth.feeds[${i}].price`, faults),
+				expo: reqNum(f.expo, `deepbook.pyth.feeds[${i}].expo`, faults)
 			})),
-			marketMakerRunning: bool(v.marketMakerRunning),
-			serverUrl: str(v.serverUrl),
-			indexerUrl: str(v.indexerUrl)
+			hasSeedLiquidity: bool(v.hasSeedLiquidity),
+			serverUrl: optStr(v.serverUrl),
+			indexerUrl: optStr(v.indexerUrl),
+			narrowingFault: faultDetail(faults)
 		};
 	})));
 	const seal = control.resolvedValues.pipe(Effect.map((values) => matching(values, (id) => id.startsWith("seal:")).map(({ pluginKey, value }) => {
 		const v = value;
-		const sealMode = v.mode === "live" ? "live" : v.mode === "fork-known" ? "fork-known" : "local-keygen";
-		const keyServers = (v.serverConfigs ?? []).map((c) => ({
-			objectId: strReq(c.objectId),
-			weight: num(c.weight) ?? 1
+		const faults = newFaults();
+		const sealMode = narrowEnum(v.mode, [
+			"local-keygen",
+			"live",
+			"fork-known"
+		], "seal.mode", faults, "local-keygen");
+		const keyServers = (v.serverConfigs ?? []).map((c, i) => ({
+			objectId: reqStr(c.objectId, `seal.serverConfigs[${i}].objectId`, faults),
+			weight: optNum(c.weight) ?? 1
 		}));
 		return {
 			pluginKey,
 			mode: sealMode,
-			objectId: strReq(v.objectId),
-			keyServerUrl: strReq(v.keyServerUrl),
+			objectId: reqStr(v.objectId, "seal.objectId", faults),
+			keyServerUrl: reqStr(v.keyServerUrl, "seal.keyServerUrl", faults),
 			keyServers,
-			threshold: keyServers.length
+			threshold: keyServers.length,
+			narrowingFault: faultDetail(faults)
 		};
 	})));
 	const coinCaps = control.resolvedValues.pipe(Effect.map((values) => matching(values, (id) => id.startsWith("coin:")).map(({ pluginKey, value }) => {
 		const v = value;
-		const source = v.source === "registry" ? "registry" : v.source === "builtin" ? "builtin" : "on-chain";
+		const faults = newFaults();
+		const source = narrowEnum(v.source, [
+			"registry",
+			"on-chain",
+			"builtin"
+		], "coin.source", faults, "on-chain");
 		return {
 			pluginKey,
-			symbol: str(v.symbol),
-			fullCoinType: strReq(v.fullCoinType),
-			decimals: num(v.decimals) ?? 0,
+			symbol: optStr(v.symbol),
+			fullCoinType: reqStr(v.fullCoinType, "coin.fullCoinType", faults),
+			decimals: reqNum(v.decimals, "coin.decimals", faults, 0),
 			source,
-			treasuryCapId: str(v.treasuryCapId),
-			packageId: str(v.packageId)
+			treasuryCapId: optStr(v.treasuryCapId),
+			packageId: optStr(v.packageId),
+			narrowingFault: faultDetail(faults)
 		};
 	})));
 	const mintCoin = (input) => Effect.gen(function* () {
@@ -206,12 +208,17 @@ const buildDashboardDomain = (deps) => {
 			detail: `invalid amountBaseUnits '${input.amountBaseUnits}': expected a positive integer string`,
 			digest: null
 		};
-		const match = matching(yield* control.resolvedValues, (id) => id.startsWith("coin:")).map(({ value }) => value).find((v) => strReq(v.fullCoinType) === input.coinType);
-		if (match === void 0) return {
-			ok: false,
-			detail: `no resolved coin found for type '${input.coinType}'`,
-			digest: null
-		};
+		const candidates = matching(yield* control.resolvedValues, (id) => id.startsWith("coin:")).map(({ value }) => value);
+		const matchFaults = newFaults();
+		const match = candidates.find((v) => reqStr(v.fullCoinType, "coin.fullCoinType", matchFaults) === input.coinType);
+		if (match === void 0) {
+			const fault = faultDetail(matchFaults);
+			return {
+				ok: false,
+				detail: fault === null ? `no resolved coin found for type '${input.coinType}'` : `no resolved coin found for type '${input.coinType}' (${fault})`,
+				digest: null
+			};
+		}
 		if (typeof match.mintFromCap !== "function") return {
 			ok: false,
 			detail: `coin '${input.coinType}' has no in-process treasury cap signer — mint is only available for local-package coins whose publisher still owns the TreasuryCap`,
@@ -235,10 +242,10 @@ const buildDashboardDomain = (deps) => {
 		})));
 	});
 	/** The chain id the SUI funding path keys on, read from the resolved sui
-	*  value (same `chain` field the sui codegen/snapshot decls stamp). */
+	*  value (same `chainId` field the sui codegen/snapshot decls stamp). */
 	const readChainId = control.resolvedValues.pipe(Effect.map((values) => {
 		const sui = matching(values, (id) => id === "sui")[0];
-		return sui === void 0 ? null : str(sui.value.chain);
+		return sui === void 0 ? null : optStr(sui.value.chainId);
 	}));
 	const fundableCoins = Effect.gen(function* () {
 		const out = [];
@@ -269,28 +276,24 @@ const buildDashboardDomain = (deps) => {
 		const recipient = input.recipient.trim();
 		if (!SUI_ADDRESS_RE.test(recipient)) return {
 			ok: false,
-			detail: `invalid recipient '${input.recipient}': expected a 0x-prefixed Sui address`,
-			digest: null
+			detail: `invalid recipient '${input.recipient}': expected a 0x-prefixed Sui address`
 		};
 		if (strategyRegistry === null) return {
 			ok: false,
-			detail: "funding unavailable: no strategy registry wired",
-			digest: null
+			detail: "funding unavailable: no strategy registry wired"
 		};
 		const coinType = input.coinType?.trim() ?? "";
 		if (coinType === "" || coinType === SUI_FULL_COIN_TYPE) {
 			const chain = yield* readChainId;
 			if (chain === null) return {
 				ok: false,
-				detail: "cannot fund SUI: no resolved sui plugin / chain id in this stack",
-				digest: null
+				detail: "cannot fund SUI: no resolved sui plugin / chain id in this stack"
 			};
 			const key = faucetCapabilityKeyFor(chain);
 			const strategy = yield* strategyRegistry.get(key).pipe(Effect.catchTag("StrategyNotFoundError", () => Effect.succeed(null)));
 			if (strategy === null) return {
 				ok: false,
-				detail: `no SUI faucet strategy registered for chain '${chain}'`,
-				digest: null
+				detail: `no SUI faucet strategy registered for chain '${chain}'`
 			};
 			const amount = parseAmount(input.amountBaseUnits) ?? 1000000000n;
 			return yield* strategy.request({
@@ -298,36 +301,30 @@ const buildDashboardDomain = (deps) => {
 				amount
 			}).pipe(Effect.map(() => ({
 				ok: true,
-				detail: `requested SUI for ${recipient} (fixed-amount faucet grant)`,
-				digest: null
+				detail: `requested SUI for ${recipient} (fixed-amount faucet grant)`
 			})), Effect.catch((cause) => Effect.succeed({
 				ok: false,
-				detail: `SUI faucet request failed: ${faucetCauseDetail(cause)}`,
-				digest: null
+				detail: `SUI faucet request failed: ${faucetCauseDetail(cause)}`
 			})), Effect.catchCause((cause) => Effect.succeed({
 				ok: false,
-				detail: `SUI faucet request crashed: ${String(cause)}`,
-				digest: null
+				detail: `SUI faucet request crashed: ${String(cause)}`
 			})));
 		}
 		const amount = parseAmount(input.amountBaseUnits);
 		if (amount === null) return {
 			ok: false,
-			detail: `invalid amountBaseUnits '${input.amountBaseUnits ?? ""}': expected a positive integer string`,
-			digest: null
+			detail: `invalid amountBaseUnits '${input.amountBaseUnits ?? ""}': expected a positive integer string`
 		};
 		const key = `coinType:${coinType}`;
 		const strategy = yield* strategyRegistry.get(key).pipe(Effect.catchTag("StrategyNotFoundError", () => Effect.succeed(null)));
 		if (strategy === null) return {
 			ok: false,
-			detail: `no funding strategy registered for coin '${coinType}' — WAL needs the walrus plugin (with an exchange) and DEEP needs the deepbook plugin`,
-			digest: null
+			detail: `no funding strategy registered for coin '${coinType}' — WAL needs the walrus plugin (with an exchange) and DEEP needs the deepbook plugin`
 		};
-		const account = matching(yield* control.resolvedValues, (id) => id.startsWith("account/")).map(({ value }) => value).find((v) => str(v.address) === recipient);
+		const account = matching(yield* control.resolvedValues, (id) => id.startsWith("account/")).map(({ value }) => value).find((v) => optStr(v.address) === recipient);
 		if (strategy.requiresRecipientAccount === true && account === void 0) return {
 			ok: false,
-			detail: `coin '${coinType}' is funded by an account-signed swap, but '${recipient}' is not a resolved account in this stack — fund a configured account (the swap spends its SUI)`,
-			digest: null
+			detail: `coin '${coinType}' is funded by an account-signed swap, but '${recipient}' is not a resolved account in this stack — fund a configured account (the swap spends its SUI)`
 		};
 		return yield* strategy.request({
 			address: recipient,
@@ -335,16 +332,13 @@ const buildDashboardDomain = (deps) => {
 			...account === void 0 ? {} : { account }
 		}).pipe(Effect.map(() => ({
 			ok: true,
-			detail: `funded ${amount} base units of ${coinType} to ${recipient}`,
-			digest: null
+			detail: `funded ${amount} base units of ${coinType} to ${recipient}`
 		})), Effect.catch((cause) => Effect.succeed({
 			ok: false,
-			detail: `${coinSymbolFromType(coinType)} funding failed: ${fundingCauseDetail(cause)}`,
-			digest: null
+			detail: `${coinSymbolFromType(coinType)} funding failed: ${fundingCauseDetail(cause)}`
 		})), Effect.catchCause((cause) => Effect.succeed({
 			ok: false,
-			detail: `${coinSymbolFromType(coinType)} funding crashed: ${String(cause)}`,
-			digest: null
+			detail: `${coinSymbolFromType(coinType)} funding crashed: ${String(cause)}`
 		})));
 	});
 	return {
@@ -352,50 +346,12 @@ const buildDashboardDomain = (deps) => {
 		deepbook,
 		seal,
 		coinCaps,
-		postgresStats: Effect.gen(function* () {
-			const instances = matching(yield* control.resolvedValues, (id) => id === "postgres");
-			if (instances.length === 0) return [];
-			const out = [];
-			for (const { pluginKey, value } of instances) {
-				const pg = value;
-				if (containerRuntime === null) {
-					out.push(unavailablePgStats(pluginKey, pg, "container runtime unavailable"));
-					continue;
-				}
-				const database = strReq((pg.databases ?? [])[0]) || "postgres";
-				const pgUser = str(pg.user) ?? "postgres";
-				const role = str(pg.name) ?? "postgres";
-				const stats = yield* Effect.gen(function* () {
-					const handles = yield* containerRuntime.inspectByLabels({
-						app: String(identity.app),
-						stack: String(identity.stack),
-						plugin: "postgres",
-						role
-					});
-					const running = handles.find((h) => h.status === "running") ?? handles[0];
-					if (running === void 0) return unavailablePgStats(pluginKey, pg, "no running postgres container found");
-					const result = yield* containerRuntime.exec(running, [
-						"psql",
-						"-U",
-						pgUser,
-						"-d",
-						database,
-						"-tAc",
-						PG_STATS_SQL
-					]);
-					if (result.exitCode !== 0) return unavailablePgStats(pluginKey, pg, `psql exited ${result.exitCode}: ${result.stderr.trim().slice(0, 200)}`);
-					return parsePgStats(pluginKey, pg, result.stdout);
-				}).pipe(Effect.catchCause((cause) => Effect.succeed(unavailablePgStats(pluginKey, pg, String(cause)))));
-				out.push(stats);
-			}
-			return out;
-		}),
 		mintCoin,
 		fundableCoins,
 		fundAccount
 	};
 };
-Effect.succeed(null), Effect.succeed([]), Effect.succeed([]), Effect.succeed([]), Effect.succeed([]), Effect.succeed([]);
+Effect.succeed(null), Effect.succeed([]), Effect.succeed([]), Effect.succeed([]), Effect.succeed([]);
 //#endregion
 export { buildDashboardDomain };