@treeseed/sdk 0.12.59 → 0.12.61

package/dist/reconcile/desired-state.js

@@ -238,6 +238,7 @@ function deriveTreeseedDesiredUnits({
       secrets: {},
       metadata: {
         serviceKey,
+        serviceInstanceKey: configuredService.instanceKey ?? desiredServiceName,
         scheduleManaged: Array.isArray(configuredService.schedule) && configuredService.schedule.length > 0,
         scheduleBootstrap: false,
         scheduleDeployScopes: ["staging", "prod"],
@@ -293,13 +294,14 @@ function deriveTreeseedDesiredUnits({
           return isPublicTreeDxNodeServiceKey(serviceKey) ? "api-runtime" : "api-runtime";
       }
     })();
+    const runtimeInstanceKey = serviceKey === "operationsRunner" ? configuredService.instanceKey ?? desiredServiceName : serviceKey;
     add({
-      unitId: createTreeseedReconcileUnitId(runtimeUnitType, serviceKey),
+      unitId: createTreeseedReconcileUnitId(runtimeUnitType, runtimeInstanceKey),
       unitType: runtimeUnitType,
       provider: "treeseed",
       identity,
       target,
-      logicalName: serviceKey,
+      logicalName: runtimeInstanceKey,
       dependencies: [
         concreteId,
         ...apiCustomDomainId ? [apiCustomDomainId] : [],
@@ -310,7 +312,7 @@ function deriveTreeseedDesiredUnits({
         publicBaseUrl: serviceState?.publicBaseUrl ?? null
       },
       secrets: {},
-      metadata: { bootstrapSystem: serviceBootstrapSystem }
+      metadata: { serviceKey, bootstrapSystem: serviceBootstrapSystem }
     });
   }
   return { deployConfig, legacyState, units };

package/dist/reconcile/engine.js

@@ -309,7 +309,7 @@ async function reconcileTreeseedTarget({
     };
     const unitStartMs = performance.now();
     timingEntries.push(unitTiming);
-    write?.(`Applying ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
+    write?.(`${planOnly ? "Planning" : "Applying"} ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const adapter = registry.get(plan.unit.unitType, plan.unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(planned.state, plan.unit);
     try {
@@ -372,34 +372,40 @@ async function reconcileTreeseedTarget({
       unitTiming.status = "failed";
       wrapAdapterFailure("apply", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
     }
+    if (planOnly) {
+      const plannedResult = { ...result, verification: null };
+      unitTiming.durationMs = elapsedMs(unitStartMs);
+      unitTiming.status = "success";
+      write?.(`Finished plan for ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName}) in ${formatDurationMs(unitTiming.durationMs)}.`);
+      results.push(plannedResult);
+      return;
+    }
     let refreshedObserved = result.observed;
-    if (!planOnly) {
-      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);
-      }
+    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?.({

package/dist/reconcile/live-acceptance.js

@@ -11,6 +11,7 @@ import { runTreeseedGit } from "../operations/services/git-runner.js";
 import {
   deleteRailwayProject,
   ensureRailwayEnvironment,
+  ensureRailwayCustomDomain,
   ensureRailwayGeneratedServiceDomain,
   ensureRailwayPostgresService,
   ensureRailwayProject,
@@ -21,7 +22,6 @@ import {
   listRailwayServices,
   listRailwayVariables,
   listRailwayVolumes,
-  railwayGraphqlRequest,
   resolveRailwayWorkspaceContext,
   upsertRailwayVariables
 } from "../operations/services/railway-api.js";
@@ -1217,16 +1217,7 @@ async function runRailwayAcceptance(cwd, environment, runId, prefix, env, fetchI
     const generatedDomain = await ensureRailwayGeneratedServiceDomain({ projectId, environmentId, serviceId, targetPort: 80, env, fetchImpl });
     let customDomainCreated = false;
     try {
-      await railwayGraphqlRequest({
-        query: `
-mutation TreeseedLiveRailwayCustomDomainCreate($input: CustomDomainCreateInput!) {
-	customDomainCreate(input: $input) { id domain serviceId environmentId }
-}
-`.trim(),
-        variables: { input: { projectId, environmentId, serviceId, domain: customDomain } },
-        env,
-        fetchImpl
-      });
+      await ensureRailwayCustomDomain({ projectId, environmentId, serviceId, domain: customDomain, env, fetchImpl });
       customDomainCreated = true;
     } catch {
       customDomainCreated = false;

package/dist/reconcile/providers/railway-iac.d.ts

@@ -14,10 +14,51 @@ export type TreeseedRailwayIacService = {
     healthcheckPath?: string | null;
     healthcheckTimeoutSeconds?: number | null;
     runtimeMode?: string | null;
+    numReplicas?: number | null;
     volumeMountPath?: string | null;
+    volumeName?: string | null;
+    volumeAddress?: string | null;
     variables?: Record<string, string>;
     secrets?: Record<string, string>;
     detachVolumeIds?: string[];
+    customDomains?: string[];
+};
+export type TreeseedRailwayObservedService = {
+    id: string;
+    name: string;
+};
+export type TreeseedRailwayObservedVolumeInstance = {
+    id?: string | null;
+    environmentId?: string | null;
+    serviceId?: string | null;
+    mountPath?: string | null;
+    state?: string | null;
+    isPendingDeletion?: boolean | null;
+    deletedAt?: string | null;
+};
+export type TreeseedRailwayObservedVolume = {
+    id: string;
+    name?: string | null;
+    instances: TreeseedRailwayObservedVolumeInstance[];
+};
+export type TreeseedRailwayVolumeBinding = {
+    serviceName: string;
+    volumeId: string;
+    volumeName: string;
+    canonicalVolumeName: string;
+    mode: 'canonical' | 'environment-owned' | 'shared-legacy';
+    reason: string;
+};
+export type TreeseedRailwayVolumeBindingResult = {
+    bindings: TreeseedRailwayVolumeBinding[];
+    blockedReasons: string[];
+};
+export type TreeseedRailwayPendingVolumeCollision = {
+    serviceName: string;
+    volumeId: string;
+    canonicalVolumeName: string;
+    mountPath: string;
+    serviceId: string | null;
 };
 export type TreeseedRailwayIacDatabase = {
     serviceName: string;
@@ -57,6 +98,111 @@ export type RailwayIacValidationResult = {
     blockedReasons: string[];
     allowedDrift: string[];
 };
+export declare function waitForRailwayVolumeAdoptionResources<TService, TVolume>({ load, serviceName, volumeId, attempts, intervalMs, sleep, }: {
+    load: () => Promise<{
+        services: Array<TService & {
+            name?: string | null;
+        }>;
+        volumes: Array<TVolume & {
+            id?: string | null;
+        }>;
+    }>;
+    serviceName: string;
+    volumeId: string;
+    attempts?: number;
+    intervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<{
+    service: TService & {
+        name?: string | null;
+    };
+    volume: TVolume & {
+        id?: string | null;
+    };
+    services: (TService & {
+        name?: string | null;
+    })[];
+    volumes: (TVolume & {
+        id?: string | null;
+    })[];
+    attempt: number;
+} | null>;
+export declare function waitForRailwayServices<TService extends {
+    name?: string | null;
+}>({ load, serviceNames, attempts, intervalMs, sleep, }: {
+    load: () => Promise<TService[]>;
+    serviceNames: Iterable<string>;
+    attempts?: number;
+    intervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<{
+    services: TService[];
+    attempt: number;
+} | null>;
+export declare function waitForRailwayVolumeName<TVolume extends {
+    id?: string | null;
+    name?: string | null;
+}>({ load, volumeId, expectedName, attempts, intervalMs, sleep, }: {
+    load: () => Promise<TVolume[]>;
+    volumeId: string;
+    expectedName: string;
+    attempts?: number;
+    intervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<{
+    volume: TVolume;
+    attempt: number;
+} | null>;
+export declare function waitForRailwayVolumeDetachment<TVolume extends {
+    id?: string | null;
+    instances?: Array<{
+        environmentId?: string | null;
+        serviceId?: string | null;
+    }>;
+}>({ load, volumeId, environmentId, serviceId, attempts, intervalMs, sleep, }: {
+    load: () => Promise<TVolume[]>;
+    volumeId: string;
+    environmentId: string;
+    serviceId: string;
+    attempts?: number;
+    intervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<{
+    volume: TVolume | null;
+    attempt: number;
+} | null>;
+export declare function waitForRailwayServiceAbsence<TService extends {
+    id?: string | null;
+}>({ load, serviceId, attempts, intervalMs, sleep, }: {
+    load: () => Promise<TService[]>;
+    serviceId: string;
+    attempts?: number;
+    intervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<{
+    attempt: number;
+} | null>;
+export declare function cleanupStaleRailwayIacRenders(tenantRoot: string, now?: number): string[];
+export declare function railwayIacApplyFailure(response: RailwayIacApplyResponse): string | null;
+export declare function runRailwayIacWithRateLimitRetry<T>(run: () => Promise<T>, { delaysMs, sleep, onRetry, onWait, }?: {
+    delaysMs?: number[];
+    sleep?: (milliseconds: number) => Promise<unknown>;
+    onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
+    onWait?: (attempt: number, remainingMs: number) => void;
+}): Promise<T>;
+export declare function findRailwayPendingVolumeNameCollisions(input: {
+    services: TreeseedRailwayIacService[];
+    liveServices?: TreeseedRailwayObservedService[];
+    volumes: TreeseedRailwayObservedVolume[];
+}): TreeseedRailwayPendingVolumeCollision[];
+export declare function resolveRailwayIacVolumeBindings(input: {
+    environmentId: string;
+    services: TreeseedRailwayIacService[];
+    liveServices: TreeseedRailwayObservedService[];
+    volumes: TreeseedRailwayObservedVolume[];
+}): TreeseedRailwayVolumeBindingResult;
+export declare function detachRetainedRailwayVolumeBindings(resources: ResourceNode[], bindings: TreeseedRailwayVolumeBinding[]): ResourceNode[];
+export declare function detachRetainedRailwayCustomDomains(resources: ResourceNode[], domains: string[]): ResourceNode[];
 export declare function renderRailwayIacProject(input: TreeseedRailwayIacProjectInput): TreeseedRailwayIacRenderResult;
 export declare function selectRailwayIacRetainedResources(plan: Pick<RailwayIacPlanResponse, 'changeSet' | 'currentGraph'>, allowedNames: Iterable<string>): ResourceNode[];
 export declare function validateRailwayIacChangeSet(changeSet: RailwayChangeSet | undefined, desiredNames: {
@@ -66,6 +212,8 @@ export declare function validateRailwayIacChangeSet(changeSet: RailwayChangeSet
     scope: string;
     serviceSourceModes?: Record<string, string | null | undefined>;
     serviceSourceRefs?: Record<string, string | null | undefined>;
+    allowedResourceDeletions?: string[];
+    protectedResourceNames?: string[];
 }): RailwayIacValidationResult;
 export declare function planRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacPlanResponse>;
 export declare function applyRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacApplyResponse>;