Subscription Types

type ContentUpdate {
  contentId: ID!
  content: Content
  resolvedRef: ResolvedPackageRef!
  action: String!
  timestamp: DateTime!
}

subscription.on('data', (update) => {
  if (update.action === 'DELETED') {
    removeContent(update.contentId);
    return;
  }

  // Content may be null if payload exceeds 100KB
  if (update.content) {
    refreshContent(update.content, update.resolvedRef);
  } else {
    // Fetch separately
    fetchContent(update.contentId).then(content => {
      refreshContent(content, update.resolvedRef);
    });
  }
});

type ComponentUpdate {
  componentId: ID!
  component: Component
  resolvedRef: ResolvedPackageRef!
  action: String!
  timestamp: DateTime!
}

type PackageUpdate {
  packageId: ID!
  resolvedRef: ResolvedPackageRef!
  action: String!
  timestamp: DateTime!
}

type PreviewUpdate {
  preview: PreviewResult!
  action: String!
  timestamp: DateTime!
}

union PreviewResult = ComponentPreview | ContentPreview

type ComponentPreview {
  componentId: ID!
  componentName: String!
  component: Component
  resolvedRef: ResolvedPackageRef!
}

type ContentPreview {
  contentId: ID!
  contentName: String!
  contentTypeName: String!
  content: Content
  resolvedRef: ResolvedPackageRef!
}

subscription.on('data', (update) => {
  const { preview, action } = update;

  if (action === 'DELETED') {
    if (preview.__typename === 'ComponentPreview') {
      removeComponentPreview(preview.componentId);
    } else {
      removeContentPreview(preview.contentId);
    }
    return;
  }

  // Handle component preview
  if (preview.__typename === 'ComponentPreview') {
    if (preview.component) {
      refreshComponentPreview(preview.component, preview.resolvedRef);
    } else {
      fetchComponent(preview.componentId).then(component => {
        refreshComponentPreview(component, preview.resolvedRef);
      });
    }
  }

  // Handle content preview
  if (preview.__typename === 'ContentPreview') {
    if (preview.content) {
      refreshContentPreview(preview.content, preview.resolvedRef);
    } else {
      fetchContent(preview.contentId).then(content => {
        refreshContentPreview(content, preview.resolvedRef);
      });
    }
  }
});

if (!update.content) {
  // Payload exceeded 100KB, fetch separately
  const content = await fetchContent(update.contentId);
  refreshContent(content, update.resolvedRef);
}