@jupiterone/integration-sdk-cli 12.8.1 → 13.0.0

package/dist/src/bocchi/templates/top-level/README.md.hbs

@@ -0,0 +1,114 @@
+# JupiterOne Integration
+
+Learn about the data ingested, benefits of this integration, and how to use it
+with JupiterOne in the [integration documentation](docs/jupiterone.md).
+
+## Development
+
+### Prerequisites
+
+1. Install [Node.js](https://nodejs.org/) using the
+   [installer](https://nodejs.org/en/download/) or a version manager such as
+   [nvm](https://github.com/nvm-sh/nvm) or [fnm](https://github.com/Schniz/fnm).
+2. Install [`yarn`](https://yarnpkg.com/getting-started/install) or
+   [`npm`](https://github.com/npm/cli#installation) to install dependencies.
+3. Install dependencies with `yarn install`.
+4. Register an account in the system this integration targets for ingestion and
+   obtain API credentials.
+5. `cp .env.example .env` and add necessary values for runtime configuration.
+
+   When an integration executes, it needs API credentials and any other
+   configuration parameters necessary for its work (provider API credentials,
+   data ingestion parameters, etc.). The names of these parameters are defined
+   by the `IntegrationInstanceConfigFieldMap`in `src/config.ts`. When the
+   integration is executed outside the JupiterOne managed environment (local
+   development or on-prem), values for these parameters are read from Node's
+   `process.env` by converting config field names to constant case. For example,
+   `clientId` is read from `process.env.CLIENT_ID`.
+
+   The `.env` file is loaded into `process.env` before the integration code is
+   executed. This file is not required should you configure the environment
+   another way. `.gitignore` is configured to avoid committing the `.env` file.
+
+### Running the integration
+
+#### Running directly
+
+1. `yarn start` to collect data
+2. `yarn graph` to show a visualization of the collected data
+3. `yarn j1-integration -h` for additional commands
+
+#### Running with Docker
+
+Create an integration instance for the integration in JupiterOne. With an
+**JupiterOne API Key** scoped to the integration or an API Key with permissions
+to synchronize data and the **Integration Instance ID**:
+
+1. `docker build -t $IMAGE_NAME .`
+2. `docker run -e "JUPITERONE_API_KEY=<JUPITERONE_API_KEY>" -e "JUPITERONE_ACCOUNT=<JUPITERONE_ACCOUNT> -e "INTEGRATION_INSTANCE_ID=<INTEGRATION_INSTANCE_ID>" "JUPITERONE_API_BASE_URL=<JUPITERONE_API_BASE_URL>" $IMAGE_NAME`
+
+### Making Contributions
+
+Start by taking a look at the source code. The integration is basically a set of
+functions called steps, each of which ingests a collection of resources and
+relationships. The goal is to limit each step to as few resource types as
+possible so that should the ingestion of one type of data fail, it does not
+necessarily prevent the ingestion of other, unrelated data. That should be
+enough information to allow you to get started coding!
+
+See the
+[SDK development documentation](https://github.com/JupiterOne/sdk/blob/main/docs/integrations/development.md)
+for a deep dive into the mechanics of how integrations work.
+
+See [docs/development.md](docs/development.md) for any additional details about
+developing this integration.
+
+## Testing the integration
+
+Ideally, all major calls to the API and converter functions would be tested. You
+can run the tests with `yarn test`, and you can run the tests as they execute in
+the CI/CD environment with `yarn test:ci` (adds linting and type-checking to
+`yarn test`). If you have a valid runtime configuration, you can run the tests
+with your credentials using `yarn test:env`.
+
+For more details on setting up tests, and specifically on using recordings to
+simulate API responses, see `test/README.md`.
+
+### Changelog
+
+The history of this integration's development can be viewed at
+[CHANGELOG.md](CHANGELOG.md).
+
+## Versioning this project
+
+This project is versioned using [auto](https://intuit.github.io/auto/).
+
+Versioning and publishing to NPM are now handled via adding GitHub labels to
+pull requests. The following labels should be used for this process:
+
+- patch
+- minor
+- major
+- release
+
+For each pull request, the degree of change should be registered by applying the
+appropriate label of patch, minor, or major. This allows the repository to keep
+track of the highest degree of change since the last release. When ready to
+publish to NPM, the PR should have both its appropriate patch, minor, or major
+label applied as well as a release label. The release label will denote to the
+system that we need to publish to NPM and will correctly version based on the
+highest degree of change since the last release, package the project, and
+publish it to NPM.
+
+In order to successfully version and publish to NPM we need access to two
+secrets: a valid NPM token for publishing and a GitHub token for querying the
+repo and pushing version changes. For JupiterOne projects please put in a ticket
+with security to have the repository correctly granted access. For external
+projects, please provide secrets with access to your own NPM and GitHub
+accounts. The secret names should be set to NPM_AUTH_TOKEN and
+AUTO_GITHUB_PAT_TOKEN respectively (or the action can be updated to accommodate
+different naming conventions).
+
+We are not currently using the functionality for auto to update the CHANGELOG.
+As such, please remember to update CHANGELOG.md with the appropriate version,
+date, and changes.

package/dist/src/bocchi/templates/top-level/docs/development.md.hbs

@@ -0,0 +1,28 @@
+# Development
+
+Add details here to give a brief overview of how to work with the provider APIs.
+Please reference any SDKs or API docs used to help build the integration here.
+
+## Prerequisites
+
+Supply details about software or tooling (like maybe Docker or Terraform) that
+is needed for development here.
+
+Please supply references to documentation that details how to install those
+dependencies here.
+
+Tools like Node.js and NPM are already covered in the [README](../README.md) so
+don't bother documenting that here.
+
+## Provider account setup
+
+Please provide information about the steps needed to create an account with a
+provider. Images and references to a provider's documentation is very helpful
+for new developers picking up your work.
+
+## Authentication
+
+Supply details here for information on how to authenticate with a provider so
+that developers have an idea of what's needed to hit APIs. It may be useful to
+provide explanations for each value specified in the
+[`IntegrationInstanceConfigFieldMap`](../src/config.ts).

package/dist/src/bocchi/templates/top-level/docs/jupiterone.md.hbs

@@ -0,0 +1 @@
+# {{titleCase vendorName}}

package/dist/src/bocchi/templates/top-level/docs/spec/index.ts.hbs

@@ -0,0 +1,14 @@
+import { IntegrationSpecConfig } from '@jupiterone/integration-sdk-core';
+import { IntegrationConfig } from '../../src/config';
+{{#each template.steps}}
+import { {{camelCase entity.name}}Spec } from './{{kebabCase id}}';
+{{/each}}
+
+export const invocationConfig: IntegrationSpecConfig<IntegrationConfig> =
+  {
+    integrationSteps: [
+    {{#each template.steps}}
+      ...{{camelCase entity.name}}Spec,
+    {{/each}}
+    ],
+  };

package/dist/src/bocchi/templates/top-level/husky.config.js.hbs

@@ -0,0 +1 @@
+module.exports = require('@jupiterone/integration-sdk-dev-tools/config/husky');

package/dist/src/bocchi/templates/top-level/jest.config.js.hbs

@@ -0,0 +1 @@
+module.exports = require('@jupiterone/integration-sdk-dev-tools/config/jest');

package/dist/src/bocchi/templates/top-level/jupiterone/questions/questions.yaml.hbs

@@ -0,0 +1,16 @@
+---
+sourceId: managed:{{kebabCase vendorName}}
+integrationDefinitionId: '${integration_definition_id}'
+questions:
+  []
+  # - id: integration-question-template-replace-me
+  #   title: What kinds of questions will this integration support?
+  #   description:
+  #     TODO Every integration should contribute questions! Please be careful
+  #     to replace this before deploying the integration to JupiterOne.
+  #   queries:
+  #     - name: good
+  #       query: |
+  #         find * with _integrationDefinitionId = '${integration_definition_id}'
+  #   tags:
+  #     - template

package/dist/src/bocchi/templates/top-level/lint-staged.config.js.hbs

@@ -0,0 +1 @@
+module.exports = require('@jupiterone/integration-sdk-dev-tools/config/lint-staged');

package/dist/src/bocchi/templates/top-level/package.json.hbs

@@ -0,0 +1,49 @@
+{
+  "name": "{{packageName}}",
+  "version": "0.0.1",
+  "description": "{{packageDescription}}",
+  "license": "MPL-2.0",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "src",
+    "jupiterone"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0 <20.x"
+  },
+  "scripts": {
+    "start": "j1-integration collect",
+    "graph": "j1-integration visualize",
+    "graph:types": "j1-integration visualize-types",
+    "graph:spec": "j1-integration visualize-types --project-path docs/spec --output-file ./.j1-integration/types-graph/index.spec.html",
+    "graph:dependencies": "j1-integration visualize-dependencies",
+    "validate:questions:dry": "j1-integration validate-question-file --dry-run",
+    "validate:questions": "j1-integration validate-question-file -a $MANAGED_QUESTIONS_JUPITERONE_ACCOUNT_ID -k $MANAGED_QUESTIONS_JUPITERONE_API_KEY",
+    "lint": "eslint . --cache --fix --ext .ts,.tsx",
+    "format": "prettier --write \"**/*.{ts,js,json,css,md,yml}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,css,md,yml}\"",
+    "type-check": "tsc",
+    "test": "jest",
+    "test:env": "LOAD_ENV=1 yarn test",
+    "test:ci": "yarn format:check && yarn lint && yarn type-check && yarn test",
+    "build": "tsc -p tsconfig.dist.json --declaration && cp README.md dist/README.md && cp -r jupiterone/ dist/jupiterone/",
+    "build:docker": "tsc --declaration false --emitDeclarationOnly false -p tsconfig.dist.json",
+    "prepush": "yarn format:check && yarn lint && yarn type-check && jest --changedSince main",
+    "postversion": "cp package.json ./dist/package.json"
+  },
+  "dependencies": {
+    "@jupiterone/integration-sdk-http-client": "^12.7.0"
+  },
+  "peerDependencies": {
+    "@jupiterone/integration-sdk-core": "^12.7.0"
+  },
+  "devDependencies": {
+    "@jupiterone/integration-sdk-core": "^12.7.0",
+    "@jupiterone/integration-sdk-dev-tools": "^12.7.0",
+    "@jupiterone/integration-sdk-testing": "^12.7.0"
+  }
+}

package/dist/src/bocchi/templates/top-level/prettier.config.js.hbs

@@ -0,0 +1 @@
+module.exports = require('@jupiterone/integration-sdk-dev-tools/config/prettier');

package/dist/src/bocchi/templates/top-level/src/client.ts.hbs

@@ -0,0 +1,116 @@
+import { BaseAPIClient } from '@jupiterone/integration-sdk-http-client';
+import { IntegrationConfig } from './config';
+import { 
+{{#each template.steps}}
+  {{pascalCase entity.name}}, 
+{{/each}}
+} from './steps/types';
+import { Entity, IntegrationLogger } from '@jupiterone/integration-sdk-core';
+
+export type ResourceIteratee<T> = (each: T) => Promise<void> | void;
+
+export class APIClient extends BaseAPIClient {
+  private authHeaders: Record<string, string>;
+
+  constructor(readonly config: IntegrationConfig, logger: IntegrationLogger) {
+    super({
+      baseUrl: '{{template.baseUrl}}',
+      logger,
+      {{#if template.tokenBucket}}
+      tokenBucket: {
+        maximumCapacity: {{template.tokenBucket.maximumCapacity}},
+        refillRate: {{template.tokenBucket.refillRate}}
+      }
+      {{/if}}
+    });
+  }
+
+  {{#if (isNotEndpointAuth template.authentication.strategy)}}
+  protected getAuthorizationHeaders(): Record<string, string> {
+    return { {{#each (sanitizeAuthObject template.authentication.authHeaders)}}'{{@key}}': `{{this}}`,{{/each}} };
+  }  
+  {{else}}
+  protected async getAuthorizationHeaders(): Promise<Record<string, string>> {
+    const response = await (await this.retryableRequest(
+      `${this.baseUrl}{{template.authentication.params.path}}`,
+      {
+        authorize: false, // needed only for authentication call
+        headers: { {{#each (sanitizeAuthObject template.authentication.params.headers)}}'{{@key}}': `{{this}}`,{{/each}} },
+        method: '{{sanitizeHttpMethod template.authentication.params.method}}',
+      {{#if request.params}}
+        body: { {{#each (sanitizeAuthObject template.authentication.params.body)}}{{@key}}: {{this}},{{/each}} }
+      {{/if}}
+      }
+    )).json();
+    return { {{#each (sanitizeAuthObject template.authentication.authHeaders)}}'{{@key}}': `{{this}}`,{{/each}} }
+  }
+  {{/if}}
+
+  public async verifyAuthentication(): Promise<void> {
+    {{#if (isNotEndpointAuth template.authentication.strategy)}}
+    // TODO: implement
+    await new Promise(() => { throw new Error('Unimplemented: Pick an API call to use for validation!') });
+    {{else}}
+    await this.getAuthorizationHeaders();
+    {{/if}}
+  }
+{{#each template.steps}}
+
+  {{#if (isSingletonRequest response.responseType)}}
+  public async get{{pascalCase entity.name}}({{#if parentAssociation}}parentEntity: Entity{{/if}}): Promise<{{pascalCase entity.name}}> {
+    const url = `${this.baseUrl}{{{sanitizeUrlPath request.urlTemplate}}}`;
+    const response = await (await this.retryableRequest(
+      url,
+      {
+        method: '{{sanitizeHttpMethod request.method}}',
+      {{#if request.params}}
+        body: { {{#each (sanitizeHttpBody request.params)}}'{{@key}}': `{{this}}`,{{/each}} }
+      {{/if}}
+      }
+    )).json();
+    return response.{{response.dataPath}} as {{pascalCase entity.name}};
+  }
+  {{else}}
+  public async iterate{{pascalCase entity.name}}s(
+    {{#if parentAssociation}}
+    parentEntity: Entity,
+    {{/if}}
+    iteratee: ResourceIteratee<{{pascalCase entity.name}}>
+  ): Promise<void> {
+    {{#if response.nextTokenPath}}
+    let nextToken: string | undefined;
+    do {
+    {{/if}}
+      const url = `${this.baseUrl}{{{sanitizeUrlPath request.urlTemplate}}}`;
+      const response = await (await this.retryableRequest(
+        url,
+        {
+          method: '{{sanitizeHttpMethod request.method}}',
+        {{#if request.params}}
+          body: { {{#each (sanitizeHttpBody request.params)}}'{{@key}}': `{{this}}`,{{/each}} }
+        {{/if}}
+        }
+      )).json();
+      const resources = response.{{response.dataPath}} as {{pascalCase entity.name}}[];
+      for (const resource of resources) {
+        await iteratee(resource);
+      }
+    {{#if response.nextTokenPath}}
+      nextToken = response.{{response.nextTokenPath}};
+    } while (nextToken);
+    {{/if}}
+  }
+  {{/if}}
+{{/each}}
+}
+
+let client: APIClient | undefined;
+
+export function createAPIClient(
+  config: IntegrationConfig,
+  logger: IntegrationLogger
+): APIClient {
+  return client
+    ? client
+    : new APIClient(config, logger);
+}

package/dist/src/bocchi/templates/top-level/src/config.ts.hbs

@@ -0,0 +1,41 @@
+{{#with template}}
+import {
+  IntegrationExecutionContext,
+  IntegrationValidationError,
+  IntegrationInstanceConfigFieldMap,
+} from '@jupiterone/integration-sdk-core';
+import { createAPIClient } from './client';
+
+export const instanceConfigFields = {
+{{#each instanceConfigFields}}
+    {{@key}}: {
+      {{#if type}}type: '{{type}}',{{/if}}
+      {{#if mask}}mask: {{mask}},{{/if}}
+      {{#if optional}}optional: {{optional}},{{/if}}
+    },
+{{/each}}
+} satisfies IntegrationInstanceConfigFieldMap;
+
+export interface IntegrationConfig {
+{{#each instanceConfigFields}}
+  {{@key}}: {{configTypeToType type}};
+{{/each}}
+}
+
+export async function validateInvocation(
+  context: IntegrationExecutionContext<IntegrationConfig>,
+) {
+  const { config } = context.instance;
+
+  {{#with (requiredConfig instanceConfigFields)}}
+  {{#if this.length}}
+  if ({{#each this}}!config.{{this}}{{#unless @last}} || {{/unless}}{{/each}}) {
+    throw new IntegrationValidationError('Config requires all of{{#each this}} {{this}}{{/each}}');
+  }
+  {{/if}}
+  {{/with}}
+
+  const apiClient = createAPIClient(config);
+  await apiClient.verifyAuthentication();
+}
+{{/with}}

package/dist/src/bocchi/templates/top-level/src/index.test.ts.hbs

@@ -0,0 +1,6 @@
+import { invocationConfig as implementedConfig } from '.';
+import { invocationConfig as specConfig } from '../docs/spec';
+
+test('implemented integration should match spec', () => {
+  expect(implementedConfig).toImplementSpec(specConfig, { requireSpec: true });
+});

package/dist/src/bocchi/templates/top-level/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/dist/src/bocchi/templates/top-level/src/steps/constants.ts.hbs

@@ -0,0 +1,60 @@
+{{#with template}}
+import {
+  RelationshipClass,
+  StepEntityMetadata,
+  StepRelationshipMetadata,
+} from '@jupiterone/integration-sdk-core';
+
+export const Steps = {
+{{#each steps}}
+  {{constantCase id}}: '{{id}}',
+  {{#if directRelationships}}
+    {{#with (getDirectRelationships this)}}
+      {{#each this}}
+  BUILD_{{constantCase sourceStep.entity.name}}_{{constantCase targetStep.entity.name}}_RELATIONSHIPS: 'build-{{kebabCase sourceStep.entity.name}}-{{kebabCase targetStep.entity.name}}-relationships',
+      {{/each}}
+    {{/with}}
+  {{/if}}
+  {{#if mappedRelationships}}
+  BUILD_{{constantCase entity.name}}_MAPPED_RELATIONSHIPS: 'build-{{kebabCase entity.name}}-mapped-relationships',
+  {{/if}}
+{{/each}}
+} satisfies Record<string, string>;
+
+export const Entities = {
+{{#each steps}}
+  {{#with entity}}
+  {{constantCase name}}: {
+    resourceName: '{{name}}',
+    _type: '{{_type}}',
+    _class: ['{{_class}}'],
+  },
+  {{/with}}
+{{/each}}
+} satisfies Record<string, StepEntityMetadata>;
+
+export const Relationships = {
+{{#each steps}}
+  {{#if parentAssociation}}
+    {{#with (getStepByType parentAssociation.parentEntityType)}}{{constantCase entity.name}}{{/with}}_{{constantCase parentAssociation.relationshipClass}}_{{constantCase entity.name}}: {
+      sourceType: Entities.{{#with (getStepByType parentAssociation.parentEntityType)}}{{constantCase entity.name}}{{/with}}._type,
+      _class: RelationshipClass.{{constantCase parentAssociation.relationshipClass}},
+      targetType: Entities.{{constantCase entity.name}}._type,
+      _type: '{{getRelationshipType parentAssociation.relationshipClass parentAssociation.parentEntityType entity._type}}',
+    },
+  {{/if}}
+  {{#if directRelationships}}
+    {{#with (getDirectRelationships this)}}
+      {{#each this}}
+  {{constantCase sourceStep.entity.name}}_{{constantCase relationshipClass}}_{{constantCase targetStep.entity.name}}: {
+    sourceType: Entities.{{constantCase sourceStep.entity.name}}._type,
+    _class: RelationshipClass.{{constantCase relationshipClass}},
+    targetType: Entities.{{constantCase targetStep.entity.name}}._type,
+    _type: '{{getRelationshipType relationshipClass sourceStep.entity._type targetStep.entity._type}}',
+  },
+      {{/each}}
+    {{/with}}
+  {{/if}}
+{{/each}}
+} satisfies Record<string, StepRelationshipMetadata>;
+{{/with}}

package/dist/src/bocchi/templates/top-level/src/steps/converters.ts.hbs

@@ -0,0 +1,37 @@
+{{#with template}}
+import { createIntegrationEntity } from '@jupiterone/integration-sdk-core';
+import { Entities } from './constants';
+import { 
+{{#each steps}}
+  {{pascalCase entity.name}}, 
+{{/each}}
+} from './types';
+
+{{#each steps}}
+    {{#with entity}}
+export function create{{pascalCase name}}Entity(data: {{pascalCase name}}) {
+  return createIntegrationEntity({
+    entityData: {
+      source: data,
+      assign: {
+        _key: data.{{_keyPath}},
+        _type: Entities.{{constantCase name}}._type,
+        _class: Entities.{{constantCase name}}._class,
+        {{#if staticFields}}
+          {{#each staticFields}}
+        {{@key}}: {{{escape this}}},
+          {{/each}}
+        {{/if}}
+        {{#if fieldMappings}}
+          {{#each fieldMappings}}
+        {{@key}}: data.{{this}},
+          {{/each}}
+        {{/if}}
+      },
+    },
+  });
+}
+  {{/with}}
+
+{{/each}}
+{{/with}}

package/dist/src/bocchi/templates/top-level/src/steps/index.ts.hbs

@@ -0,0 +1,13 @@
+{{#with template}}
+{{#each steps}}
+import { {{camelCase entity.name}}Steps } from './{{id}}';
+{{/each}}
+
+const integrationSteps = [
+{{#each steps}}
+  ...{{camelCase entity.name}}Steps,
+{{/each}}
+];
+
+export { integrationSteps };
+{{/with}}

package/dist/src/bocchi/templates/top-level/src/steps/types.ts.hbs

@@ -0,0 +1,6 @@
+{{#with template}}
+{{#each steps}}
+export type {{pascalCase entity.name}} = any;
+
+{{/each}}
+{{/with}}

package/dist/src/bocchi/templates/top-level/test/README.md.hbs

@@ -0,0 +1,5 @@
+# Testing Integrations
+
+For information on testing integrations see: 
+
+[Testing Integrations](https://github.com/JupiterOne/sdk/blob/main/docs/integrations/testing.md)

package/dist/src/bocchi/templates/top-level/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 template.instanceConfigFields}}
+const DEFAULT_{{constantCase @key}} = '';
+{{/each}}
+
+export const integrationConfig: IntegrationConfig = {
+  {{#each template.instanceConfigFields}}
+  {{camelCase @key}}: process.env.{{constantCase @key}} ?? DEFAULT_{{constantCase @key}},
+  {{/each}}
+};
+
+export function buildStepTestConfigForStep(stepId: string): StepTestConfig {
+  return {
+    stepId,
+    instanceConfig: integrationConfig,
+    invocationConfig: invocationConfig as IntegrationInvocationConfig,
+  };
+}

package/dist/src/bocchi/templates/top-level/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/dist/src/bocchi/templates/top-level/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"
+  ]
+}