@jupiterone/integration-sdk-cli 9.5.0 → 9.6.2

package/src/generator/template/src/config.ts.hbs

@@ -0,0 +1,39 @@
+import {
+  IntegrationExecutionContext,
+  {{#if configFields}}IntegrationValidationError,{{/if}}
+  IntegrationInstanceConfigFieldMap,
+  IntegrationInstanceConfig,
+} from '@jupiterone/integration-sdk-core';
+import { createAPIClient } from './client';
+
+export const instanceConfigFields: IntegrationInstanceConfigFieldMap = {
+  {{#each configFields}}
+  {{camelCase field}}: {
+    type: '{{type}}',
+    mask: {{mask}}
+  },
+  {{/each}}
+};
+
+export interface IntegrationConfig extends IntegrationInstanceConfig {
+  {{#each configFields}}
+  {{camelCase field}}: {{ type }};
+  {{/each}}
+}
+
+export async function validateInvocation(
+  context: IntegrationExecutionContext<IntegrationConfig>,
+) {
+  const { config } = context.instance;
+
+  {{#if configFields}}
+  if ({{#each configFields}}!config.{{camelCase field}}{{#unless @last}}||{{/unless}}{{/each}}) {
+    throw new IntegrationValidationError(
+      'Config requires all of {{#each configFields}}{{camelCase field}}{{#unless @last}},{{/unless}}{{/each}}',
+    );
+  }
+  {{/if}}
+
+  const apiClient = createAPIClient(config);
+  await apiClient.verifyAuthentication();
+}

package/src/generator/template/src/index.ts.hbs

@@ -0,0 +1,14 @@
+import { IntegrationInvocationConfig } from '@jupiterone/integration-sdk-core';
+import { integrationSteps } from './steps';
+import {
+  validateInvocation,
+  IntegrationConfig,
+  instanceConfigFields,
+} from './config';
+
+export const invocationConfig: IntegrationInvocationConfig<IntegrationConfig> =
+  {
+    instanceConfigFields,
+    validateInvocation,
+    integrationSteps,
+  };

package/src/generator/template/src/steps/constants.ts.hbs

@@ -0,0 +1,34 @@
+import {
+  {{#if relationships}}RelationshipClass,{{/if}}
+  StepEntityMetadata,
+  StepRelationshipMetadata,
+} from '@jupiterone/integration-sdk-core';
+
+export const Steps: Record<{{#unless steps}}string{{/unless}}{{#each steps}}'{{constantCase name}}'{{#unless @last}}|{{/unless}}{{/each}}, string> = {
+  {{#each steps}}
+  {{constantCase name}}: '{{kebabCase name}}',
+  {{/each}}
+};
+
+export const Entities: Record<{{#unless entities}}string{{/unless}}{{#each entities}}'{{constantCase resourceName}}'{{#unless @last}}|{{/unless}}{{/each}}
+, StepEntityMetadata > = {
+  {{#each entities}}
+  {{constantCase resourceName}}: {
+    resourceName: '{{resourceName}}',
+    _type: '{{_type}}',
+    _class: [{{#each _class}}'{{this}}'{{#unless @last}},{{/unless}}{{/each}}],
+  },
+  {{/each}}
+};
+
+export const Relationships: Record<{{#unless relationships}}string{{/unless}}{{#each relationships}}'{{constantCase (generateRelationshipName this)}}'{{#unless @last}}|{{/unless}}{{/each}},
+StepRelationshipMetadata> = {
+  {{#each relationships}}
+  {{constantCase (generateRelationshipName this)}}: {
+    sourceType: Entities.{{ constantCase from.resourceName }}._type,
+    targetType: Entities.{{ constantCase to.resourceName }}._type,
+    _type: '{{snakeCase (generateRelationshipType this)}}',
+    _class: RelationshipClass.{{_class}},
+  },
+  {{/each}}
+};

package/src/generator/template/src/steps/index.ts.hbs

@@ -0,0 +1,7 @@
+{{#each steps}}
+import { {{camelCase name}}Steps } from './{{kebabCase name}}'
+{{/each}}
+
+const integrationSteps = [{{#each steps}}...{{camelCase name}}Steps{{#unless @last}},{{/unless}}{{/each}}];
+
+export { integrationSteps };

package/src/generator/template/src/validateInvocation.ts.hbs

@@ -0,0 +1,23 @@
+import { Recording } from '@jupiterone/integration-sdk-testing';
+
+describe('#validateInvocation', () => {
+  let recording: Recording;
+
+  afterEach(async () => {
+    if (recording) {
+      await recording.stop();
+    }
+  });
+
+  test.todo('requires valid config', async () => {
+    // TODO
+  });
+
+  test.todo('successfully validates invocation', async () => {
+    // TODO
+  });
+
+  describe('fails validating invocation', () => {
+    // TODO
+  });
+});

package/src/generator/template/test/README.md.hbs

@@ -0,0 +1,4 @@
+# Testing Integrations
+
+For information on testing integrations see: 
+

package/src/generator/template/test/config.ts.hbs

@@ -0,0 +1,30 @@
+import { IntegrationInvocationConfig } from '@jupiterone/integration-sdk-core';
+import { StepTestConfig } from '@jupiterone/integration-sdk-testing';
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import { invocationConfig } from '../src';
+import { IntegrationConfig } from '../src/config';
+
+if (process.env.LOAD_ENV) {
+  dotenv.config({
+    path: path.join(__dirname, '../.env'),
+  });
+}
+
+{{#each configField}}
+const DEFAULT_{{constantCase field}} = '';
+{{/each}}
+
+export const integrationConfig: IntegrationConfig = {
+  {{#each configField}}
+  {{camelCase field}}: process.env.{{constantCase field}} || DEFAULT_{{constantCase field}}
+  {{/each}}
+};
+
+export function buildStepTestConfigForStep(stepId: string): StepTestConfig {
+  return {
+    stepId,
+    instanceConfig: integrationConfig,
+    invocationConfig: invocationConfig as IntegrationInvocationConfig,
+  };
+}

package/src/generator/template/test/recording.ts.hbs

@@ -0,0 +1,74 @@
+import {
+  setupRecording,
+  Recording,
+  SetupRecordingInput,
+  mutations,
+} from '@jupiterone/integration-sdk-testing';
+
+export { Recording };
+
+export function setupProjectRecording(
+  input: Omit<SetupRecordingInput, 'mutateEntry'>,
+): Recording {
+  return setupRecording({
+    ...input,
+    redactedRequestHeaders: ['Authorization'],
+    redactedResponseHeaders: ['set-cookie'],
+    mutateEntry: mutations.unzipGzippedRecordingEntry,
+    /*mutateEntry: (entry) => {
+      redact(entry);
+    },*/
+  });
+}
+
+// a more sophisticated redaction example below:
+
+/*
+function getRedactedOAuthResponse() {
+  return {
+    access_token: '[REDACTED]',
+    expires_in: 9999,
+    token_type: 'Bearer',
+  };
+}
+
+function redact(entry): void {
+  if (entry.request.postData) {
+    entry.request.postData.text = '[REDACTED]';
+  }
+
+  if (!entry.response.content.text) {
+    return;
+  }
+
+  //let's unzip the entry so we can modify it
+  mutations.unzipGzippedRecordingEntry(entry);
+
+  //we can just get rid of all response content if this was the token call
+  const requestUrl = entry.request.url;
+  if (requestUrl.match(/oauth\/token/)) {
+    entry.response.content.text = JSON.stringify(getRedactedOAuthResponse());
+    return;
+  }
+
+  //if it wasn't a token call, parse the response text, removing any carriage returns or newlines
+  const responseText = entry.response.content.text;
+  const parsedResponseText = JSON.parse(responseText.replace(/\r?\n|\r/g, ''));
+
+  //now we can modify the returned object as desired
+  //in this example, if the return text is an array of objects that have the 'tenant' property...
+  if (parsedResponseText[0]?.tenant) {
+    for (let i = 0; i < parsedResponseText.length; i++) {
+      parsedResponseText[i].client_secret = '[REDACTED]';
+      parsedResponseText[i].jwt_configuration = '[REDACTED]';
+      parsedResponseText[i].signing_keys = '[REDACTED]';
+      parsedResponseText[i].encryption_key = '[REDACTED]';
+      parsedResponseText[i].addons = '[REDACTED]';
+      parsedResponseText[i].client_metadata = '[REDACTED]';
+      parsedResponseText[i].mobile = '[REDACTED]';
+      parsedResponseText[i].native_social_login = '[REDACTED]';
+    }
+  }
+
+  entry.response.content.text = JSON.stringify(parsedResponseText);
+} */

package/src/generator/template/tsconfig.dist.json.hbs

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src", "package.json"],
+  "exclude": [
+    "dist",
+    "**/*.test.ts",
+    "**/*.test.js",
+    "**/*/__tests__/**/*.ts",
+    "**/*/__tests__/**/*.js",
+    "**/*/__mocks__/**/*.ts",
+    "**/*/__mocks__/**/*.js"
+  ]
+}

package/src/generator/template/tsconfig.json.hbs

@@ -0,0 +1,7 @@
+{
+  "extends": "./node_modules/@jupiterone/integration-sdk-dev-tools/config/typescript",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "exclude": ["dist"]
+}

package/src/generator/util.ts

@@ -0,0 +1,39 @@
+import { Entity } from './entitiesFlow';
+
+async function askRepeatedly<T>(
+  inquirer,
+  cb: () => Promise<void>,
+): Promise<void> {
+  let again = false;
+  do {
+    await cb();
+    again = await askAgain(inquirer);
+  } while (again);
+}
+
+function generateChoicesFromEntities(entities) {
+  const choices: { name: string; value: Entity }[] = [];
+  for (const entity of entities) {
+    choices.push({
+      name: entity._type,
+      value: entity,
+    });
+  }
+  return choices;
+}
+
+async function confirmPrompt(inquiurer, message) {
+  return (
+    await inquiurer.prompt({
+      type: 'confirm',
+      name: 'value',
+      message,
+    })
+  ).value;
+}
+
+async function askAgain(inquirer) {
+  return await confirmPrompt(inquirer, 'Add another?');
+}
+
+export { askAgain, askRepeatedly, confirmPrompt, generateChoicesFromEntities };

package/src/index.ts

@@ -14,6 +14,7 @@ import {
   generateIntegrationGraphSchemaCommand,
   generateIngestionSourcesConfigCommand,
   troubleshootLocalExecution,
+  generate,
 } from './commands';
 
 export function createCli() {
@@ -30,5 +31,6 @@ export function createCli() {
     .addCommand(visualizeDependencies())
     .addCommand(generateIntegrationGraphSchemaCommand())
     .addCommand(generateIngestionSourcesConfigCommand())
-    .addCommand(troubleshootLocalExecution());
+    .addCommand(troubleshootLocalExecution())
+    .addCommand(generate());
 }

package/tsconfig.dist.json

@@ -5,7 +5,9 @@
   },
   "include": ["src"],
   "exclude": [
-    "**/dist/*",
+    "jest.config.js",
+    "jest.setup.ts",
+    "**/dist/**/*",
     "**/*.test.ts",
     "**/__tests__/**/*.ts",
     "**/__mocks__/**/*.ts"