@membranehq/cli 0.1.1

package/src/modules/workspace-element-service/index.ts

@@ -0,0 +1,304 @@
+import { WorkspaceElementSpecs, WorkspaceElementType, type IntegrationAppClient } from '@integration-app/sdk'
+import { toCamelCase } from 'js-convert-case'
+
+import { getTypeAndKeyFromPath } from './getTypeAndKeyFromPath'
+import { membraneClient } from '../api'
+import { INTEGRATION_ELEMENTS } from './constants'
+import { FileChangeEventType, FileChangeEvent } from '../file-watcher/types'
+
+import type { FileWatcher } from '../file-watcher'
+
+interface WorkspaceDataCache {
+  [key: string]: unknown[]
+  integration?: Array<{ id: string; key: string; name: string }>
+}
+
+export class WorkspaceElementService {
+  private client: IntegrationAppClient
+  private workspaceDataCache: WorkspaceDataCache = {}
+  private cacheExpirationTime = 5 * 60 * 1000 // 5 minutes
+  private lastCacheUpdate = 0
+
+  constructor(private readonly fileWatcher: FileWatcher) {
+    this.setupEventHandlers()
+  }
+
+  async init(): Promise<void> {
+    this.client = await membraneClient.getClient(this.fileWatcher.getCwd())
+
+    // Perform initial pull (same as `membrane pull`).
+    // 1. Get all remote elements.
+    // 2. Match all local elements with all the remote elements.
+    // 3. Compare local and remote elements. If there is a conflict (some local data will be overwritten) - ask for confirmation
+    // 4. Compare the list of remote and local elements. If there are elements in local that are not in remote - ask for confirmation to delete.
+  }
+
+  private setupEventHandlers(): void {
+    this.fileWatcher.on('added', (event) => this.processElementChange(event, 'added'))
+    this.fileWatcher.on('changed', (event) => this.processElementChange(event, 'changed'))
+    this.fileWatcher.on('deleted', (event) => this.processElementChange(event, 'deleted'))
+  }
+
+  private async processElementChange(event: FileChangeEvent, eventType: FileChangeEventType): Promise<void> {
+    try {
+      const ref = getTypeAndKeyFromPath(event.relativePath)
+      if (!ref || !ref.key || !ref.type) {
+        console.debug(`Skipping file change - could not extract element reference from: ${event.relativePath}`)
+        return
+      }
+
+      console.debug(`Processing ${eventType} element: ${ref.key} of type ${ref.type}`)
+
+      switch (eventType) {
+        case 'added':
+        case 'changed':
+          await this.pushElement(ref.type, { ...event.data, key: ref.key })
+          break
+        case 'deleted':
+          // ToDo: implement UI for confirming deleting of the remote elements
+          break
+      }
+    } catch (e) {
+      // ToDo: save errors and display them in the UI
+      console.error(`Failed to process event ${eventType} for element ${event.relativePath}:`, e)
+    }
+  }
+
+  private async pushElement(elementType: WorkspaceElementType, elementData: Record<string, unknown>): Promise<void> {
+    const elementConfig = INTEGRATION_ELEMENTS[elementType]
+
+    if (!elementConfig) {
+      throw new Error(`Unknown element type: ${elementType}`)
+    }
+
+    const element = { ...elementData }
+
+    const workspaceData = await this.getWorkspaceData()
+
+    // Clean up element data
+    delete element.integrationId
+
+    const destinationElement = this.matchElement(element, elementType, workspaceData)
+
+    if (destinationElement) {
+      // Element exists - update or reset logic
+      await this.handleExistingElement(elementType, element, destinationElement)
+    } else {
+      // Element doesn't exist - create logic
+      await this.handleNewElement(elementType, element, workspaceData)
+    }
+  }
+
+  private async handleExistingElement(
+    elementType: WorkspaceElementType,
+    element: Record<string, unknown>,
+    destinationElement: Record<string, unknown>,
+  ): Promise<void> {
+    const elementConfig = INTEGRATION_ELEMENTS[elementType]
+
+    const singleElementAccessorKey = toCamelCase(WorkspaceElementSpecs[elementType].name)
+
+    if (!this.hasParent(element) || (this.elementIsCustomized(element) && this.hasParent(element))) {
+      // Update the element without parent OR the integration-specific element that should be customized
+      await this.client[singleElementAccessorKey](destinationElement.id).put(element)
+      console.debug(`Updated ${element.integrationKey || 'universal'} ${elementConfig.element} ${element.key}`)
+    } else if (this.hasParent(element)) {
+      // Reset Integration-specific element if it has universal parent
+      try {
+        await this.client[singleElementAccessorKey](destinationElement.id).reset()
+        console.debug(
+          `Customization reset ${element.integrationKey || 'universal'} ${elementConfig.element} ${element.key}`,
+        )
+      } catch (error) {
+        console.debug('Error resetting element:', destinationElement, element)
+        throw error
+      }
+    } else {
+      console.warn(
+        `Corrupted element detected. Manual migration required: ${element.integrationKey || 'universal'} ${elementConfig.element} ${element.key}`,
+      )
+    }
+  }
+
+  private async handleNewElement(
+    elementType: WorkspaceElementType,
+    element: Record<string, unknown>,
+    workspaceData: WorkspaceDataCache,
+  ): Promise<void> {
+    const elementConfig = INTEGRATION_ELEMENTS[elementType]
+    const singleElementAccessorKey = toCamelCase(WorkspaceElementSpecs[elementType].name)
+    const pluralElementAccessorKey = toCamelCase(WorkspaceElementSpecs[elementType].namePlural)
+
+    if (this.hasParent(element)) {
+      // Element has parent - apply universal to integration first
+      try {
+        await this.client[singleElementAccessorKey]({
+          key: element.key,
+        }).apply([element.integrationKey])
+      } catch (_error) {
+        // If apply fails, try direct put or create
+        try {
+          await this.client[singleElementAccessorKey]({
+            key: element.key,
+            integrationKey: element.integrationKey,
+          }).put(element)
+        } catch (_error) {
+          // Last resort - create with integration ID
+          const integrationId = this.findIntegrationId(element.integrationKey as string, workspaceData)
+          await this.client[pluralElementAccessorKey].create({
+            ...element,
+            integrationId,
+          })
+        }
+      }
+
+      // If element is customized, apply customization
+      if (this.elementIsCustomized(element)) {
+        try {
+          await this.client[singleElementAccessorKey]({
+            key: element.key,
+            integrationKey: element.integrationKey,
+          }).put(element)
+          console.debug(
+            `Applied & Customized ${element.integrationKey || 'universal'} ${elementConfig.element} ${element.key}`,
+          )
+        } catch (_error) {
+          console.debug('Error customizing element:', element)
+          throw _error
+        }
+      } else {
+        console.debug(`Applied universal ${elementConfig.element} ${element.key} to ${element.integrationKey}`)
+      }
+    } else {
+      // Element has no parent - create directly
+      try {
+        if (element.integrationKey) {
+          delete element.integration
+          const integrationId = this.findIntegrationId(element.integrationKey as string, workspaceData)
+          element.integrationId = integrationId
+        }
+        await this.client[pluralElementAccessorKey].create(element)
+        console.debug(`Created ${element.integrationKey || 'universal'} ${elementConfig.element} ${element.key}`)
+      } catch (_error) {
+        console.debug(`Error creating element ${elementType}`, this.hasParent(element), element.integrationKey, element)
+        throw _error
+      }
+    }
+  }
+
+  private hasParent(element: Record<string, unknown>): boolean {
+    return Object.keys(element).some((key) => /universal.*Id/g.test(key) || /parentId/g.test(key))
+  }
+
+  private elementIsCustomized(element: Record<string, unknown>): boolean {
+    return !!(element.integrationKey && (element.customized || element.isCustomized))
+  }
+
+  private matchElement(
+    element: Record<string, unknown>,
+    elementType: WorkspaceElementType,
+    workspaceData: WorkspaceDataCache,
+  ): Record<string, unknown> | undefined {
+    const matchedElements = workspaceData[elementType]?.filter((item: any) => {
+      return item.key === element.key && item.integrationKey === element.integrationKey && !item.archivedAt
+    })
+
+    if (!matchedElements || matchedElements.length === 0) {
+      return undefined
+    }
+
+    if (matchedElements.length > 1) {
+      throw new Error(
+        `More than one ${element.integrationKey || 'universal'} ${elementType} with key ${element.key} found in the workspace`,
+      )
+    }
+
+    return matchedElements[0] as Record<string, unknown>
+  }
+
+  private findIntegrationId(integrationKey: string, workspaceData: WorkspaceDataCache): string {
+    const integration = workspaceData.integration?.find((item) => item.key === integrationKey)
+    if (!integration) {
+      throw new Error(`Integration with key ${integrationKey} not found`)
+    }
+    return integration.id
+  }
+
+  private async getWorkspaceData(): Promise<WorkspaceDataCache> {
+    const now = Date.now()
+
+    // Return cached data if it's still valid
+    if (this.lastCacheUpdate && now - this.lastCacheUpdate < this.cacheExpirationTime) {
+      return this.workspaceDataCache
+    }
+
+    // Refresh cache
+    console.debug('Refreshing workspace data cache')
+    const workspaceData: WorkspaceDataCache = {}
+
+    try {
+      // Get integrations first (needed for integration-specific elements)
+      const integrations = await this.client.integrations.findAll()
+      workspaceData.integration = integrations.map((item: any) => ({
+        id: item.id,
+        key: item.key,
+        name: item.name,
+      }))
+
+      // Get all exportable element types
+      for (const elementType of Object.keys(INTEGRATION_ELEMENTS)) {
+        const elementConfig = INTEGRATION_ELEMENTS[elementType as WorkspaceElementType]
+        if (elementConfig.exportable === false) continue
+
+        try {
+          const elements = []
+
+          // Get all universal elements
+          const universalElements = await this.client[elementConfig.elements].findAll()
+          elements.push(...universalElements)
+
+          // Get all integration-specific elements if applicable
+          if (elementConfig.integrationSpecific) {
+            for (const integration of integrations) {
+              try {
+                const integrationElements = await this.client[elementConfig.elements].findAll({
+                  integrationId: integration.id,
+                })
+                elements.push(
+                  ...integrationElements.map((item: any) => ({
+                    ...item,
+                    integrationKey: integration.key,
+                  })),
+                )
+              } catch (error) {
+                console.error(`Failed to fetch ${elementType} for integration ${integration.key}:`, error)
+              }
+            }
+          }
+
+          workspaceData[elementType] = elements
+        } catch (error) {
+          console.error(`Failed to fetch ${elementType} elements:`, error)
+          workspaceData[elementType] = []
+        }
+      }
+
+      this.workspaceDataCache = workspaceData
+      this.lastCacheUpdate = now
+      console.debug('Workspace data cache refreshed successfully')
+
+      return workspaceData
+    } catch (error) {
+      console.error('Failed to refresh workspace data cache:', error)
+
+      // Return existing cache if available, otherwise empty cache
+      if (Object.keys(this.workspaceDataCache).length > 0) {
+        console.debug('Using existing workspace data cache due to refresh failure')
+        return this.workspaceDataCache
+      }
+
+      // Return empty cache as fallback
+      return { integration: [] }
+    }
+  }
+}

package/src/testing/environment.ts

@@ -0,0 +1,172 @@
+import fs from 'fs'
+import path from 'path'
+
+import Anthropic from '@anthropic-ai/sdk'
+import { IntegrationAppClient } from '@integration-app/sdk'
+import yaml from 'js-yaml'
+import jwt, { Algorithm } from 'jsonwebtoken'
+import merge from 'lodash/merge.js'
+
+import { BaseTestSuite } from './test-suites/base'
+import { readProjectConfig } from '../modules/config/project/readProjectConfig'
+
+import type { ProjectConfig } from '../modules/config/project/useProjectConfig'
+
+const LLM_MODEL = 'claude-sonnet-4-20250514'
+
+export interface TestRunOptions {
+  fix?: boolean
+}
+
+export class TestEnvironment {
+  client: IntegrationAppClient
+
+  connectionId: string
+
+  testsDir: string
+
+  testBasePath: string
+
+  options: TestRunOptions
+
+  llm: {
+    complete: (params: { prompt: string; maxTokens: number }) => Promise<string>
+  }
+
+  state: Record<string, unknown> = {}
+
+  constructor({
+    connectionId,
+    testsDir,
+    testBasePath,
+    client,
+    options,
+    llm,
+  }: {
+    connectionId: string
+    testsDir: string
+    testBasePath: string
+    options: TestRunOptions
+    client: IntegrationAppClient
+    llm: {
+      complete: (params: { prompt: string; maxTokens: number }) => Promise<string>
+    }
+  }) {
+    this.client = client
+    this.connectionId = connectionId
+    this.testsDir = testsDir
+    this.testBasePath = testBasePath
+    this.llm = llm
+    this.options = options
+  }
+
+  static async create({
+    connectionId,
+    testBasePath,
+    options,
+  }: {
+    connectionId: string
+    testBasePath: string
+    options: TestRunOptions
+  }): Promise<TestEnvironment> {
+    const workspaceConfig = readProjectConfig()
+
+    if (!workspaceConfig) {
+      throw new Error('No membrane.config.yml found. Please run `membrane init` first.')
+    }
+
+    if (!workspaceConfig.workspaceKey || !workspaceConfig.workspaceSecret) {
+      throw new Error('Missing workspace credentials')
+    }
+
+    if (!workspaceConfig.anthropicApiKey) {
+      throw new Error('Anthropic API key not configured. Run `membrane init` to set up testing.')
+    }
+
+    const client = new IntegrationAppClient({
+      token: await this.createMembraneToken(workspaceConfig),
+      apiUri: workspaceConfig.apiUri,
+    })
+
+    const anthropicClient = new Anthropic({
+      apiKey: workspaceConfig.anthropicApiKey,
+    })
+
+    const llm = {
+      complete: async ({ prompt, maxTokens }) => {
+        const response = await anthropicClient.messages.create({
+          model: LLM_MODEL,
+          max_tokens: maxTokens,
+          messages: [
+            {
+              role: 'user',
+              content: prompt,
+            },
+          ],
+        })
+        return response.content[0].type === 'text' ? response.content[0].text : ''
+      },
+    }
+
+    return new TestEnvironment({
+      client,
+      options,
+      connectionId,
+      testsDir: `src/testing/tests`,
+      testBasePath,
+      llm,
+    })
+  }
+
+  async run(suites: BaseTestSuite[]) {
+    this.state = {}
+    const allResults = {}
+    for (const suite of suites) {
+      await suite.run()
+      merge(allResults, suite.getResult())
+    }
+
+    this.writeResults(allResults)
+  }
+
+  async readYaml<T>(yamlPath: string): Promise<T | undefined> {
+    const fullConfigPath = path.join(this.testsDir, this.testBasePath, this.connectionId, yamlPath)
+    if (!fs.existsSync(fullConfigPath)) {
+      return undefined
+    }
+
+    return yaml.load(fs.readFileSync(fullConfigPath, 'utf8')) as T
+  }
+
+  async writeYaml(yamlPath: string, config: any) {
+    const fullConfigPath = path.join(this.testsDir, this.testBasePath, this.connectionId, yamlPath)
+    fs.mkdirSync(path.dirname(fullConfigPath), { recursive: true })
+    fs.writeFileSync(fullConfigPath, yaml.dump(config, { noRefs: true }))
+  }
+
+  writeResults(results: any) {
+    const connectionTestsDir = path.join(this.testsDir, this.testBasePath, this.connectionId)
+    fs.mkdirSync(connectionTestsDir, { recursive: true })
+
+    const resultsPath = path.join(connectionTestsDir, 'test-results.yaml')
+    fs.writeFileSync(resultsPath, yaml.dump(results, { noRefs: true }))
+    console.debug(`[TestRunner] Results written to: ${resultsPath}`)
+  }
+
+  private static async createMembraneToken(workspaceConfig: ProjectConfig) {
+    const customerId = workspaceConfig.testCustomerId || 'test-customer'
+
+    const tokenData = {
+      id: customerId,
+      name: customerId,
+    }
+
+    const options = {
+      issuer: workspaceConfig.workspaceKey,
+      expiresIn: 7200,
+      algorithm: 'HS512' as Algorithm,
+    }
+
+    return jwt.sign(tokenData, workspaceConfig.workspaceSecret, options)
+  }
+}

package/src/testing/runners/base.runner.ts

@@ -0,0 +1,27 @@
+import { getPaths } from '../../utils/constants'
+
+import type { IntegrationAppClient } from '@integration-app/sdk'
+
+export abstract class BaseRunner<T> {
+  protected client!: IntegrationAppClient
+  protected workspace?: string
+
+  protected fsPaths: ReturnType<typeof getPaths>
+
+  constructor(protected options?: T) {
+    this.fsPaths = getPaths()
+
+    if (options && typeof options === 'object') {
+      const opts = options as Record<string, unknown>
+      if ('client' in opts && opts.client) {
+        this.client = opts.client as IntegrationAppClient
+      }
+      if ('workspace' in opts) {
+        this.workspace = opts.workspace as string
+      }
+    }
+  }
+
+  abstract initialize(): Promise<void>
+  abstract run(): Promise<void>
+}

package/src/testing/runners/test.runner.ts

@@ -0,0 +1,123 @@
+import { ConnectorDataCollection } from '@integration-app/sdk'
+import merge from 'lodash/merge.js'
+
+import { BaseRunner } from './base.runner'
+import { Logger } from '../../utils/logger'
+import { TestEnvironment } from '../environment'
+import { DataCollectionTestSuite } from '../test-suites/data-collection'
+
+interface TestOptions {
+  testPath: string
+  path?: string
+  fix?: boolean
+}
+
+export class TestRunner extends BaseRunner<TestOptions> {
+  constructor(options: TestOptions) {
+    super(options)
+  }
+
+  async initialize(): Promise<void> {
+    Logger.debug('Initializing test runner', {
+      prefix: 'TestRunner',
+    })
+  }
+
+  async run(): Promise<void> {
+    try {
+      const { testPath, path, fix } = this.options
+
+      // Parse the test path (e.g., "connectors/netsuite/data/contacts/create")
+      const pathParts = testPath.split('/')
+
+      if (pathParts.length < 2) {
+        Logger.error('Invalid test path. Expected format: <type>/<name>[/additional/path][/method]')
+        process.exit(1)
+      }
+
+      const [testType, testName, ...additionalPath] = pathParts
+
+      // For now, only connectors are fully supported
+      if (testType !== 'connectors') {
+        Logger.error(
+          `Test type "${testType}" is not yet fully implemented. Currently only "connectors" is fully supported.`,
+        )
+        Logger.error('Supported test types: connectors')
+        process.exit(1)
+      }
+
+      const connectionId = testName
+
+      const testBasePath = testType
+
+      const combinedPath = [...additionalPath, ...(path ? path.split('/') : [])].join('/')
+
+      const environment = await TestEnvironment.create({
+        connectionId,
+        testBasePath,
+        options: { fix },
+      })
+
+      const client = environment.client
+
+      const dataCollections = (await client.get(`connections/${connectionId}/data`)) as ConnectorDataCollection[]
+
+      const suites = []
+
+      const pathSegments = combinedPath ? combinedPath.split('/') : []
+
+      if (pathSegments.length === 0 || pathSegments[0] === 'data') {
+        if (pathSegments[0] === 'data') {
+          pathSegments.shift()
+        }
+
+        // Extract test method if present (e.g., "contacts/create" -> dataCollectionKey="contacts", testMethod="create")
+        let testMethod: string | undefined
+        let dataCollectionKey: string | undefined
+
+        if (pathSegments.length >= 1) {
+          dataCollectionKey = pathSegments[0]
+
+          if (pathSegments.length >= 2 && pathSegments[1].trim() !== '') {
+            testMethod = pathSegments[1]
+          }
+        }
+
+        for (const dataCollection of dataCollections) {
+          if (dataCollectionKey && dataCollectionKey !== dataCollection.key) {
+            continue
+          }
+
+          const suite = new DataCollectionTestSuite({
+            environment,
+            dataCollectionKey: dataCollection.key,
+            testMethod,
+          })
+
+          suites.push(suite)
+        }
+      }
+
+      if (suites.length === 0) {
+        Logger.error(`No test suites found for path: ${testPath}${combinedPath ? '/' + combinedPath : ''}`)
+        process.exit(1)
+      }
+
+      // Run suites while preserving state between data collections
+      const allResults = {}
+      for (const suite of suites) {
+        await suite.run()
+        const suiteResult = suite.getResult()
+        Logger.debug(`Suite ${suite.constructor.name} result:`, { prefix: 'TestRunner' })
+        merge(allResults, suiteResult)
+      }
+
+      console.debug(`[TestRunner] All results collected:`, Object.keys(allResults))
+      // Write the collected results
+      environment.writeResults(allResults)
+    } catch (error) {
+      console.error('Error in TestRunner.run():', error)
+      throw error
+    }
+  }
+}