@prismatic-io/prism 3.3.0 → 4.2.0

package/lib/generate/util.js

@@ -3,117 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendRequiredFields = exports.addRequiredInputs = exports.createDescription = void 0;
+exports.createDescription = void 0;
 const striptags_1 = __importDefault(require("striptags"));
-const ts_morph_1 = require("ts-morph");
-exports.createDescription = (text) => {
+const createDescription = (text) => {
     if (!text) {
         return "";
     }
-    const strippedText = striptags_1.default(text);
+    const strippedText = (0, striptags_1.default)(text);
     const [nonEmptyLine] = strippedText.split("\n").filter((t) => t.trim() != "");
     const [fragment] = nonEmptyLine.split(/[.!?]/g);
     return fragment.replace(/`/g, "'");
 };
-const addProperty = (inputsFile, inputName, propertyList) => {
-    const placeholder = inputsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        declarations: [
-            { name: "genericActionInput", initializer: ts_morph_1.Writers.object({}) },
-        ],
-    });
-    const object = placeholder.getDeclarations()[0].getInitializer();
-    object.addPropertyAssignments(propertyList);
-    inputsFile.addVariableStatement({
-        declarationKind: ts_morph_1.VariableDeclarationKind.Const,
-        isExported: true,
-        declarations: [
-            { name: inputName, initializer: `input(${object.print()})` },
-        ],
-    });
-    placeholder.remove();
-};
-exports.addRequiredInputs = (projectType, inputsFile, addRetry) => {
-    addProperty(inputsFile, "apiBaseUrl", [
-        { name: `"label"`, initializer: `"API Base URL"` },
-        { name: `"type"`, initializer: `"string"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional url you can specify to overide the default provided by the OpenAPI spec."`,
-        },
-    ]);
-    addProperty(inputsFile, "debugRequest", [
-        { name: `"label"`, initializer: `"Debug Request"` },
-        { name: `"type"`, initializer: `"boolean"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional boolean you can toggle to log the contents of the HTTP request for each action."`,
-        },
-    ]);
-    addProperty(inputsFile, "timeout", [
-        { name: `"label"`, initializer: `"Timeout"` },
-        { name: `"type"`, initializer: `"string"` },
-        { name: `"required"`, initializer: `false` },
-        {
-            name: `"comments"`,
-            initializer: `"An optional input that indicates how long the client will await a response."`,
-        },
-    ]);
-    if (addRetry) {
-        addProperty(inputsFile, "maxRetries", [
-            { name: `"label"`, initializer: `"Max Retries"` },
-            { name: `"type"`, initializer: `"string"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional input that indicates how many times this client will retry the request."`,
-            },
-        ]);
-        addProperty(inputsFile, "retryDelayMS", [
-            { name: `"label"`, initializer: `"Retry Delay (MS)"` },
-            { name: `"type"`, initializer: `"string"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional input that indicates a delay between retries."`,
-            },
-        ]);
-        addProperty(inputsFile, "retryOnAllErrors", [
-            { name: `"label"`, initializer: `"Retry On All Errors"` },
-            { name: `"type"`, initializer: `"boolean"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional boolean that will have the client retry the request, reguardless of what type of error is thrown."`,
-            },
-        ]);
-        addProperty(inputsFile, "useExponentialBackoff", [
-            { name: `"label"`, initializer: `"Use Exponential Backoff"` },
-            { name: `"type"`, initializer: `"boolean"` },
-            { name: `"required"`, initializer: `false` },
-            {
-                name: `"comments"`,
-                initializer: `"An optional boolean that will enable exponential backoff on retry."`,
-            },
-        ]);
-    }
-    return inputsFile;
-};
-exports.appendRequiredFields = ({ inputFields, addRetry, includeClient, }) => {
-    if (!includeClient) {
-        return inputFields;
-    }
-    const base = [...inputFields, "apiBaseUrl", "debugRequest", "timeout"];
-    return addRetry
-        ? [
-            ...base,
-            "maxRetries",
-            "retryDelayMS",
-            "retryOnAllErrors",
-            "useExponentialBackoff",
-        ]
-        : base;
-};
-//# sourceMappingURL=util.js.map
+exports.createDescription = createDescription;

package/lib/graphql.js

@@ -1,70 +1,42 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gql = exports.client = exports.unauthedClient = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const apollo_client_1 = require("apollo-client");
-const apollo_link_1 = require("apollo-link");
-const apollo_link_context_1 = require("apollo-link-context");
-const apollo_link_http_1 = require("apollo-link-http");
-const apollo_cache_inmemory_1 = require("apollo-cache-inmemory");
-const graphql_utils_1 = require("@prismatic-io/graphql-utils");
+exports.gql = exports.gqlRequest = void 0;
+const url_1 = require("url");
+const graphql_request_1 = require("graphql-request");
 const auth_1 = require("./auth");
-const graphql_tag_1 = __importDefault(require("graphql-tag"));
-exports.gql = graphql_tag_1.default;
-const authContext = apollo_link_context_1.setContext(() => __awaiter(void 0, void 0, void 0, function* () {
-    const accessToken = yield auth_1.getAccessToken();
-    return accessToken
-        ? {
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "Prismatic-Client": "prism",
-            },
-        }
-        : { "Prismatic-Client": "prism" };
-}));
-const prismaticUri = (_a = process.env.PRISMATIC_URL) !== null && _a !== void 0 ? _a : "https://app.prismatic.io";
-const grapheneErrorLink = new apollo_link_1.ApolloLink((operation, forward) => forward(operation).map((response) => {
-    const errors = [
-        ...(graphql_utils_1.getSystemErrors(response) || []),
-        ...(graphql_utils_1.getDataErrors(response) || []),
-    ];
+const isErrored = (result) => {
+    if (!(Boolean(result) &&
+        typeof result === "object" &&
+        result !== null &&
+        "errors" in result)) {
+        return false;
+    }
+    const assumed = result;
+    return Boolean(assumed.errors) && assumed.errors.length > 0;
+};
+const formatError = (field, messages) => {
+    const message = messages.join("\n");
+    if (field === "__all__") {
+        return message;
+    }
+    return `${field}: ${message}`;
+};
+const gqlRequest = async ({ document, variables, }) => {
+    const accessToken = await (0, auth_1.getAccessToken)();
+    const url = new url_1.URL("/api", auth_1.prismaticUrl).toString();
+    const result = await (0, graphql_request_1.request)(url, document, variables, {
+        Authorization: `Bearer ${accessToken}`,
+        "Prismatic-Client": "prism",
+    });
+    const errors = Object.values(result)
+        .filter(isErrored)
+        .flatMap(({ errors }) => errors)
+        .map(({ field, messages }) => formatError(field, messages));
     if (errors.length > 0) {
-        errors.forEach(({ message, field }) => {
-            const label = !field || field === "__all__" ? "Error" : field;
-            console.error(`${label}: ${message}`);
-        });
-        process.exit(1);
+        throw new Error(errors.join("\n"));
     }
-    return response;
-}));
-const httpLink = new apollo_link_http_1.HttpLink({
-    uri: `${prismaticUri}/api`,
-    headers: {
-        // FIXME: What should this actually be...? ALB requires it for HTTPS calls.
-        Referer: prismaticUri,
-    },
-    fetch: node_fetch_1.default,
-});
-exports.unauthedClient = new apollo_client_1.ApolloClient({
-    link: grapheneErrorLink.concat(httpLink),
-    cache: new apollo_cache_inmemory_1.InMemoryCache(),
-});
-exports.client = new apollo_client_1.ApolloClient({
-    link: authContext.concat(grapheneErrorLink).concat(httpLink),
-    cache: new apollo_cache_inmemory_1.InMemoryCache(),
-});
-exports.default = exports.client;
-//# sourceMappingURL=graphql.js.map
+    return result;
+};
+exports.gqlRequest = gqlRequest;
+var graphql_request_2 = require("graphql-request");
+Object.defineProperty(exports, "gql", { enumerable: true, get: function () { return graphql_request_2.gql; } });

package/lib/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var command_1 = require("@oclif/command");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });
-//# sourceMappingURL=index.js.map
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/lib/utils/component/publish.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadConnectionIcons = exports.uploadFile = exports.publishDefinition = exports.confirmPublish = exports.checkSignature = exports.createComponentPackage = exports.validateDefinition = exports.loadEntrypoint = exports.seekComponentPackageDistDirectory = void 0;
+const core_1 = require("@oclif/core");
+const fs_1 = require("../../fs");
+const path_1 = require("path");
+const tempy_1 = __importDefault(require("tempy"));
+const crypto_1 = __importDefault(require("crypto"));
+const archiver_1 = __importDefault(require("archiver"));
+const graphql_1 = require("../../graphql");
+const axios_1 = __importDefault(require("axios"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_2 = require("path");
+const seekComponentPackageDistDirectory = async () => {
+    while (!(await (0, fs_1.exists)("package.json"))) {
+        const tempDir = process.cwd();
+        process.chdir("../");
+        if (process.cwd() == tempDir) {
+            core_1.CliUx.ux.error("Failed to find 'package.json' file. Is the current path a component?", { exit: 1 });
+        }
+    }
+    if (!(await (0, fs_1.exists)("./dist"))) {
+        core_1.CliUx.ux.error("Failed to find 'dist' folder. Is the current path a component?", {
+            exit: 1,
+        });
+    }
+    process.chdir("./dist");
+};
+exports.seekComponentPackageDistDirectory = seekComponentPackageDistDirectory;
+const loadEntrypoint = async () => {
+    // If we don't have an index.js in cwd seek directories to find package.json of component
+    if (!(await (0, fs_1.exists)("index.js"))) {
+        await (0, exports.seekComponentPackageDistDirectory)();
+    }
+    // If we still didn't find index.js error out
+    if (!(await (0, fs_1.exists)("index.js"))) {
+        core_1.CliUx.ux.error("Failed to find 'index.js' entrypoint file. Is the current path a component?", { exit: 1 });
+    }
+    // Require index.js and access its root-most default export which should be the Component config
+    const cwd = process.cwd();
+    const entrypointPath = (0, path_1.resolve)(cwd, "./index.js");
+    const { default: definition } = require(entrypointPath); // eslint-disable-line @typescript-eslint/no-var-requires
+    return definition;
+};
+exports.loadEntrypoint = loadEntrypoint;
+const validateDefinition = async (definition) => {
+    // Output basic information to the user to confirm that this component is what they want to publish
+    const { display: { label, description, iconPath },
+    // connections,
+     } = definition;
+    if (!label || !description) {
+        core_1.CliUx.ux.error("Missing required values `label` or `description`. Exiting.", { exit: 1 });
+    }
+    if (iconPath && !(await (0, fs_1.exists)(iconPath))) {
+        core_1.CliUx.ux.error("Icon was specified (iconPath) but a file was not found at specified path. Exiting.", { exit: 1 });
+    }
+    // TODO: Check if all Connection icons exist.
+};
+exports.validateDefinition = validateDefinition;
+const createComponentPackage = async () => {
+    const zip = (0, archiver_1.default)("zip", { zlib: { level: 9 } });
+    const pathPromise = tempy_1.default.write(zip, { extension: "zip" });
+    // Zip all files in the current directory (since we found the index.js entrypoint)
+    zip.directory(process.cwd(), false);
+    await zip.finalize();
+    return pathPromise;
+};
+exports.createComponentPackage = createComponentPackage;
+const checkSignature = async ({ key }, packagePath) => {
+    // Retrieve the existing signature of the component if it exists.
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query component($key: String!) {
+        components(key: $key) {
+          nodes {
+            signature
+          }
+        }
+      }
+    `,
+        variables: {
+            key,
+        },
+    });
+    const { components: { nodes: [{ signature: existingSignature } = { signature: null }], }, } = result;
+    // Generate the signature of the package so we may compare it against the existing one.
+    const packageSignature = crypto_1.default
+        .createHash("sha1")
+        .update(await fs_1.fs.readFile(packagePath))
+        .digest("hex");
+    return existingSignature === packageSignature;
+};
+exports.checkSignature = checkSignature;
+const confirmPublish = async ({ display: { label, description } }, confirm = true) => {
+    if (!confirm)
+        return;
+    core_1.CliUx.ux.log(label, "-", description);
+    const continuePublish = await core_1.CliUx.ux.confirm(`Would you like to publish ${label}? (y/N)`);
+    if (!continuePublish)
+        core_1.CliUx.ux.exit(0);
+};
+exports.confirmPublish = confirmPublish;
+const publishDefinition = async ({ actions, triggers, connections, ...rest }, comment) => {
+    // FIXME: Ideally we should just pass the entire configuration blob but Graphene can't represent
+    // a dictionary having arbitrary keys. For now, split actions and triggers out.
+    const actionDefinitions = Object.values(actions || {}).map((action) => {
+        return {
+            ...action,
+            examplePayload: (action === null || action === void 0 ? void 0 : action.examplePayload)
+                ? JSON.stringify(action === null || action === void 0 ? void 0 : action.examplePayload)
+                : JSON.stringify({}),
+        };
+    });
+    const triggerDefinitions = Object.values(triggers || {}).map((trigger) => {
+        return {
+            ...trigger,
+            examplePayload: (trigger === null || trigger === void 0 ? void 0 : trigger.examplePayload)
+                ? JSON.stringify(trigger === null || trigger === void 0 ? void 0 : trigger.examplePayload)
+                : JSON.stringify({}),
+        };
+    });
+    const connectionDefinitions = connections || [];
+    // Initiate start of the publish procedure by sending config data and receive back presigned s3 URL
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      mutation publishComponent(
+        $definition: ComponentDefinitionInput!
+        $actions: [ActionDefinitionInput]!
+        $triggers: [TriggerDefinitionInput]
+        $connections: [ConnectionDefinitionInput]
+        $comment: String
+      ) {
+        publishComponent(
+          input: {
+            definition: $definition
+            actions: $actions
+            triggers: $triggers
+            connections: $connections
+            comment: $comment
+          }
+        ) {
+          publishResult {
+            component {
+              id
+              versionNumber
+            }
+            iconUploadUrl
+            packageUploadUrl
+            connectionIconUploadUrls {
+              connectionKey
+              iconUploadUrl
+            }
+          }
+          errors {
+            field
+            messages
+          }
+        }
+      }
+    `,
+        variables: {
+            definition: rest,
+            actions: actionDefinitions,
+            triggers: triggerDefinitions,
+            connections: connectionDefinitions,
+            comment,
+        },
+    });
+    const { iconUploadUrl, packageUploadUrl, connectionIconUploadUrls, component: { versionNumber }, } = result.publishComponent.publishResult;
+    const uploadUrls = connectionIconUploadUrls.reduce((result, { connectionKey, iconUploadUrl }) => ({
+        ...result,
+        [connectionKey]: iconUploadUrl,
+    }), {});
+    return {
+        iconUploadUrl,
+        packageUploadUrl,
+        connectionIconUploadUrls: uploadUrls,
+        versionNumber,
+    };
+};
+exports.publishDefinition = publishDefinition;
+const uploadFile = async (filePath, destinationUrl) => {
+    try {
+        // TODO: Stream instead of Buffer.
+        const response = await axios_1.default.put(destinationUrl, await fs_1.fs.readFile(filePath), { headers: { "Content-Type": mime_types_1.default.contentType((0, path_2.extname)(filePath)) } });
+        return response;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const { message } = error;
+            throw new Error(message);
+        }
+        throw error;
+    }
+};
+exports.uploadFile = uploadFile;
+const uploadConnectionIcons = async ({ connections }, connectionIconUploadUrls) => {
+    if (!connections ||
+        !connections.length ||
+        !connectionIconUploadUrls ||
+        !Object.keys(connectionIconUploadUrls).length) {
+        return;
+    }
+    const iconPaths = connections.reduce((result, { key, iconPath }) => {
+        if (!iconPath) {
+            return result;
+        }
+        return {
+            ...result,
+            [key]: iconPath,
+        };
+    }, {});
+    const promises = Object.entries(connectionIconUploadUrls).map(async ([connectionKey, uploadUrl]) => (0, exports.uploadFile)(iconPaths[connectionKey], uploadUrl));
+    await Promise.all(promises);
+};
+exports.uploadConnectionIcons = uploadConnectionIcons;

package/lib/utils/component/query.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryComponentKeys = void 0;
+const graphql_1 = require("../../graphql");
+const queryComponentKeys = async (keys) => {
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query components($keys: [String]!) {
+        components(key_In: $keys) {
+          nodes {
+            id
+            key
+            versionNumber
+            public
+          }
+        }
+      }
+    `,
+        variables: { keys },
+    });
+    return result.components.nodes;
+};
+exports.queryComponentKeys = queryComponentKeys;

package/lib/utils/date.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTimestamp = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+const formatTimestamp = (timestamp) => (0, dayjs_1.default)(timestamp, "YYYY-MM-DDTHH:mm:ss.SSS000+Z", true).format("HH:mm:ss.SSS");
+exports.formatTimestamp = formatTimestamp;
+exports.default = dayjs_1.default;

package/lib/utils/execution/logs.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayLogs = exports.waitForExecutionCompletion = void 0;
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const date_1 = require("../date");
+const graphql_1 = require("../../graphql");
+const util_1 = require("util");
+const setTimeoutPromise = (0, util_1.promisify)(setTimeout);
+const waitForExecutionCompletion = (executionId) => {
+    return new Promise((resolve, reject) => {
+        const interval = setInterval(async () => {
+            try {
+                const result = await (0, graphql_1.gqlRequest)({
+                    document: (0, graphql_1.gql) `
+            query pollExecution($executionId: ID!) {
+              executionResult(id: $executionId) {
+                endedAt
+              }
+            }
+          `,
+                    variables: { executionId },
+                });
+                const { endedAt } = result.executionResult;
+                if (endedAt) {
+                    clearInterval(interval);
+                    // Grace period to let logs finish flowing; logs are fully async and are
+                    // not guaranteed to be added in chronological order.
+                    await setTimeoutPromise(1000);
+                    resolve();
+                }
+            }
+            catch (error) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 1000);
+    });
+};
+exports.waitForExecutionCompletion = waitForExecutionCompletion;
+const displayLogs = async (executionId) => {
+    await (0, exports.waitForExecutionCompletion)(executionId);
+    // TODO: Add paging
+    const result = await (0, graphql_1.gqlRequest)({
+        document: (0, graphql_1.gql) `
+      query logs($executionId: ID!) {
+        executionResult(id: $executionId) {
+          logs(orderBy: { field: TIMESTAMP, direction: ASC }) {
+            nodes {
+              timestamp
+              severity
+              message
+            }
+          }
+        }
+      }
+    `,
+        variables: { executionId },
+    });
+    const logs = result.executionResult.logs.nodes;
+    core_1.CliUx.ux.table(logs, {
+        timestamp: {
+            get: ({ timestamp }) => (0, date_1.formatTimestamp)(timestamp),
+        },
+        severity: {
+            minWidth: 12,
+            get: ({ severity }) => {
+                if (severity == "INFO") {
+                    return chalk_1.default.blue("info");
+                }
+                if (severity == "WARN") {
+                    return chalk_1.default.yellow("warn");
+                }
+                if (severity == "ERROR") {
+                    return chalk_1.default.red("error");
+                }
+                return severity.toLowerCase();
+            },
+        },
+        message: {},
+    }, { "no-header": true });
+};
+exports.displayLogs = displayLogs;