@treeseed/sdk 0.11.0 → 0.12.4

package/dist/reconcile/engine.js

@@ -26,7 +26,7 @@ function formatVerificationFailure(verification) {
   ].filter(Boolean);
   return details.length > 0 ? `Verification failed (${details.join(" | ")})` : "Verification failed.";
 }
-function createRunContext(tenantRoot, target, launchEnv, write, dryRun = false) {
+function createRunContext(tenantRoot, target, launchEnv, write, dryRun = false, session) {
   const { deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
   return {
     tenantRoot,
@@ -35,9 +35,75 @@ function createRunContext(tenantRoot, target, launchEnv, write, dryRun = false)
     launchEnv,
     dryRun,
     write,
-    session: /* @__PURE__ */ new Map()
+    session: session ?? /* @__PURE__ */ new Map()
   };
 }
+function normalizeSelectorValues(values) {
+  return new Set((values ?? []).map((value) => value.trim()).filter(Boolean));
+}
+function unitSelectorValues(unit) {
+  const metadata = unit.metadata ?? {};
+  const spec = unit.spec ?? {};
+  const serviceKey = typeof metadata.serviceKey === "string" ? metadata.serviceKey : null;
+  const placement = typeof metadata.placement === "string" ? metadata.placement : null;
+  const appId = typeof metadata.applicationId === "string" ? metadata.applicationId : typeof metadata.appId === "string" ? metadata.appId : typeof spec.applicationId === "string" ? spec.applicationId : null;
+  const packageId = typeof metadata.packageId === "string" ? metadata.packageId : appId;
+  const serviceName = typeof spec.serviceName === "string" ? spec.serviceName : null;
+  const serviceId = typeof metadata.serviceId === "string" ? metadata.serviceId : typeof spec.serviceId === "string" ? spec.serviceId : null;
+  return {
+    provider: unit.provider,
+    unitType: unit.unitType,
+    unitId: unit.unitId,
+    serviceIds: [
+      unit.logicalName,
+      serviceId,
+      serviceKey,
+      serviceName,
+      unit.unitType.startsWith("railway-service:") ? unit.unitType.slice("railway-service:".length) : null,
+      unit.unitType.endsWith("-runtime") ? unit.logicalName : null
+    ].filter((value) => Boolean(value)),
+    serviceTypes: [unit.unitType],
+    placements: [placement].filter((value) => Boolean(value)),
+    appIds: [appId].filter((value) => Boolean(value)),
+    packageIds: [packageId].filter((value) => Boolean(value))
+  };
+}
+function unitMatchesSelector(unit, selector) {
+  if (!selector) return true;
+  const values = unitSelectorValues(unit);
+  const provider = normalizeSelectorValues(selector.provider ?? selector.host);
+  const unitIds = normalizeSelectorValues(selector.unitId);
+  const unitTypes = normalizeSelectorValues([
+    ...selector.unitType ?? [],
+    ...selector.resourceKind ?? []
+  ]);
+  const serviceIds = normalizeSelectorValues(selector.serviceId);
+  const serviceTypes = normalizeSelectorValues(selector.serviceType);
+  const placements = normalizeSelectorValues(selector.placement);
+  const appIds = normalizeSelectorValues(selector.appId);
+  const packageIds = normalizeSelectorValues(selector.packageId);
+  const has = (needle, haystack) => needle.size === 0 || haystack.some((entry) => needle.has(entry));
+  return has(provider, [values.provider]) && has(unitIds, [values.unitId]) && has(unitTypes, [values.unitType]) && has(serviceIds, values.serviceIds) && has(serviceTypes, values.serviceTypes) && has(placements, values.placements) && has(appIds, values.appIds) && has(packageIds, values.packageIds);
+}
+function includeDependencies(units, selected) {
+  const byId = new Map(units.map((unit) => [unit.unitId, unit]));
+  const included = new Map(selected.map((unit) => [unit.unitId, unit]));
+  const visit = (unit) => {
+    for (const dependencyId of unit.dependencies) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency || included.has(dependency.unitId)) continue;
+      included.set(dependency.unitId, dependency);
+      visit(dependency);
+    }
+  };
+  for (const unit of selected) visit(unit);
+  return units.filter((unit) => included.has(unit.unitId));
+}
+function filterUnitsBySelector(units, selector) {
+  if (!selector) return units;
+  const selected = units.filter((unit) => unitMatchesSelector(unit, selector));
+  return includeDependencies(units, selected);
+}
 function dependencyLevels(units) {
   const remaining = new Map(units.map((unit) => [unit.unitId, unit]));
   const completed = /* @__PURE__ */ new Set();
@@ -129,10 +195,13 @@ async function refreshTreeseedUnits({
   target,
   env = process.env,
   systems,
+  selector,
+  units: explicitUnits,
   write
 }) {
   const derived = deriveTreeseedDesiredUnits({ tenantRoot, target });
-  const units = filterTreeseedDesiredUnitsByBootstrapSystems(derived.units, systems);
+  const baseUnits = explicitUnits ?? filterTreeseedDesiredUnitsByBootstrapSystems(derived.units, systems);
+  const units = filterUnitsBySelector(baseUnits, selector);
   const deployConfig = derived.deployConfig;
   const registry = createTreeseedReconcileRegistry(deployConfig);
   const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
@@ -166,9 +235,11 @@ async function planTreeseedReconciliation({
   target,
   env = process.env,
   systems,
+  selector,
+  units,
   write
 }) {
-  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems, write });
+  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems, selector, units, write });
   const registry = createTreeseedReconcileRegistry(observed.deployConfig);
   const context = createRunContext(tenantRoot, target, env, write);
   const plans = [];
@@ -204,12 +275,15 @@ async function reconcileTreeseedTarget({
   target,
   env = process.env,
   systems,
+  selector,
+  units,
   write,
-  dryRun = false
+  dryRun = false,
+  session
 }) {
-  const planned = await planTreeseedReconciliation({ tenantRoot, target, env, systems, write });
+  const planned = await planTreeseedReconciliation({ tenantRoot, target, env, systems, selector, units, write });
   const registry = createTreeseedReconcileRegistry(planned.deployConfig);
-  const context = createRunContext(tenantRoot, target, env, write, dryRun);
+  const context = createRunContext(tenantRoot, target, env, write, dryRun, session);
   const results = [];
   const verificationMap = /* @__PURE__ */ new Map();
   const timingEntries = [];
@@ -298,6 +372,35 @@ async function reconcileTreeseedTarget({
       unitTiming.status = "failed";
       wrapAdapterFailure("apply", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
     }
+    let refreshedObserved = result.observed;
+    if (!dryRun) {
+      try {
+        const stageStartMs = performance.now();
+        refreshedObserved = await Promise.resolve(adapter.refresh({
+          context,
+          unit: plan.unit,
+          persistedState: persisted
+        }));
+        result = {
+          ...result,
+          observed: refreshedObserved
+        };
+        unitTiming.children?.push({
+          name: `${unitTiming.name}:refresh-after-apply`,
+          durationMs: elapsedMs(stageStartMs),
+          status: "success"
+        });
+      } catch (error) {
+        unitTiming.children?.push({
+          name: `${unitTiming.name}:refresh-after-apply`,
+          durationMs: elapsedMs(unitStartMs),
+          status: "failed"
+        });
+        unitTiming.durationMs = elapsedMs(unitStartMs);
+        unitTiming.status = "failed";
+        wrapAdapterFailure("refresh", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
+      }
+    }
     write?.(`Verifying ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const postconditions = await Promise.resolve(adapter.requiredPostconditions?.({
       context,
@@ -311,7 +414,7 @@ async function reconcileTreeseedTarget({
         context,
         unit: plan.unit,
         persistedState: persisted,
-        observed: result.observed,
+        observed: refreshedObserved,
         diff: plan.diff,
         result,
         postconditions
@@ -370,9 +473,12 @@ async function destroyTreeseedTargetUnits({
   tenantRoot,
   target,
   env = process.env,
+  selector,
+  units: explicitUnits,
   write
 }) {
-  const { units, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
+  const { units: allUnits, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
+  const units = filterUnitsBySelector(explicitUnits ?? allUnits, selector);
   const registry = createTreeseedReconcileRegistry(deployConfig);
   const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
   const context = createRunContext(tenantRoot, target, env, write);
@@ -413,11 +519,14 @@ async function collectTreeseedReconcileStatus({
   tenantRoot,
   target,
   env = process.env,
-  systems
+  systems,
+  selector,
+  units,
+  session
 }) {
-  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems });
+  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems, selector, units });
   const registry = createTreeseedReconcileRegistry(observed.deployConfig);
-  const context = createRunContext(tenantRoot, target, env);
+  const context = createRunContext(tenantRoot, target, env, void 0, false, session);
   const plans = await Promise.all(observed.units.map(async (unit) => {
     const adapter = registry.get(unit.unitType, unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(observed.state, unit);
@@ -441,7 +550,7 @@ async function collectTreeseedReconcileStatus({
     context,
     state: observed.state
   });
-  const units = observed.units.map((unit) => {
+  const unitStatuses = observed.units.map((unit) => {
     const observation = observed.observations.get(unit.unitId);
     const verification = verificationResults.get(unit.unitId)?.verification ?? null;
     return {
@@ -455,21 +564,76 @@ async function collectTreeseedReconcileStatus({
       verification
     };
   });
-  const ready = units.every((unit) => unit.verification?.verified === true);
-  const blockers = units.filter((unit) => unit.verification?.verified !== true).map((unit) => `Reconcile unit ${unit.provider}:${unit.unitType} is unverified: ${formatVerificationFailure(unit.verification)}.`);
-  const warnings = units.flatMap((unit) => unit.warnings);
+  const ready = unitStatuses.every((unit) => unit.verification?.verified === true);
+  const blockers = unitStatuses.filter((unit) => unit.verification?.verified !== true).map((unit) => `Reconcile unit ${unit.provider}:${unit.unitType} is unverified: ${formatVerificationFailure(unit.verification)}.`);
+  const warnings = unitStatuses.flatMap((unit) => unit.warnings);
   return {
     target,
     ready,
     blockers,
     warnings,
-    units
+    units: unitStatuses
   };
 }
+async function reconcileTreeseedNestedTarget({
+  parentContext,
+  selector,
+  target,
+  dryRun
+}) {
+  const previousVerificationResults = parentContext.session.get("treeseed:verification-results");
+  const previousTimings = parentContext.session.get("treeseed:timings");
+  try {
+    return await reconcileTreeseedTarget({
+      tenantRoot: parentContext.tenantRoot,
+      target,
+      env: parentContext.launchEnv,
+      selector,
+      write: parentContext.write,
+      dryRun,
+      session: parentContext.session
+    });
+  } finally {
+    if (previousVerificationResults === void 0) {
+      parentContext.session.delete("treeseed:verification-results");
+    } else {
+      parentContext.session.set("treeseed:verification-results", previousVerificationResults);
+    }
+    if (previousTimings === void 0) {
+      parentContext.session.delete("treeseed:timings");
+    } else {
+      parentContext.session.set("treeseed:timings", previousTimings);
+    }
+  }
+}
+async function verifyTreeseedNestedTarget({
+  parentContext,
+  selector,
+  target
+}) {
+  const previousVerificationResults = parentContext.session.get("treeseed:verification-results");
+  try {
+    return await collectTreeseedReconcileStatus({
+      tenantRoot: parentContext.tenantRoot,
+      target,
+      env: parentContext.launchEnv,
+      selector,
+      session: parentContext.session
+    });
+  } finally {
+    if (previousVerificationResults === void 0) {
+      parentContext.session.delete("treeseed:verification-results");
+    } else {
+      parentContext.session.set("treeseed:verification-results", previousVerificationResults);
+    }
+  }
+}
 export {
   collectTreeseedReconcileStatus,
   destroyTreeseedTargetUnits,
   planTreeseedReconciliation,
+  reconcileTreeseedNestedTarget,
   reconcileTreeseedTarget,
-  refreshTreeseedUnits
+  refreshTreeseedUnits,
+  verifyTreeseedNestedTarget
 };

package/dist/reconcile/index.d.ts

@@ -1,10 +1,10 @@
-export * from './contracts.ts';
-export * from './platform.ts';
-export * from './bootstrap-systems.ts';
-export * from './desired-state.ts';
-export * from './engine.ts';
-export * from './errors.ts';
-export * from './live-acceptance.ts';
-export * from './registry.ts';
-export * from './state.ts';
-export * from './units.ts';
+export * from './contracts.js';
+export * from './platform.js';
+export * from './bootstrap-systems.js';
+export * from './desired-state.js';
+export * from './engine.js';
+export * from './errors.js';
+export * from './live-acceptance.js';
+export * from './registry.js';
+export * from './state.js';
+export * from './units.js';

package/dist/reconcile/live-acceptance.d.ts

@@ -1,4 +1,6 @@
-import { type TreeseedCanonicalAction, type TreeseedCanonicalDrift, type TreeseedCanonicalGraphNode, type TreeseedCanonicalReconcileReport } from './platform.ts';
+import { type TreeseedCanonicalAction, type TreeseedCanonicalDrift, type TreeseedCanonicalGraphNode, type TreeseedCanonicalReconcileReport } from './platform.js';
+import type { TreeseedDesiredResource } from '../platform/desired-state.js';
+import type { TreeseedReconcileSelector } from './contracts.js';
 export type TreeseedLiveReconcileProvider = 'railway' | 'cloudflare' | 'github' | 'local';
 export type TreeseedLiveReconcileMode = 'smoke' | 'acceptance' | 'cleanup';
 export type TreeseedLiveReconcileEnvironment = 'local' | 'staging' | 'prod';
@@ -52,6 +54,18 @@ export interface TreeseedLiveReconcileRunResult {
     providers: TreeseedLiveReconcileProviderReport[];
     ok: boolean;
 }
+export interface TreeseedLiveAcceptanceScenario {
+    id: string;
+    provider: TreeseedLiveReconcileProvider;
+    capability: string;
+    desiredResources: TreeseedDesiredResource[];
+    selector: TreeseedReconcileSelector;
+    expectedActions: TreeseedCanonicalAction['kind'][];
+    cleanupSelector: TreeseedReconcileSelector;
+    required: boolean;
+    probeOnly?: boolean;
+    cleanupRequired: boolean;
+}
 export interface TreeseedLiveReconcileProgressEvent {
     provider: TreeseedLiveReconcileProvider;
     mode: TreeseedLiveReconcileMode;
@@ -74,6 +88,13 @@ export interface RunTreeseedLiveReconcileTestsOptions {
     fetchImpl?: typeof fetch;
     onProgress?: (event: TreeseedLiveReconcileProgressEvent) => void;
 }
+export declare function compileTreeseedLiveAcceptanceScenarios(input: {
+    tenantRoot: string;
+    environment: TreeseedLiveReconcileEnvironment;
+    provider: TreeseedLiveReconcileProvider | 'all';
+    mode: TreeseedLiveReconcileMode;
+    runId: string;
+}): TreeseedLiveAcceptanceScenario[];
 export declare function treeseedLiveReconcileProviderCapabilities(provider: TreeseedLiveReconcileProvider): string[];
 export declare function treeseedLiveReconcileResourcePrefix(environment: TreeseedLiveReconcileEnvironment, provider: TreeseedLiveReconcileProvider, runId: string): string;
 export declare function runTreeseedLiveReconcileTests(options: RunTreeseedLiveReconcileTestsOptions): Promise<TreeseedLiveReconcileRunResult>;