@jupiterone/integration-sdk-cli 8.23.1 → 8.24.1

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,84 +11,48 @@ import {
   executeIntegrationInstance,
   FileSystemGraphObjectStore,
   finalizeSynchronization,
-  getAccountFromEnvironment,
-  getApiBaseUrl,
-  getApiKeyFromEnvironment,
   initiateSynchronization,
+  synchronizationStatus,
 } from '@jupiterone/integration-sdk-runtime';
 import { createPersisterApiStepGraphObjectDataUploader } from '@jupiterone/integration-sdk-runtime/dist/src/execution/uploader';
 
 import { loadConfig } from '../config';
 import * as log from '../log';
+import {
+  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')
-    .requiredOption(
-      '-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('-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',
-      );
-
-      log.debug('Loading API Key from JUPITERONE_API_KEY environment variable');
-      const accessToken = getApiKeyFromEnvironment();
+export function run(): Command {
+  const command = createCommand('run');
 
-      log.debug('Loading account from JUPITERONE_ACCOUNT environment variable');
-      const account = getAccountFromEnvironment();
+  addPathOptionsToCommand(command);
+  addApiClientOptionsToCommand(command);
+  addSyncOptionsToCommand(command);
 
-      let apiBaseUrl: string;
-      if (options.apiBaseUrl) {
-        if (options.development) {
-          throw new Error(
-            'Invalid configuration supplied.  Cannot specify both --api-base-url and --development(-d) flags.',
-          );
-        }
-        apiBaseUrl = options.apiBaseUrl;
-      } else {
-        apiBaseUrl = getApiBaseUrl({
-          dev: options.development,
-        });
-      }
-      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 { integrationInstanceId } = 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',
@@ -98,7 +62,7 @@ export function run() {
       const synchronizationContext = await initiateSynchronization({
         logger,
         apiClient,
-        integrationInstanceId,
+        ...getSyncOptions(actionCommand.opts()),
       });
 
       logger = synchronizationContext.logger;
@@ -112,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,
@@ -127,7 +93,7 @@ export function run() {
           invocationConfig,
           {
             current: {
-              startedOn: startTime,
+              startedOn: synchronizationContext.job.startTimestamp,
             },
           },
           {
@@ -150,12 +116,19 @@ export function run() {
 
         log.displayExecutionResults(executionResults);
 
-        const synchronizationResult = await finalizeSynchronization({
-          ...synchronizationContext,
-          partialDatasets: executionResults.metadata.partialDatasets,
-        });
-
-        log.displaySynchronizationResults(synchronizationResult);
+        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();
         if (!logger.isHandledError(err)) {

package/src/commands/sync.ts

@@ -1,92 +1,60 @@
-import { createCommand } from 'commander';
-import path from 'path';
+import { Command, createCommand, OptionValues } from 'commander';
 
 import {
   createApiClient,
   createIntegrationLogger,
-  getAccountFromEnvironment,
-  getApiBaseUrl,
-  getApiKeyFromEnvironment,
   synchronizeCollectedData,
 } from '@jupiterone/integration-sdk-runtime';
 
 import * as log from '../log';
-
-export function sync() {
-  return createCommand('sync')
+import {
+  addApiClientOptionsToCommand,
+  addPathOptionsToCommand,
+  addSyncOptionsToCommand,
+  configureRuntimeFilesystem,
+  getApiClientOptions,
+  getSyncOptions,
+  validateApiClientOptions,
+  validateSyncOptions,
+} from './options';
+
+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',
     )
-    .requiredOption(
-      '-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(
-      '-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',
+    .action(async (options: OptionValues, actionCommand: Command) => {
+      configureRuntimeFilesystem(actionCommand.opts());
+      validateApiClientOptions(actionCommand.opts());
+      validateSyncOptions(actionCommand.opts());
+
+      const clientApiOptions = getApiClientOptions(actionCommand.opts());
+      const apiClient = createApiClient(clientApiOptions);
+      log.debug(
+        `Configured JupiterOne API client. (apiBaseUrl: '${clientApiOptions.apiBaseUrl}', account: ${clientApiOptions.account})`,
       );
 
-      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();
-
-      let apiBaseUrl: string;
-      if (options.apiBaseUrl) {
-        if (options.development) {
-          throw new Error(
-            'Invalid configuration supplied.  Cannot specify both --api-base-url and --development(-d) flags.',
-          );
-        }
-        apiBaseUrl = options.apiBaseUrl;
-      } else {
-        apiBaseUrl = getApiBaseUrl({
-          dev: options.development,
-        });
-      }
-      log.debug(`Configuring client to access "${apiBaseUrl}"`);
-
-      const apiClient = createApiClient({
-        apiBaseUrl,
-        account,
-        accessToken,
-      });
-
-      const { integrationInstanceId } = options;
-
       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({ integrationInstanceId }),
+        logger: logger.child(syncOptions),
         apiClient,
-        integrationInstanceId,
-        uploadBatchSize: options.uploadBatchSize,
-        uploadRelationshipBatchSize: options.uploadRelationshipBatchSize,
+        ...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)}`);
 }