@prismatic-io/spectral 8.1.7 → 9.0.0-rc.2

package/dist/generators/componentManifest/createStaticFiles.js

@@ -0,0 +1,145 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReadme = exports.renderTsConfig = exports.renderPackageJson = exports.renderIndex = exports.createStaticFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("./helpers");
+const createTemplate_1 = require("../utils/createTemplate");
+const createStaticFiles = ({ component, dryRun, signature, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (verbose) {
+        console.info("Creating static files...");
+    }
+    const index = yield (0, exports.renderIndex)({
+        component: {
+            key: component.key,
+            public: Boolean(component.public),
+            signature,
+        },
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir,
+    });
+    const packageJson = yield (0, exports.renderPackageJson)({
+        dryRun,
+        dependencies,
+        packageName,
+        verbose,
+        sourceDir,
+        destinationDir,
+        registry,
+    });
+    const tsConfig = yield (0, exports.renderTsConfig)({
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir,
+    });
+    const readme = yield (0, exports.renderReadme)({
+        component: {
+            key: component.key,
+            label: component.display.label,
+            description: component.display.description,
+            isPublic: Boolean(component.public),
+            action: Object.keys(component.actions).length
+                ? {
+                    key: Object.keys(component.actions)[0],
+                }
+                : null,
+            trigger: Object.keys(component.triggers).length
+                ? {
+                    key: Object.keys(component.triggers)[0],
+                }
+                : null,
+            connection: component.connections.length
+                ? {
+                    key: component.connections[0].key,
+                }
+                : null,
+            dataSource: Object.keys(component.dataSources).length
+                ? {
+                    key: Object.keys(component.dataSources)[0],
+                    type: component.dataSources[Object.keys(component.dataSources)[0]]
+                        .dataSourceType,
+                }
+                : null,
+        },
+        packageName,
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir,
+    });
+    if (verbose) {
+        console.info("");
+    }
+    return Promise.resolve({
+        index,
+        packageJson,
+        tsConfig,
+        readme,
+    });
+});
+exports.createStaticFiles = createStaticFiles;
+const renderIndex = ({ component, dryRun, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "index.ts.ejs"),
+        destination: path_1.default.join(destinationDir, "src", "index.ts"),
+        data: {
+            component,
+        },
+        verbose,
+        dryRun,
+    });
+});
+exports.renderIndex = renderIndex;
+const renderPackageJson = ({ dryRun, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "package.json.ejs"),
+        destination: path_1.default.join(destinationDir, "package.json"),
+        data: {
+            packageName,
+            spectralVersion: dependencies.spectral,
+            typescriptVersion: dependencies.devDependencies.typescript,
+            helpers: helpers_1.helpers,
+            registry,
+        },
+        dryRun,
+        verbose,
+    });
+});
+exports.renderPackageJson = renderPackageJson;
+const renderTsConfig = ({ dryRun, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "tsconfig.json.ejs"),
+        destination: path_1.default.join(destinationDir, "tsconfig.json"),
+        dryRun,
+        verbose,
+    });
+});
+exports.renderTsConfig = renderTsConfig;
+const renderReadme = ({ component, dryRun, packageName, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "README.md.ejs"),
+        destination: path_1.default.join(destinationDir, "README.md"),
+        data: {
+            component,
+            helpers: helpers_1.helpers,
+            packageName,
+        },
+        dryRun,
+        verbose,
+    });
+});
+exports.renderReadme = renderReadme;

package/dist/generators/componentManifest/createTriggers.d.ts

@@ -0,0 +1,13 @@
+import { Component } from "../../serverTypes";
+interface CreateTriggersProps {
+    component: Component;
+    dryRun: boolean;
+    verbose: boolean;
+    sourceDir: string;
+    destinationDir: string;
+}
+export declare const createTriggers: ({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateTriggersProps) => Promise<{
+    triggersIndex: string | void;
+    triggers: (string | void)[];
+}>;
+export {};

package/dist/generators/componentManifest/createTriggers.js

@@ -0,0 +1,95 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTriggers = void 0;
+const path_1 = __importDefault(require("path"));
+const getInputs_1 = require("./getInputs");
+const getImports_1 = require("./getImports");
+const helpers_1 = require("./helpers");
+const createTemplate_1 = require("../utils/createTemplate");
+const DOCUMENT_PROPERTIES = [
+    "comments",
+    "default",
+    "example",
+    "placeholder",
+];
+const createTriggers = ({ component, dryRun, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    if (verbose) {
+        console.info("Creating triggers...");
+    }
+    const triggersIndex = yield renderTriggersIndex({
+        triggers: Object.entries((_a = component.triggers) !== null && _a !== void 0 ? _a : {}).map(([triggerKey, trigger]) => {
+            return {
+                key: trigger.key || triggerKey,
+            };
+        }),
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir,
+    });
+    const triggers = yield Promise.all(Object.entries((_b = component.triggers) !== null && _b !== void 0 ? _b : {}).map(([triggerKey, trigger]) => __awaiter(void 0, void 0, void 0, function* () {
+        const inputs = (0, getInputs_1.getInputs)({
+            inputs: trigger.inputs,
+            documentProperties: DOCUMENT_PROPERTIES,
+        });
+        const imports = (0, getImports_1.getImports)({ inputs });
+        return yield renderTrigger({
+            trigger: {
+                key: trigger.key || triggerKey,
+                label: trigger.display.description,
+                description: trigger.display.description,
+                inputs,
+            },
+            dryRun,
+            imports,
+            verbose,
+            sourceDir,
+            destinationDir,
+        });
+    })));
+    if (verbose) {
+        console.info("");
+    }
+    return Promise.resolve({
+        triggersIndex,
+        triggers,
+    });
+});
+exports.createTriggers = createTriggers;
+const renderTriggersIndex = ({ triggers, dryRun, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "triggers", "index.ts.ejs"),
+        destination: path_1.default.join(destinationDir, "triggers", "index.ts"),
+        data: {
+            triggers,
+        },
+        dryRun,
+        verbose,
+    });
+});
+const renderTrigger = ({ dryRun, imports, trigger, verbose, sourceDir, destinationDir, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, createTemplate_1.createTemplate)({
+        source: path_1.default.join(sourceDir, "triggers", "trigger.ts.ejs"),
+        destination: path_1.default.join(destinationDir, "triggers", `${trigger.key}.ts`),
+        data: {
+            helpers: helpers_1.helpers,
+            imports,
+            trigger,
+        },
+        dryRun,
+        verbose,
+    });
+});

package/dist/generators/componentManifest/getImports.d.ts

@@ -0,0 +1,7 @@
+import { Input } from "./getInputs";
+export declare type Imports = Record<string, string[]>;
+interface GetImportsProps {
+    inputs: Input[];
+}
+export declare const getImports: ({ inputs }: GetImportsProps) => Imports;
+export {};

package/dist/generators/componentManifest/getImports.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImports = void 0;
+const getImports = ({ inputs }) => {
+    return inputs.reduce((acc, input) => {
+        if (typeof input.type === "string") {
+            return acc;
+        }
+        return Object.assign(Object.assign({}, acc), { [input.type.module]: acc[input.type.module]
+                ? !acc[input.type.module].includes(input.type.type)
+                    ? [...acc[input.type.module], input.type.type]
+                    : acc[input.type.module]
+                : [input.type.type] });
+    }, {});
+};
+exports.getImports = getImports;

package/dist/generators/componentManifest/getInputs.d.ts

@@ -0,0 +1,23 @@
+import { Input as ServerTypeInput } from "../../serverTypes";
+import { InputFieldDefinition } from "../../types/Inputs";
+export interface Input {
+    key: string;
+    label: string;
+    type: InputType;
+    required: boolean | undefined;
+    properties: {
+        key: keyof ServerTypeInput;
+        value: string;
+    }[];
+}
+export declare type InputType = string | {
+    type: string;
+    module: string;
+};
+interface GetInputsProps {
+    inputs: ServerTypeInput[];
+    documentProperties: (keyof ServerTypeInput)[];
+}
+export declare const getInputs: ({ inputs, documentProperties, }: GetInputsProps) => Input[];
+export declare const INPUT_TYPE_MAP: Record<InputFieldDefinition["type"], InputType>;
+export {};

package/dist/generators/componentManifest/getInputs.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INPUT_TYPE_MAP = exports.getInputs = void 0;
+const getInputs = ({ inputs, documentProperties, }) => {
+    return inputs.map((input) => {
+        return {
+            key: input.key,
+            label: input.label,
+            type: getInputType(input),
+            required: input.required,
+            properties: documentProperties.reduce((acc, key) => {
+                const value = input[key]
+                    ? JSON.stringify(input[key])
+                        .replace(/(^"|"$)|(^'|'$)/g, "")
+                        .trim()
+                    : null;
+                if (typeof value === "undefined" || value === null || value === "") {
+                    return acc;
+                }
+                return [
+                    ...acc,
+                    {
+                        key,
+                        value,
+                    },
+                ];
+            }, []),
+        };
+    });
+};
+exports.getInputs = getInputs;
+exports.INPUT_TYPE_MAP = {
+    string: "string",
+    data: "string",
+    text: "string",
+    password: "string",
+    boolean: "boolean",
+    code: "string",
+    conditional: {
+        type: "ConditionalExpression",
+        module: "@prismatic-io/spectral",
+    },
+    connection: {
+        type: "Connection",
+        module: "@prismatic-io/spectral",
+    },
+    objectSelection: {
+        type: "ObjectSelection",
+        module: "@prismatic-io/spectral",
+    },
+    objectFieldMap: {
+        type: "ObjectFieldMap",
+        module: "@prismatic-io/spectral",
+    },
+    jsonForm: {
+        type: "JSONForm",
+        module: "@prismatic-io/spectral",
+    },
+    dynamicObjectSelection: "string",
+    dynamicFieldSelection: "string",
+};
+const getInputType = (input) => {
+    return input.model
+        ? input.model.map((choice) => `"${choice.value}"`).join(" | ")
+        : exports.INPUT_TYPE_MAP[input.type] || "never";
+};

package/dist/generators/componentManifest/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare const helpers: {
+    createDependencyImports: ({ imports, }: import("../utils/createDependencyImports").CreateDependencyImportsProps) => string[];
+    capitalizeFirstLetter: (value: string) => string;
+    generatePackageJsonVersion: () => string;
+};

package/dist/generators/componentManifest/helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = void 0;
+const capitalizeFirstLetter_1 = require("../utils/capitalizeFirstLetter");
+const createDependencyImports_1 = require("../utils/createDependencyImports");
+const generatePackageJsonVersion_1 = require("../utils/generatePackageJsonVersion");
+exports.helpers = {
+    createDependencyImports: createDependencyImports_1.createDependencyImports,
+    capitalizeFirstLetter: capitalizeFirstLetter_1.capitalizeFirstLetter,
+    generatePackageJsonVersion: generatePackageJsonVersion_1.generatePackageJsonVersion,
+};

package/dist/generators/componentManifest/index.d.ts

@@ -0,0 +1,15 @@
+import { PackageDependencies } from "./createStaticFiles";
+import { Component } from "../../serverTypes";
+interface CreateComponentManifestProps {
+    component: Component;
+    dryRun: boolean;
+    includeSignature: boolean;
+    packageName: string;
+    dependencies: PackageDependencies;
+    verbose: boolean;
+    sourceDir: string;
+    destinationDir: string;
+    registry: string | null;
+}
+export declare const createComponentManifest: ({ component, dryRun, includeSignature, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }: CreateComponentManifestProps) => Promise<void>;
+export {};

package/dist/generators/componentManifest/index.js

@@ -0,0 +1,78 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentManifest = void 0;
+const path_1 = __importDefault(require("path"));
+const createActions_1 = require("./createActions");
+const createConnections_1 = require("./createConnections");
+const createDataSources_1 = require("./createDataSources");
+const createStaticFiles_1 = require("./createStaticFiles");
+const createTriggers_1 = require("./createTriggers");
+const removeComponentManifest_1 = require("./removeComponentManifest");
+const getComponentSignatureWithPrism_1 = require("../utils/getComponentSignatureWithPrism");
+const createComponentManifest = ({ component, dryRun, includeSignature, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const signature = includeSignature
+        ? yield (0, getComponentSignatureWithPrism_1.getComponentSignatureWithPrism)()
+        : null;
+    if (verbose) {
+        console.info(`Creating a component manifest for ${component.display.label}...`);
+        console.log("");
+    }
+    (0, removeComponentManifest_1.removeComponentManifest)({
+        destinationDir,
+        verbose,
+    });
+    yield (0, createStaticFiles_1.createStaticFiles)({
+        component,
+        dryRun,
+        packageName,
+        signature,
+        dependencies,
+        verbose,
+        sourceDir,
+        destinationDir,
+        registry,
+    });
+    const srcDir = path_1.default.join(destinationDir, "src");
+    yield (0, createActions_1.createActions)({
+        component,
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir: srcDir,
+    });
+    yield (0, createTriggers_1.createTriggers)({
+        component,
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir: srcDir,
+    });
+    yield (0, createConnections_1.createConnections)({
+        component,
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir: srcDir,
+    });
+    yield (0, createDataSources_1.createDataSources)({
+        component,
+        dryRun,
+        verbose,
+        sourceDir,
+        destinationDir: srcDir,
+    });
+    console.info(`Component manifest created successfully for ${component.display.label} in ${destinationDir}!`);
+});
+exports.createComponentManifest = createComponentManifest;

package/dist/generators/componentManifest/removeComponentManifest.d.ts

@@ -0,0 +1,6 @@
+interface RemoveComponentManifestProps {
+    destinationDir: string;
+    verbose: boolean;
+}
+export declare const removeComponentManifest: ({ destinationDir, verbose, }: RemoveComponentManifestProps) => void;
+export {};

package/dist/generators/componentManifest/removeComponentManifest.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeComponentManifest = void 0;
+const fs_extra_1 = require("fs-extra");
+const removeComponentManifest = ({ destinationDir, verbose, }) => {
+    if (verbose) {
+        console.info("Removing existing component manifest files...");
+    }
+    try {
+        (0, fs_extra_1.removeSync)(destinationDir);
+    }
+    catch (err) {
+        console.error(err);
+    }
+    if (verbose) {
+        console.info("");
+    }
+};
+exports.removeComponentManifest = removeComponentManifest;