@membranehq/cli 0.1.1 → 0.1.3

package/src/legacy/types.ts

@@ -1,17 +0,0 @@
-import { WorkspaceElementType } from '@integration-app/sdk'
-
-export type ConnectorsMapping = Record<string, string>
-
-export interface PushContext {
-  connectorsMapping: ConnectorsMapping
-}
-
-interface WorkspaceElement {
-  key: string
-  integration?: {
-    key: string
-  }
-  integrationKey?: string
-}
-
-export type WorkspaceData = Partial<Record<WorkspaceElementType, WorkspaceElement[]>>

package/src/legacy/util.ts

@@ -1,149 +0,0 @@
-import { INTEGRATION_ELEMENTS, baseExportCleanup } from './integrationElements'
-import { WorkspaceData } from './push/types'
-import { Logger } from '../utils/logger'
-
-async function getWorkspaceData(iApp, logs = 'full'): Promise<WorkspaceData> {
-  const workspaceData: any = {}
-
-  Logger.info('Getting remote workspace data')
-
-  const integrations = await iApp.integrations.findAll()
-  workspaceData.integration = integrations.map((item) => cleanUpForExport('integration', item))
-
-  for (const elementType of Object.keys(INTEGRATION_ELEMENTS) as any[]) {
-    const element = INTEGRATION_ELEMENTS[elementType]
-    if (element.exportable === false) continue
-
-    const elementEnteties = []
-    Logger.info(`Reading ${element.elements} from remote workspace`)
-    // Get all universal elements
-    const elements = await iApp[element.elements].findAll()
-
-    elementEnteties.push(
-      ...elements.map((item) => {
-        return cleanUpForExport(elementType, item)
-      }),
-    )
-
-    // Get all integration specific elements
-    if (element.integrationSpecific) {
-      for (const integration of integrations) {
-        const integrationElements = await iApp[element.elements].findAll({
-          integrationId: integration.id,
-        })
-        elementEnteties.push(
-          ...integrationElements.map((item) => {
-            item.integrationKey = integration.key
-            return cleanUpForExport(elementType, item)
-          }),
-        )
-      }
-    }
-
-    if (elementEnteties.length > 0) {
-      if (logs == 'full') {
-        // eslint-disable-next-line no-console
-        console.table(
-          elementEnteties
-            .map((item) => {
-              return {
-                key: item.key,
-                integrationKey: item.integrationKey,
-                universal: !item.integrationKey,
-              }
-            })
-            .reduce((acc, item) => {
-              if (!acc) {
-                acc = {}
-              }
-              if (!acc[item.key]) {
-                acc[item.key] = {}
-              }
-              if (item.universal) {
-                acc[item.key].universal = true
-              }
-              if (item.integrationKey) {
-                if (!acc[item.key].integration) {
-                  acc[item.key].integration = item.integrationKey
-                } else {
-                  acc[item.key].integration += ` ${item.integrationKey}`
-                }
-              }
-              return acc
-            }, {}),
-        )
-        // eslint-disable-next-line no-console
-        console.groupEnd()
-      }
-    }
-    workspaceData[elementType] = elementEnteties
-  }
-  Logger.success('Remote workspace data retrieved successfully')
-  return workspaceData
-}
-
-function splitWorkspaceData(data: WorkspaceData) {
-  const universalElements: any = {}
-  const integrationSpecificElements: any = {}
-  for (const elementType of Object.keys(data)) {
-    universalElements[elementType] = []
-    integrationSpecificElements[elementType] = []
-
-    const isIntegrationSpecific = INTEGRATION_ELEMENTS[elementType]?.integrationSpecific
-
-    if (isIntegrationSpecific) {
-      for (const element of data[elementType]) {
-        if (element.integrationKey || element.integration || element.integrationId) {
-          integrationSpecificElements[elementType].push(element)
-        } else {
-          universalElements[elementType].push(element)
-        }
-      }
-    } else {
-      universalElements[elementType].push(...data[elementType])
-    }
-  }
-  return { universalElements, integrationSpecificElements }
-}
-function cleanUpForExport(elementType, element) {
-  element = baseExportCleanup(element)
-  return INTEGRATION_ELEMENTS[elementType].exportCleanup
-    ? INTEGRATION_ELEMENTS[elementType].exportCleanup(element)
-    : element
-}
-function hasParent(element) {
-  return Object.keys(element).some((key) => /universal.*Id/g.test(key) || /parentId/g.test(key))
-}
-
-function coloredLog(message, color) {
-  const colors = {
-    Reset: '\x1b[0m',
-    Bright: '\x1b[1m',
-    Dim: '\x1b[2m',
-    Underscore: '\x1b[4m',
-    Blink: '\x1b[5m',
-    Reverse: '\x1b[7m',
-    Hidden: '\x1b[8m',
-    Black: '\x1b[30m',
-    Red: '\x1b[31m',
-    Green: '\x1b[32m',
-    Yellow: '\x1b[33m',
-    Blue: '\x1b[34m',
-    Magenta: '\x1b[35m',
-    Cyan: '\x1b[36m',
-    White: '\x1b[37m',
-    Gray: '\x1b[90m',
-    BgBlack: '\x1b[40m',
-    BgRed: '\x1b[41m',
-    BgGreen: '\x1b[42m',
-    BgYellow: '\x1b[43m',
-    BgBlue: '\x1b[44m',
-    BgMagenta: '\x1b[45m',
-    BgCyan: '\x1b[46m',
-    BgWhite: '\x1b[47m',
-    BgGray: '\x1b[100m',
-  }
-  console.debug('\x1b[0m', `\x1b[${colors[color]}`, message, '\x1b[0m')
-}
-
-export { getWorkspaceData, splitWorkspaceData, hasParent, coloredLog }

package/src/legacy/workspace-elements/connectors.ts

@@ -1,397 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-import { Connector, IntegrationAppClient } from '@integration-app/sdk'
-import archiver from 'archiver'
-import FormData from 'form-data'
-import yaml from 'js-yaml'
-import unzipper from 'unzipper'
-
-import { getPaths } from '../../utils/constants'
-import { Logger } from '../../utils/logger'
-import { ConnectorsMapping, PushContext, WorkspaceData } from '../push/types'
-import { coloredLog } from '../util'
-
-const CONNECTORS_DIR = 'connectors'
-const CONNECTOR_DEVELOPMENT_VERSION_NAME = 'development'
-const connectorsCache: Record<string, Connector> = {}
-
-export async function pullConnectors({
-  client,
-  basePath,
-  allConnectors = false,
-}: {
-  client: IntegrationAppClient
-  basePath: string
-  allConnectors?: boolean
-}) {
-  // We only pull connectors used in integrations.
-  const integrations = await client.integrations.findAll()
-
-  const pulledConnectors: Set<string> = new Set()
-  const pulledConnectorVersions: Record<string, Set<string>> = {}
-
-  for (const integration of integrations) {
-    const connectorId = integration.connectorId
-    const connectorVersion = integration.connectorVersion
-
-    if (!pulledConnectorVersions[connectorId]?.has(integration.connectorVersion)) {
-      let connector: Connector
-      try {
-        connector = await getConnector({ client, connectorId })
-      } catch (error) {
-        console.error(`Failed to pull connector ${connectorId}. Skipping...`)
-        continue
-      }
-
-      const isConnectorCustom = !!connector.workspaceId
-      const shouldPullConnector = isConnectorCustom || allConnectors
-
-      if (shouldPullConnector) {
-        if (!pulledConnectors.has(connectorId)) {
-          await pullConnector({ basePath, client, connector })
-          pulledConnectors.add(connectorId)
-        }
-
-        if (!pulledConnectorVersions[connectorId]) {
-          pulledConnectorVersions[connectorId] = new Set()
-        }
-
-        if (!pulledConnectorVersions[connectorId].has(connectorVersion)) {
-          await pullConnectorVersion({
-            client,
-            connector,
-            connectorVersion,
-            basePath,
-          })
-          pulledConnectorVersions[connectorId].add(connectorVersion)
-        }
-      }
-    }
-  }
-}
-
-export async function pushConnectors({
-  client,
-  basePath,
-  workspaceData,
-  pushContext,
-  workspaceId,
-}: {
-  client: IntegrationAppClient
-  basePath: string
-  workspaceData: WorkspaceData
-  pushContext: PushContext
-  workspaceId: string
-}) {
-  const connectorsMapping: ConnectorsMapping = {}
-
-  console.debug('[Push] Loading custom connectors')
-  // Get Connectors
-  const iApp = client
-  const customConnectors = await iApp.get(`/connectors?workspaceId=${workspaceId}`)
-  console.debug('[Push] Loading public connectors')
-  workspaceData.connector = customConnectors
-
-  const connectorsPath = getConnectorsPath()
-
-  const connectorDirs = fs.existsSync(connectorsPath) ? fs.readdirSync(connectorsPath) : []
-
-  for (const connectorDir of connectorDirs) {
-    console.debug(`[Push] Loading connector from: ${connectorDir}`)
-
-    const pathsInsideConnectorDir = fs.readdirSync(path.join(connectorsPath, connectorDir))
-
-    const connector = await readConnector(connectorDir)
-
-    delete connector.baseUri
-
-    if (connector.uuid && workspaceData.connector?.find((item: any) => item.uuid == connector.uuid)) {
-      connectorsMapping[connector.id] = (workspaceData.connector as any).find((item) => item.uuid == connector.uuid).id
-      coloredLog(`Matched ${connector.name} uuid: ${connector.uuid}`, 'Blue')
-    } else if (!connectorsMapping[connector.id]) {
-      console.debug(`Creating connector ${connector.name} (${connector.key})`)
-      const resp = await iApp.post('connectors', {
-        ...connector,
-        workspaceId,
-      })
-      connectorsMapping[connector.id] = resp.id
-    }
-
-    const connectorVersions = pathsInsideConnectorDir.filter((item) =>
-      fs.statSync(path.join(connectorsPath, connectorDir, item)).isDirectory(),
-    )
-
-    for (const version of connectorVersions) {
-      await pushConnectorVersion({
-        client,
-        connector,
-        version,
-        basePath,
-        connectorId: connectorsMapping[connector.id],
-      })
-    }
-  }
-
-  pushContext.connectorsMapping = connectorsMapping
-}
-
-export async function handleConnectorFileChange(
-  filename: string,
-  config: any,
-  pushContext: PushContext,
-): Promise<void> {
-  // Extract connector name from path
-  const match = filename.match(/connectors\/([^/]+)\/([^/]+)\/src\/(.*)/)
-
-  if (!match) return
-
-  const connectorFolderName = match[1]
-  const connectorVersion = match[2]
-
-  if (connectorVersion != CONNECTOR_DEVELOPMENT_VERSION_NAME) {
-    Logger.warning(
-      `Detected change in non-development version of connector ${connectorFolderName}. This change will be ignored.`,
-    )
-  }
-
-  const relativeFilename = match[3]
-
-  const paths = getPaths()
-  const fullPath = path.join(paths.membraneDirPath, filename)
-
-  const connector = await readConnector(connectorFolderName)
-
-  const connectorId = connector?.id
-
-  if (!connectorId) {
-    Logger.warning(`Connector ${connectorFolderName} has no id. Ignoring file change`)
-    return
-  }
-
-  const pushConnectorId = pushContext.connectorsMapping[connectorId]
-
-  if (!pushConnectorId) {
-    Logger.warning(`Connector ${connectorFolderName} not found in target workspace. Ignoring file change.`)
-    return
-  }
-
-  if (fs.existsSync(fullPath)) {
-    Logger.info(`Pushing updated file ${relativeFilename} for connector ${connectorFolderName}`)
-    await config.client.put(
-      `connectors/${pushConnectorId}/files/${relativeFilename}`,
-      fs.readFileSync(fullPath, 'utf-8'),
-      {
-        headers: {
-          'Content-Type': 'text/plain',
-        },
-      },
-    )
-  } else {
-    Logger.info(`Deleting file ${relativeFilename} for connector ${connectorFolderName}`)
-    await config.client.delete(`connectors/${pushConnectorId}/files/${relativeFilename}`)
-  }
-}
-
-function getConnectorsPath(): string {
-  const paths = getPaths()
-  return path.join(paths.membraneDirPath, CONNECTORS_DIR)
-}
-
-async function readConnector(connectorDir: string): Promise<Connector> {
-  return yaml.load(
-    fs.readFileSync(path.join(getConnectorsPath(), connectorDir, `${connectorDir}.yml`), 'utf8'),
-  ) as Connector
-}
-
-async function createZipArchive(srcDirPath: string, zipFilePath: string): Promise<void> {
-  console.debug(`Zipping ${srcDirPath} into ${zipFilePath}`)
-
-  return new Promise((resolve, reject) => {
-    const output = fs.createWriteStream(zipFilePath)
-    const archive = archiver('zip', {
-      zlib: { level: 9 }, // Sets the compression level
-    })
-
-    output.on('close', () => {
-      coloredLog(`Successfully created ${zipFilePath}`, 'Green')
-      resolve()
-    })
-
-    output.on('end', () => {
-      console.debug('Data has been drained')
-    })
-
-    archive.on('warning', (err) => {
-      if (err.code === 'ENOENT') {
-        console.warn(err)
-      } else {
-        reject(err)
-      }
-    })
-
-    archive.on('error', (err) => {
-      reject(err)
-    })
-
-    archive.pipe(output)
-
-    // Add all files from src directory to the archive
-    const files = fs.readdirSync(srcDirPath)
-    for (const file of files) {
-      const filePath = path.join(srcDirPath, file)
-      const stats = fs.statSync(filePath)
-      if (stats.isFile()) {
-        archive.file(filePath, { name: file })
-      } else if (stats.isDirectory()) {
-        archive.directory(filePath, file)
-      }
-    }
-
-    archive.finalize()
-  })
-}
-
-async function extractZipArchive(zipData: Buffer, destDirPath: string): Promise<void> {
-  console.debug(`Unzipping into ${destDirPath}`)
-
-  return new Promise((resolve, reject) => {
-    const stream = unzipper.Parse()
-    stream.on('entry', (entry) => {
-      const fileName = entry.path
-      const type = entry.type // 'Directory' or 'File'
-      const size = entry.vars.uncompressedSize // There is also compressedSize;
-
-      if (type === 'Directory') {
-        const dirPath = path.join(destDirPath, fileName)
-        fs.mkdirSync(dirPath, { recursive: true })
-        entry.autodrain()
-      } else {
-        const filePath = path.join(destDirPath, fileName)
-        const dirPath = path.dirname(filePath)
-        fs.mkdirSync(dirPath, { recursive: true })
-
-        const writeStream = fs.createWriteStream(filePath)
-        entry.pipe(writeStream)
-        writeStream.on('finish', () => {
-          console.debug(`Extracted: ${fileName}`)
-        })
-      }
-    })
-
-    stream.on('end', () => {
-      coloredLog(`Successfully extracted to ${destDirPath}`, 'Green')
-      resolve()
-    })
-
-    stream.on('error', (err) => {
-      reject(err)
-    })
-
-    stream.write(zipData)
-    stream.end()
-  })
-}
-
-async function pushConnectorVersion({
-  client,
-  connector,
-  version,
-  connectorId,
-  basePath,
-}: {
-  client: IntegrationAppClient
-  connector: Connector
-  connectorId: string
-  version: string
-  basePath: string
-}) {
-  const versionDir = path.join(getConnectorsPath(), getConnectorDirName(connector), version)
-  const srcDir = path.join(versionDir, 'src')
-
-  if (!fs.existsSync(srcDir)) {
-    console.debug(`No src directory found for ${connector.name} version ${version}`)
-    return
-  }
-
-  const zipFilePath = path.join(versionDir, `${version}.zip`)
-
-  try {
-    await createZipArchive(srcDir, zipFilePath)
-
-    const form = new FormData()
-    form.append('file', fs.createReadStream(zipFilePath))
-
-    console.debug(`Pushing connector version ${version} for ${connector.name}`)
-    await client.put(`connectors/${connectorId}/versions/${version}`, form, {
-      headers: form.getHeaders(),
-    })
-
-    coloredLog(`Successfully pushed connector version ${version} for ${connector.name}`, 'Green')
-  } finally {
-    // Clean up the temporary zip file
-    if (fs.existsSync(zipFilePath)) {
-      fs.unlinkSync(zipFilePath)
-    }
-  }
-}
-
-async function getConnector({ client, connectorId }: { client: IntegrationAppClient; connectorId: string }) {
-  if (connectorsCache[connectorId]) {
-    return connectorsCache[connectorId]
-  }
-
-  const connector = await client.get(`connectors/${connectorId}`)
-  connectorsCache[connectorId] = connector
-  return connector
-}
-
-async function pullConnector({
-  basePath,
-  connector,
-}: {
-  basePath: string
-  client: IntegrationAppClient
-  connector: Connector
-}) {
-  const connectorDir = path.join(basePath, getConnectorDirName(connector))
-  fs.mkdirSync(connectorDir, { recursive: true })
-
-  const connectorFilePath = path.join(connectorDir, `${getConnectorDirName(connector)}.yml`)
-  fs.writeFileSync(connectorFilePath, yaml.dump(connector))
-
-  coloredLog(`Pulled connector ${connector.name}`, 'Green')
-}
-
-async function pullConnectorVersion({
-  client,
-  connector,
-  connectorVersion,
-  basePath,
-}: {
-  client: IntegrationAppClient
-  connector: Connector
-  connectorVersion: string
-  basePath: string
-}) {
-  const connectorDir = path.join(basePath, getConnectorDirName(connector))
-  const versionDir = path.join(connectorDir, getConnectorVersionDirName(connectorVersion))
-
-  try {
-    const response = await client.get(`connectors/${connector.id}/versions/${connectorVersion}`)
-    const zipData = Buffer.from(response, 'base64')
-
-    await extractZipArchive(zipData, versionDir)
-    coloredLog(`Pulled connector version ${connectorVersion} for ${connector.name}`, 'Green')
-  } catch (error) {
-    console.debug(`Failed to pull connector version ${connectorVersion} for ${connector.name}:`, error)
-  }
-}
-
-function getConnectorDirName(connector: Connector) {
-  return connector.key
-}
-
-function getConnectorVersionDirName(connectorVersion: string) {
-  return connectorVersion
-}

package/src/legacy/workspace-elements/index.ts

@@ -1,27 +0,0 @@
-import { WorkspaceElementSpecs, WorkspaceElementType } from '@integration-app/sdk'
-
-import { WorkspaceData } from '../push/types'
-
-export function getWorkspaceElementTypePath(type: WorkspaceElementType): string {
-  return WorkspaceElementSpecs[type].apiPath
-}
-
-export function mergeWorkspaceData(data: WorkspaceData, otherData: WorkspaceData): WorkspaceData {
-  for (const elementType of Object.keys(otherData)) {
-    data[elementType] = [...(data[elementType] || []), ...otherData[elementType]]
-  }
-
-  return data
-}
-
-export const PUSHABLE_ELEMENT_TYPES: WorkspaceElementType[] = [
-  WorkspaceElementType.Integration,
-  WorkspaceElementType.Scenario,
-  WorkspaceElementType.Action,
-  WorkspaceElementType.Flow,
-  WorkspaceElementType.AppDataSchema,
-  WorkspaceElementType.AppEventType,
-  WorkspaceElementType.DataLinkTable,
-  WorkspaceElementType.DataSource,
-  WorkspaceElementType.FieldMapping,
-]

package/src/legacy/workspace-tools/commands/pullWorkspace.ts

@@ -1,70 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-import { IntegrationAppClient, WorkspaceElementType } from '@integration-app/sdk'
-import YAML from 'js-yaml'
-
-import { coloredLog, getWorkspaceData } from '../../util'
-import { getWorkspaceElementTypePath } from '../../workspace-elements'
-import { pullConnectors } from '../../workspace-elements/connectors'
-
-interface ExportPackageOptions {
-  outputPath?: string
-  allConnectors?: boolean
-  client?: IntegrationAppClient
-}
-
-export async function pullWorkspace(options: ExportPackageOptions): Promise<void> {
-  const { outputPath, allConnectors, client } = options
-
-  await pullConnectors({
-    client,
-    basePath: outputPath,
-    allConnectors,
-  })
-
-  const workspaceData = await getWorkspaceData(client)
-
-  for (const elementType of Object.keys(workspaceData)) {
-    if (workspaceData[elementType].length > 0) {
-      try {
-        fs.readdirSync(outputPath)
-      } catch (_err) {
-        fs.mkdirSync(outputPath, { recursive: true })
-      }
-
-      const elementTypePath = getWorkspaceElementTypePath(elementType as WorkspaceElementType)
-
-      for (const element of workspaceData[elementType]) {
-        try {
-          fs.readdirSync(path.join(outputPath, elementTypePath, `${element.key}`))
-        } catch (_err) {
-          fs.mkdirSync(path.join(outputPath, elementTypePath, `${element.key}`), {
-            recursive: true,
-          })
-        }
-        if (element.integration || element.integrationKey) {
-          const integrationKey = element.integration ? element.integration.key : element.integrationKey
-          try {
-            fs.readdirSync(path.join(outputPath, elementTypePath, `${element.key}`, `${integrationKey}`))
-          } catch (_err) {
-            fs.mkdirSync(path.join(outputPath, elementTypePath, `${element.key}`, `${integrationKey}`), {
-              recursive: true,
-            })
-          }
-          fs.writeFileSync(
-            path.join(outputPath, elementTypePath, `${element.key}`, `${integrationKey}`, `${integrationKey}.yaml`),
-            YAML.dump(element),
-          )
-        } else {
-          fs.writeFileSync(
-            path.join(outputPath, elementTypePath, element.key, `${element.key}.yaml`),
-            YAML.dump(element),
-          )
-        }
-      }
-    }
-  }
-
-  coloredLog(`Data written to ${outputPath} successfully.`, 'BgGreen')
-}