@treeseed/sdk 0.10.28 → 0.12.4

package/dist/hosting/contracts.d.ts

@@ -0,0 +1,208 @@
+import type { TreeseedDeployConfig } from '../platform/contracts.js';
+import type { TreeseedDiscoveredApplication } from './apps.js';
+export type TreeseedHostingEnvironment = 'local' | 'staging' | 'prod';
+export type TreeseedHostCapability = 'project' | 'environment' | 'container' | 'volume' | 'database' | 'domain' | 'dns' | 'object-store' | 'web-site' | 'source-repository' | 'workflow' | 'email-relay' | 'scheduled-job' | 'process' | 'secret' | 'variable' | 'deployment' | 'health' | 'logs' | 'port' | 'hot-reload';
+export type TreeseedServicePlacement = 'web' | 'api' | 'database' | 'knowledge-library' | 'runner-capacity' | 'repository' | 'content-storage' | 'email' | 'operations' | 'custom';
+export type TreeseedHostingAction = 'noop' | 'create' | 'update' | 'verify' | 'rename' | 'adopt' | 'reattach' | 'retain' | 'delete' | 'blocked';
+export type TreeseedHostingStatus = 'unknown' | 'pending' | 'ready' | 'degraded' | 'blocked';
+export interface TreeseedHostCapabilityDescriptor {
+    id: TreeseedHostCapability;
+    environments: TreeseedHostingEnvironment[];
+}
+export interface TreeseedHostAdapterOperationInput {
+    environment: TreeseedHostingEnvironment;
+    unit: TreeseedHostingUnit;
+    graph: TreeseedHostingGraph;
+    dryRun?: boolean;
+}
+export interface TreeseedHostAdapterOperationResult {
+    status: TreeseedHostingStatus;
+    locators: Record<string, string | null>;
+    state: Record<string, unknown>;
+    warnings: string[];
+}
+export interface TreeseedHostAdapter {
+    id: string;
+    label: string;
+    capabilities: TreeseedHostCapabilityDescriptor[];
+    refresh(input: TreeseedHostAdapterOperationInput): Promise<TreeseedHostAdapterOperationResult> | TreeseedHostAdapterOperationResult;
+    diff(input: TreeseedHostAdapterOperationInput & {
+        observed: TreeseedHostAdapterOperationResult;
+    }): Promise<TreeseedHostingUnitPlan> | TreeseedHostingUnitPlan;
+    apply(input: TreeseedHostAdapterOperationInput & {
+        plan: TreeseedHostingUnitPlan;
+    }): Promise<TreeseedHostAdapterOperationResult> | TreeseedHostAdapterOperationResult;
+    verify(input: TreeseedHostAdapterOperationInput & {
+        observed: TreeseedHostAdapterOperationResult;
+    }): Promise<TreeseedHostingVerification> | TreeseedHostingVerification;
+    status(input: TreeseedHostAdapterOperationInput): Promise<TreeseedHostAdapterOperationResult> | TreeseedHostAdapterOperationResult;
+}
+export interface TreeseedServiceTypeAdapter {
+    id: string;
+    label: string;
+    placement: TreeseedServicePlacement;
+    requiredCapabilities: TreeseedHostCapability[];
+    composes?: string[];
+    defaultHostByEnvironment?: Partial<Record<TreeseedHostingEnvironment, string>>;
+    describe?(unit: TreeseedHostingUnit): string;
+}
+export interface TreeseedHostingEnvironmentBinding {
+    hostId: string;
+    projectGroupId?: string;
+    enabled?: boolean;
+    config?: Record<string, unknown>;
+}
+export interface TreeseedServiceInstanceSpec {
+    id: string;
+    label: string;
+    serviceType: string;
+    placement?: TreeseedServicePlacement;
+    dependencies?: string[];
+    projectGroupId?: string;
+    config?: Record<string, unknown>;
+    secretRefs?: string[];
+    variableRefs?: string[];
+    environments?: Partial<Record<TreeseedHostingEnvironment, TreeseedHostingEnvironmentBinding>>;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeseedHostProjectGroup {
+    id: string;
+    label: string;
+    hostId: string;
+    environments: Partial<Record<TreeseedHostingEnvironment, {
+        projectName?: string;
+        projectId?: string;
+        environmentName?: string;
+        environmentId?: string;
+        sharedAcrossEnvironments?: boolean;
+    }>>;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeseedApplicationHostingProfile {
+    id: string;
+    label: string;
+    description?: string;
+    services: TreeseedServiceInstanceSpec[];
+    projectGroups?: TreeseedHostProjectGroup[];
+    metadata?: Record<string, unknown>;
+}
+export interface TreeseedHostingGraphInput {
+    tenantRoot: string;
+    environment: TreeseedHostingEnvironment;
+    configRoot?: string;
+    appId?: string;
+    deployConfig?: TreeseedDeployConfig;
+    hostAdapters?: Record<string, TreeseedHostAdapter>;
+    serviceTypeAdapters?: Record<string, TreeseedServiceTypeAdapter>;
+    profiles?: TreeseedApplicationHostingProfile[];
+    filter?: TreeseedHostingGraphFilter;
+}
+export interface TreeseedHostingGraphFilter {
+    serviceIds?: string[];
+    placements?: TreeseedServicePlacement[];
+    hosts?: string[];
+}
+export interface TreeseedHostingUnit {
+    id: string;
+    label: string;
+    serviceType: TreeseedServiceTypeAdapter;
+    placement: TreeseedServicePlacement;
+    host: TreeseedHostAdapter;
+    environment: TreeseedHostingEnvironment;
+    projectGroup: TreeseedHostProjectGroup | null;
+    dependencies: string[];
+    requiredCapabilities: TreeseedHostCapability[];
+    config: Record<string, unknown>;
+    secretRefs: string[];
+    variableRefs: string[];
+    metadata: Record<string, unknown>;
+    application?: Pick<TreeseedDiscoveredApplication, 'id' | 'root' | 'relativeRoot' | 'configPath' | 'roles'>;
+}
+export interface TreeseedHostingGraph {
+    tenantRoot: string;
+    environment: TreeseedHostingEnvironment;
+    deployConfig: TreeseedDeployConfig;
+    applications?: TreeseedDiscoveredApplication[];
+    hosts: Record<string, TreeseedHostAdapter>;
+    serviceTypes: Record<string, TreeseedServiceTypeAdapter>;
+    profiles: TreeseedApplicationHostingProfile[];
+    projectGroups: Record<string, TreeseedHostProjectGroup>;
+    units: TreeseedHostingUnit[];
+    placements: TreeseedHostingPlacementSummary[];
+    warnings: string[];
+}
+export interface TreeseedHostingUnitPlan {
+    unitId: string;
+    action: TreeseedHostingAction;
+    reasons: string[];
+    before: Record<string, unknown>;
+    after: Record<string, unknown>;
+    warnings: string[];
+    actions?: TreeseedHostingAction[];
+    retainedResources?: unknown[];
+    blockedDrift?: unknown[];
+    providerLimitations?: unknown[];
+}
+export interface TreeseedHostingVerificationCheck {
+    key: string;
+    label: string;
+    ok: boolean;
+    expected?: unknown;
+    observed?: unknown;
+    issues: string[];
+}
+export interface TreeseedHostingVerification {
+    unitId: string;
+    status: TreeseedHostingStatus;
+    verified: boolean;
+    checks: TreeseedHostingVerificationCheck[];
+    warnings: string[];
+}
+export interface TreeseedHostingPlan {
+    environment: TreeseedHostingEnvironment;
+    dryRun: boolean;
+    units: Array<{
+        unit: TreeseedHostingUnit;
+        observed: TreeseedHostAdapterOperationResult;
+        plan: TreeseedHostingUnitPlan;
+        verification: TreeseedHostingVerification;
+    }>;
+    placements: TreeseedHostingPlacementSummary[];
+    warnings: string[];
+}
+export interface TreeseedHostingApplyResult {
+    environment: TreeseedHostingEnvironment;
+    dryRun: boolean;
+    selectedApps?: string[];
+    selectedSystems?: string[];
+    skippedSystems?: Array<{
+        system: string;
+        reason: string;
+    }>;
+    transport?: Record<string, Record<string, string>>;
+    results: Array<{
+        unit: TreeseedHostingUnit;
+        plan: TreeseedHostingUnitPlan;
+        result: TreeseedHostAdapterOperationResult;
+        verification: TreeseedHostingVerification;
+    }>;
+    placements: TreeseedHostingPlacementSummary[];
+    warnings: string[];
+}
+export interface TreeseedHostingPlacementSummary {
+    placement: TreeseedServicePlacement;
+    label: string;
+    serviceIds: string[];
+    hostIds: string[];
+    status: TreeseedHostingStatus;
+    advanced: boolean;
+}
+export interface TreeseedPersistedHostingLocator {
+    unitId: string;
+    serviceType: string;
+    hostId: string;
+    environment: TreeseedHostingEnvironment;
+    projectGroupId: string | null;
+    locators: Record<string, string | null>;
+    updatedAt: string;
+}

package/dist/hosting/graph.d.ts

@@ -0,0 +1,195 @@
+import { type TreeseedCanonicalAction, type TreeseedCanonicalDrift, type TreeseedCanonicalGraphNode, type TreeseedCanonicalPostcondition } from '../reconcile/index.js';
+import type { TreeseedRunnableBootstrapSystem } from '../reconcile/bootstrap-systems.js';
+import type { TreeseedHostingApplyResult, TreeseedHostingEnvironment, TreeseedHostingGraph, TreeseedHostingGraphInput, TreeseedHostingPlan, TreeseedHostingPlacementSummary, TreeseedHostingUnit, TreeseedServicePlacement } from './contracts.js';
+export declare function compileTreeseedHostingGraph(input: TreeseedHostingGraphInput): TreeseedHostingGraph;
+export declare function planTreeseedHostingGraph(input: TreeseedHostingGraphInput & {
+    dryRun?: boolean;
+}): Promise<TreeseedHostingPlan>;
+/**
+ * @deprecated Use reconcileTreeseedTarget with hosting selectors instead.
+ */
+export declare function applyTreeseedHostingGraph(input: TreeseedHostingGraphInput & {
+    dryRun?: boolean;
+}): Promise<TreeseedHostingApplyResult>;
+export declare function serializeHostingUnit(unit: TreeseedHostingUnit): {
+    id: string;
+    label: string;
+    serviceType: string;
+    placement: TreeseedServicePlacement;
+    hostId: string;
+    environment: TreeseedHostingEnvironment;
+    projectGroupId: string | null;
+    requiredCapabilities: import("./contracts.js").TreeseedHostCapability[];
+    secretRefs: string[];
+    variableRefs: string[];
+    application: {
+        id: string;
+        relativeRoot: string;
+        roles: string[];
+    } | null;
+    config: unknown;
+    metadata: unknown;
+};
+export declare function serializeHostingPlan(plan: TreeseedHostingPlan): {
+    selectedApps: string[];
+    selectedSystems: TreeseedRunnableBootstrapSystem[];
+    skippedSystems: {
+        system: string;
+        reason: string;
+    }[];
+    transport: {
+        railway: {
+            reconcile: string;
+            deploy: string;
+        };
+    } | undefined;
+    placements: TreeseedHostingPlacementSummary[];
+    units: {
+        unit: {
+            id: string;
+            label: string;
+            serviceType: string;
+            placement: TreeseedServicePlacement;
+            hostId: string;
+            environment: TreeseedHostingEnvironment;
+            projectGroupId: string | null;
+            requiredCapabilities: import("./contracts.js").TreeseedHostCapability[];
+            secretRefs: string[];
+            variableRefs: string[];
+            application: {
+                id: string;
+                relativeRoot: string;
+                roles: string[];
+            } | null;
+            config: unknown;
+            metadata: unknown;
+        };
+        desired: {
+            id: string;
+            label: string;
+            serviceType: string;
+            placement: TreeseedServicePlacement;
+            hostId: string;
+            environment: TreeseedHostingEnvironment;
+            projectGroupId: string | null;
+            requiredCapabilities: import("./contracts.js").TreeseedHostCapability[];
+            secretRefs: string[];
+            variableRefs: string[];
+            application: {
+                id: string;
+                relativeRoot: string;
+                roles: string[];
+            } | null;
+            config: unknown;
+            metadata: unknown;
+        };
+        observed: import("./contracts.js").TreeseedHostAdapterOperationResult;
+        diff: import("./contracts.js").TreeseedHostingUnitPlan;
+        actions: import("./contracts.js").TreeseedHostingAction[];
+        retainedResources: unknown[];
+        blockedDrift: unknown[];
+        providerLimitations: unknown[];
+        plan: import("./contracts.js").TreeseedHostingUnitPlan;
+        verification: import("./contracts.js").TreeseedHostingVerification;
+    }[];
+    warnings: string[];
+    desiredGraph: TreeseedCanonicalGraphNode[];
+    observedGraph: TreeseedCanonicalGraphNode[];
+    stateGraph: TreeseedCanonicalGraphNode[];
+    diff: TreeseedCanonicalDrift[];
+    actions: TreeseedCanonicalAction[];
+    postconditions: TreeseedCanonicalPostcondition[];
+    selectedResources: string[];
+    skippedResources: Array<{
+        id: string;
+        reason: string;
+    }>;
+    blockedDrift: TreeseedCanonicalDrift[];
+    providerLimitations: TreeseedCanonicalDrift[];
+    retainedResources: TreeseedCanonicalGraphNode[];
+    destroyedResources: TreeseedCanonicalGraphNode[];
+    liveVerification: import("../reconcile/platform.js").TreeseedCanonicalLiveVerification;
+    ok: boolean;
+    environment: TreeseedHostingEnvironment;
+    dryRun: boolean;
+};
+export declare function serializeHostingApplyResult(result: TreeseedHostingApplyResult): {
+    selectedApps: string[];
+    selectedSystems: string[];
+    skippedSystems: {
+        system: string;
+        reason: string;
+    }[];
+    transport: Record<string, Record<string, string>> | undefined;
+    placements: TreeseedHostingPlacementSummary[];
+    results: {
+        unit: {
+            id: string;
+            label: string;
+            serviceType: string;
+            placement: TreeseedServicePlacement;
+            hostId: string;
+            environment: TreeseedHostingEnvironment;
+            projectGroupId: string | null;
+            requiredCapabilities: import("./contracts.js").TreeseedHostCapability[];
+            secretRefs: string[];
+            variableRefs: string[];
+            application: {
+                id: string;
+                relativeRoot: string;
+                roles: string[];
+            } | null;
+            config: unknown;
+            metadata: unknown;
+        };
+        desired: {
+            id: string;
+            label: string;
+            serviceType: string;
+            placement: TreeseedServicePlacement;
+            hostId: string;
+            environment: TreeseedHostingEnvironment;
+            projectGroupId: string | null;
+            requiredCapabilities: import("./contracts.js").TreeseedHostCapability[];
+            secretRefs: string[];
+            variableRefs: string[];
+            application: {
+                id: string;
+                relativeRoot: string;
+                roles: string[];
+            } | null;
+            config: unknown;
+            metadata: unknown;
+        };
+        observed: import("./contracts.js").TreeseedHostAdapterOperationResult;
+        diff: import("./contracts.js").TreeseedHostingUnitPlan;
+        actions: import("./contracts.js").TreeseedHostingAction[];
+        retainedResources: unknown[];
+        blockedDrift: unknown[];
+        providerLimitations: unknown[];
+        plan: import("./contracts.js").TreeseedHostingUnitPlan;
+        result: import("./contracts.js").TreeseedHostAdapterOperationResult;
+        verification: import("./contracts.js").TreeseedHostingVerification;
+    }[];
+    warnings: string[];
+    desiredGraph: TreeseedCanonicalGraphNode[];
+    observedGraph: TreeseedCanonicalGraphNode[];
+    stateGraph: TreeseedCanonicalGraphNode[];
+    diff: TreeseedCanonicalDrift[];
+    actions: TreeseedCanonicalAction[];
+    postconditions: TreeseedCanonicalPostcondition[];
+    selectedResources: string[];
+    skippedResources: Array<{
+        id: string;
+        reason: string;
+    }>;
+    blockedDrift: TreeseedCanonicalDrift[];
+    providerLimitations: TreeseedCanonicalDrift[];
+    retainedResources: TreeseedCanonicalGraphNode[];
+    destroyedResources: TreeseedCanonicalGraphNode[];
+    liveVerification: import("../reconcile/platform.js").TreeseedCanonicalLiveVerification;
+    ok: boolean;
+    environment: TreeseedHostingEnvironment;
+    dryRun: boolean;
+};
+export declare function hostingEnvironmentLabel(environment: TreeseedHostingEnvironment): string;