@checkstack/integration-backend 0.1.30 → 0.3.0

package/src/provider-registry.test.ts

@@ -1,314 +1,84 @@
-import { describe, it, expect, beforeEach } from "bun:test";
+/**
+ * Provider registry behaviour tests — scoped to connection-management
+ * after the Automation Platform migration. Subscription / delivery
+ * concerns moved to the trigger / action registries on the automation
+ * side; the integration registry now only owns connection schemas.
+ */
+import { describe, expect, it, beforeEach } from "bun:test";
 import { z } from "zod";
+import { Versioned, configString } from "@checkstack/backend-api";
 import {
   createIntegrationProviderRegistry,
   type IntegrationProviderRegistry,
 } from "./provider-registry";
 import type { IntegrationProvider } from "./provider-types";
-import { Versioned } from "@checkstack/backend-api";
 
-/**
- * Unit tests for IntegrationProviderRegistry.
- *
- * Tests cover:
- * - Provider registration with proper namespacing
- * - Provider retrieval by qualified ID
- * - Config schema JSON conversion
- */
+const testPlugin = { pluginId: "test-plugin" } as const;
 
-// Test plugin metadata
-const testPluginMetadata = {
-  pluginId: "test-plugin",
-  displayName: "Test Plugin",
-} as const;
-
-// Test config schemas
-const webhookConfigSchema = z.object({
-  url: z.string().url(),
-  method: z.enum(["GET", "POST"]),
-  timeout: z.number().default(5000),
+const sampleConnectionSchema = z.object({
+  apiKey: configString({ "x-secret": true }).describe("API key"),
 });
 
-const slackConfigSchema = z.object({
-  webhookUrl: z.string().url(),
-  channel: z.string(),
-});
+type SampleConnection = z.infer<typeof sampleConnectionSchema>;
 
-// Create test providers
-function createTestProvider(
-  id: string,
-  schema: z.ZodType<unknown>
-): IntegrationProvider<unknown> {
-  return {
-    id,
-    displayName: `${id.charAt(0).toUpperCase()}${id.slice(1)} Provider`,
-    description: `Deliver events via ${id}`,
-    icon: "Webhook",
-    config: new Versioned({
-      version: 1,
-      schema,
-    }),
-    deliver: async () => ({ success: true }),
-  };
-}
+const sampleProvider: IntegrationProvider<SampleConnection> = {
+  id: "sample",
+  displayName: "Sample",
+  description: "Sample provider for tests",
+  icon: "Webhook",
+  connectionSchema: new Versioned({
+    version: 1,
+    schema: sampleConnectionSchema,
+  }),
+};
 
 describe("IntegrationProviderRegistry", () => {
   let registry: IntegrationProviderRegistry;
-
   beforeEach(() => {
     registry = createIntegrationProviderRegistry();
   });
 
-  // ─────────────────────────────────────────────────────────────────────────
-  // Provider Registration
-  // ─────────────────────────────────────────────────────────────────────────
-
-  describe("register", () => {
-    it("registers a provider with a fully qualified ID", () => {
-      const provider = createTestProvider("webhook", webhookConfigSchema);
-
-      registry.register(provider, testPluginMetadata);
-
-      expect(registry.hasProvider("test-plugin.webhook")).toBe(true);
-    });
-
-    it("generates correct qualified ID", () => {
-      const provider = createTestProvider("webhook", webhookConfigSchema);
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.webhook");
-      expect(registered?.qualifiedId).toBe("test-plugin.webhook");
-      expect(registered?.ownerPluginId).toBe("test-plugin");
-    });
-
-    it("preserves provider metadata", () => {
-      const provider: IntegrationProvider<unknown> = {
-        id: "custom",
-        displayName: "Custom Provider",
-        description: "A custom provider for testing",
-        icon: "Cog",
-        config: new Versioned({ version: 1, schema: webhookConfigSchema }),
-        deliver: async () => ({ success: true }),
-      };
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.custom");
-      expect(registered?.displayName).toBe("Custom Provider");
-      expect(registered?.description).toBe("A custom provider for testing");
-      expect(registered?.icon).toBe("Cog");
-    });
-
-    it("preserves deliver function", () => {
-      const deliverFn = async () => ({ success: true, externalId: "ext-123" });
-      const provider: IntegrationProvider<unknown> = {
-        id: "webhook",
-        displayName: "Webhook",
-        config: new Versioned({ version: 1, schema: webhookConfigSchema }),
-        deliver: deliverFn,
-      };
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.webhook");
-      expect(registered?.deliver).toBeDefined();
-    });
-
-    it("preserves testConnection function if provided", () => {
-      const provider: IntegrationProvider<unknown> = {
-        id: "webhook",
-        displayName: "Webhook",
-        config: new Versioned({ version: 1, schema: webhookConfigSchema }),
-        deliver: async () => ({ success: true }),
-        testConnection: async () => ({ success: true, message: "OK" }),
-      };
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.webhook");
-      expect(registered?.testConnection).toBeDefined();
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Provider Retrieval
-  // ─────────────────────────────────────────────────────────────────────────
-
-  describe("getProviders", () => {
-    it("returns empty array when no providers registered", () => {
-      expect(registry.getProviders()).toEqual([]);
-    });
-
-    it("returns all registered providers", () => {
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        testPluginMetadata
-      );
-      registry.register(
-        createTestProvider("slack", slackConfigSchema),
-        testPluginMetadata
-      );
-
-      const providers = registry.getProviders();
-      expect(providers.length).toBe(2);
-      expect(providers.map((p) => p.id).sort()).toEqual(["slack", "webhook"]);
-    });
-  });
-
-  describe("getProvider", () => {
-    it("returns undefined for non-existent provider", () => {
-      expect(registry.getProvider("non-existent.provider")).toBeUndefined();
-    });
-
-    it("returns provider by qualified ID", () => {
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        testPluginMetadata
-      );
-
-      const provider = registry.getProvider("test-plugin.webhook");
-      expect(provider?.displayName).toBe("Webhook Provider");
-    });
+  it("namespaces ids by plugin", () => {
+    registry.register(sampleProvider, testPlugin);
+    const registered = registry.getProvider("test-plugin.sample");
+    expect(registered).toBeDefined();
+    expect(registered?.qualifiedId).toBe("test-plugin.sample");
+    expect(registered?.ownerPluginId).toBe("test-plugin");
   });
 
-  describe("hasProvider", () => {
-    it("returns false for non-existent provider", () => {
-      expect(registry.hasProvider("non-existent.provider")).toBe(false);
-    });
-
-    it("returns true for registered provider", () => {
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        testPluginMetadata
-      );
-
-      expect(registry.hasProvider("test-plugin.webhook")).toBe(true);
-    });
+  it("returns all registered providers", () => {
+    registry.register(sampleProvider, testPlugin);
+    registry.register(
+      { ...sampleProvider, id: "other" } as IntegrationProvider<SampleConnection>,
+      testPlugin,
+    );
+    expect(registry.getProviders()).toHaveLength(2);
   });
 
-  // ─────────────────────────────────────────────────────────────────────────
-  // Config Schema
-  // ─────────────────────────────────────────────────────────────────────────
-
-  describe("getProviderConfigSchema", () => {
-    it("returns undefined for non-existent provider", () => {
-      expect(
-        registry.getProviderConfigSchema("non-existent.provider")
-      ).toBeUndefined();
-    });
-
-    it("returns JSON Schema for provider config", () => {
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        testPluginMetadata
-      );
-
-      const schema = registry.getProviderConfigSchema("test-plugin.webhook");
-      expect(schema).toBeDefined();
-      expect(typeof schema).toBe("object");
-      expect(schema?.type).toBe("object");
-    });
-
-    it("JSON Schema includes property definitions", () => {
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        testPluginMetadata
-      );
-
-      const schema = registry.getProviderConfigSchema("test-plugin.webhook");
-      const properties = schema?.properties as Record<string, unknown>;
-
-      expect(properties).toBeDefined();
-      expect(properties.url).toBeDefined();
-      expect(properties.method).toBeDefined();
-      expect(properties.timeout).toBeDefined();
-    });
+  it("reports presence via hasProvider", () => {
+    registry.register(sampleProvider, testPlugin);
+    expect(registry.hasProvider("test-plugin.sample")).toBe(true);
+    expect(registry.hasProvider("test-plugin.missing")).toBe(false);
   });
 
-  // ─────────────────────────────────────────────────────────────────────────
-  // Multi-Plugin Registration
-  // ─────────────────────────────────────────────────────────────────────────
-
-  describe("multi-plugin registration", () => {
-    it("handles providers from multiple plugins", () => {
-      const plugin1 = { pluginId: "plugin-1" } as const;
-      const plugin2 = { pluginId: "plugin-2" } as const;
-
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        plugin1
-      );
-      registry.register(
-        createTestProvider("webhook", webhookConfigSchema),
-        plugin2
-      );
-
-      expect(registry.hasProvider("plugin-1.webhook")).toBe(true);
-      expect(registry.hasProvider("plugin-2.webhook")).toBe(true);
-
-      const providers = registry.getProviders();
-      expect(providers.length).toBe(2);
-    });
-
-    it("correctly namespaces providers by plugin", () => {
-      const plugin1 = { pluginId: "integration-webhook" } as const;
-      const plugin2 = { pluginId: "integration-slack" } as const;
-
-      registry.register(
-        {
-          ...createTestProvider("default", webhookConfigSchema),
-          displayName: "Webhook",
-        },
-        plugin1
-      );
-      registry.register(
-        {
-          ...createTestProvider("default", slackConfigSchema),
-          displayName: "Slack",
-        },
-        plugin2
-      );
-
-      expect(
-        registry.getProvider("integration-webhook.default")?.displayName
-      ).toBe("Webhook");
-      expect(
-        registry.getProvider("integration-slack.default")?.displayName
-      ).toBe("Slack");
-    });
+  it("exposes the connection JSON schema when present", () => {
+    registry.register(sampleProvider, testPlugin);
+    const schema = registry.getProviderConnectionSchema("test-plugin.sample");
+    expect(schema).toBeDefined();
+    expect((schema as Record<string, unknown>).type).toBe("object");
   });
 
-  // ─────────────────────────────────────────────────────────────────────────
-  // Supported Events
-  // ─────────────────────────────────────────────────────────────────────────
-
-  describe("supportedEvents", () => {
-    it("preserves supportedEvents array", () => {
-      const provider: IntegrationProvider<unknown> = {
-        id: "limited",
-        displayName: "Limited Provider",
-        config: new Versioned({ version: 1, schema: webhookConfigSchema }),
-        supportedEvents: ["incident.created", "incident.resolved"],
-        deliver: async () => ({ success: true }),
-      };
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.limited");
-      expect(registered?.supportedEvents).toEqual([
-        "incident.created",
-        "incident.resolved",
-      ]);
-    });
-
-    it("handles provider with no supportedEvents (accepts all)", () => {
-      const provider = createTestProvider("webhook", webhookConfigSchema);
-
-      registry.register(provider, testPluginMetadata);
-
-      const registered = registry.getProvider("test-plugin.webhook");
-      expect(registered?.supportedEvents).toBeUndefined();
-    });
+  it("returns undefined for providers without a connection schema", () => {
+    const minimal: IntegrationProvider<undefined> = {
+      id: "minimal",
+      displayName: "Minimal",
+    };
+    registry.register(
+      minimal as IntegrationProvider<unknown>,
+      testPlugin,
+    );
+    expect(
+      registry.getProviderConnectionSchema("test-plugin.minimal"),
+    ).toBeUndefined();
   });
 });

package/src/provider-registry.ts

@@ -6,8 +6,11 @@ import type {
 } from "./provider-types";
 
 /**
- * Registry for integration providers.
- * Plugins register their providers here to enable webhook delivery to external systems.
+ * Registry for integration providers — now scoped to connection
+ * management only. Per-subscription `config` + `deliver` moved to the
+ * Automation platform's `ActionDefinition` (see
+ * `@checkstack/automation-backend`); the legacy subscription system is
+ * gone.
  */
 export interface IntegrationProviderRegistry {
   /**
@@ -30,11 +33,6 @@ export interface IntegrationProviderRegistry {
   /** Check if a provider is registered */
   hasProvider(qualifiedId: string): boolean;
 
-  /** Get the JSON Schema for a provider's config */
-  getProviderConfigSchema(
-    qualifiedId: string
-  ): Record<string, unknown> | undefined;
-
   /** Get the JSON Schema for a provider's connection config (if any) */
   getProviderConnectionSchema(
     qualifiedId: string
@@ -46,7 +44,6 @@ export interface IntegrationProviderRegistry {
  */
 export function createIntegrationProviderRegistry(): IntegrationProviderRegistry {
   const providers = new Map<string, RegisteredIntegrationProvider<unknown>>();
-  const configSchemas = new Map<string, Record<string, unknown>>();
   const connectionSchemas = new Map<string, Record<string, unknown>>();
 
   return {
@@ -64,12 +61,6 @@ export function createIntegrationProviderRegistry(): IntegrationProviderRegistry
 
       providers.set(qualifiedId, registered);
 
-      // Convert the provider's config schema to JSON Schema for UI
-      // Uses the platform's toJsonSchema which handles secrets/colors
-      const jsonSchema = toJsonSchema(provider.config.schema);
-      configSchemas.set(qualifiedId, jsonSchema);
-
-      // Also convert connection schema if present
       if (provider.connectionSchema) {
         const connectionJsonSchema = toJsonSchema(
           provider.connectionSchema.schema
@@ -92,12 +83,6 @@ export function createIntegrationProviderRegistry(): IntegrationProviderRegistry
       return providers.has(qualifiedId);
     },
 
-    getProviderConfigSchema(
-      qualifiedId: string
-    ): Record<string, unknown> | undefined {
-      return configSchemas.get(qualifiedId);
-    },
-
     getProviderConnectionSchema(
       qualifiedId: string
     ): Record<string, unknown> | undefined {

package/src/provider-types.ts

@@ -1,95 +1,11 @@
 /**
- * Integration Provider Types
- *
- * These types define the contract for integration provider plugins.
- * All backend-only types live here - frontend uses Zod schemas from integration-common.
+ * Integration Provider Types — connection-only after the Automation
+ * Platform migration. Per-event delivery context types are gone; the
+ * Automation engine's `ActionExecutionContext` replaces them.
  */
-import { z } from "zod";
-import type { Versioned, Logger, Hook } from "@checkstack/backend-api";
+import type { Versioned, Logger } from "@checkstack/backend-api";
 import type { LucideIconName } from "@checkstack/common";
 
-// =============================================================================
-// Integration Event Definition Types
-// =============================================================================
-
-/**
- * Metadata for registering a hook as an integration event.
- * Plugins use this to expose their hooks for external webhook subscriptions.
- */
-export interface IntegrationEventDefinition<T = unknown> {
-  /** The hook to expose (from the owning plugin) */
-  hook: Hook<T>;
-
-  /** Human-readable name for the UI */
-  displayName: string;
-
-  /** Description of when this event fires */
-  description?: string;
-
-  /** Category for UI grouping (e.g., "Health", "Incidents", "Maintenance") */
-  category?: string;
-
-  /** Zod schema for the payload (used for UI preview and validation) */
-  payloadSchema: z.ZodType<T>;
-
-  /**
-   * Optional: Transform hook payload before sending to webhooks.
-   * Use this to enrich the payload with additional context or
-   * redact sensitive fields.
-   */
-  transformPayload?: (payload: T) => Record<string, unknown>;
-}
-
-// =============================================================================
-// Integration Provider Types
-// =============================================================================
-
-/**
- * Context passed to the provider's deliver() method.
- */
-export interface IntegrationDeliveryContext<TConfig = unknown> {
-  event: {
-    /** Fully qualified event ID */
-    eventId: string;
-    /** Event payload (possibly transformed) */
-    payload: Record<string, unknown>;
-    /** ISO timestamp when the event was emitted */
-    timestamp: string;
-    /** Unique ID for this delivery attempt */
-    deliveryId: string;
-  };
-  subscription: {
-    /** Subscription ID */
-    id: string;
-    /** Subscription name */
-    name: string;
-  };
-  /** Provider-specific configuration */
-  providerConfig: TConfig;
-  /** Scoped logger for delivery tracing */
-  logger: Logger;
-  /**
-   * Get connection credentials by ID (for providers with connectionSchema).
-   * Only available when provider has a connectionSchema defined.
-   */
-  getConnectionWithCredentials?: (
-    connectionId: string
-  ) => Promise<{ config: Record<string, unknown> } | undefined>;
-}
-
-/**
- * Result of a provider delivery attempt.
- */
-export interface IntegrationDeliveryResult {
-  success: boolean;
-  /** External ID returned by the target system (e.g., Jira issue key) */
-  externalId?: string;
-  /** Error message if delivery failed */
-  error?: string;
-  /** Milliseconds to wait before retrying (if applicable) */
-  retryAfterMs?: number;
-}
-
 /**
  * Result of testing a provider connection.
  */
@@ -144,15 +60,19 @@ export interface GetConnectionOptionsParams {
 
 /**
  * Integration provider definition.
- * Providers define how to deliver events to specific external systems.
+ * Connection-provider definition. Plugins register one per external
+ * system to expose a connection schema, test endpoint, and dynamic
+ * dropdown resolvers used by the Automation editor's config forms.
  *
- * @template TConfig - Per-subscription configuration type
- * @template TConnection - Site-wide connection configuration type (optional)
+ * The legacy `config` (per-subscription) + `deliver` fields are gone:
+ * those responsibilities moved to the Automation platform's
+ * `ActionDefinition` (see `@checkstack/automation-backend`). Existing
+ * subscriptions are migrated to automations on boot — see
+ * `core/automation-backend/src/migration/`.
+ *
+ * @template TConnection - Site-wide connection configuration type
  */
-export interface IntegrationProvider<
-  TConfig = unknown,
-  TConnection = undefined
-> {
+export interface IntegrationProvider<TConnection = undefined> {
   /** Local identifier, namespaced on registration to {pluginId}.{id} */
   id: string;
 
@@ -165,38 +85,21 @@ export interface IntegrationProvider<
   /** Lucide icon name in PascalCase (e.g., 'Webhook') */
   icon?: LucideIconName;
 
-  /** Per-subscription configuration schema */
-  config: Versioned<TConfig>;
-
   /**
    * Optional site-wide connection schema.
    * When provided, the platform will:
    * - Store connections centrally via ConfigService
    * - Show a "Connections" management UI
-   * - Add a connection dropdown to subscription config
+   * - Make connections selectable in automation action config forms
    */
   connectionSchema?: Versioned<TConnection>;
 
   /**
-   * Events this provider can handle.
-   * If undefined, provider accepts all events.
-   * Event IDs are fully qualified: {pluginId}.{hookId}
-   */
-  supportedEvents?: string[];
-
-  /**
-   * Optional documentation to help users configure their endpoints.
-   * Displayed in the UI when creating/editing subscriptions.
+   * Optional documentation to help users configure connections.
+   * Displayed on the connections page.
    */
   documentation?: ProviderDocumentation;
 
-  /**
-   * Transform and deliver the event to the external system.
-   */
-  deliver(
-    context: IntegrationDeliveryContext<TConfig>
-  ): Promise<IntegrationDeliveryResult>;
-
   /**
    * Optional: Test the connection configuration.
    * Called when admin clicks "Test Connection" in the connections UI.
@@ -205,9 +108,9 @@ export interface IntegrationProvider<
   testConnection?(config: TConnection): Promise<TestConnectionResult>;
 
   /**
-   * Optional: Fetch dynamic options for cascading dropdowns.
-   * Called when subscription config has fields with x-options-resolver.
-   * Only applicable when connectionSchema is defined.
+   * Optional: Fetch dynamic options for cascading dropdowns inside
+   * automation action config forms. Resolver names are declared via
+   * `configString({ "x-options-resolver": "name" })` in action configs.
    */
   getConnectionOptions?(
     params: GetConnectionOptionsParams
@@ -217,10 +120,8 @@ export interface IntegrationProvider<
 /**
  * Registered provider with full namespace information.
  */
-export interface RegisteredIntegrationProvider<
-  TConfig = unknown,
-  TConnection = unknown
-> extends IntegrationProvider<TConfig, TConnection> {
+export interface RegisteredIntegrationProvider<TConnection = unknown>
+  extends IntegrationProvider<TConnection> {
   /** Fully qualified ID: {pluginId}.{id} */
   qualifiedId: string;
 
@@ -228,30 +129,3 @@ export interface RegisteredIntegrationProvider<
   ownerPluginId: string;
 }
 
-/**
- * Registered integration event with full namespace information.
- */
-export interface RegisteredIntegrationEvent<T = unknown> {
-  /** Fully qualified event ID: {pluginId}.{hookId} */
-  eventId: string;
-
-  /** Original hook reference */
-  hook: Hook<T>;
-
-  /** Plugin that registered this event */
-  ownerPluginId: string;
-
-  /** UI metadata */
-  displayName: string;
-  description?: string;
-  category?: string;
-
-  /** JSON Schema for payload (derived from Zod) */
-  payloadJsonSchema: Record<string, unknown>;
-
-  /** Original Zod schema */
-  payloadSchema: z.ZodType<T>;
-
-  /** Optional payload transformer */
-  transformPayload?: (payload: T) => Record<string, unknown>;
-}