@prismatic-io/prism 5.0.2 → 5.1.0

package/lib/commands/translations/list.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const graphql_1 = require("../../graphql");
+const processDataForTranslations_1 = require("../../utils/translations/processDataForTranslations");
+const queries_graphql_1 = require("../../queries.graphql");
+const fs_1 = require("../../fs");
+class TranslationsCommand extends core_1.Command {
+    async run() {
+        const { flags: { "output-file": output }, } = await this.parse(TranslationsCommand);
+        const cwd = process.cwd();
+        const result = await (0, graphql_1.gqlRequest)({
+            document: queries_graphql_1.GET_MARKETPLACE_INTEGRATIONS_TRANSLATIONS,
+        });
+        const processedIntegrations = (0, processDataForTranslations_1.processIntegrationsForTranslations)(result);
+        if (output) {
+            process.chdir(cwd);
+            this.log(`Writing translations to ${output}`);
+            fs_1.fs.writeFile(output, JSON.stringify(processedIntegrations, null, 2));
+        }
+        else {
+            this.logJson(processedIntegrations);
+        }
+    }
+}
+exports.default = TranslationsCommand;
+TranslationsCommand.description = "Generate Dynamic Phrases for Embedded Marketplace";
+TranslationsCommand.flags = {
+    "output-file": core_1.Flags.string({
+        required: false,
+        char: "o",
+        description: "Output the results of the action to a specified file",
+        default: "translations_output.json",
+    }),
+};

package/lib/queries.graphql.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_MARKETPLACE_INTEGRATIONS_TRANSLATIONS = void 0;
+const graphql_1 = require("./graphql");
+exports.GET_MARKETPLACE_INTEGRATIONS_TRANSLATIONS = (0, graphql_1.gql) `
+  fragment IntegrationTranslation on Integration {
+    name
+    description
+    definition
+    category
+    overview
+    configPages
+    requiredConfigVariables {
+      nodes {
+        key
+        description
+        inputs {
+          nodes {
+            name
+            meta
+          }
+        }
+      }
+    }
+  }
+  query MarketplaceTranslations {
+    marketplaceIntegrations {
+      nodes {
+        id
+        ...IntegrationTranslation
+        instances(isSystem: false) {
+          nodes {
+            id
+            name
+            integration {
+              ...IntegrationTranslation
+            }
+          }
+        }
+      }
+    }
+  }
+`;

package/lib/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+// @generated
+// This file was automatically generated and should not be edited.
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/translations/processDataForTranslations.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIntegrationsForTranslations = void 0;
+const serialize_1 = require("../serialize");
+const processedProperties = new Set();
+const setResultProperty = (property) => {
+    if (property && !processedProperties.has(property)) {
+        processedProperties.add(property);
+    }
+};
+const processProperties = (properties) => {
+    properties.forEach((property) => setResultProperty(property));
+};
+const processIntegration = (integration) => {
+    const { name, description, category, overview, definition, instances } = integration;
+    processProperties([name, description, category, overview]);
+    if (definition) {
+        processIntegrationDefinition(definition);
+    }
+    if (!instances) {
+        return;
+    }
+    instances.nodes.forEach((instance) => processIntegrationInstance(instance));
+};
+const processIntegrationInstance = (instance) => {
+    if (!instance) {
+        return;
+    }
+    const { name, integration } = instance;
+    setResultProperty(name);
+    if (!integration) {
+        return;
+    }
+    processIntegration(instance.integration);
+};
+const processIntegrationDefinition = (unparsedYamlDefinition) => {
+    const definition = (0, serialize_1.loadYaml)(unparsedYamlDefinition);
+    const { category, description, configPages, flows, labels, requiredConfigVars, } = definition;
+    processProperties([description, category]);
+    configPages === null || configPages === void 0 ? void 0 : configPages.forEach((page) => {
+        setResultProperty(page.name);
+        setResultProperty(page.tagline);
+        page.elements.forEach((element) => setResultProperty(element.value));
+    });
+    flows === null || flows === void 0 ? void 0 : flows.forEach(traverse);
+    processProperties(labels !== null && labels !== void 0 ? labels : []);
+    requiredConfigVars === null || requiredConfigVars === void 0 ? void 0 : requiredConfigVars.forEach((configVar) => {
+        var _a, _b;
+        if (configVar.dataType === "date" ||
+            configVar.dataType === "timestamp" ||
+            configVar.dataType === "schedule") {
+            return;
+        }
+        setResultProperty(configVar.key);
+        setResultProperty(configVar.description);
+        if ("collectionType" in configVar) {
+            try {
+                const valueParsed = JSON.parse((_a = configVar.defaultValue) !== null && _a !== void 0 ? _a : "");
+                valueParsed.forEach((value) => {
+                    if (typeof value === "string") {
+                        setResultProperty(value);
+                    }
+                    if (typeof value === "object") {
+                        Object.entries(value).forEach(([key, value]) => {
+                            setResultProperty(key);
+                            setResultProperty(value);
+                        });
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`JSON Parsing Error: ${error}`);
+            }
+        }
+        if (configVar.dataType === "picklist") {
+            processProperties((_b = configVar.pickList) !== null && _b !== void 0 ? _b : []);
+        }
+    });
+};
+const traverse = (flowOrStep) => {
+    var _a, _b;
+    const stack = [flowOrStep];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (isFlow(current)) {
+            // Handling Flow type
+            processProperties([current.name, current.description]);
+            stack.push(...current.steps);
+        }
+        else if (isStep(current)) {
+            // Handling Step type
+            processProperties([
+                current.name,
+                current.description,
+                (_b = (_a = current.action) === null || _a === void 0 ? void 0 : _a.component) === null || _b === void 0 ? void 0 : _b.key,
+            ]);
+            if (current.steps) {
+                stack.push(...current.steps);
+            }
+            if (current.branches) {
+                stack.push(...current.branches.map((branch) => ({
+                    name: branch.name,
+                    steps: branch.steps,
+                })));
+            }
+        }
+        else {
+            // Handling Branch type
+            setResultProperty(current.name);
+            stack.push(...current.steps);
+        }
+    }
+};
+const isFlow = (object) => {
+    return "steps" in object && Array.isArray(object.steps);
+};
+const isStep = (object) => {
+    return "action" in object;
+};
+const processIntegrationsForTranslations = (data) => {
+    data.marketplaceIntegrations.nodes.forEach((integration) => {
+        if (!integration) {
+            return;
+        }
+        processIntegration(integration);
+    });
+    const result = Object.fromEntries(processedProperties.entries());
+    return result;
+};
+exports.processIntegrationsForTranslations = processIntegrationsForTranslations;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.0.2",
+  "version": "5.1.0",
   "commands": {
     "login": {
       "id": "login",
@@ -1188,6 +1188,27 @@
       },
       "args": {}
     },
+    "translations:list": {
+      "id": "translations:list",
+      "description": "Generate Dynamic Phrases for Embedded Marketplace",
+      "strict": true,
+      "pluginName": "@prismatic-io/prism",
+      "pluginAlias": "@prismatic-io/prism",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "output-file": {
+          "name": "output-file",
+          "type": "option",
+          "char": "o",
+          "description": "Output the results of the action to a specified file",
+          "required": false,
+          "multiple": false,
+          "default": "translations_output.json"
+        }
+      },
+      "args": {}
+    },
     "alerts:events:list": {
       "id": "alerts:events:list",
       "description": "List Alert Events for an Alert Monitor",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/prism",
-  "version": "5.0.2",
+  "version": "5.1.0",
   "description": "Build, deploy, and support integrations in Prismatic from the comfort of your command line",
   "keywords": [
     "prismatic",
@@ -164,6 +164,9 @@
       },
       "organization:users": {
         "description": "Manage Organization Users"
+      },
+      "translations:list": {
+        "description": "Generates phrases for all marketplace integrations"
       }
     }
   },