@spica/cli 0.18.17 → 0.18.18-pre2

package/src/commands/project/sync.js

@@ -1,785 +0,0 @@
-import caporalCore from "@caporal/core";
-const { CaporalValidator } = caporalCore;
-import { spin } from "../../console.js";
-import { httpService } from "../../http.js";
-import { availableSyncModules, validateSyncIds, validateSyncModules } from "../../validator.js";
-import { bold, green, red } from "colorette";
-import lodash from "lodash";
-const { isEqual } = lodash;
-let IGNORE_ERRORS;
-let CONCURRENCY_LIMIT;
-async function sync({ options: { sourceUrl, sourceApikey, targetUrl, targetApikey, modules, bucketIds, functionIds, apikeyIds, policyIds, envVarIds, dryRun, ignoreErrors, concurrencyLimit } }) {
-    IGNORE_ERRORS = ignoreErrors;
-    CONCURRENCY_LIMIT = concurrencyLimit;
-    const sourceService = httpService.create({
-        baseUrl: sourceUrl.toString(),
-        authorization: `APIKEY ${sourceApikey}`
-    });
-    const targetService = httpService.create({
-        baseUrl: targetUrl.toString(),
-        authorization: `APIKEY ${targetApikey}`
-    });
-    modules = modules
-        .toString()
-        .split(",")
-        .map(m => m.trim());
-    const coreSynchronizers = [
-        FunctionSynchronizer,
-        BucketSynchronizer,
-        ApikeySynchronizer,
-        PolicySynchronizer,
-        EnvironmentVariableSynchronizer
-    ];
-    const synchronizers = [];
-    for (const Ctor of coreSynchronizers) {
-        const synchronizer = new Ctor(sourceService, targetService, {
-            bucketIds: transformIDs(bucketIds),
-            functionIds: transformIDs(functionIds),
-            apikeyIds: transformIDs(apikeyIds),
-            policyIds: transformIDs(policyIds),
-            envVarIds: transformIDs(envVarIds)
-        });
-        const subSynchronizers = await synchronizer.initialize().catch(e => {
-            return Promise.reject(returnErrorMessage(e));
-        });
-        synchronizers.push(synchronizer);
-        synchronizers.push(...subSynchronizers);
-    }
-    for (const name of modules) {
-        const moduleSynchronizers = synchronizers.filter(s => s.moduleName == name);
-        for (const synchronizer of moduleSynchronizers) {
-            const { insertions, updations, deletions } = await synchronizer.analyze().catch(e => {
-                return Promise.reject(returnErrorMessage(e));
-            });
-            if (dryRun) {
-                printActions({
-                    insertions,
-                    updations,
-                    deletions,
-                    field: synchronizer.primaryField,
-                    moduleName: synchronizer.getDisplayableModuleName()
-                });
-            }
-            else {
-                try {
-                    await synchronizer.synchronize();
-                }
-                catch (error) {
-                    Promise.reject(returnErrorMessage(error));
-                }
-                console.log(`\n${synchronizer.getDisplayableModuleName()} synchronization has been completed!`.toUpperCase());
-            }
-        }
-    }
-}
-export default function (program) {
-    return program
-        .command("project sync", `Synchronize selected module objects between two spica instances(local or remote).
-${red("ATTENTION")}: Source and target instance versions must be minimum v0.9.19 and for the best results both instance versions should be the same. 
-Also this command will perform adding, overwriting and removing actions of the target instance and it's irreversible. 
-We highly recommend you to use --dry-run=true and check the changes that will be applied before start.`)
-        .option("--source-url", "API address of the instance where objects will be synchronized from", {
-        required: true,
-        validator: CaporalValidator.STRING
-    })
-        .option("--source-apikey", "Apikey of the instance where objects will be synchronized from", {
-        required: true,
-        validator: CaporalValidator.STRING
-    })
-        .option("--target-url", "API address of the instance where objects will be synchronized to", {
-        required: true,
-        validator: CaporalValidator.STRING
-    })
-        .option("--target-apikey", "API address of the instance where objects will be synchronized to", {
-        required: true,
-        validator: CaporalValidator.STRING
-    })
-        .option("--modules", `Module names of objects that will be synchronized. Available modules: ${green(availableSyncModules.join(","))}`, {
-        required: true,
-        validator: validateSyncModules
-    })
-        .option("--bucket-ids <ids>", "Buckets that will be synchronized (comma-separated)", {
-        required: false,
-        validator: validateSyncIds
-    })
-        .option("--function-ids <ids>", "Functions that will be synchronized (comma-separated)", {
-        required: false,
-        validator: validateSyncIds
-    })
-        .option("--apikey-ids <ids>", "Apikeys that will be synchronized (comma-separated)", {
-        required: false,
-        validator: validateSyncIds
-    })
-        .option("--policy-ids <ids>", "Policies that will be synchronized (comma-separated)", {
-        required: false,
-        validator: validateSyncIds
-    })
-        .option("--env-var-ids <ids>", "Environment variables that will be synchronized (comma-separated)", {
-        required: false,
-        validator: validateSyncIds
-    })
-        .option("--dry-run", "Shows the changes that will be applied to the target instance.", {
-        default: false
-    })
-        .option("--ignore-errors", "Set true if you don't want to interrupt sync process because of failed requests.", {
-        default: false
-    })
-        .option("--concurrency-limit", "Increase(if you want to speed up), decrease(if you get some error like ECONNRESET) this value to adjust how many parallel requests that will be sent to the target instance", {
-        default: 100,
-        validator: CaporalValidator.NUMBER
-    })
-        .action(sync);
-}
-export class ResourceGroupComparisor {
-    constructor(sources, targets, uniqueField = "_id", ignoredFields = []) {
-        this.sources = sources;
-        this.targets = targets;
-        this.uniqueField = uniqueField;
-        this.ignoredFields = ignoredFields;
-        this.existings = [];
-        this.existingIds = [];
-        this.existings = targets.filter(target => sources.some(source => source[this.uniqueField] == target[this.uniqueField]));
-        this.existingIds = this.existings.map(existing => existing[this.uniqueField]);
-    }
-    updations() {
-        const updations = [];
-        for (const existing of this.existings) {
-            const source = this.sources.find(source => source[this.uniqueField] == existing[this.uniqueField]);
-            if (this.ignoredFields.length) {
-                this.ignoredFields.forEach(field => {
-                    delete source[field];
-                    delete existing[field];
-                });
-            }
-            if (!isEqual(source, existing)) {
-                updations.push(source);
-            }
-        }
-        return updations;
-    }
-    insertions() {
-        return this.sources.filter(source => this.existingIds.indexOf(source[this.uniqueField]) == -1);
-    }
-    deletions() {
-        return this.targets.filter(target => this.existingIds.indexOf(target[this.uniqueField]) == -1);
-    }
-}
-export class FunctionSynchronizer {
-    constructor(sourceService, targetService, options) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.options = options;
-        this.moduleName = "function";
-        this.primaryField = "name";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    async initialize() {
-        const synchronizers = [];
-        const sourceFns = await getFilteredResources("function", this.sourceService, this.options.functionIds);
-        for (const fn of sourceFns) {
-            synchronizers.push(new FunctionDependencySynchronizer(this.sourceService, this.targetService, fn));
-        }
-        synchronizers.push(new FunctionIndexSynchronizer(this.sourceService, this.targetService));
-        return synchronizers;
-    }
-    async analyze() {
-        console.log();
-        let sourceFns = await spin({
-            text: "Fetching functions from source instance",
-            op: () => getFilteredResources("function", this.sourceService, this.options.functionIds)
-        });
-        const targetFns = await spin({
-            text: "Fetching functions from target instance",
-            op: () => getFilteredResources("function", this.targetService, this.options.functionIds)
-        });
-        const decider = new ResourceGroupComparisor(sourceFns, targetFns);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(fn => () => this.targetService.post("function", fn).catch(e => handleRejection({
-            action: "insert",
-            e,
-            objectName: this.moduleName + " " + fn.name
-        })));
-        await spinUntilPromiseEnd(insertPromiseFactories, "Inserting functions to the target instance");
-        const updatePromiseFactories = this.updations.map(fn => () => this.targetService.put(`function/${fn._id}`, fn).catch(e => handleRejection({
-            action: "update",
-            e,
-            objectName: this.moduleName + " " + fn.name
-        })));
-        await spinUntilPromiseEnd(updatePromiseFactories, "Updating target instance functions");
-        const deletePromiseFactories = this.deletions.map(fn => () => this.targetService.delete(`function/${fn._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: this.moduleName + " " + fn.name,
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, "Deleting target instance functions");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName;
-    }
-}
-export class FunctionDependencySynchronizer {
-    constructor(sourceService, targetService, fn) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.fn = fn;
-        this.moduleName = "function";
-        this.subModuleName = "dependency";
-        this.primaryField = "name";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        const deleteTypes = deps => deps.map(d => {
-            delete d.types;
-            return d;
-        });
-        const sourceDeps = await this.sourceService
-            .get(`function/${this.fn._id}/dependencies`)
-            .then(deleteTypes);
-        const targetDeps = await this.targetService
-            .get(`function/${this.fn._id}/dependencies`)
-            .then(deleteTypes)
-            .catch(e => {
-            if (isNotFoundException(e)) {
-                return [];
-            }
-            return Promise.reject(e.data);
-        });
-        const decider = new ResourceGroupComparisor(sourceDeps, targetDeps, "name");
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const promiseFactories = [];
-        const insertBody = [...this.insertions, ...this.updations].reduce((acc, dep) => {
-            const depName = `${dep.name}@${dep.version.slice(1)}`;
-            acc.name.push(depName);
-            return acc;
-        }, { name: [] });
-        if (insertBody.name.length) {
-            promiseFactories.push(() => this.targetService.post(`function/${this.fn._id}/dependencies`, insertBody).catch(e => {
-                handleRejection({
-                    action: "insert",
-                    e,
-                    objectName: this.getDisplayableModuleName()
-                });
-            }));
-        }
-        const deletePromiseFactories = this.deletions.map(dep => () => this.targetService.delete(`function/${this.fn._id}/dependencies/${dep.name}`).catch(e => handleRejection({
-            action: "update",
-            e,
-            objectName: this.getDisplayableModuleName()
-        })));
-        if (deletePromiseFactories.length) {
-            promiseFactories.push(...deletePromiseFactories);
-        }
-        return spinUntilPromiseEnd(promiseFactories, `Updating function '${this.fn.name}' dependencies`);
-    }
-    getDisplayableModuleName() {
-        return `${this.moduleName} '${this.fn.name}' ${this.subModuleName}`;
-    }
-}
-export class FunctionIndexSynchronizer {
-    constructor(sourceService, targetService) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.moduleName = "function";
-        this.subModuleName = "index";
-        this.primaryField = "name";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        const sourceFns = await this.sourceService.get("function");
-        const sourceFnIndexes = await Promise.all(sourceFns.map(fn => this.sourceService.get(`function/${fn._id}/index`).then(res => {
-            return {
-                _id: fn._id,
-                name: fn.name,
-                index: res.index
-            };
-        })));
-        const targetFnIndexes = await Promise.all(sourceFns.map(fn => this.targetService
-            .get(`function/${fn._id}/index`)
-            .then(res => {
-            return {
-                _id: fn._id,
-                name: fn.name,
-                index: res.index
-            };
-        })
-            .catch(e => {
-            if (isNotFoundException(e)) {
-                return false;
-            }
-            return Promise.reject(e.data);
-        }))).then(indexes => indexes.filter(Boolean));
-        const decider = new ResourceGroupComparisor(sourceFnIndexes, targetFnIndexes);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    synchronize() {
-        const promiseFactories = [...this.insertions, ...this.updations].map(fn => () => this.targetService.post(`function/${fn._id}/index`, { index: fn.index }).catch(e => handleRejection({
-            action: "insert",
-            objectName: this.getDisplayableModuleName() + " " + fn.name,
-            e
-        })));
-        return spinUntilPromiseEnd(promiseFactories, "Writing indexes to the target instance functions");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName + " " + this.subModuleName;
-    }
-}
-export class BucketDataSynchronizer {
-    constructor(sourceService, targetService, bucket) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.bucket = bucket;
-        this.moduleName = "bucket-data";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-        this.primaryField = this.bucket.primary;
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        const params = {
-            localize: false
-        };
-        const sourceData = await this.sourceService.get(`bucket/${this.bucket._id}/data`, {
-            params
-        });
-        const targetData = await this.targetService
-            .get(`bucket/${this.bucket._id}/data`, {
-            params
-        })
-            .catch(e => {
-            if (isNotFoundException(e)) {
-                return [];
-            }
-            return Promise.reject(e.data);
-        });
-        const decider = new ResourceGroupComparisor(sourceData, targetData);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(data => () => this.targetService.post(`bucket/${this.bucket._id}/data`, data).catch(e => handleRejection({
-            action: "insert",
-            objectName: this.getDisplayableModuleName() + " " + data[this.primaryField],
-            e
-        })));
-        await spinUntilPromiseEnd(insertPromiseFactories, `Inserting bucket ${this.bucket.title} data to the target instance`);
-        const updatePromiseFactories = this.updations.map(data => () => this.targetService.put(`bucket/${this.bucket._id}/data/${data._id}`, data).catch(e => handleRejection({
-            action: "update",
-            e,
-            objectName: this.getDisplayableModuleName() + " " + data[this.primaryField]
-        })));
-        await spinUntilPromiseEnd(updatePromiseFactories, `Updating bucket ${this.bucket.title} data on the target instance`);
-        const deletePromiseFactories = this.deletions.map(data => () => this.targetService.delete(`bucket/${this.bucket._id}/data/${data._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: this.getDisplayableModuleName() + " " + data[this.primaryField],
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, `Deleting bucket ${this.bucket.title} data from the target instance`);
-    }
-    getDisplayableModuleName() {
-        return `${this.moduleName} '${this.bucket.title}'`;
-    }
-}
-export class BucketSynchronizer {
-    constructor(sourceService, targetService, options) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.options = options;
-        this.moduleName = "bucket";
-        this.primaryField = "title";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    async initialize() {
-        const synchronizers = [];
-        const sourceBuckets = await getFilteredResources("bucket", this.sourceService, this.options.bucketIds);
-        for (const bucket of sourceBuckets) {
-            synchronizers.push(new BucketDataSynchronizer(this.sourceService, this.targetService, bucket));
-        }
-        return synchronizers;
-    }
-    async analyze() {
-        console.log();
-        const sourceBuckets = await spin({
-            text: "Fetching buckets from source instance",
-            op: () => getFilteredResources("bucket", this.sourceService, this.options.bucketIds)
-        });
-        const targetBuckets = await spin({
-            text: "Fetching buckets from target instance",
-            op: () => getFilteredResources("bucket", this.targetService, this.options.bucketIds)
-        });
-        const decider = new ResourceGroupComparisor(sourceBuckets, targetBuckets);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(bucket => () => this.targetService.post("bucket", bucket).catch(e => handleRejection({
-            action: "insert",
-            objectName: this.getDisplayableModuleName() + " " + bucket.title,
-            e
-        })));
-        await spinUntilPromiseEnd(insertPromiseFactories, "Inserting buckets to the target instance");
-        const updatePromiseFactories = this.updations.map(bucket => () => this.targetService.put(`bucket/${bucket._id}`, bucket).catch(e => handleRejection({
-            action: "update",
-            objectName: this.getDisplayableModuleName() + " " + bucket.title,
-            e
-        })));
-        await spinUntilPromiseEnd(updatePromiseFactories, "Updating buckets on the target instance");
-        const deletePromiseFactories = this.deletions.map(bucket => () => this.targetService.delete(`bucket/${bucket._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: bucket.title,
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, "Deleting bucket from the target instance");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName;
-    }
-}
-export class ApikeySynchronizer {
-    constructor(sourceService, targetService, options) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.options = options;
-        this.moduleName = "apikey";
-        this.primaryField = "name";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        console.log();
-        const sourceApikeys = await spin({
-            text: "Fetching apikeys from source instance",
-            op: () => getFilteredResources("passport/apikey", this.sourceService, this.options.apikeyIds, true)
-        });
-        const targetApikeys = await spin({
-            text: "Fetching apikeys from target instance",
-            op: () => getFilteredResources("passport/apikey", this.targetService, this.options.apikeyIds, true)
-        });
-        const decider = new ResourceGroupComparisor(sourceApikeys, targetApikeys);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(apikey => () => {
-            const insertRejectionHandler = e => handleRejection({
-                action: "insert",
-                objectName: this.getDisplayableModuleName() + " " + apikey.name,
-                e
-            });
-            const policies = [...apikey.policies];
-            delete apikey.policies;
-            const apikeyInsertPromise = this.targetService
-                .post("passport/apikey", apikey)
-                .catch(e => insertRejectionHandler(e));
-            return apikeyInsertPromise.then(() => {
-                const policyAttachPromises = policies.map(policy => this.targetService
-                    .put(`passport/apikey/${apikey._id}/policy/${policy}`)
-                    .catch(e => insertRejectionHandler(e)));
-                return Promise.all(policyAttachPromises);
-            });
-        });
-        await spinUntilPromiseEnd(insertPromiseFactories, "Inserting apikeys to the target instance");
-        const updatePromiseFactories = this.updations.map(apikey => () => {
-            const rejectionHandler = e => {
-                handleRejection({
-                    action: "update",
-                    objectName: this.getDisplayableModuleName() + " " + apikey.name,
-                    e
-                });
-            };
-            const policies = [...apikey.policies];
-            delete apikey.policies;
-            const apikeyDeletePromise = this.targetService
-                .delete(`passport/apikey/${apikey._id}`)
-                .catch(e => rejectionHandler(e));
-            const apikeyInsertPromise = apikeyDeletePromise.then(() => this.targetService.post(`passport/apikey`, apikey).catch(e => rejectionHandler(e)));
-            return apikeyInsertPromise.then(() => {
-                const policyAttachPromises = policies.map(policy => this.targetService
-                    .put(`passport/apikey/${apikey._id}/policy/${policy}`)
-                    .catch(e => rejectionHandler(e)));
-                return Promise.all(policyAttachPromises);
-            });
-        });
-        await spinUntilPromiseEnd(updatePromiseFactories, "Updating apikeys on the target instance");
-        const deletePromiseFactories = this.deletions.map(apikey => () => this.targetService.delete(`passport/apikey/${apikey._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: apikey.name,
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, "Deleting apikeys from the target instance");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName;
-    }
-}
-export class PolicySynchronizer {
-    constructor(sourceService, targetService, options) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.options = options;
-        this.moduleName = "policy";
-        this.primaryField = "name";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        console.log();
-        const sourcePolicies = await spin({
-            text: "Fetching policies from source instance",
-            op: () => getFilteredResources("passport/policy", this.sourceService, this.options.policyIds, true)
-        });
-        const targetPolicies = await spin({
-            text: "Fetching policies from target instance",
-            op: () => getFilteredResources("passport/policy", this.targetService, this.options.policyIds, true)
-        });
-        const decider = new ResourceGroupComparisor(sourcePolicies, targetPolicies);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(policy => () => {
-            delete policy.system;
-            return this.targetService.post("passport/policy", policy).catch(e => handleRejection({
-                action: "insert",
-                objectName: this.getDisplayableModuleName() + " " + policy.name,
-                e
-            }));
-        });
-        await spinUntilPromiseEnd(insertPromiseFactories, "Inserting policies to the target instance");
-        const updatePromiseFactories = this.updations.map(policy => () => {
-            delete policy.system;
-            return this.targetService.put(`passport/policy/${policy._id}`, policy).catch(e => handleRejection({
-                action: "update",
-                objectName: this.getDisplayableModuleName() + " " + policy.name,
-                e
-            }));
-        });
-        await spinUntilPromiseEnd(updatePromiseFactories, "Updating policies on the target instance");
-        const deletePromiseFactories = this.deletions.map(policy => () => this.targetService.delete(`passport/policy/${policy._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: policy.name,
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, "Deleting policies from the target instance");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName;
-    }
-}
-export class EnvironmentVariableSynchronizer {
-    constructor(sourceService, targetService, options) {
-        this.sourceService = sourceService;
-        this.targetService = targetService;
-        this.options = options;
-        this.moduleName = "env-var";
-        this.primaryField = "key";
-        this.insertions = [];
-        this.updations = [];
-        this.deletions = [];
-    }
-    initialize() {
-        return Promise.resolve([]);
-    }
-    async analyze() {
-        console.log();
-        const sourceEnvVars = await spin({
-            text: "Fetching env vars from source instance",
-            op: () => getFilteredResources("env-var", this.sourceService, this.options.envVarIds)
-        });
-        const targetEnvVars = await spin({
-            text: "Fetching env vars from target instance",
-            op: () => getFilteredResources("env-var", this.targetService, this.options.envVarIds)
-        });
-        const decider = new ResourceGroupComparisor(sourceEnvVars, targetEnvVars);
-        this.insertions = decider.insertions();
-        this.updations = decider.updations();
-        this.deletions = decider.deletions();
-        return {
-            insertions: this.insertions,
-            updations: this.updations,
-            deletions: this.deletions
-        };
-    }
-    async synchronize() {
-        console.log();
-        const insertPromiseFactories = this.insertions.map(envVar => () => this.targetService.post("env-var", envVar).catch(e => handleRejection({
-            action: "insert",
-            objectName: this.getDisplayableModuleName() + " " + envVar.key,
-            e
-        })));
-        await spinUntilPromiseEnd(insertPromiseFactories, "Inserting env vars to the target instance");
-        const updatePromiseFactories = this.updations.map(envVar => () => this.targetService.put(`env-var/${envVar._id}`, envVar).catch(e => handleRejection({
-            action: "update",
-            objectName: this.getDisplayableModuleName() + " " + envVar.key,
-            e
-        })));
-        await spinUntilPromiseEnd(updatePromiseFactories, "Updating env vars on the target instance");
-        const deletePromiseFactories = this.deletions.map(envVar => () => this.targetService.delete(`env-var/${envVar._id}`).catch(e => handleRejection({
-            action: "delete",
-            objectName: envVar.key,
-            e
-        })));
-        await spinUntilPromiseEnd(deletePromiseFactories, "Deleting env vars from the target instance");
-    }
-    getDisplayableModuleName() {
-        return this.moduleName;
-    }
-}
-function printActions({ insertions, updations, deletions, field, moduleName }) {
-    const joinActions = (actions) => {
-        const MAX_LINES = 20;
-        actions = actions.map(a => `- ${a[field]}`);
-        if (actions.length > MAX_LINES) {
-            actions = actions.slice(0, MAX_LINES);
-            actions.push("...more");
-        }
-        return actions.join("\n");
-    };
-    console.log();
-    console.log(`----- ${moduleName.toUpperCase()} -----`);
-    console.log(`\n* Found ${bold(insertions.length)} objects to ${bold("insert")}: 
-${joinActions(insertions)}`);
-    console.log(`\n* Found ${bold(updations.length)} objects to ${bold("update")}: 
-${joinActions(updations)}`);
-    console.log(`\n* Found ${bold(deletions.length)} objects to ${bold("delete")}: 
-${joinActions(deletions)}`);
-}
-export var SendingPromiseStrategy;
-(function (SendingPromiseStrategy) {
-    SendingPromiseStrategy[SendingPromiseStrategy["All"] = 0] = "All";
-    SendingPromiseStrategy[SendingPromiseStrategy["OneByOne"] = 1] = "OneByOne";
-    SendingPromiseStrategy[SendingPromiseStrategy["Batch"] = 2] = "Batch";
-    SendingPromiseStrategy[SendingPromiseStrategy["Retry"] = 3] = "Retry";
-})(SendingPromiseStrategy || (SendingPromiseStrategy = {}));
-function spinUntilPromiseEnd(promiseFactories, label) {
-    if (!promiseFactories.length) {
-        return;
-    }
-    return spin({
-        text: label,
-        op: async (spinner) => {
-            let progress = 0;
-            let count = 0;
-            const concurrency = Math.min(promiseFactories.length, CONCURRENCY_LIMIT);
-            let batchPromises = [];
-            for (let i = 0; i < promiseFactories.length; i++) {
-                batchPromises.push(promiseFactories[i]);
-                if (batchPromises.length == concurrency || i == promiseFactories.length - 1) {
-                    await Promise.all(batchPromises.map(b => b()));
-                    batchPromises = [];
-                }
-                count++;
-                progress = (100 / promiseFactories.length) * count;
-                spinner.text = `${label} (%${Math.round(progress)})`;
-            }
-            return;
-        }
-    });
-}
-function handleRejection({ action, objectName, e }) {
-    const errorMessage = returnErrorMessage(e);
-    const msg = `
-Failed to ${action} ${bold(objectName)}.
-${errorMessage}`;
-    if (IGNORE_ERRORS) {
-        return console.warn(msg);
-    }
-    else {
-        return Promise.reject(msg);
-    }
-}
-function returnErrorMessage(e) {
-    return e.data ? e.data.message || e.data : e;
-}
-function isNotFoundException(e) {
-    const code = 404;
-    return e.status == code || e.statusCode == code || (e.data && e.data.statusCode == code);
-}
-async function getFilteredResources(path, service, ids, paginate) {
-    const res = await service.get(path);
-    const resources = paginate ? res.data : res;
-    return ids ? resources.filter(resource => ids.includes(resource._id)) : resources;
-}
-function transformIDs(ids) {
-    return ids === "string" ? ids.split(",") : [];
-}
-//# sourceMappingURL=sync.js.map