@jupiterone/integration-sdk-cli 8.24.0 → 8.25.0

package/src/commands/run.ts

@@ -1,4 +1,4 @@
-import { createCommand } from 'commander';
+import { Command, createCommand, OptionValues } from 'commander';
 import path from 'path';
 
 import { Metric } from '@jupiterone/integration-sdk-core';
@@ -11,8 +11,6 @@ import {
   executeIntegrationInstance,
   FileSystemGraphObjectStore,
   finalizeSynchronization,
-  getAccountFromEnvironment,
-  getApiKeyFromEnvironment,
   initiateSynchronization,
   synchronizationStatus,
 } from '@jupiterone/integration-sdk-runtime';
@@ -21,77 +19,40 @@ import { createPersisterApiStepGraphObjectDataUploader } from '@jupiterone/integ
 import { loadConfig } from '../config';
 import * as log from '../log';
 import {
-  getApiBaseUrlOption,
-  getSynchronizationJobSourceOptions,
+  addApiClientOptionsToCommand,
+  addPathOptionsToCommand,
+  addSyncOptionsToCommand,
+  configureRuntimeFilesystem,
+  getApiClientOptions,
+  getSyncOptions,
+  validateApiClientOptions,
+  validateSyncOptions,
 } from './options';
 
 const DEFAULT_UPLOAD_CONCURRENCY = 5;
 
-export function run() {
-  return createCommand('run')
-    .description('collect and sync to upload entities and relationships')
-    .option(
-      '-i, --integrationInstanceId <id>',
-      '_integrationInstanceId assigned to uploaded entities and relationships',
-    )
-    .option(
-      '-p, --project-path <directory>',
-      'path to integration project directory',
-      process.cwd(),
-    )
-    .option(
-      '-d, --development',
-      '"true" to target apps.dev.jupiterone.io',
-      !!process.env.JUPITERONE_DEV,
-    )
-    .option('--api-base-url <url>', 'API base URL used during run operation')
-    .option('--skip-finalize', 'skip synchronization finalization')
-    .option(
-      '--source <integration-managed|integration-external|api>',
-      'configure the synchronization job source value',
-      'integration-managed',
-    )
-    .option(
-      '--scope <anystring>',
-      'configure the synchronization job scope value',
-    )
-    .option('-V, --disable-schema-validation', 'disable schema validation')
-    .option(
-      '-u, --upload-batch-size <number>',
-      'specify number of items per batch for upload (default 250)',
-    )
-    .option(
-      '-ur, --upload-relationship-batch-size <number>',
-      'specify number of relationships per batch for upload (default 250)',
-    )
-    .action(async (options) => {
-      const projectPath = path.resolve(options.projectPath);
-      // Point `fileSystem.ts` functions to expected location relative to
-      // integration project path.
-      process.env.JUPITERONE_INTEGRATION_STORAGE_DIRECTORY = path.resolve(
-        projectPath,
-        '.j1-integration',
-      );
+export function run(): Command {
+  const command = createCommand('run');
 
-      log.debug('Loading API Key from JUPITERONE_API_KEY environment variable');
-      const accessToken = getApiKeyFromEnvironment();
+  addPathOptionsToCommand(command);
+  addApiClientOptionsToCommand(command);
+  addSyncOptionsToCommand(command);
 
-      log.debug('Loading account from JUPITERONE_ACCOUNT environment variable');
-      const account = getAccountFromEnvironment();
-
-      const apiBaseUrl = getApiBaseUrlOption(options);
-      log.debug(`Configuring client to access "${apiBaseUrl}"`);
+  return command
+    .description('collect and sync to upload entities and relationships')
+    .option('-V, --disable-schema-validation', 'disable schema validation')
+    .action(async (options: OptionValues, actionCommand: Command) => {
+      configureRuntimeFilesystem(actionCommand.opts());
+      validateApiClientOptions(actionCommand.opts());
+      validateSyncOptions(actionCommand.opts());
 
       const startTime = Date.now();
 
-      const apiClient = createApiClient({
-        apiBaseUrl,
-        accessToken,
-        account,
-      });
-
-      const synchronizationJobSourceOptions =
-        getSynchronizationJobSourceOptions(options);
+      const clientApiOptions = getApiClientOptions(actionCommand.opts());
+      const apiClient = createApiClient(clientApiOptions);
+      log.debug(
+        `Configured JupiterOne API client. (apiBaseUrl: '${clientApiOptions.apiBaseUrl}', account: ${clientApiOptions.account})`,
+      );
 
       let logger = createIntegrationLogger({
         name: 'local',
@@ -101,7 +62,7 @@ export function run() {
       const synchronizationContext = await initiateSynchronization({
         logger,
         apiClient,
-        ...synchronizationJobSourceOptions,
+        ...getSyncOptions(actionCommand.opts()),
       });
 
       logger = synchronizationContext.logger;
@@ -115,7 +76,9 @@ export function run() {
         .on('event', (event) => eventPublishingQueue.enqueue(event))
         .on('metric', (metric) => metrics.push(metric));
 
-      const invocationConfig = await loadConfig(path.join(projectPath, 'src'));
+      const invocationConfig = await loadConfig(
+        path.resolve(options.projectPath, 'src'),
+      );
 
       const graphObjectStore = new FileSystemGraphObjectStore({
         prettifyFiles: true,
@@ -130,7 +93,7 @@ export function run() {
           invocationConfig,
           {
             current: {
-              startedOn: startTime,
+              startedOn: synchronizationContext.job.startTimestamp,
             },
           },
           {
@@ -153,18 +116,18 @@ export function run() {
 
         log.displayExecutionResults(executionResults);
 
-        if (!options.skipFinalize) {
-          const synchronizationResult = await finalizeSynchronization({
-            ...synchronizationContext,
-            partialDatasets: executionResults.metadata.partialDatasets,
-          });
-          log.displaySynchronizationResults(synchronizationResult);
-        } else {
+        if (options.skipFinalize) {
           log.info(
             'Skipping synchronization finalization. Job will remain in "AWAITING_UPLOADS" state.',
           );
           const jobStatus = await synchronizationStatus(synchronizationContext);
           log.displaySynchronizationResults(jobStatus);
+        } else {
+          const synchronizationResult = await finalizeSynchronization({
+            ...synchronizationContext,
+            partialDatasets: executionResults.metadata.partialDatasets,
+          });
+          log.displaySynchronizationResults(synchronizationResult);
         }
       } catch (err) {
         await eventPublishingQueue.onIdle();

package/src/commands/sync.ts

@@ -1,93 +1,60 @@
-import { createCommand } from 'commander';
-import path from 'path';
+import { Command, createCommand, OptionValues } from 'commander';
 
 import {
   createApiClient,
   createIntegrationLogger,
-  getAccountFromEnvironment,
-  getApiKeyFromEnvironment,
   synchronizeCollectedData,
 } from '@jupiterone/integration-sdk-runtime';
 
 import * as log from '../log';
 import {
-  getApiBaseUrlOption,
-  getSynchronizationJobSourceOptions,
+  addApiClientOptionsToCommand,
+  addPathOptionsToCommand,
+  addSyncOptionsToCommand,
+  configureRuntimeFilesystem,
+  getApiClientOptions,
+  getSyncOptions,
+  validateApiClientOptions,
+  validateSyncOptions,
 } from './options';
 
-export function sync() {
-  return createCommand('sync')
+export function sync(): Command {
+  const command = createCommand('sync');
+
+  addPathOptionsToCommand(command);
+  addApiClientOptionsToCommand(command);
+  addSyncOptionsToCommand(command);
+
+  return command
     .description(
       'sync collected data with JupiterOne, requires JUPITERONE_API_KEY, JUPITERONE_ACCOUNT',
     )
-    .option(
-      '-i, --integrationInstanceId <id>',
-      '_integrationInstanceId assigned to uploaded entities and relationships',
-    )
-    .option(
-      '-p, --project-path <directory>',
-      'path to integration project directory',
-      process.cwd(),
-    )
-    .option(
-      '-d, --development',
-      '"true" to target apps.dev.jupiterone.io',
-      !!process.env.JUPITERONE_DEV,
-    )
-    .option('--api-base-url <url>', 'API base URL used during sync operation.')
-    .option(
-      '--source <integration-managed|integration-external|api>',
-      'configure the synchronization job source value',
-      'integration-managed',
-    )
-    .option(
-      '--scope <anystring>',
-      'configure the synchronization job scope value',
-    )
-    .option(
-      '-u, --upload-batch-size <number>',
-      'specify number of items per batch for upload (default 250)',
-    )
-    .option(
-      '-ur, --upload-relationship-batch-size <number>',
-      'specify number of relationships per batch for upload (default 250)',
-    )
-    .action(async (options) => {
-      // Point `fileSystem.ts` functions to expected location relative to
-      // integration project path.
-      process.env.JUPITERONE_INTEGRATION_STORAGE_DIRECTORY = path.resolve(
-        options.projectPath,
-        '.j1-integration',
-      );
-
-      log.debug('Loading API Key from JUPITERONE_API_KEY environment variable');
-      const accessToken = getApiKeyFromEnvironment();
-
-      log.debug('Loading account from JUPITERONE_ACCOUNT environment variable');
-      const account = getAccountFromEnvironment();
+    .action(async (options: OptionValues, actionCommand: Command) => {
+      configureRuntimeFilesystem(actionCommand.opts());
+      validateApiClientOptions(actionCommand.opts());
+      validateSyncOptions(actionCommand.opts());
 
-      const apiBaseUrl = getApiBaseUrlOption(options);
-      log.debug(`Configuring client to access "${apiBaseUrl}"`);
-
-      const apiClient = createApiClient({
-        apiBaseUrl,
-        account,
-        accessToken,
-      });
-
-      const synchronizationJobSourceOptions =
-        getSynchronizationJobSourceOptions(options);
+      const clientApiOptions = getApiClientOptions(actionCommand.opts());
+      const apiClient = createApiClient(clientApiOptions);
+      log.debug(
+        `Configured JupiterOne API client. (apiBaseUrl: '${clientApiOptions.apiBaseUrl}', account: ${clientApiOptions.account})`,
+      );
 
       const logger = createIntegrationLogger({
         name: 'local',
         pretty: true,
       });
+
+      const syncOptions = getSyncOptions(actionCommand.opts());
+      if (syncOptions.skipFinalize)
+        log.info(
+          'Skipping synchronization finalization. Job will remain in "AWAITING_UPLOADS" state.',
+        );
+
       const job = await synchronizeCollectedData({
-        logger: logger.child(synchronizationJobSourceOptions),
+        logger: logger.child(syncOptions),
         apiClient,
-        uploadBatchSize: options.uploadBatchSize,
-        uploadRelationshipBatchSize: options.uploadRelationshipBatchSize,
-        ...synchronizationJobSourceOptions,
+        ...syncOptions,
       });
 
       log.displaySynchronizationResults(job);

package/src/log.ts

@@ -11,6 +11,7 @@ import {
   Metric,
 } from '@jupiterone/integration-sdk-core';
 
+/* eslint-disable no-console */
 export function debug(msg: string) {
   console.log(`${chalk.gray(msg)}`);
 }