@unito/integration-cli 0.55.1

package/dist/integrationGenerator/test/resources/integration.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai_1 = require("chai");
+const path = tslib_1.__importStar(require("path"));
+const sinon = tslib_1.__importStar(require("sinon"));
+const tmp_1 = tslib_1.__importDefault(require("tmp"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const Integration = tslib_1.__importStar(require("../../src/resources/integration"));
+describe('Integration Resource Generation', () => {
+    let tempDir;
+    const boilerplatePath = path.join(__dirname, '../../integrationBoilerplate');
+    afterEach(() => {
+        sinon.restore();
+    });
+    describe('generateIntegrationSkeleton', () => {
+        beforeEach(() => {
+            tempDir = tmp_1.default.dirSync({ prefix: 'outputIntegrations-' }).name;
+        });
+        afterEach(async () => {
+            await fs_1.default.promises.rm(tempDir, { recursive: true });
+            sinon.restore();
+        });
+        it('should not create a new integration directory if it already exists', async () => {
+            const existingIntegrationName = 'existingIntegration';
+            await Integration.generateIntegrationSkeleton(existingIntegrationName, tempDir);
+            try {
+                await Integration.generateIntegrationSkeleton(existingIntegrationName, tempDir);
+            }
+            catch (e) {
+                (0, chai_1.expect)(e).to.eql(new Error(`Integration already exists with this name: ${existingIntegrationName}`));
+            }
+        });
+        it('should create a new integration directory if it does not exist', async () => {
+            const integrationName = 'NewIntegration';
+            const result = await Integration.generateIntegrationSkeleton(integrationName, tempDir);
+            (0, chai_1.expect)(result).equal(path.join(tempDir, integrationName.toLowerCase()));
+            (0, chai_1.expect)(fs_1.default.existsSync(result)).to.be.true;
+            const expectedFiles = await fs_1.default.promises.readdir(boilerplatePath);
+            expectedFiles.push('.npmrc');
+            const createdFiles = await fs_1.default.promises.readdir(result);
+            (0, chai_1.expect)(createdFiles).to.deep.eq(expectedFiles.sort());
+            createdFiles.forEach(createdField => (0, chai_1.expect)(expectedFiles.includes(createdField)));
+        });
+        it('generates an .npmrc file', async () => {
+            const result = await Integration.generateIntegrationSkeleton('foo', tempDir);
+            const npmrc = await fs_1.default.promises.readFile(`${result}/.npmrc`, 'utf-8');
+            (0, chai_1.expect)(npmrc).to.include('//npm.pkg.github.com/:_authToken=${UNITO_GITHUB_PKG_TOKEN}');
+        });
+    });
+});

package/dist/schemas/authorization.json

@@ -0,0 +1,204 @@
+{
+  "$id": "https://unito.io/integration_cli/authorization.schema.json",
+  "title": "Authorization",
+  "type": "object",
+  "description": "An authorization is a way to obtain and generate credentials for an integration",
+  "additionalProperties": false,
+  "required": ["name", "method"],
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "development": {
+      "type": "boolean",
+      "description": "Whether the authorization is used locally for development purposes only"
+    },
+    "instructionsImage": {
+      "description": "The Base64-encoded data URL of an <img> src content or null. For example: 'data:image/png;base64,<base64>'",
+      "anyOf": [{ "type": "null" }, { "type": "string" }]
+    },
+    "instructionsMarkdown": {
+      "description": "A string representing a markdown document or null",
+      "anyOf": [{ "type": "null" }, { "type": "string" }]
+    },
+    "method": {
+      "type": "string",
+      "description": "The method of authorization",
+      "enum": ["custom", "oauth2"],
+      "tsEnumNames": ["CUSTOM", "OAUTH2"]
+    },
+    "oauth2": {
+      "$ref": "#/$defs/oauth2"
+    },
+    "variables": {
+      "type": "object",
+      "description": "Variables to obtain credentials from an end-user",
+      "additionalProperties": false,
+      "patternProperties": {
+        "^(?!refreshToken$)(?!accessToken$)(?!scope$)(?!expiresIn$)(?!tokenType$)(?!oauth2ExtraParameters$).*$": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["type"],
+          "properties": {
+            "type": {
+              "type": "string",
+              "enum": ["boolean", "number", "password", "string", "text"],
+              "tsEnumNames": ["BOOLEAN", "NUMBER", "PASSWORD", "STRING", "TEXT"]
+            },
+            "format": {
+              "type": "string",
+              "description": "The JSON Schema format that the value of the variable must comply to",
+              "enum": ["email", "uri"],
+              "tsEnumNames": ["EMAIL", "URI"]
+            },
+            "pattern": {
+              "description": "The JSON Schema regular expression template for the string value. Only the values that match this template will be accepted. The regular expression syntax used is from JavaScript (more specifically, ECMA 262)",
+              "type": "string"
+            },
+            "label": {
+              "type": "string"
+            },
+            "required": {
+              "type": "boolean"
+            },
+            "defaultValue": {
+              "oneOf": [
+                { "type": "string" },
+                { "type": "number" },
+                { "type": "boolean" }
+              ]
+            },
+            "placeholder": {
+              "type": "string"
+            },
+            "help": {
+              "type": "string"
+            },
+            "documentationUrl": {
+              "type": "string",
+              "format": "uri"
+            }
+          }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "authorizationResponseContentType": {
+      "type": "string",
+      "description": "The content type of exchanged information with the provider",
+      "enum": ["application/x-www-form-urlencoded", "application/json"],
+      "tsEnumNames": ["URL_ENCODED", "JSON"]
+    },
+    "authorizationRequestParameters": {
+      "type": "object",
+      "description": "The extra information used to communicate with the provider",
+      "additionalProperties": false,
+      "properties": {
+        "header": {
+          "type": "object",
+          "description": "Extra information to include in the HTTP request headers",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "description": "A string",
+                "type": "string"
+              },
+              {
+                "description": "A number",
+                "type": "number"
+              },
+              {
+                "description": "A boolean",
+                "type": "boolean"
+              }
+            ]
+          }
+        },
+        "body": {
+          "type": "object",
+          "description": "Extra information to include in the HTTP request body",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "description": "A string",
+                "type": "string"
+              },
+              {
+                "description": "A number",
+                "type": "number"
+              },
+              {
+                "description": "A boolean",
+                "type": "boolean"
+              }
+            ]
+          }
+        }
+      }
+    },
+    "oauth2": {
+      "type": "object",
+      "description": "Parameters to obtain OAuth 2 credentials from an end-user",
+      "additionalProperties": false,
+      "required": ["tokenUrl", "scopes"],
+      "properties": {
+        "clientSecret": {
+          "type": "string",
+          "description": "The Client Secret obtained from the provider."
+        },
+        "clientId": {
+          "type": "string",
+          "description": "The Client Id obtained from the provider."
+        },
+        "authorizationUrl": {
+          "type": "string",
+          "description": "The URL to grant or deny access to the user account.",
+          "format": "uri-template"
+        },
+        "tokenUrl": {
+          "type": "string",
+          "description": "The URL to obtain or refresh an access token.",
+          "format": "uri-template"
+        },
+        "grantType": {
+          "type": "string",
+          "description": "The type of grant of the OAuth 2 authorization",
+          "enum": ["authorization_code", "password"],
+          "tsEnumNames": ["AUTHORIZATION_CODE", "PASSWORD"]
+        },
+        "scopes": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "description": "The requested scope of access to the user account",
+            "additionalProperties": false,
+            "required": ["name"],
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "The name of the scope"
+              },
+              "help": {
+                "type": "string",
+                "description": "Message to the end-user to explain the usage of the scope by Unito"
+              }
+            }
+          }
+        },
+        "tokenRequestParameters": {
+          "$ref": "#/$defs/authorizationRequestParameters"
+        },
+        "refreshRequestParameters": {
+          "$ref": "#/$defs/authorizationRequestParameters"
+        },
+        "requestContentType": {
+          "$ref": "#/$defs/authorizationResponseContentType"
+        },
+        "responseContentType": {
+          "$ref": "#/$defs/authorizationResponseContentType"
+        }
+      }
+    }
+  }
+}

package/dist/schemas/automation.json

@@ -0,0 +1,81 @@
+{
+  "$id": "https://unito.io/integration_cli/automation.schema.json",
+  "title": "Automation",
+  "type": "object",
+  "description": "The configuration of the automation of an integration",
+  "additionalProperties": false,
+  "properties": {
+    "headers": {
+      "type": "object",
+      "description": "The headers to add to the request",
+      "required": ["authorizationHeaderPrefix"],
+      "properties": {
+        "authorizationHeaderPrefix": {
+          "type": "string",
+          "description": "The value of the Authorization header. e.g \"Bearer\""
+        }
+      },
+      "additionalProperties": {
+        "type": "string",
+        "description": "Custom headers values"
+      }
+    },
+    "items": {
+      "type": "object",
+      "description": "The items to generate",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "collection": {
+            "$ref": "#/$defs/endpoint"
+          },
+          "item": {
+            "$ref": "#/$defs/endpoint"
+          }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "endpoint": {
+      "type": "object",
+      "description": "The endpoint to generate",
+      "additionalProperties": false,
+      "required": ["endpointURI", "idKey"],
+      "properties": {
+        "endpointURI": {
+          "type": "string",
+          "description": "Endpoint of the resource e.g /foo/bar/resource"
+        },
+        "idKey": {
+          "type": "string",
+          "description": "Which field is the unique identifier (id) of your item"
+        },
+        "keyToResponse": {
+          "type": "string",
+          "description": "Key to Access Nested Item (if applicable) like \"data\" that will lead to the item"
+        },
+        "usedId": {
+          "type": "string",
+          "default": ""
+        },
+        "directParent": {
+          "type": "string",
+          "default": ""
+        },
+        "httpMethod": {
+          "type": "string",
+          "description": "The verb of the HTTP request",
+          "default": "GET",
+          "enum": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+          "tsEnumNames": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]
+        },
+        "body": {
+          "type": "string",
+          "default": ""
+        }
+      }
+    }
+  }
+}

package/dist/schemas/configuration.json

@@ -0,0 +1,89 @@
+{
+  "$id": "https://unito.io/integration_cli/configuration.schema.json",
+  "title": "Configuration",
+  "type": "object",
+  "description": "The configuration of an integration",
+  "additionalProperties": false,
+  "required": ["name"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z0-9_-]+$",
+      "description": "The name of the integration"
+    },
+    "baseUrl": {
+      "type": "string",
+      "description": "The base URL where the integration is located",
+      "default": ""
+    },
+    "graphRelativeUrl": {
+      "type": "string",
+      "description": "The relative URL (to the baseUrl) where the graph of items of the integration is located",
+      "default": "/"
+    },
+    "credentialAccountRelativeUrl": {
+      "type": "string",
+      "description": "The relative URL (to the baseUrl) to fetch the current integration's authenticated user",
+      "default": "/me"
+    },
+    "webhookParsingRelativeUrl": {
+      "type": ["string", "null"],
+      "description": "The relative URL (to the baseUrl) to parse a webhook payload"
+    },
+    "webhookSubscriptionsRelativeUrl": {
+      "type": ["string", "null"],
+      "description": "The relative URL (to the baseUrl) to operate on webhook subscriptions"
+    },
+    "webhookAcknowledgeRelativeUrl": {
+      "type": ["string", "null"],
+      "description": "The relative URL (to the baseUrl) to acknowledge webhook sender"
+    },
+    "ui": {
+      "type": "object",
+      "description": "The UI-related information of the integration",
+      "additionalProperties": false,
+      "properties": {
+        "displayName": {
+          "type": "string",
+          "description": "The name of the integration, as it should be displayed in a UI"
+        },
+        "logo": {
+          "type": "string",
+          "description": "Base64-encoded SVG of the logo of the integration"
+        }
+      }
+    },
+    "authorizations": {
+      "type": "array",
+      "description": "The authorizations of the integration",
+      "items": {
+        "$ref": "https://unito.io/integration_cli/authorization.schema.json"
+      }
+    },
+    "testAccounts": {
+      "type": "object",
+      "description": "The test accounts of the integration",
+      "additionalProperties": false,
+      "properties": {
+        "development": {
+          "type": "object",
+          "description": "Test account for local development",
+          "additionalProperties": true
+        },
+        "compliance": {
+          "type": "object",
+          "description": "Test account for compliance tests",
+          "additionalProperties": true
+        }
+      }
+    },
+    "secrets": {
+      "type": "object",
+      "description": "The secrets of the integration",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^unito-secret-v[0-9]+:\/\/.*$"
+      }
+    }
+  }
+}

package/dist/scripts/generateTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate the Integration CLI types
+ *
+ * Execute with:
+ *
+ *     npx ts-node scripts/generateTypes.ts
+ */
+export {};

package/dist/scripts/generateTypes.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Generate the Integration CLI types
+ *
+ * Execute with:
+ *
+ *     npx ts-node scripts/generateTypes.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+const fs = tslib_1.__importStar(require("fs"));
+async function execute() {
+    const directory = `${__dirname}/../schemas`;
+    const compiled = await (0, json_schema_to_typescript_1.compileFromFile)(`${directory}/configuration.json`, {
+        declareExternallyReferenced: true,
+        enableConstEnums: false,
+        style: {
+            bracketSpacing: true,
+            printWidth: 120,
+            semi: true,
+            singleQuote: true,
+            useTabs: false,
+            tabWidth: 2,
+            trailingComma: 'all',
+        },
+        unknownAny: true,
+        $refOptions: {
+            resolve: {
+                local: {
+                    order: 1,
+                    canRead: true,
+                    read: async function (file, _callback) {
+                        const filename = file.url.split('https://unito.io/integration_cli/').at(1)?.split('.schema.json')?.at(0);
+                        return fs.readFileSync(`${directory}/${filename}.json`, 'utf8');
+                    },
+                },
+            },
+        },
+    });
+    console.log(compiled);
+}
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+execute();

package/dist/src/baseCommand.d.ts

@@ -0,0 +1,14 @@
+import { Command, Interfaces } from '@oclif/core';
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    static enableJsonFlag: boolean;
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<any>;
+    protected finally(_: Error | undefined): Promise<any>;
+}

package/dist/src/baseCommand.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const core_1 = require("@oclif/core");
+class BaseCommand extends core_1.Command {
+    // add the --json flag
+    static enableJsonFlag = true;
+    flags;
+    args;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+    }
+    // istanbul ignore next
+    async run() {
+        // emit analytics
+        await this.config.runHook('checkConfig', { id: 'my_command' });
+    }
+    // istanbul ignore next
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async catch(err) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    // istanbul ignore next
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async finally(_) {
+        // called after execution and catching up, whether the command was wrong or not
+        return super.finally(_);
+    }
+}
+exports.BaseCommand = BaseCommand;

package/dist/src/commands/activity.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Activity extends BaseCommand<typeof Activity> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        number: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/activity.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const integrations_1 = require("../resources/integrations");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../services/integrationsPlatform"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../resources/configuration"));
+class Activity extends baseCommand_1.BaseCommand {
+    static description = 'Show the activity associated with your integration';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        number: core_1.Flags.integer({
+            char: 'n',
+            summary: 'number of events to show',
+            description: `Limit the number of events to show. Must be less than or equal to 1000. Default is 1000.
+
+      Usage: <%= config.bin %> <%= command.id %> --number=10`,
+        }),
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Activity);
+        // Read the configurations.
+        const globalConfiguration = await GlobalConfiguration.read(this.config.configDir);
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const integrationConfiguration = await IntegrationConfiguration.getConfiguration(environment);
+        // Choose the right API key for the environment.
+        let apiKey = undefined;
+        if (environment === GlobalConfiguration.Environment.Local) {
+            apiKey = globalConfiguration.apiKeyLocal;
+        }
+        else if (environment === GlobalConfiguration.Environment.Staging) {
+            apiKey = globalConfiguration.apiKeyStaging;
+        }
+        else {
+            apiKey = globalConfiguration.apiKey;
+        }
+        // Setup the platform client.
+        IntegrationsPlatform.setApiKey(apiKey);
+        IntegrationsPlatform.setEnvironment(environment);
+        core_1.ux.action.start('Finding the integration');
+        const integration = await IntegrationsPlatform.getIntegrationByName(integrationConfiguration.name);
+        if (!integration) {
+            core_1.ux.log(chalk_1.default.redBright(`Integration not found! You can only retrieve activity for existing integrations.`));
+            this.exit(-1);
+        }
+        core_1.ux.action.stop();
+        core_1.ux.action.start('Retrieving activity');
+        const events = await IntegrationsPlatform.getIntegrationEvents(integration.id);
+        core_1.ux.action.stop();
+        for (const event of events.slice(0, flags.number ?? 1000)) {
+            core_1.ux.log();
+            core_1.ux.log(chalk_1.default.bold(`  ${event.date} - ${event.title}`));
+            core_1.ux.log(`  ${event.text}`);
+            core_1.ux.log(chalk_1.default.dim(chalk_1.default.italic(`  ${event.tags.join(', ')}`)));
+        }
+    }
+}
+exports.default = Activity;

package/dist/src/commands/dev.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Dev extends BaseCommand<typeof Dev> {
+    static description: string;
+    static examples: string[];
+    catch(error: Error): Promise<void>;
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        crawlMode: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        checks: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'config-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}