@snowplow/snowtype 0.1.0

package/LICENSE

@@ -0,0 +1,57 @@
+# Snowplow Personal & Academic License Agreement
+
+_Version 1.0, September 2023_
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it, but only for any non-commercial purpose.
+
+Non-commercial purposes include only:
+
+* Personal use for research, experiment, personal study, or hobby projects, without any anticipated commercial application.
+* Use for teaching purposes by lecturers of a school or university.
+* Use to evaluate the sufficiency of the software for the commercial needs of you or your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software for a non-commercial purpose.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice. Otherwise, all your licenses end immediately.
+
+## No Liability
+
+**As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.**
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

package/bin/bin

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/index.js");

package/dist/api/ConsoleAPI.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleAPI = void 0;
+const got_1 = __importDefault(require("got"));
+const utils_1 = require("../utils");
+class ConsoleAPI {
+    apiKey;
+    organizationId;
+    accessToken;
+    apiHost = "https://console.snowplowanalytics.com/api/msc";
+    constructor({ apiKey, organizationId }) {
+        this.apiKey = apiKey;
+        this.organizationId = organizationId;
+    }
+    async fetchAccessToken() {
+        if (this.accessToken) {
+            return this.accessToken;
+        }
+        const accessTokenUrl = `${this.apiHost}/v1/organizations/${this.organizationId}/credentials/v2/token`;
+        const { accessToken } = await (0, got_1.default)(accessTokenUrl, {
+            headers: { "X-API-Key": this.apiKey },
+        }).json();
+        this.accessToken = accessToken;
+        return accessToken;
+    }
+    /* TODO allow for adding params in the resourceUrl before reaching fetchResource */
+    async fetchResource(resourceUrl) {
+        const token = await this.fetchAccessToken();
+        return (0, got_1.default)(resourceUrl, {
+            headers: { Authorization: "Bearer " + token },
+        }).json();
+    }
+    /* Todo, return schema type */
+    async fetchSchemaVersion({ schema, }) {
+        const { vendor, name, format, version } = (0, utils_1.splitIgluSchemaUrlParts)(schema);
+        const schemaSHA256 = (0, utils_1.hashSHA256)(`${this.organizationId}-${vendor}-${name}-${format}`);
+        const schemaVersionUrl = `${this.apiHost}/v1/organizations/${this.organizationId}/data-structures/v1/${schemaSHA256}/versions/${version}`;
+        return await this.fetchResource(schemaVersionUrl);
+    }
+    async fetchSchemaHash({ schema }) {
+        const { vendor, name, format } = (0, utils_1.splitIgluSchemaUrlParts)(schema);
+        const schemaSHA256 = (0, utils_1.hashSHA256)(`${this.organizationId}-${vendor}-${name}-${format}`);
+        const schemaVersionUrl = `${this.apiHost}/v1/organizations/${this.organizationId}/data-structures/v1/${schemaSHA256}`;
+        return await this.fetchResource(schemaVersionUrl);
+    }
+    async fetchTrackingScenario({ scenarioId }) {
+        const schemaVersionUrl = `${this.apiHost}/v1/organizations/${this.organizationId}/tracking-scenarios/v1/${scenarioId}`;
+        return await this.fetchResource(schemaVersionUrl);
+    }
+    // TODO - refine all of it
+    async authenticate() {
+        return this.fetchAccessToken()
+            .then((token) => !!token)
+            .catch(() => false);
+    }
+}
+exports.ConsoleAPI = ConsoleAPI;

package/dist/api/fetchIgluCentralSchema.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIgluCentralSchema = void 0;
+const got_1 = __importDefault(require("got"));
+async function fetchIgluCentralSchema({ schema, }) {
+    return (await (0, got_1.default)(`https://raw.githubusercontent.com/snowplow/iglu-central/master/schemas/${schema.replace("iglu:", "")}`)).body;
+}
+exports.fetchIgluCentralSchema = fetchIgluCentralSchema;

package/dist/api/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetchIgluCentralSchema"), exports);
+__exportStar(require("./ConsoleAPI"), exports);

package/dist/command-utils/index.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkScenarioUpdates = exports.createStorageJSON = exports.checkDataStructureUpdates = exports.addConfigAttribute = exports.createConfigFile = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_1 = require("../utils");
+const DEFAULT_CONFIG_NAME = 'snowtype.config.json';
+const DEFAULT_CONFIG = {
+    tracker: "@snowplow/browser-tracker",
+    language: "typescript",
+    outpath: "./snowtype"
+};
+const DEFAULT_STORAGE_FILE = '.snowtype-lock.json';
+function writeToConfig(config) {
+    (0, fs_1.writeFileSync)((0, path_1.resolve)(process.cwd(), `./${DEFAULT_CONFIG_NAME}`), JSON.stringify(config, null, 2));
+}
+function createConfigFile(partialConfig) {
+    const config = { ...DEFAULT_CONFIG, ...partialConfig };
+    try {
+        writeToConfig(config);
+        return true;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}
+exports.createConfigFile = createConfigFile;
+// TODO refactor file stuff
+function addConfigAttribute(attribute, value) {
+    try {
+        const rawConfig = (0, fs_1.readFileSync)((0, path_1.resolve)(process.cwd(), `./${DEFAULT_CONFIG_NAME}`), { encoding: "utf-8" });
+        const parsedConfig = JSON.parse(rawConfig);
+        const valueExists = parsedConfig[attribute].some(entry => entry === value);
+        if (!valueExists) {
+            parsedConfig[attribute].push(value);
+        }
+        // TODO, run validate after patch and if failed abort ?
+        writeToConfig(parsedConfig);
+        return true;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}
+exports.addConfigAttribute = addConfigAttribute;
+/**
+ *
+ *
+ * @export
+ * @param {ConsoleAPI} consoleApi
+ * @param {string[]} dataStructures Array with Console data structure iglu URLs
+ * @return {*}  {Promise<string[]>}
+ */
+async function checkDataStructureUpdates(consoleApi, dataStructures) {
+    // Should we store the time we fetched the previous URL ?
+    // Does newest means by time uploaded or by version, should this be an option ?
+    const schemaUpdates = await Promise.all(dataStructures.map(async (dataStructureUrl) => {
+        const { version } = (0, utils_1.splitIgluSchemaUrlParts)(dataStructureUrl);
+        const { deployments } = (await consoleApi.fetchSchemaHash({ schema: dataStructureUrl }));
+        // Should we get only PROD ? (PROLLY)
+        // With one pass, find the latest.
+        const latestDeployment = deployments.reduce((accum, cur) => {
+            const currentTs = new Date(cur.ts);
+            if (currentTs > new Date(accum.ts)) {
+                return cur;
+            }
+            return accum;
+        }, deployments[0]);
+        if (latestDeployment.version === version) {
+            return {
+                previous: dataStructureUrl,
+                next: dataStructureUrl
+            };
+        }
+        return {
+            previous: dataStructureUrl,
+            next: (0, utils_1.replaceIgluSchemaPart)(dataStructureUrl, { version: latestDeployment.version })
+        };
+    }));
+    return schemaUpdates;
+}
+exports.checkDataStructureUpdates = checkDataStructureUpdates;
+// the storage JSON file. Will it go on the `snowtype` folder or in a `.snowtype` directory ?
+function createStorageJSON({ trackingScenarios }) {
+    try {
+        const latestGenerationConfig = { trackingScenarios: trackingScenarios.map(ts => ({ [ts.id]: ts.version })) };
+        (0, fs_1.writeFileSync)((0, path_1.resolve)(process.cwd(), `./${DEFAULT_CONFIG_NAME}/${DEFAULT_STORAGE_FILE}`), JSON.stringify(latestGenerationConfig, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}
+exports.createStorageJSON = createStorageJSON;
+// replace latestGenerationConfig type with what we decide. Created from createStorageJSON
+// Just check if there is any update ? The generator for now will regenerate all anyway.
+async function checkScenarioUpdates(consoleApi, trackingScenarioIds, latestGenerationConfig) {
+    // trackingScenarios would be [ts.id]: ts.version
+    const { trackingScenarios } = latestGenerationConfig;
+    const updates = {};
+    await Promise.all(trackingScenarioIds.map(async (trackingScenarioId) => {
+        const existingScenarioGeneratedVersion = trackingScenarios[trackingScenarioId];
+        // should we check if trackingScenarioId exists in the storage, and if not notify for update ?
+        if (!existingScenarioGeneratedVersion) {
+            return trackingScenarioId;
+        }
+        const scenario = (await consoleApi.fetchTrackingScenario({ scenarioId: trackingScenarioId })).data[0];
+        if ((scenario.version || 0) > existingScenarioGeneratedVersion) {
+            updates[trackingScenarioId] = {
+                previous: existingScenarioGeneratedVersion,
+                next: scenario.version
+            };
+        }
+        return trackingScenarioId;
+    }));
+    return updates;
+}
+exports.checkScenarioUpdates = checkScenarioUpdates;

package/dist/commands/actions/constants.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRACKER_LANGUAGES = exports.DEFAULT_LOCK = exports.DEFAULT_FILENAME = exports.DEFAULT_STORAGE_FILENAME = exports.DEFAULT_CONFIG_NAME = void 0;
+exports.DEFAULT_CONFIG_NAME = 'snowtype.config.json';
+exports.DEFAULT_STORAGE_FILENAME = '.snowtype-lock.json';
+exports.DEFAULT_FILENAME = 'snowplow';
+exports.DEFAULT_LOCK = '.snowtype.json';
+exports.TRACKER_LANGUAGES = {
+    '@snowplow/javascript-tracker': [
+        {
+            value: 'javascript',
+            name: 'JavaScript'
+        }
+    ],
+    '@snowplow/browser-tracker': [
+        {
+            value: 'javascript',
+            name: 'JavaScript'
+        },
+        {
+            value: 'typescript',
+            name: 'TypeScript'
+        }
+    ],
+    '@snowplow/node-tracker': [
+        {
+            value: 'javascript',
+            name: 'JavaScript'
+        },
+        {
+            value: 'typescript',
+            name: 'TypeScript'
+        }
+    ],
+    'snowplow-android-tracker': [
+        {
+            value: 'kotlin',
+            name: 'Kotlin'
+        }
+    ],
+    'snowplow-ios-tracker': [
+        {
+            value: 'swift',
+            name: 'Swift'
+        }
+    ],
+    'snowplow-golang-tracker': [
+        {
+            value: 'go',
+            name: 'Go'
+        }
+    ]
+};

package/dist/commands/actions/dispatch.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.act = void 0;
+const logger_1 = require("../logger");
+const utils_1 = require("./utils");
+function act(action) {
+    return (options, cmd) => {
+        const globalOptions = (0, utils_1.getGlobalOptions)(cmd);
+        const logging = (0, logger_1.createLogger)();
+        const spinner = (0, utils_1.createSpinner)();
+        const logger = logging.withVerbosity(globalOptions.verbose);
+        const apiKey = globalOptions.apiKey;
+        return action(apiKey, logger, spinner, options)
+            .then(() => stopSpinner(spinner))
+            .catch((err) => {
+            errHandle(err, logger, spinner);
+        });
+    };
+}
+exports.act = act;
+function errHandle(err, logger, spinner) {
+    stopSpinner(spinner);
+    logger.error(err);
+    throw err;
+}
+function stopSpinner(spinner) {
+    if (spinner.isSpinning() === true) {
+        spinner.stop(true);
+    }
+}

package/dist/commands/actions/generate.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAction = exports.execGenerate = void 0;
+const process_1 = require("process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const mkdirp_1 = require("mkdirp");
+const snowtype_core_1 = require("@snowplow/snowtype-core");
+const api_1 = require("../../api");
+const errors_1 = require("../../errors");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const dispatch_1 = require("./dispatch");
+function checkGenerateOptions(logger) {
+    logger.debug("Checking for existing configuration..");
+    (0, utils_1.guardConfigExistsValid)();
+    logger.success("Valid configuration found");
+}
+async function execGenerate(apiKey, logger, spinner) {
+    checkGenerateOptions(logger);
+    spinner.setSpinnerTitle("Generating...");
+    if (spinner.isSpinning() === false) {
+        spinner.start();
+    }
+    const config = (0, utils_1.getConfig)();
+    if ((0, utils_1.isEmpty)(config.dataStructures) &&
+        (0, utils_1.isEmpty)(config.igluCentralSchemas) &&
+        (0, utils_1.isEmpty)(config.trackingScenarioIds)) {
+        logger.warn("Data Structures, Schemas and Tracking Scenarios are empty.");
+    }
+    const consoleApi = new api_1.ConsoleAPI({
+        apiKey,
+        organizationId: config.organizationId,
+    });
+    // we could also throw properly in api
+    const isAuthenticated = await consoleApi.authenticate();
+    if (!isAuthenticated) {
+        throw new errors_1.SnowtypeAuthError();
+    }
+    const dataProducts = await (0, utils_1.mkDataProducts)(consoleApi, config.trackingScenarioIds);
+    const igluSchemas = await (0, utils_1.mkIgluSchemas)(config.igluCentralSchemas);
+    const dataStructures = await (0, utils_1.mkDataStructures)(consoleApi, config.dataStructures);
+    const genCfg = {
+        language: config.language,
+        tracker: config.tracker,
+        schemas: [...igluSchemas, ...dataStructures],
+        dataProducts,
+    };
+    const generationOutput = await (0, snowtype_core_1.generate)(genCfg);
+    logger.success("Code generated, writing...");
+    const output = generationOutput?.lines.join("\n");
+    const trueDir = (0, path_1.resolve)((0, process_1.cwd)(), config.outpath);
+    mkdirp_1.mkdirp.sync(trueDir);
+    const trueFile = constants_1.DEFAULT_FILENAME + (0, utils_1.getExtension)(config.language);
+    (0, fs_1.writeFileSync)((0, path_1.resolve)(trueDir, trueFile), output);
+    (0, utils_1.writeLockFile)(dataProducts, config.outpath);
+}
+exports.execGenerate = execGenerate;
+exports.generateAction = (0, dispatch_1.act)(execGenerate);

package/dist/commands/actions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchAction = exports.generateAction = exports.updateAction = exports.initAction = void 0;
+var init_1 = require("./init");
+Object.defineProperty(exports, "initAction", { enumerable: true, get: function () { return init_1.initAction; } });
+var update_1 = require("./update");
+Object.defineProperty(exports, "updateAction", { enumerable: true, get: function () { return update_1.updateAction; } });
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generateAction", { enumerable: true, get: function () { return generate_1.generateAction; } });
+var patch_1 = require("./patch");
+Object.defineProperty(exports, "patchAction", { enumerable: true, get: function () { return patch_1.patchAction; } });

package/dist/commands/actions/init.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAction = void 0;
+const prompts_1 = require("@inquirer/prompts");
+const errors_1 = require("../../errors");
+const api_1 = require("../../api");
+const config_1 = require("../../config");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const types_1 = require("./types");
+const dispatch_1 = require("./dispatch");
+const initPrompts = [
+    {
+        type: "password",
+        message: "Enter your Snowplow organization ID:",
+        mask: true,
+        validate: utils_1.isNonEmpty,
+    },
+    {
+        type: "select",
+        message: "Select the Snowplow Tracker to use:",
+        choices: [
+            {
+                value: "@snowplow/javascript-tracker",
+                name: "JavaScript Tracker",
+            },
+            {
+                value: "@snowplow/browser-tracker",
+                name: "Browser Tracker",
+            },
+            {
+                value: "@snowplow/node-tracker",
+                name: "Node Tracker",
+            },
+            {
+                value: "snowplow-android-tracker",
+                name: "Android Tracker",
+            },
+            {
+                value: "snowplow-ios-tracker",
+                name: "iOS Tracker",
+            },
+            {
+                value: "snowplow-golang-tracker",
+                name: "Golang Tracker",
+            },
+        ],
+    },
+    {
+        // placeholder
+        type: "select",
+        message: "Select the language to use:",
+    },
+    {
+        type: "input",
+        message: "Enter the directory for Snowtype output:",
+        default: "./snowtype",
+    },
+];
+const defaultOptions = {
+    organizationId: "",
+    tracker: "",
+    language: "",
+    outpath: "",
+};
+function getOrAsk(key, opts, inquire, override = "") {
+    if (override) {
+        return Promise.resolve(override);
+    }
+    // @ts-expect-error index signature
+    if (Object.prototype.hasOwnProperty.call(opts, key) && opts[key] != null) {
+        // @ts-expect-error index signature
+        const provided = opts[key];
+        if (typeof provided === "string") {
+            return Promise.resolve(provided);
+        }
+        throw new errors_1.SnowtypeInternalError("Invalid default options.");
+    }
+    if ((0, types_1.isInputPrompt)(inquire)) {
+        return (0, prompts_1.input)(inquire);
+    }
+    if ((0, types_1.isPasswordPrompt)(inquire)) {
+        return (0, prompts_1.password)(inquire);
+    }
+    if ((0, types_1.isSelectPrompt)(inquire)) {
+        return (0, prompts_1.select)(inquire);
+    }
+    throw new errors_1.SnowtypeInternalError("Unknown Prompt inquired.");
+}
+function mkChoices(languages, prompt) {
+    if ((0, types_1.isSelectPrompt)(prompt)) {
+        prompt.choices = languages;
+    }
+    return prompt;
+}
+async function checkInitOptions(options, logger) {
+    const initOptions = { ...defaultOptions };
+    logger.debug("Checking for existing configuration file..");
+    (0, utils_1.guardConfigNotExistsValid)();
+    const orgId = await getOrAsk("organizationId", options, initPrompts[0]);
+    initOptions.organizationId = orgId;
+    const tracker = await getOrAsk("tracker", options, initPrompts[1]);
+    if (!(0, utils_1.isValidTracker)(tracker)) {
+        throw new errors_1.SnowtypeOptionError("tracker", tracker);
+    }
+    initOptions.tracker = tracker;
+    const langs = constants_1.TRACKER_LANGUAGES[tracker];
+    if (!Array.isArray(langs) || langs.length === 0) {
+        throw new errors_1.SnowtypeInternalError("Missing language entry.");
+    }
+    let language;
+    if (langs.length === 1) {
+        const languageSelection = langs[0];
+        if (typeof languageSelection === "undefined") {
+            throw new errors_1.SnowtypeInternalError("Missing language.");
+        }
+        language = await getOrAsk("language", options, initPrompts[2], languageSelection.value);
+    }
+    else {
+        language = await getOrAsk("language", options, mkChoices(langs, initPrompts[2]));
+    }
+    if (!(0, utils_1.isValidLanguage)(initOptions.tracker, language)) {
+        throw new errors_1.SnowtypeOptionError("language", language);
+    }
+    initOptions.language = language;
+    const outpath = await getOrAsk("outpath", options, initPrompts[3]);
+    initOptions.outpath = outpath;
+    logger.debug("Assempling initialization options..");
+    return initOptions;
+}
+async function execInit(apiKey, logger, spinner, options) {
+    const initOpts = await checkInitOptions(options, logger);
+    spinner.setSpinnerTitle("Initialising...");
+    if (spinner.isSpinning() === false) {
+        spinner.start();
+    }
+    logger.debug("Creating configuration with options: ".concat(JSON.stringify(initOpts)));
+    const config = (0, utils_1.completeInitConfig)(initOpts);
+    // @ts-expect-error fix
+    (0, config_1.validateConfig)(config);
+    const consoleApi = new api_1.ConsoleAPI({
+        apiKey,
+        organizationId: config.organizationId,
+    });
+    const isAuthenticated = await consoleApi.authenticate();
+    if (!isAuthenticated) {
+        throw new errors_1.SnowtypeAuthError();
+    }
+    logger.success("Authentication succeeded");
+    (0, utils_1.writeConfigToFile)(config);
+    logger.success("Configuration created");
+}
+exports.initAction = (0, dispatch_1.act)(execInit);

package/dist/commands/actions/patch.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchAction = void 0;
+const command_utils_1 = require("../../command-utils");
+const errors_1 = require("../../errors");
+const generate_1 = require("./generate");
+const utils_1 = require("./utils");
+const dispatch_1 = require("./dispatch");
+const defaultOptions = {
+    trackingScenarioIds: [],
+    dataStructures: [],
+    igluCentralSchemas: [],
+    yes: false
+};
+function checkPatchOptions(options, logger) {
+    const patchOptions = { ...defaultOptions, ...options };
+    if (Object.values(patchOptions).every((v) => typeof v === 'boolean' || v.length === 0)) {
+        throw new errors_1.SnowtypeMissingOptionsError();
+    }
+    logger.debug("Checking for existing configuration..");
+    (0, utils_1.guardConfigExistsValid)();
+    logger.success("Valid configuration found");
+    return patchOptions;
+}
+function execPatch(apiKey, logger, spinner, options) {
+    const patchOptions = checkPatchOptions(options, logger);
+    logger.debug("Starting patch process with options: ".concat(JSON.stringify(patchOptions)));
+    const patchEntries = Object.entries(patchOptions);
+    patchEntries.forEach(([key, value]) => {
+        if (key !== "yes" && Array.isArray(value) && value.length !== 0) {
+            value.forEach((element) => {
+                (0, command_utils_1.addConfigAttribute)(key, element);
+            });
+        }
+    });
+    logger.success("Configuration patched");
+    if (patchOptions.yes === true) {
+        return (0, generate_1.execGenerate)(apiKey, logger, spinner);
+    }
+    else {
+        logger.log("Code is not generated yet for the patched configuration");
+    }
+    return Promise.resolve(undefined);
+}
+exports.patchAction = (0, dispatch_1.act)(execPatch);

package/dist/commands/actions/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSelectPrompt = exports.isConfirmPrompt = exports.isPasswordPrompt = exports.isInputPrompt = void 0;
+function isInputPrompt(p) {
+    return p.type === 'input';
+}
+exports.isInputPrompt = isInputPrompt;
+function isPasswordPrompt(p) {
+    return p.type === 'password';
+}
+exports.isPasswordPrompt = isPasswordPrompt;
+function isConfirmPrompt(p) {
+    return p.type === 'confirm';
+}
+exports.isConfirmPrompt = isConfirmPrompt;
+function isSelectPrompt(p) {
+    return p.type === 'select';
+}
+exports.isSelectPrompt = isSelectPrompt;