@prismatic-io/prism 3.3.0 → 4.2.0

package/lib/utils/integration/definition.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponentTestHarnessIntegration = exports.defaultDefinition = exports.buildStep = exports.buildConnectionConfigVar = exports.componentTestIntegrationName = void 0;
+const serialize_1 = require("../serialize");
+const lodash_1 = require("lodash");
+const export_1 = require("./export");
+const componentTestIntegrationName = (componentKey, name) => `Component Test Harness - ${componentKey} - ${name}`;
+exports.componentTestIntegrationName = componentTestIntegrationName;
+const buildConnectionConfigVar = ({ key: componentKey, isPublic }, { key, values }) => {
+    return {
+        key: "testConnection",
+        description: "Test Connection",
+        dataType: "connection",
+        connection: {
+            component: {
+                key: componentKey,
+                isPublic,
+                version: "LATEST",
+            },
+            key,
+        },
+        inputs: values,
+    };
+};
+exports.buildConnectionConfigVar = buildConnectionConfigVar;
+const buildStep = ({ key: componentKey, isPublic }, { key, values }) => {
+    return {
+        name: "Test Step",
+        action: {
+            component: {
+                key: componentKey,
+                isPublic,
+                version: "LATEST",
+            },
+            key,
+        },
+        inputs: values,
+    };
+};
+exports.buildStep = buildStep;
+const defaultDefinition = ({ integrationInfo: { name: integrationName }, componentInfo, actionInfo, connectionInfo, }) => {
+    const requiredConfigVars = connectionInfo
+        ? [(0, exports.buildConnectionConfigVar)(componentInfo, connectionInfo)]
+        : [];
+    const { key: componentKey } = componentInfo;
+    const definition = {
+        definitionVersion: 6,
+        name: integrationName,
+        description: `Test Harness for the ${componentKey} Component`,
+        category: "Component Development",
+        requiredConfigVars,
+        flows: [
+            {
+                name: "Flow 1",
+                steps: [
+                    {
+                        name: "Trigger",
+                        isTrigger: true,
+                        action: {
+                            component: {
+                                key: "webhook-triggers",
+                                isPublic: true,
+                                version: "LATEST",
+                            },
+                            key: "webhook",
+                        },
+                    },
+                    (0, exports.buildStep)(componentInfo, actionInfo),
+                ],
+            },
+        ],
+    };
+    return definition;
+};
+exports.defaultDefinition = defaultDefinition;
+const buildComponentTestHarnessIntegration = async (info) => {
+    var _a, _b;
+    const { integrationInfo: { id: integrationId }, componentInfo, actionInfo, connectionInfo, } = info;
+    const definition = integrationId
+        ? await (0, export_1.exportDefinition)({ integrationId })
+        : (0, exports.defaultDefinition)(info);
+    // Update "current definition" accordingly.
+    if (connectionInfo) {
+        const connection = (0, exports.buildConnectionConfigVar)(componentInfo, connectionInfo);
+        const existingConnection = (_b = (_a = definition.requiredConfigVars) === null || _a === void 0 ? void 0 : _a.filter(({ key }) => key === "testConnection")) === null || _b === void 0 ? void 0 : _b[0];
+        if (existingConnection) {
+            (0, lodash_1.merge)(existingConnection, connection);
+        }
+        else if (definition.requiredConfigVars) {
+            definition.requiredConfigVars.push(connection);
+        }
+        else {
+            definition.requiredConfigVars = [connection];
+        }
+    }
+    const step = (0, exports.buildStep)(componentInfo, actionInfo);
+    const existingStep = definition.flows[0].steps.filter(({ name }) => name === "Test Step")[0];
+    (0, lodash_1.merge)(existingStep, step);
+    return (0, serialize_1.dumpYaml)(definition);
+};
+exports.buildComponentTestHarnessIntegration = buildComponentTestHarnessIntegration;

package/lib/utils/integration/export.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportDefinition = exports.INTEGRATION_DEFINITION_VERSION = void 0;
+const graphql_1 = require("../../graphql");
+const serialize_1 = require("../serialize");
+/** The version of the Integration definition to request.
+ *  It's important to request a version that corresponds with the
+ *  feature set in this version.
+ */
+exports.INTEGRATION_DEFINITION_VERSION = 6;
+const exportDefinition = async ({ integrationId, latestComponents = false, definitionVersion = exports.INTEGRATION_DEFINITION_VERSION, }) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query export(
+        $id: ID!
+        $version: Int!
+        $useLatestComponentVersions: Boolean!
+      ) {
+        integration(id: $id) {
+          definition(
+            version: $version
+            useLatestComponentVersions: $useLatestComponentVersions
+          )
+        }
+      }
+    `,
+        variables: {
+            id: integrationId,
+            version: definitionVersion,
+            useLatestComponentVersions: latestComponents,
+        },
+    });
+    const definition = result.integration.definition;
+    return (0, serialize_1.loadYaml)(definition);
+};
+exports.exportDefinition = exportDefinition;

package/lib/utils/integration/import.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDefinition = void 0;
+const graphql_1 = require("../../graphql");
+const importDefinition = async (definition, integrationId) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation importIntegration($definition: String!, $integrationId: ID) {
+        importIntegration(
+          input: { definition: $definition, integrationId: $integrationId }
+        ) {
+          integration {
+            id
+            flows {
+              nodes {
+                id
+                name
+              }
+            }
+            testConfigVariables(status: "pending") {
+              nodes {
+                id
+                authorizeUrl
+              }
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: {
+            definition,
+            integrationId,
+        },
+    });
+    const integration = result.importIntegration.integration;
+    return {
+        integrationId: integration.id,
+        flows: integration.flows.nodes,
+        pendingAuthorizations: integration.testConfigVariables.nodes.map(({ id, authorizeUrl: url }) => ({ id, url })),
+    };
+};
+exports.importDefinition = importDefinition;

package/lib/utils/integration/invoke.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIntegrationFlow = exports.getIntegrationFlow = void 0;
+const graphql_1 = require("../../graphql");
+/** Return Flow ID of given flow name on specified Integration. */
+const getIntegrationFlow = async (integrationId, flowName) => {
+    // TODO: Make flows searchable by name.
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query flowId($integrationID: ID!) {
+        integration(id: $id) {
+          flows {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `,
+        variables: { integrationID: integrationId },
+    });
+    const integration = result.integration;
+    const flows = integration.flows.nodes
+        .map(({ id, name }) => ({
+        id,
+        name: name.toLowerCase().trim(),
+    }))
+        .filter(({ name }) => name === flowName);
+    if (flows.length > 1) {
+        throw new Error(`Found more than one result for Flow name: ${flowName}`);
+    }
+    if (flows.length === 0) {
+        throw new Error(`Failed to find a Flow with the given name: ${flowName}`);
+    }
+    return flows[0].id;
+};
+exports.getIntegrationFlow = getIntegrationFlow;
+const runIntegrationFlow = async ({ integrationId, flowId, flowName, }) => {
+    const integrationFlowId = flowName
+        ? await (0, exports.getIntegrationFlow)(integrationId, flowName)
+        : flowId;
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation testIntegrationFlow($id: ID!) {
+        testIntegrationFlow(input: { id: $id }) {
+          testIntegrationFlowResult {
+            execution {
+              id
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: { id: integrationFlowId },
+    });
+    const executionId = result.testIntegrationFlow.testIntegrationFlowResult.execution.id;
+    return { executionId };
+};
+exports.runIntegrationFlow = runIntegrationFlow;

package/lib/utils/integration/query.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollForActiveConfigVarState = exports.integrationByName = void 0;
+const graphql_1 = require("../../graphql");
+const integrationByName = async (name) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query integration($name: String!) {
+        integrations(name: $name) {
+          nodes {
+            id
+          }
+        }
+      }
+    `,
+        variables: { name },
+    });
+    const [integration, ...rest] = result.integrations.nodes;
+    if (rest.length !== 0) {
+        throw new Error(`Found more than one Integration with name: ${name}`);
+    }
+    return integration;
+};
+exports.integrationByName = integrationByName;
+const pollForActiveConfigVarState = async (integrationId, configVarId) => {
+    return new Promise((resolve, reject) => {
+        const interval = setInterval(async () => {
+            try {
+                const result = await (0, graphql_1.gqlRequest)({
+                    document: (0, graphql_1.gql) `
+            query state($integrationId: ID!) {
+              integration(id: $integrationId) {
+                testConfigVariables(status_In: ["pending", "active", "error"]) {
+                  nodes {
+                    id
+                    status
+                  }
+                }
+              }
+            }
+          `,
+                    variables: { integrationId },
+                });
+                const testConfigVariables = result.integration.testConfigVariables.nodes;
+                const [{ status: serverStatus }] = testConfigVariables.filter(({ id }) => id === configVarId);
+                const status = serverStatus.toLowerCase();
+                if (status !== "pending") {
+                    clearInterval(interval);
+                    resolve(status === "active");
+                }
+            }
+            catch (error) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 5000);
+    });
+};
+exports.pollForActiveConfigVarState = pollForActiveConfigVarState;

package/lib/utils/serialize.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadYaml = exports.dumpYaml = void 0;
+const js_yaml_1 = require("js-yaml");
+const dumpYaml = (value, extraOptions) => (0, js_yaml_1.dump)(value, { ...extraOptions, noRefs: true });
+exports.dumpYaml = dumpYaml;
+const loadYaml = (value, extraOptions) => (0, js_yaml_1.load)(value, { ...extraOptions });
+exports.loadYaml = loadYaml;

package/lib/utils/user/query.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoAmI = void 0;
+const graphql_1 = require("../../graphql");
+const whoAmI = async () => {
+    const { authenticatedUser } = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query whoami {
+        authenticatedUser {
+          name
+          email
+          org {
+            name
+          }
+          customer {
+            name
+          }
+        }
+      }
+    `,
+    });
+    return authenticatedUser;
+};
+exports.whoAmI = whoAmI;

package/lib/yeoman.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenerator = void 0;
+const yeoman_environment_1 = __importDefault(require("yeoman-environment"));
+// TODO: Derive this from the generator package
+const generatorTypes = [
+    "component",
+    "action",
+    "trigger",
+    "connection",
+    "formats",
+];
+const runGenerator = async (generatorName, options) => {
+    if (!generatorTypes.includes(generatorName)) {
+        throw new Error(`Invalid generator type specified: ${generatorName}`);
+    }
+    const env = yeoman_environment_1.default.createEnv();
+    env.register(require.resolve(`@prismatic-io/generator-spectral/generators/${generatorName}`), generatorName);
+    await env.run(generatorName, options);
+};
+exports.runGenerator = runGenerator;