unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/graphql/resolvers.ts

@@ -1,1008 +0,0 @@
-import type { GraphQLContext } from './types.js';
-import type { UnrealBridge } from '../unreal-bridge.js';
-import { AutomationBridge } from '../automation/index.js';
-
-export const scalarResolvers = {
-  Vector: {
-    serialize: (value: any) => {
-      if (!value) return null;
-      return typeof value === 'object' && 'x' in value && 'y' in value && 'z' in value
-        ? value
-        : null;
-    },
-    parseValue: (value: any) => value,
-    parseLiteral: (ast: any) => {
-      if (ast.kind === 'ObjectValue') {
-        const value: any = {};
-        ast.fields.forEach((field: any) => {
-          value[field.name.value] = field.value.value;
-        });
-        return value;
-      }
-      return null;
-    }
-  },
-  Rotator: {
-    serialize: (value: any) => {
-      if (!value) return null;
-      return typeof value === 'object' && 'pitch' in value && 'yaw' in value && 'roll' in value
-        ? value
-        : null;
-    },
-    parseValue: (value: any) => value,
-    parseLiteral: (ast: any) => {
-      if (ast.kind === 'ObjectValue') {
-        const value: any = {};
-        ast.fields.forEach((field: any) => {
-          value[field.name.value] = field.value.value;
-        });
-        return value;
-      }
-      return null;
-    }
-  },
-  Transform: {
-    serialize: (value: any) => value,
-    parseValue: (value: any) => value,
-    parseLiteral: (ast: any) => {
-      if (ast.kind === 'ObjectValue') {
-        const value: any = {};
-        ast.fields.forEach((field: any) => {
-          if (field.value.kind === 'ObjectValue') {
-            value[field.name.value] = {};
-            field.value.fields.forEach((f: any) => {
-              value[field.name.value][f.name.value] = f.value.value;
-            });
-          } else {
-            value[field.name.value] = field.value.value;
-          }
-        });
-        return value;
-      }
-      return null;
-    }
-  },
-  JSON: {
-    serialize: (value: any) => value,
-    parseValue: (value: any) => value,
-    parseLiteral: (ast: any) => {
-      switch (ast.kind) {
-        case 'StringValue':
-          return ast.value;
-        case 'BooleanValue':
-          return ast.value;
-        case 'IntValue':
-        case 'FloatValue':
-          return Number(ast.value);
-        case 'ObjectValue':
-          const value: any = {};
-          ast.fields.forEach((field: any) => {
-            value[field.name.value] = (scalarResolvers as any).JSON.parseLiteral(field.value);
-          });
-          return value;
-        case 'ListValue':
-          return ast.values.map((v: any) => (scalarResolvers as any).JSON.parseLiteral(v));
-        default:
-          return null;
-      }
-    }
-  }
-};
-
-interface Asset {
-  name: string;
-  path: string;
-  class: string;
-  packagePath: string;
-  size?: number;
-  metadata?: Record<string, any>;
-  tags?: string[];
-}
-
-interface Actor {
-  name: string;
-  class: string;
-  location?: { x: number; y: number; z: number };
-  rotation?: { pitch: number; yaw: number; roll: number };
-  scale?: { x: number; y: number; z: number };
-  tags?: string[];
-  properties?: Record<string, any>;
-}
-
-interface Blueprint {
-  name: string;
-  path: string;
-  parentClass?: string;
-  variables?: Array<{
-    name: string;
-    type: string;
-    defaultValue?: any;
-    metadata?: Record<string, any>;
-  }>;
-  functions?: Array<{
-    name: string;
-    inputs?: Array<{ name: string; type: string }>;
-    outputs?: Array<{ name: string; type: string }>;
-  }>;
-  events?: Array<{ name: string; type: string }>;
-  components?: Array<{ name: string; type: string; properties?: Record<string, any> }>;
-  scsHierarchy?: Record<string, any>;
-}
-
-import { Logger } from '../utils/logger.js';
-
-const log = new Logger('GraphQL:Resolvers');
-
-/**
- * Creates a GraphQL-friendly error with proper extensions
- */
-class GraphQLResolverError extends Error {
-  extensions: { code: string; originalError?: string };
-
-  constructor(message: string, code: string = 'UNREAL_ENGINE_ERROR', originalError?: Error) {
-    super(message);
-    this.name = 'GraphQLResolverError';
-    this.extensions = {
-      code,
-      originalError: originalError?.message
-    };
-  }
-}
-
-/**
- * Helper to create resolver errors with proper logging
- */
-function createResolverError(operation: string, error: unknown): GraphQLResolverError {
-  const message = error instanceof Error ? error.message : String(error);
-  log.error(`${operation} failed:`, message);
-  return new GraphQLResolverError(`${operation} failed: ${message}`, 'UNREAL_ENGINE_ERROR', error instanceof Error ? error : undefined);
-}
-
-function logAutomationFailure(source: string, response: any) {
-  try {
-    if (!response || response.success !== false) {
-      return;
-    }
-    const errorText = (response.error || response.message || '').toString();
-    if (errorText.length === 0) {
-      return;
-    }
-    log.error(`${source} automation failure:`, errorText);
-  } catch {
-  }
-}
-
-/**
- * Helper to get actor properties from Unreal Bridge
- */
-async function getActorProperties(
-  bridge: UnrealBridge,
-  actorName: string
-): Promise<Record<string, any>> {
-  try {
-    const result = await bridge.getObjectProperty({
-      objectPath: actorName,
-      propertyName: '*',
-      timeoutMs: 5000
-    });
-    return result.success ? result.value || {} : {};
-  } catch (error) {
-    log.error('Failed to get actor properties:', error);
-    return {};
-  }
-}
-
-/**
- * Helper to list assets
- */
-async function listAssets(
-  automationBridge: AutomationBridge,
-  filter?: { class?: string; tag?: string; pathStartsWith?: string },
-  pagination?: { offset?: number; limit?: number }
-): Promise<{ assets: Asset[]; totalCount: number }> {
-  try {
-    const response = await automationBridge.sendAutomationRequest(
-      'list_assets',
-      {
-        filter: filter || {},
-        pagination: pagination || { offset: 0, limit: 50 }
-      },
-      { timeoutMs: 30000 }
-    );
-
-    if (response.success && response.result) {
-      const result = response.result as any;
-      return {
-        assets: result.assets || [],
-        totalCount: result.totalCount || 0
-      };
-    }
-
-    logAutomationFailure('list_assets', response);
-    log.warn('Failed to list assets - returning empty set');
-    return { assets: [], totalCount: 0 };
-  } catch (error) {
-    log.error('Failed to list assets:', error);
-    throw createResolverError('listAssets', error);
-  }
-}
-
-/**
- * Helper to list actors
- */
-async function listActors(
-  automationBridge: AutomationBridge,
-  filter?: { class?: string; tag?: string }
-): Promise<{ actors: Actor[] }> {
-  try {
-    const response = await automationBridge.sendAutomationRequest(
-      'list_actors',
-      {
-        filter: filter || {}
-      },
-      { timeoutMs: 30000 }
-    );
-
-    if (response.success && response.result) {
-      const result = response.result as any;
-      return {
-        actors: result.actors || []
-      };
-    }
-
-    logAutomationFailure('list_actors', response);
-    return { actors: [] };
-  } catch (error) {
-    console.error('Failed to list actors:', error);
-    return { actors: [] };
-  }
-}
-
-
-
-/**
- * GraphQL Resolvers Implementation
- */
-export const resolvers = {
-  // Query resolvers
-  Query: {
-    assets: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      const { assets, totalCount } = await listAssets(
-        context.automationBridge,
-        filter,
-        pagination
-      );
-
-      // Convert to connection format for pagination
-      const edges = assets.map((asset, index) => ({
-        node: asset,
-        cursor: Buffer.from(`${asset.path}:${index}`).toString('base64')
-      }));
-
-      return {
-        edges,
-        pageInfo: {
-          hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
-          hasPreviousPage: (pagination?.offset || 0) > 0,
-          startCursor: edges.length > 0 ? edges[0].cursor : null,
-          endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-        },
-        totalCount
-      };
-    },
-
-    asset: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      try {
-        if (!context.loaders) {
-          throw new Error('Loaders not initialized');
-        }
-        return await context.loaders.assetLoader.load(path);
-      } catch (error) {
-        console.error('Failed to get asset:', error);
-        return null;
-      }
-    },
-
-    actors: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      const { actors } = await listActors(context.automationBridge, filter);
-
-      const offset = pagination?.offset ?? 0;
-      const limit = pagination?.limit ?? 50;
-
-      const paginatedActors = actors.slice(offset, offset + limit);
-
-      const edges = paginatedActors.map((actor, index) => ({
-        node: actor,
-        cursor: Buffer.from(`${actor.name}:${offset + index}`).toString('base64')
-      }));
-
-      return {
-        edges,
-        pageInfo: {
-          hasNextPage: offset + paginatedActors.length < actors.length,
-          hasPreviousPage: offset > 0,
-          startCursor: edges.length > 0 ? edges[0].cursor : null,
-          endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-        },
-        totalCount: actors.length
-      };
-    },
-
-    actor: async (_: any, { name }: { name: string }, context: GraphQLContext) => {
-      try {
-        if (!context.loaders) {
-          throw new Error('Loaders not initialized');
-        }
-        return await context.loaders.actorLoader.load(name);
-      } catch (error) {
-        console.error('Failed to get actor:', error);
-        return null;
-      }
-    },
-
-    blueprints: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'list_blueprints',
-          {
-            filter: filter || {},
-            pagination: pagination || { offset: 0, limit: 50 }
-          },
-          { timeoutMs: 30000 }
-        );
-
-        const blueprints: Blueprint[] = response.success && response.result
-          ? (response.result as any).blueprints || []
-          : [];
-
-        const edges = blueprints.map((blueprint, index) => ({
-          node: blueprint,
-          cursor: Buffer.from(`${blueprint.path}:${index}`).toString('base64')
-        }));
-
-        return {
-          edges,
-          pageInfo: {
-            hasNextPage: (pagination?.offset || 0) + blueprints.length < (response.result as any)?.totalCount || 0,
-            hasPreviousPage: (pagination?.offset || 0) > 0,
-            startCursor: edges.length > 0 ? edges[0].cursor : null,
-            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-          },
-          totalCount: blueprints.length
-        };
-      } catch (error) {
-        console.error('Failed to list blueprints:', error);
-        return {
-          edges: [],
-          pageInfo: {
-            hasNextPage: false,
-            hasPreviousPage: false,
-            startCursor: null,
-            endCursor: null
-          },
-          totalCount: 0
-        };
-      }
-    },
-
-    blueprint: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      if (!context.loaders) {
-        throw new Error('Loaders not initialized');
-      }
-      return await context.loaders.blueprintLoader.load(path);
-    },
-
-    levels: async (_: any, __: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'list_levels',
-          {},
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).levels || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to list levels:', error);
-        return [];
-      }
-    },
-
-    currentLevel: async (_: any, __: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_current_level',
-          {},
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        return null;
-      } catch (error) {
-        console.error('Failed to get current level:', error);
-        return null;
-      }
-    },
-
-    materials: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      try {
-        const materialFilter = { ...filter, class: 'MaterialInterface' };
-        const { assets, totalCount } = await listAssets(
-          context.automationBridge,
-          materialFilter,
-          pagination
-        );
-
-        const offset = pagination?.offset ?? 0;
-        const edges = assets.map((material, index) => ({
-          node: material, // Material type in schema matches Asset mostly
-          cursor: Buffer.from(`${material.path}:${offset + index}`).toString('base64')
-        }));
-
-        return {
-          edges,
-          pageInfo: {
-            hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
-            hasPreviousPage: (pagination?.offset || 0) > 0,
-            startCursor: edges.length > 0 ? edges[0].cursor : null,
-            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-          },
-          totalCount
-        };
-      } catch (error) {
-        console.error('Failed to list materials:', error);
-        return {
-          edges: [],
-          pageInfo: {
-            hasNextPage: false,
-            hasPreviousPage: false,
-            startCursor: null,
-            endCursor: null
-          },
-          totalCount: 0
-        };
-      }
-    },
-
-    sequences: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      try {
-        const sequenceFilter = { ...filter, class: 'LevelSequence' };
-        const { assets, totalCount } = await listAssets(
-          context.automationBridge,
-          sequenceFilter,
-          pagination
-        );
-
-        const offset = pagination?.offset ?? 0;
-        const edges = assets.map((sequence, index) => ({
-          node: sequence,
-          cursor: Buffer.from(`${sequence.path}:${offset + index}`).toString('base64')
-        }));
-
-        return {
-          edges,
-          pageInfo: {
-            hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
-            hasPreviousPage: (pagination?.offset || 0) > 0,
-            startCursor: edges.length > 0 ? edges[0].cursor : null,
-            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-          },
-          totalCount
-        };
-      } catch (error) {
-        console.error('Failed to list sequences:', error);
-        return {
-          edges: [],
-          pageInfo: {
-            hasNextPage: false,
-            hasPreviousPage: false,
-            startCursor: null,
-            endCursor: null
-          },
-          totalCount: 0
-        };
-      }
-    },
-
-    worldPartitionCells: async (_: any, __: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'manage_world_partition',
-          { subAction: 'get_cells' },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).cells || [];
-        }
-        return [];
-      } catch (error) {
-        console.error('Failed to list world partition cells:', error);
-        return [];
-      }
-    },
-
-    niagaraSystems: async (_: any, args: any, context: GraphQLContext) => {
-      const { filter, pagination } = args;
-      try {
-        // Re-use list_assets with filter for NiagaraSystem class
-        const niagaraFilter = { ...filter, class: 'NiagaraSystem' };
-        const { assets, totalCount } = await listAssets(
-          context.automationBridge,
-          niagaraFilter,
-          pagination
-        );
-
-        const offset = pagination?.offset ?? 0;
-        const edges = assets.map((asset, index) => ({
-          node: {
-            ...asset,
-            emitters: [],
-            parameters: []
-          },
-          cursor: Buffer.from(`${asset.path}:${offset + index}`).toString('base64')
-        }));
-
-        return {
-          edges,
-          pageInfo: {
-            hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
-            hasPreviousPage: (pagination?.offset || 0) > 0,
-            startCursor: edges.length > 0 ? edges[0].cursor : null,
-            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
-          },
-          totalCount
-        };
-      } catch (error) {
-        console.error('Failed to list niagara systems:', error);
-        return {
-          edges: [],
-          pageInfo: {
-            hasNextPage: false,
-            hasPreviousPage: false,
-            startCursor: null,
-            endCursor: null
-          },
-          totalCount: 0
-        };
-      }
-    },
-
-    niagaraSystem: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      try {
-        // Check if it's a niagara system
-        const asset = await context.automationBridge.sendAutomationRequest(
-          'get_asset',
-          { assetPath: path },
-          { timeoutMs: 10000 }
-        );
-        if (asset.success && asset.result && (asset.result as any).class === 'NiagaraSystem') {
-          return {
-            ...(asset.result as any),
-            emitters: [],
-            parameters: []
-          };
-        }
-        return null;
-      } catch (error) {
-        console.error('Failed to get niagara system:', error);
-        return null;
-      }
-    },
-
-    search: async (_: any, { query, type }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'search',
-          {
-            query,
-            type: type || 'ALL'
-          },
-          { timeoutMs: 30000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).results || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to search:', error);
-        return [];
-      }
-    }
-  },
-
-  // Mutation resolvers
-  Mutation: {
-    duplicateAsset: async (_: any, { path, newName }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'duplicate_asset',
-          {
-            assetPath: path,
-            newName
-          },
-          { timeoutMs: 60000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to duplicate asset');
-      } catch (error) {
-        console.error('Failed to duplicate asset:', error);
-        throw error;
-      }
-    },
-
-    moveAsset: async (_: any, { path, newPath }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'move_asset',
-          {
-            assetPath: path,
-            destinationPath: newPath
-          },
-          { timeoutMs: 60000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to move asset');
-      } catch (error) {
-        console.error('Failed to move asset:', error);
-        throw error;
-      }
-    },
-
-    deleteAsset: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'delete_asset',
-          {
-            assetPath: path
-          },
-          { timeoutMs: 30000 }
-        );
-
-        return response.success || false;
-      } catch (error) {
-        console.error('Failed to delete asset:', error);
-        return false;
-      }
-    },
-
-    spawnActor: async (_: any, { input }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'spawn_actor',
-          input,
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to spawn actor');
-      } catch (error) {
-        console.error('Failed to spawn actor:', error);
-        throw error;
-      }
-    },
-
-    deleteActor: async (_: any, { name }: { name: string }, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'delete_actor',
-          {
-            actorName: name
-          },
-          { timeoutMs: 10000 }
-        );
-
-        return response.success || false;
-      } catch (error) {
-        console.error('Failed to delete actor:', error);
-        return false;
-      }
-    },
-
-    setActorTransform: async (_: any, { name, transform }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'set_actor_transform',
-          {
-            actorName: name,
-            transform
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to set actor transform');
-      } catch (error) {
-        console.error('Failed to set actor transform:', error);
-        throw error;
-      }
-    },
-
-    createBlueprint: async (_: any, { input }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'create_blueprint',
-          input,
-          { timeoutMs: 60000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to create blueprint');
-      } catch (error) {
-        console.error('Failed to create blueprint:', error);
-        throw error;
-      }
-    },
-
-    addVariableToBlueprint: async (_: any, { path, input }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'add_variable_to_blueprint',
-          {
-            blueprintPath: path,
-            ...input
-          },
-          { timeoutMs: 30000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to add variable to blueprint');
-      } catch (error) {
-        console.error('Failed to add variable to blueprint:', error);
-        throw error;
-      }
-    },
-
-    addFunctionToBlueprint: async (_: any, { path, input }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'add_function_to_blueprint',
-          {
-            blueprintPath: path,
-            ...input
-          },
-          { timeoutMs: 30000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to add function to blueprint');
-      } catch (error) {
-        console.error('Failed to add function to blueprint:', error);
-        throw error;
-      }
-    },
-
-    loadLevel: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'load_level',
-          {
-            levelPath: path
-          },
-          { timeoutMs: 30000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to load level');
-      } catch (error) {
-        console.error('Failed to load level:', error);
-        throw error;
-      }
-    },
-
-    saveLevel: async (_: any, { path }: { path?: string }, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'save_level',
-          {
-            levelPath: path
-          },
-          { timeoutMs: 30000 }
-        );
-
-        return response.success || false;
-      } catch (error) {
-        console.error('Failed to save level:', error);
-        return false;
-      }
-    },
-
-    createMaterialInstance: async (_: any, { parentPath, name, parameters }: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'create_material_instance',
-          {
-            parentMaterialPath: parentPath,
-            instanceName: name,
-            parameters: parameters || {}
-          },
-          { timeoutMs: 30000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
-        }
-
-        throw new Error(response.error || 'Failed to create material instance');
-      } catch (error) {
-        console.error('Failed to create material instance:', error);
-        throw error;
-      }
-    }
-  },
-
-  // Field resolvers
-  Asset: {
-    dependencies: async (parent: Asset, _: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_asset_dependencies',
-          {
-            assetPath: parent.path
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).dependencies || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to get asset dependencies:', error);
-        return [];
-      }
-    },
-
-    dependents: async (parent: Asset, _: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_asset_dependents',
-          {
-            assetPath: parent.path
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).dependents || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to get asset dependents:', error);
-        return [];
-      }
-    }
-  },
-
-  Actor: {
-    properties: async (parent: Actor, _: any, context: GraphQLContext) => {
-      return await getActorProperties(context.bridge, parent.name);
-    },
-
-    components: async (parent: Actor, _: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_actor_components',
-          {
-            actorName: parent.name
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).components || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to get actor components:', error);
-        return [];
-      }
-    }
-  },
-
-  Blueprint: {
-    variables: async (parent: Blueprint, _args: any, _context: GraphQLContext) => {
-      return parent.variables || [];
-    },
-
-    functions: async (parent: Blueprint, _args: any, _context: GraphQLContext) => {
-      return parent.functions || [];
-    },
-
-    events: async (parent: Blueprint, _args: any, _context: GraphQLContext) => {
-      return parent.events || [];
-    },
-
-    components: async (parent: Blueprint, _args: any, _context: GraphQLContext) => {
-      return parent.components || [];
-    }
-  },
-
-  Material: {
-    parameters: async (parent: any, _: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_material_parameters',
-          {
-            materialPath: parent.path
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).parameters || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to get material parameters:', error);
-        return [];
-      }
-    }
-  },
-
-  Sequence: {
-    tracks: async (parent: any, _: any, context: GraphQLContext) => {
-      try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_sequence_tracks',
-          {
-            sequencePath: parent.path
-          },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return (response.result as any).tracks || [];
-        }
-
-        return [];
-      } catch (error) {
-        console.error('Failed to get sequence tracks:', error);
-        return [];
-      }
-    }
-  }
-};