@membranehq/cli 0.1.1 → 0.1.3

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

@@ -1,304 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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
-    }
-  }
-}