@membranehq/cli 0.1.1 → 0.1.3

package/src/modules/config/project/useProjectConfig.tsx

@@ -1,103 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import { createContext, useCallback, useContext, useEffect, useState } from 'react'
-import type { PropsWithChildren } from 'react'
-import YAML from 'js-yaml'
-import { z } from 'zod'
-
-import { useCwd } from '../cwd-context'
-import { readProjectConfig } from './readProjectConfig'
-
-const CONFIG_FILE_NAME = 'membrane.config.yml'
-
-export const configSchema = z.object({
-  workspaceKey: z.string().optional(),
-  workspaceSecret: z.string().optional(),
-  apiUri: z.string().optional(),
-  testCustomerId: z.string().optional(),
-  anthropicApiKey: z.string().optional(),
-})
-
-export type ProjectConfig = z.infer<typeof configSchema>
-
-export const commandSchema = z.enum(['pull'])
-export type Command = z.infer<typeof commandSchema>
-
-interface IProjectConfigContext {
-  readonly config: ProjectConfig | null
-  readonly isLoading: boolean
-  readonly updateConfig: (newConfig: Partial<ProjectConfig>) => boolean
-  readonly validateConfig: () => boolean
-}
-
-const ProjectConfigContext = createContext<IProjectConfigContext | undefined>(undefined)
-
-export function ProjectConfigProvider({ children }: PropsWithChildren) {
-  const cwd = useCwd()
-  const [config, setConfig] = useState<ProjectConfig | null>(null)
-  const [isLoading, setIsLoading] = useState(true)
-
-  useEffect(() => {
-    const config = readProjectConfig(cwd)
-    setConfig(config)
-    setIsLoading(false)
-  }, [cwd])
-
-  const updateConfig = useCallback(
-    (newConfig: Partial<ProjectConfig>): boolean => {
-      const configPath = path.join(cwd, CONFIG_FILE_NAME)
-      const currentConfig = readProjectConfig(cwd) ?? {}
-      const newConfigData = {
-        ...currentConfig,
-        ...newConfig,
-      }
-
-      const validationResult = configSchema.safeParse(newConfigData)
-      if (!validationResult.success) {
-        return false
-      }
-
-      fs.writeFileSync(configPath, YAML.dump(validationResult.data))
-      setConfig(validationResult.data)
-      return true
-    },
-    [cwd],
-  )
-
-  const validateConfig = useCallback((): boolean => {
-    return !!(config?.workspaceKey && config?.workspaceSecret)
-  }, [config])
-
-  const value: IProjectConfigContext = {
-    config,
-    isLoading,
-    updateConfig,
-    validateConfig,
-  }
-
-  return <ProjectConfigContext.Provider value={value}>{children}</ProjectConfigContext.Provider>
-}
-
-export function useProjectConfig(): IProjectConfigContext {
-  const context = useContext(ProjectConfigContext)
-  if (context === undefined) {
-    throw new Error('useProjectConfig must be used within a ProjectConfigProvider')
-  }
-  return context
-}
-
-export function clearWorkspaceConfig(): void {
-  const cwd = process.cwd()
-  const configPath = path.join(cwd, CONFIG_FILE_NAME)
-  const currentConfig = readProjectConfig(cwd) ?? {}
-  const newConfigData = {
-    ...currentConfig,
-    workspaceKey: undefined,
-    workspaceSecret: undefined,
-  }
-  // Remove keys if present
-  delete newConfigData.workspaceKey
-  delete newConfigData.workspaceSecret
-  fs.writeFileSync(configPath, YAML.dump(newConfigData))
-}

package/src/modules/config/system/index.ts

@@ -1,35 +0,0 @@
-import os from 'os'
-import path from 'path'
-
-import Conf from 'conf'
-
-const schema = {
-  pat: {
-    type: 'string',
-  },
-  workspace: {
-    type: 'object',
-  },
-}
-
-const config = new Conf({
-  schema,
-  configName: 'config',
-  cwd: path.join(os.homedir(), '.membrane'),
-})
-
-export const setPat = (token: string): void => {
-  config.set('pat', token)
-}
-
-export const getPat = (): string | undefined => {
-  return config.get('pat') as string | undefined
-}
-
-export const hasPat = (): boolean => {
-  return !!config.get('pat')
-}
-
-export const clearPat = (): void => {
-  config.delete('pat')
-}

package/src/modules/file-watcher/index.ts

@@ -1,166 +0,0 @@
-import * as crypto from 'node:crypto'
-import { EventEmitter } from 'node:events'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import chokidar from 'chokidar'
-import yaml from 'yaml'
-
-import { FileChangeEventType, FileChangeEvent, FileChangeEventMap } from './types'
-import { getMembraneDir, IGNORED_FILES } from '../config/project/paths'
-
-import type { FSWatcher } from 'chokidar'
-
-type WatchOptions = Parameters<typeof chokidar.watch>[1]
-
-const DEFAULT_WATCHER_CONFIG: WatchOptions = {
-  ignored: IGNORED_FILES,
-  persistent: true,
-  ignoreInitial: true,
-  followSymlinks: false,
-  depth: 10,
-  awaitWriteFinish: {
-    stabilityThreshold: 500,
-    pollInterval: 100,
-  },
-  ignorePermissionErrors: true,
-  atomic: true,
-  usePolling: false,
-  alwaysStat: false,
-  interval: 1000,
-  binaryInterval: 300,
-}
-
-export class FileWatcher extends EventEmitter<FileChangeEventMap> {
-  private isWatching = false
-  private watcher?: FSWatcher
-  private readonly membraneDir: string
-  private readonly contentCache: Record<string, string> = {}
-
-  constructor(private readonly options: { cwd: string }) {
-    super()
-    this.membraneDir = getMembraneDir(options.cwd)
-  }
-
-  /**
-   * Starts the file watcher
-   */
-  async start(): Promise<void> {
-    if (this.isWatching) {
-      return
-    }
-    if (!fs.existsSync(this.membraneDir)) {
-      fs.mkdirSync(this.membraneDir, { recursive: true })
-    }
-
-    this.watcher = chokidar.watch(this.membraneDir, DEFAULT_WATCHER_CONFIG)
-    this.watcher
-      .on('add', (filePath) => this.handleFileSystemEvent('added', filePath))
-      .on('change', (filePath) => this.handleFileSystemEvent('changed', filePath))
-      .on('unlink', (filePath) => this.handleFileSystemEvent('deleted', filePath))
-      .on('ready', () => (this.isWatching = true))
-  }
-
-  /**
-   * Stops the file watcher
-   */
-  async stop(): Promise<void> {
-    if (!this.isWatching || !this.watcher) {
-      return
-    }
-
-    await this.watcher.close()
-    this.isWatching = false
-    this.watcher = undefined
-    this.clearCache()
-    this.emit('stopped')
-  }
-
-  getCwd(): string {
-    return this.options.cwd
-  }
-
-  /**
-   * Handles file system events and only emits when content actually changes
-   */
-  private handleFileSystemEvent(eventType: FileChangeEventType, filePath: string): void {
-    const relativePath = path.relative(this.membraneDir, filePath)
-
-    if (eventType === 'deleted') {
-      this.removeFromCache(relativePath)
-      const event: FileChangeEvent = {
-        filePath,
-        relativePath,
-        data: undefined,
-      }
-      this.emit(eventType, event)
-      return
-    }
-
-    const fileContent = this.readFileContent(filePath)
-
-    const hasContentChanged = this.hasContentChanged(relativePath, fileContent, eventType)
-    if (!hasContentChanged) {
-      return
-    }
-
-    const event = this.processFileEvent(filePath, fileContent)
-    this.updateCache(relativePath, fileContent)
-    this.emit(eventType, event)
-  }
-
-  private readFileContent(filePath: string): string {
-    return fs.readFileSync(filePath, 'utf8')
-  }
-
-  private processFileEvent(filePath: string, fileContent: string): FileChangeEvent | null {
-    const relativePath = path.relative(this.membraneDir, filePath)
-
-    let data: any
-    try {
-      data = fileContent ? yaml.parse(fileContent) : undefined
-    } catch (_error) {
-      data = undefined
-    }
-
-    return { filePath, relativePath, data }
-  }
-
-  private hasContentChanged(relativePath: string, fileContent: string, eventType: FileChangeEventType): boolean {
-    if (eventType === 'added') {
-      return true
-    }
-
-    if (!fileContent) {
-      return this.contentCache[relativePath] !== undefined
-    }
-
-    const contentHash = this.getContentHash(fileContent)
-    const cachedHash = this.contentCache[relativePath]
-
-    return cachedHash !== contentHash
-  }
-
-  private getContentHash(fileContent: string): string {
-    return crypto.createHash('sha256').update(fileContent).digest('hex')
-  }
-
-  private updateCache(relativePath: string, fileContent: string | null): void {
-    if (!fileContent) {
-      delete this.contentCache[relativePath]
-      return
-    }
-
-    this.contentCache[relativePath] = this.getContentHash(fileContent)
-  }
-
-  private removeFromCache(relativePath: string): void {
-    delete this.contentCache[relativePath]
-  }
-
-  private clearCache(): void {
-    Object.keys(this.contentCache).forEach((key) => {
-      delete this.contentCache[key]
-    })
-  }
-}

package/src/modules/file-watcher/types.ts

@@ -1,14 +0,0 @@
-export interface FileChangeEvent {
-  filePath: string
-  relativePath: string
-  data?: any
-}
-
-export type FileChangeEventMap = {
-  added: [FileChangeEvent]
-  changed: [FileChangeEvent]
-  deleted: [FileChangeEvent]
-  stopped: []
-}
-
-export type FileChangeEventType = keyof FileChangeEventMap

package/src/modules/setup/steps.ts

@@ -1,9 +0,0 @@
-export enum Step {
-  Authenticate,
-  ConnectWorkspace,
-}
-
-export const STEP_LABELS: Record<Step, string> = {
-  [Step.Authenticate]: 'Authenticate in Membrane',
-  [Step.ConnectWorkspace]: 'Connect a Membrane Workspace',
-}

package/src/modules/setup/useSetup.ts

@@ -1,16 +0,0 @@
-import { useProjectConfig } from '../config/project'
-import { hasPat } from '../config/system'
-
-export const useSetup = () => {
-  const { config } = useProjectConfig()
-
-  const isAuthenticated = hasPat()
-  const workspaceIsConfigured = !!(config?.workspaceKey && config?.workspaceSecret)
-  const isSetupComplete = isAuthenticated && workspaceIsConfigured
-
-  return {
-    isAuthenticated,
-    workspaceIsConfigured,
-    isSetupComplete,
-  }
-}

package/src/modules/status/useStatus.ts

@@ -1,16 +0,0 @@
-import { useCwd } from '../config/cwd-context'
-import { useProjectConfig } from '../config/project'
-import { useSetup } from '../setup/useSetup'
-
-export const useStatus = () => {
-  const { isSetupComplete } = useSetup()
-  const { config } = useProjectConfig()
-  const cwd = useCwd()
-
-  return {
-    isSetupComplete,
-    workspaceKey: config?.workspaceKey,
-    config,
-    cwd,
-  }
-}

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

@@ -1,121 +0,0 @@
-import { WorkspaceElementType } from '@integration-app/sdk'
-
-export interface ElementConfig {
-  element: string
-  elements: string
-  exportable?: boolean
-  integrationSpecific?: boolean
-}
-
-export const INTEGRATION_ELEMENTS: Record<WorkspaceElementType, ElementConfig> = {
-  [WorkspaceElementType.Integration]: {
-    element: 'integration',
-    elements: 'integrations',
-    exportable: false,
-  },
-  [WorkspaceElementType.Connector]: {
-    element: 'connector',
-    elements: 'connectors',
-    exportable: false,
-  },
-  [WorkspaceElementType.Action]: {
-    element: 'action',
-    elements: 'actions',
-    integrationSpecific: true,
-  },
-  [WorkspaceElementType.AppDataSchema]: {
-    element: 'appDataSchema',
-    elements: 'appDataSchemas',
-  },
-  [WorkspaceElementType.AppEventType]: {
-    element: 'appEventType',
-    elements: 'appEventTypes',
-  },
-  [WorkspaceElementType.DataLinkTable]: {
-    element: 'dataLinkTable',
-    elements: 'dataLinkTables',
-  },
-  [WorkspaceElementType.DataSource]: {
-    element: 'dataSource',
-    elements: 'dataSources',
-    integrationSpecific: true,
-  },
-  [WorkspaceElementType.FieldMapping]: {
-    element: 'fieldMapping',
-    elements: 'fieldMappings',
-    integrationSpecific: true,
-  },
-  [WorkspaceElementType.Flow]: {
-    element: 'flow',
-    elements: 'flows',
-    integrationSpecific: true,
-  },
-  [WorkspaceElementType.Customer]: {
-    element: 'customer',
-    elements: 'customers',
-  },
-  [WorkspaceElementType.FlowInstance]: {
-    element: 'flowInstance',
-    elements: 'flowInstances',
-  },
-  [WorkspaceElementType.FlowRun]: {
-    element: 'flowRun',
-    elements: 'flowRuns',
-  },
-  [WorkspaceElementType.Scenario]: {
-    element: 'scenario',
-    elements: 'scenarios',
-  },
-  [WorkspaceElementType.ActionInstance]: {
-    element: 'actionInstance',
-    elements: 'actionInstances',
-  },
-  [WorkspaceElementType.Connection]: {
-    element: 'connection',
-    elements: 'connections',
-  },
-  [WorkspaceElementType.FieldMappingInstance]: {
-    element: 'fieldMappingInstance',
-    elements: 'fieldMappingInstances',
-  },
-  [WorkspaceElementType.DataSourceInstance]: {
-    element: 'dataSourceInstance',
-    elements: 'dataSourceInstances',
-  },
-  [WorkspaceElementType.DataLinkTableInstance]: {
-    element: 'dataLinkTableInstance',
-    elements: 'dataLinkTableInstances',
-  },
-  [WorkspaceElementType.AppEventSubscription]: {
-    element: 'appEventSubscription',
-    elements: 'appEventSubscriptions',
-  },
-  [WorkspaceElementType.AppDataSchemaInstance]: {
-    element: 'appDataSchemaInstance',
-    elements: 'appDataSchemaInstances',
-  },
-  [WorkspaceElementType.ExternalEventSubscription]: {
-    element: 'externalEventSubscription',
-    elements: 'externalEventSubscriptions',
-  },
-  [WorkspaceElementType.ExternalEventLogRecord]: {
-    element: 'externalEventLogRecord',
-    elements: 'externalEventLogRecords',
-  },
-  [WorkspaceElementType.ExternalEventPull]: {
-    element: 'externalEventPull',
-    elements: 'externalEventPulls',
-  },
-  [WorkspaceElementType.DataCollection]: {
-    element: 'dataCollection',
-    elements: 'dataCollections',
-  },
-  [WorkspaceElementType.Screen]: {
-    element: 'screen',
-    elements: 'screens',
-  },
-  [WorkspaceElementType.ActionRunLogRecord]: {
-    element: 'actionRunLogRecord',
-    elements: 'actionRunLogRecords',
-  },
-}

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

@@ -1,69 +0,0 @@
-import * as path from 'node:path'
-
-import { WorkspaceElementSpecs, WorkspaceElementType } from '@integration-app/sdk'
-
-export interface WorkspaceElementKeyReference {
-  readonly type: WorkspaceElementType
-  readonly key: string
-}
-
-export function getTypeAndKeyFromPath(relativePath: string): WorkspaceElementKeyReference | undefined {
-  // NOTE: skip connector files for now
-  if (isConnectorFile(relativePath)) {
-    return undefined
-  }
-
-  if (isWorkspaceElementFile(relativePath)) {
-    return extractWorkspaceElementKeyReference(relativePath)
-  }
-  return undefined
-}
-
-function extractWorkspaceElementKeyReference(relativePath: string): WorkspaceElementKeyReference | undefined {
-  const elementTypes = Object.values(WorkspaceElementSpecs).map((spec) => spec.apiPath)
-
-  // <element-type>/<element-key>/spec.yml or .yaml
-  const universalElementPattern = new RegExp(
-    `^(?<elementTypePlural>${elementTypes.join('|')})\/(?<elementKey>[^\/]+)\/spec\.y[a]*ml$`,
-  )
-  const universalMatch = relativePath.match(universalElementPattern)
-  if (universalMatch && universalMatch.groups) {
-    const { elementTypePlural, elementKey } = universalMatch.groups
-    const type = getWorkspaceElementTypeFromFolderName(elementTypePlural)
-    if (type) {
-      return { key: elementKey, type }
-    }
-  }
-
-  // integrations/<integration-key>/<element-type>/<element-key>/spec.yml or .yaml
-  const integratedElementPattern = new RegExp(
-    `^integrations\/(?<integrationKey>[^\/]+)\/(?<elementTypePlural>${elementTypes.join('|')})\/(?<elementKey>[^\/]+)\/spec\.y[a]*ml$`,
-  )
-  const integratedMatch = relativePath.match(integratedElementPattern)
-  if (integratedMatch && integratedMatch.groups) {
-    const { elementTypePlural, elementKey } = integratedMatch.groups
-    const type = getWorkspaceElementTypeFromFolderName(elementTypePlural)
-    if (type) {
-      return { key: elementKey, type }
-    }
-  }
-
-  return undefined
-}
-
-function isWorkspaceElementFile(relativePath: string): boolean {
-  return relativePath.endsWith('.yml') || relativePath.endsWith('.yaml')
-}
-
-function isConnectorFile(relativePath: string): boolean {
-  const [rootDir] = relativePath.split(path.sep)
-  return rootDir === WorkspaceElementSpecs[WorkspaceElementType.Connector].apiPath
-}
-
-function getWorkspaceElementTypeFromFolderName(folderName: string): WorkspaceElementType | undefined {
-  return Object.values(WorkspaceElementType).find((type) => getWorkspaceElementTypeFolderName(type) === folderName)
-}
-
-function getWorkspaceElementTypeFolderName(type: WorkspaceElementType): string {
-  return WorkspaceElementSpecs[type].apiPath
-}