refactor(graph): add preset nodes and dependencies to graph

Author: imranolas

src/commands/components/push/actions.ts

@@ -108,7 +108,7 @@ export const upsertComponentGroup = async (
 };
 
 // Component preset actions
-export const pushComponentPreset = async (space: string, componentPreset: { preset: Partial<SpaceComponentPreset> }, _token?: string, _region?: RegionCode): Promise<SpaceComponentPreset | undefined> => {
+export const pushComponentPreset = async (space: string, componentPreset: { preset: Partial<SpaceComponentPreset> }): Promise<SpaceComponentPreset | undefined> => {
   try {
     const client = mapiClient();
 
@@ -124,7 +124,7 @@ export const pushComponentPreset = async (space: string, componentPreset: { pres
   }
 };
 
-export const updateComponentPreset = async (space: string, presetId: number, componentPreset: { preset: Partial<SpaceComponentPreset> }, _token?: string, _region?: RegionCode): Promise<SpaceComponentPreset | undefined> => {
+export const updateComponentPreset = async (space: string, presetId: number, componentPreset: { preset: Partial<SpaceComponentPreset> }): Promise<SpaceComponentPreset | undefined> => {
   try {
     const client = mapiClient();
 
@@ -143,17 +143,15 @@ export const updateComponentPreset = async (space: string, presetId: number, com
 export const upsertComponentPreset = async (
   space: string,
   preset: Partial<SpaceComponentPreset>,
-  token: string,
-  region: RegionCode,
   existingId?: number,
 ): Promise<SpaceComponentPreset | undefined> => {
   if (existingId) {
     // We know it exists, update directly
-    return await updateComponentPreset(space, existingId, { preset }, token, region);
+    return await updateComponentPreset(space, existingId, { preset });
   }
   else {
     // New resource, create directly
-    return await pushComponentPreset(space, { preset }, token, region);
+    return await pushComponentPreset(space, { preset });
   }
 };
 

src/commands/components/push/graph-operations/dependency-graph.ts

@@ -2,13 +2,15 @@ import type {
   SpaceComponent,
   SpaceComponentGroup,
   SpaceComponentInternalTag,
+  SpaceComponentPreset,
 } from '../../constants';
 import type { DependencyGraph, GraphBuildingContext, NodeData, NodeType, SchemaDependencies, TargetResourceInfo, UnifiedNode } from './types';
-import { upsertComponent, upsertComponentGroup, upsertComponentInternalTag } from '../actions';
+import { upsertComponent, upsertComponentGroup, upsertComponentInternalTag, upsertComponentPreset } from '../actions';
 import {
   generateContentHash,
   normalizeComponentForComparison,
   normalizeGroupForComparison,
+  normalizePresetForComparison,
   normalizeTagForComparison,
 } from './comparison-utils';
 
@@ -61,6 +63,21 @@ export function buildDependencyGraph(context: GraphBuildingContext): DependencyG
     graph.nodes.set(nodeId, node);
   });
 
+  // Create nodes for all presets with colocated target data
+  spaceState.local.presets.forEach((preset) => {
+    const nodeId = `preset:${preset.name}`;
+    const targetPreset = spaceState.target.presets.get(preset.name);
+    const targetData = targetPreset
+      ? {
+          resource: targetPreset,
+          id: targetPreset.id,
+          hash: generateContentHash(normalizePresetForComparison(preset)),
+        }
+      : undefined;
+    const node = new PresetNode(preset, targetData);
+    graph.nodes.set(nodeId, node);
+  });
+
   // Add group parent dependencies
   spaceState.local.groups.forEach((group) => {
     if (group.parent_uuid) {
@@ -111,6 +128,18 @@ export function buildDependencyGraph(context: GraphBuildingContext): DependencyG
     }
   });
 
+  // Add preset dependencies on components
+  spaceState.local.presets.forEach((preset) => {
+    const presetId = `preset:${preset.name}`;
+
+    // Find the component this preset belongs to
+    const component = spaceState.local.components.find(c => c.id === preset.component_id);
+    if (component) {
+      const componentId = `component:${component.name}`;
+      addDependency(presetId, componentId);
+    }
+  });
+
   return graph;
 }
 
@@ -589,3 +618,77 @@ export class ComponentNode extends GraphNode<SpaceComponent> {
     return result;
   }
 }
+
+/**
+ * Preset node implementation
+ * Presets depend on components (via component_id)
+ */
+class PresetNode implements UnifiedNode<SpaceComponentPreset> {
+  public readonly id: string;
+  public readonly name: string;
+  public readonly type: NodeType = 'preset';
+  public readonly sourceData: SpaceComponentPreset;
+  public targetData?: TargetResourceInfo<SpaceComponentPreset>;
+  public readonly dependencies = new Set<string>();
+  public readonly dependents = new Set<string>();
+
+  constructor(preset: SpaceComponentPreset, targetData?: TargetResourceInfo<SpaceComponentPreset>) {
+    this.sourceData = preset;
+    this.targetData = targetData;
+    this.id = `preset:${preset.name}`;
+    this.name = preset.name;
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  normalize(): any {
+    return normalizePresetForComparison(this.sourceData);
+  }
+
+  shouldSkip(): boolean {
+    if (!this.targetData) { return false; }
+
+    const sourceHash = generateContentHash(this.normalize());
+    return sourceHash === this.targetData.hash;
+  }
+
+  resolveReferences(graph: DependencyGraph): void {
+    // Find the component this preset belongs to and update component_id
+    const componentName = this.findComponentNameById(this.sourceData.component_id, graph);
+    if (componentName) {
+      const componentNode = graph.nodes.get(`component:${componentName}`);
+      if (componentNode?.targetData) {
+        this.sourceData.component_id = componentNode.targetData.id as number;
+      }
+    }
+  }
+
+  private findComponentNameById(componentId: number, graph: DependencyGraph): string | null {
+    // Find component by matching source component_id
+    for (const [_nodeId, node] of graph.nodes) {
+      if (node.type === 'component' && (node.sourceData as SpaceComponent).id === componentId) {
+        return node.name;
+      }
+    }
+    return null;
+  }
+
+  async upsert(space: string): Promise<SpaceComponentPreset> {
+    const existingId = this.targetData?.id as number | undefined;
+    const result = await upsertComponentPreset(space, this.sourceData, existingId);
+    if (!result) {
+      throw new Error(`Failed to upsert preset: ${this.name}`);
+    }
+    return result;
+  }
+
+  updateTargetData(result: SpaceComponentPreset): void {
+    this.targetData = {
+      resource: result,
+      id: result.id,
+      hash: generateContentHash(this.normalize()),
+    };
+  }
+}

src/commands/components/push/graph-operations/index.ts

@@ -37,16 +37,8 @@ export async function pushWithDependencyGraph(
   const graph = buildDependencyGraph(context);
   validateGraph(graph);
 
-  // Process resources with 2-pass per level approach:
-  // - Pass 1: Resolve references (dependencies from previous levels exist)
-  // - Pass 2: Process resources with resolved references
+  // Process all resources using the dependency graph
   const results = await processAllResources(graph, space, maxConcurrency, force);
 
-  // TODO: Process presets after main resources
-  // const presetResults = await processPresets(spaceData.presets, graph, space, password, region);
-  // results.successful.push(...presetResults.successful);
-  // results.failed.push(...presetResults.failed);
-  // results.skipped.push(...presetResults.skipped);
-
   return results;
 }

src/commands/components/push/graph-operations/resource-processor.ts

@@ -168,6 +168,7 @@ function getResourceTypeName(type: string): string {
     case 'component': return 'component';
     case 'group': return 'group';
     case 'tag': return 'tag';
+    case 'preset': return 'preset';
     default: return type;
   }
 }
@@ -180,6 +181,7 @@ function getResourceTypeColor(type: string): string {
     case 'component': return colorPalette.COMPONENTS;
     case 'group': return '#4ade80'; // green
     case 'tag': return '#fbbf24'; // yellow
+    case 'preset': return '#a855f7'; // purple
     default: return colorPalette.COMPONENTS;
   }
 }

src/commands/components/push/graph-operations/types.ts

@@ -3,6 +3,7 @@ import type {
   SpaceComponent,
   SpaceComponentGroup,
   SpaceComponentInternalTag,
+  SpaceComponentPreset,
   SpaceDataState,
 } from '../../constants';
 
@@ -11,10 +12,10 @@ import type {
 // =============================================================================
 
 /** Types of nodes in our dependency graph */
-export type NodeType = 'component' | 'group' | 'tag';
+export type NodeType = 'component' | 'group' | 'tag' | 'preset';
 
 /** Data that can be stored in a graph node */
-export type NodeData = SpaceComponent | SpaceComponentGroup | SpaceComponentInternalTag;
+export type NodeData = SpaceComponent | SpaceComponentGroup | SpaceComponentInternalTag | SpaceComponentPreset;
 
 /** Target resource information colocated with graph nodes */
 export interface TargetResourceInfo<T extends NodeData> {