@xyo-network/xl1-cli-lib 1.20.5 → 1.20.9

package/src/configMiddleware.ts

@@ -0,0 +1,55 @@
+import { createDeepMerge } from '@xylabs/sdk-js'
+import { tryParseConfig } from '@xyo-network/chain-orchestration'
+import type { Config } from '@xyo-network/xl1-sdk'
+import {
+  ConfigZod, isZodError, resolveConfig,
+} from '@xyo-network/xl1-sdk'
+
+const deepMerge = createDeepMerge({ arrayStrategy: 'concat' })
+
+export async function configMiddleware(argv: Record<string, unknown>, setConfiguration: (config: Config) => void): Promise<void> {
+  try {
+    // Parse the various config sources
+    const configPath = argv.config as string | undefined
+    const parsedConfigFile = await tryParseConfig({ configPath }) // Config file
+    const parsedConfigArgs = ConfigZod.safeParse(argv).data ?? {} // Command-line arguments & ENV VARs
+    const parseResult = ConfigZod.safeParse(deepMerge(parsedConfigFile, parsedConfigArgs))
+    if (!parseResult.success) {
+      throw parseResult.error
+    }
+    // Deep merge with precedence
+    // TODO: Would like precedence to be defaults < file < ENV < CLI Args
+    // but there is currently no way to determine which are defaults vs
+    // user-supplied CLI Args since we set the CLI args to the defaults
+    // and receive a flattened object. We might need to manually invoke
+    // the parser without the defaults to achieve this.
+    // const mergedConfig = deepMerge(parsedConfigArgs, parsedConfigFile)
+    const mergedConfig = parseResult.data
+    const validatedMergedConfigResult = ConfigZod.safeParse(mergedConfig)
+    if (!validatedMergedConfigResult.success) {
+      throw validatedMergedConfigResult.error
+    }
+    const resolvedConfig = resolveConfig(validatedMergedConfigResult.data)
+    // Validate the merged configuration
+    const validatedConfigResult = ConfigZod.safeParse(resolvedConfig)
+    if (!validatedConfigResult.success) {
+      throw validatedConfigResult.error
+    }
+    setConfiguration(validatedConfigResult.data)
+
+    // Check if user wants to dump config and exit
+    if (argv['dump-config']) {
+      console.log(JSON.stringify(validatedConfigResult.data, null, 2))
+      // eslint-disable-next-line unicorn/no-process-exit
+      process.exit(0)
+    }
+  } catch (err) {
+    if (isZodError(err)) {
+      console.error(`Zod error: ${err.message}`)
+    } else {
+      console.error(`Error parsing configuration: ${err}`)
+    }
+    console.error(`Stack: ${err instanceof Error ? err.stack : 'N/A'}`)
+    throw new Error('Invalid configuration')
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './configMiddleware.ts'
 export * from './initLogger.ts'
 export * from './runCLI.ts'
 export * from './start.ts'

package/src/runCLI.ts

@@ -1,28 +1,26 @@
-import { createDeepMerge, isDefined } from '@xylabs/sdk-js'
-import { getApiActor, runApi } from '@xyo-network/chain-api'
-import { getMempoolActor, runMempool } from '@xyo-network/chain-mempool'
+import { isDefined } from '@xylabs/sdk-js'
 import {
-  ApiConfigZod, BridgeConfigZod, contextFromConfigWithoutLocator, locatorsFromConfig, MempoolConfigZod, Orchestrator, ProducerConfigZod,
-  RewardRedemptionConfigZod, tryParseConfig,
-  ValidatorConfigZod,
+  contextFromConfigWithoutLocator, locatorsFromConfig, Orchestrator,
 } from '@xyo-network/chain-orchestration'
-import { runProducer } from '@xyo-network/chain-producer'
 import type { ActorConfig, Config } from '@xyo-network/xl1-sdk'
-import {
-  ActorConfigZod, ConfigZod, isZodError,
-  resolveConfig,
-} from '@xyo-network/xl1-sdk'
+import { ActorConfigZod, ConfigZod } from '@xyo-network/xl1-sdk'
 import type { Argv } from 'yargs'
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
 
 import {
-  getValidatorActor, runBridge, runRewardRedemptionApi,
+  apiCommand,
+  bridgeCommand,
+  mempoolCommand,
+  producerCommand,
+  rewardRedemptionCommand,
+  startCommand,
+  withDeprecationWarning,
 } from './commands/index.ts'
+import { configMiddleware } from './configMiddleware.ts'
 import { XL1LogoColorizedAscii } from './images.ts'
 import { initLogger } from './initLogger.ts'
 import { optionsFromGlobalZodRegistry } from './optionsFromGlobalZodRegistry.ts'
-import { waitForHostPort } from './waitForHostPort.ts'
 
 /** Version string injected by Rollup at build time. */
 declare const __VERSION__: string
@@ -36,23 +34,23 @@ let configuration: Config
 
 const version = isDefined(__VERSION__) ? __VERSION__ : 'unknown'
 
-const deepMerge = createDeepMerge({ arrayStrategy: 'concat' })
+function getConfiguration(): Config {
+  return configuration
+}
 
 async function getLocatorsFromConfig(actors: string[], configuration: Config) {
   const actorConfigs: ActorConfig[] = []
   for (const actorName of actors) {
-    const rawConfig = configuration.actors.find(actor => actor.name === actorName) ?? { name: actorName }
-    const actorConfig = ActorConfigZod.loose().parse(rawConfig)
-    actorConfigs.push(actorConfig)
+    const existingConfig = configuration.actors.find(actor => actor.name === actorName)
+    if (existingConfig) {
+      actorConfigs.push(existingConfig)
+    } else {
+      const actorConfig = ActorConfigZod.loose().parse({ name: actorName })
+      actorConfigs.push(actorConfig)
+    }
   }
 
-  // merge the configs, but merge the actors list, don't concat it
-  const config = ConfigZod.parse(deepMerge(configuration, { actors: actorConfigs }))
-  const actorList = [...new Set([...config.actors.map(actor => actor.name), ...actorConfigs.map(actor => actor.name)])]
-  config.actors = actorList.map(actorName => ActorConfigZod.loose().parse(deepMerge(
-    (config.actors.find(actor => actor.name === actorName) ?? {}),
-    (actorConfigs.find(actor => actor.name === actorName) ?? {}),
-  )))
+  const config = ConfigZod.parse({ ...configuration, actors: actorConfigs })
 
   const logger = initLogger(configuration)
   const orchestrator = await Orchestrator.create({ logger })
@@ -95,127 +93,18 @@ $0 <command> [options]`)
     .env('XL1')
     .scriptName('xl1')
     .middleware(async (argv) => {
-      try {
-        // Parse the various config sources
-        const configPath = argv.config as string | undefined
-        const parsedConfigFile = await tryParseConfig({ configPath }) // Config file
-        const parsedConfigArgs = ConfigZod.safeParse(argv).data ?? {} // Command-line arguments & ENV VARs
-        const parseResult = ConfigZod.safeParse(deepMerge(parsedConfigFile, parsedConfigArgs))
-        if (!parseResult.success) {
-          throw parseResult.error
-        }
-        // Deep merge with precedence
-        // TODO: Would like precedence to be defaults < file < ENV < CLI Args
-        // but there is currently no way to determine which are defaults vs
-        // user-supplied CLI Args since we set the CLI args to the defaults
-        // and receive a flattened object. We might need to manually invoke
-        // the parser without the defaults to achieve this.
-        // const mergedConfig = deepMerge(parsedConfigArgs, parsedConfigFile)
-        const mergedConfig = parseResult.data
-        const validatedMergedConfigResult = ConfigZod.safeParse(mergedConfig)
-        if (!validatedMergedConfigResult.success) {
-          throw validatedMergedConfigResult.error
-        }
-        const resolvedConfig = resolveConfig(validatedMergedConfigResult.data)
-        // Validate the merged configuration
-        const validatedConfigResult = ConfigZod.safeParse(resolvedConfig)
-        if (!validatedConfigResult.success) {
-          throw validatedConfigResult.error
-        }
-        configuration = validatedConfigResult.data
-
-        // Check if user wants to dump config and exit
-        if (argv['dump-config']) {
-          console.log(JSON.stringify(configuration, null, 2))
-          // eslint-disable-next-line unicorn/no-process-exit
-          process.exit(0)
-        }
-      } catch (err) {
-        if (isZodError(err)) {
-          console.error(`Zod error: ${err.message}`)
-        } else {
-          console.error(`Error parsing configuration: ${err}`)
-        }
-        console.error(`Stack: ${err instanceof Error ? err.stack : 'N/A'}`)
-        throw new Error('Invalid configuration')
-      }
+      await configMiddleware(argv, (config) => {
+        configuration = config
+      })
     })
     .options(optionsFromGlobalZodRegistry())
-  // .commandDir('./command/commands', opts) // Not yet supported for ESM
     .wrap(y.terminalWidth())
-    .command('api', 'Run a XL1 API Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 API Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['api', 'mempool', 'validator'], configuration)
-          const actors = await Promise.all([getApiActor(
-            ApiConfigZod.parse(locators['api'].context.config),
-            locators['api'],
-          ), getMempoolActor(
-            MempoolConfigZod.parse(locators['mempool'].context.config),
-            locators['mempool'],
-          ), getValidatorActor(
-            ValidatorConfigZod.parse(locators['validator'].context.config),
-            locators['validator'],
-          )])
-
-          for (const actor of actors) {
-            await orchestrator.registerActor(actor)
-          }
-
-          await orchestrator.start()
-        })
-    })
-    .command('bridge', 'Run a XL1 Bridge Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 Bridge Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['bridge'], configuration)
-          await runBridge(BridgeConfigZod.parse(locators['bridge'].context.config), orchestrator, locators['bridge'])
-        })
-    })
-    .command('mempool', 'Run a XL1 Mempool Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 Mempool Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['mempool'], configuration)
-          await runMempool(MempoolConfigZod.parse(locators['mempool'].context.config), orchestrator, locators['mempool'])
-        })
-    })
-    .command('producer', 'Run a XL1 Producer Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 Producer Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['producer'], configuration)
-          await runProducer(ProducerConfigZod.parse(locators['producer'].context.config), orchestrator, locators['producer'])
-        })
-    })
-    .command('reward-redemption-api', 'Run a XL1 Rewards Redemption API Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 Rewards Redemption API Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['rewardRedemption'], configuration)
-          await runRewardRedemptionApi(RewardRedemptionConfigZod.parse(locators['rewardRedemption'].context.config), orchestrator, locators['rewardRedemption'])
-        })
-    })
-    .command('$0', 'Run a full XL1 Node', () => {}, async () => {
-      const actors = ['producer', 'api']
-      const mempoolEnabled = configuration.actors.find(actor => actor.name === 'mempool')?.enabled
-      if (mempoolEnabled) {
-        actors.push('mempool')
-      }
-      const { locators, orchestrator } = await getLocatorsFromConfig(['api', 'producer'], configuration)
-      if (mempoolEnabled) {
-        const mempoolConfig = MempoolConfigZod.parse(locators['mempool'].context.config)
-        // Start Mempool but do not block
-        await runMempool(mempoolConfig, orchestrator, locators['mempool'])
-        // Wait for Mempool to be ready
-        await waitForHostPort(mempoolConfig.host, mempoolConfig.port)
-      }
-      // Start API but do not block
-      const apiConfig = ApiConfigZod.parse(locators['api'].context.config)
-      await runApi(apiConfig, orchestrator, locators['api'])
-      // Wait for API to be ready
-      await waitForHostPort(apiConfig.host, apiConfig.port)
-      // Start Producer and block on it
-      const producerConfig = ProducerConfigZod.parse(locators['producer'].context.config)
-      await runProducer(producerConfig, orchestrator, locators['producer'])
-    })
+    .command(withDeprecationWarning(apiCommand(getConfiguration, getLocatorsFromConfig)))
+    .command(withDeprecationWarning(bridgeCommand(getConfiguration, getLocatorsFromConfig)))
+    .command(withDeprecationWarning(mempoolCommand(getConfiguration, getLocatorsFromConfig)))
+    .command(withDeprecationWarning(producerCommand(getConfiguration, getLocatorsFromConfig)))
+    .command(withDeprecationWarning(rewardRedemptionCommand(getConfiguration, getLocatorsFromConfig)))
+    .command(startCommand(getConfiguration, getLocatorsFromConfig))
     .options({
       'config': {
         type: 'string',