@factorialco/fcode-cli 1.1.0

package/dist/core/executors/python-execution-task.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const errors_1 = require("../errors");
+const execution_task_1 = require("./execution-task");
+const workspace_1 = require("../../config/workspace");
+const source_code_sanitizer_1 = require("./source-code-sanitizer");
+class PythonExecutionTask extends execution_task_1.default {
+    async run() {
+        if (!this._execFilePath) {
+            this.prepare();
+        }
+        const venvPath = (0, workspace_1.baseDependenciesPath)(this._programmingLanguage);
+        const forked = (0, node_child_process_1.spawn)(`${venvPath}/bin/python3`, ['-u', path.resolve(this._execFilePath)], {
+            stdio: 'inherit',
+            env: {},
+        });
+        return new Promise((resolve, reject) => {
+            forked.on('exit', (code) => {
+                if (code) {
+                    reject(new errors_1.ErrorExecutingProcess(`Process exited with code ${code}`));
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+            forked.on('error', (error) => {
+                if (error.message.includes('ENOENT')) {
+                    reject(new errors_1.ErrorExecutingProcess('Seems that python3 virtual environment was not created properly.'));
+                }
+                else {
+                    reject(new errors_1.ErrorExecutingProcess(error.message));
+                }
+            });
+        });
+    }
+    _getJsonLogsSetup() {
+        return `
+import logging as _logging
+import datetime as _datetime
+import builtins as _builtins
+
+class _JsonFormatter(_logging.Formatter):
+    def format(self, record):
+        return json.dumps({
+            'timestamp': _datetime.datetime.utcnow().isoformat() + 'Z',
+            'level': record.levelname,
+            'message': record.getMessage()
+        })
+
+for _h in _logging.root.handlers:
+    _h.setFormatter(_JsonFormatter())
+
+_orig_print = _builtins.print
+def _json_print(*args, **kwargs):
+    msg = ' '.join(str(a) for a in args)
+    _orig_print(json.dumps({'timestamp': _datetime.datetime.utcnow().isoformat() + 'Z', 'level': 'INFO', 'message': msg}))
+_builtins.print = _json_print
+`;
+    }
+    _getReturnBlock(result) {
+        if (this._options.jsonLogs) {
+            return `
+        _orig_print(json.dumps({'timestamp': _datetime.datetime.utcnow().isoformat() + 'Z', 'level': 'INFO', 'message': 'Return', 'data': ${result}}))`;
+        }
+        return `
+        print("Return: ", json.dumps(${result}))`;
+    }
+    _getMainBlock() {
+        const sourceCode = this.getExecutionSourceCode();
+        const jsonLogsSetup = this._options.jsonLogs ? this._getJsonLogsSetup() : '';
+        if (this._options.hookFilePath) {
+            const fn = this._options.hookFunction ?? 'main';
+            return `import fcode as _imported_fcode_module
+${jsonLogsSetup}
+import importlib.util as _importlib_util
+_spec = _importlib_util.spec_from_file_location("hooks", "${this._options.hookFilePath}")
+_hooks_module = _importlib_util.module_from_spec(_spec)
+_spec.loader.exec_module(_hooks_module)
+_hook_fn = getattr(_hooks_module, '${fn}', None)
+if callable(_hook_fn):
+    result = _hook_fn()
+    if result:
+        ${this._getReturnBlock('result').trim()}
+        _return_file = os.environ.get('FCODE_RETURN_FILE', '')
+        if _return_file:
+            with open(_return_file, 'w') as _f:
+                json.dump(result, _f)
+`;
+        }
+        else if ((0, source_code_sanitizer_1.isLegacySourceCode)(sourceCode, 'PYTHON')) {
+            return `import fcode as _imported_fcode_module
+${jsonLogsSetup}
+logger.warning("[Factorial Code executor] Warning: Top-level \`return\` statements are deprecated. Please wrap your code in a \`main()\` function to ensure proper return value handling.")
+def main():
+${(0, source_code_sanitizer_1.indentScript)(sourceCode)}
+
+try:
+    result = main()
+    if result:
+      ${this._getReturnBlock('result').trim()}
+      _return_file = os.environ.get('FCODE_RETURN_FILE', '')
+      if _return_file:
+          with open(_return_file, 'w') as _f:
+              json.dump(result, _f)
+except Exception as e:
+    print(traceback.format_exc())
+    _error_file = os.environ.get('FCODE_ERROR_FILE', '')
+    if _error_file:
+        with open(_error_file, 'w') as _f:
+            json.dump({'message': str(e)}, _f)
+    sys.exit(1)
+`;
+        }
+        else {
+            const processPath = ['processes', this._process.slug];
+            if (this._options.version != null) {
+                processPath.push('versions');
+                processPath.push(this._options.version);
+            }
+            return `import fcode as _imported_fcode_module
+${jsonLogsSetup}
+process_id = '${this._process.slug}'
+process_path = '${processPath.join('.')}.main'
+sys.path.append(os.getcwd())
+process = __import__(process_path, fromlist=[process_path])
+if (hasattr(process, 'main')):
+    result = process.main()
+    if result:
+        ${this._getReturnBlock('result').trim()}
+        _return_file = os.environ.get('FCODE_RETURN_FILE', '')
+        if _return_file:
+            with open(_return_file, 'w') as _f:
+                json.dump(result, _f)
+`;
+        }
+    }
+    async _createExecutionFiles(tempDir) {
+        if (!this._options.silent) {
+            this._options.jsonLogs
+                ? process.stdout.write(JSON.stringify({ timestamp: new Date().toISOString(), level: 'DEBUG', message: `Creating execution files for '${this._process.slug}' in ${tempDir}` }) + '\n')
+                : console.debug(`Creating execution files for '${this._process.slug}' in ${tempDir}`);
+        }
+        const execFilePath = `${tempDir}/${this._process.slug}.py`;
+        const libraryFilePath = `${tempDir}/initialize_params.py`;
+        fs.writeFileSync(libraryFilePath, JSON.stringify(this.getMetadata()));
+        fs.writeFileSync(execFilePath, `
+import sys
+import os
+import json
+import traceback
+
+sys.path.append('${path.join(this._dependenciesPath)}')
+sys.path.append('${path.join(__dirname, '..', '..', 'runtime', 'libs', 'python')}')
+
+os.environ['FCODE_LOG_LEVEL'] = '${this._options.logLevel}'
+os.environ['FCODE_RUNTIME_METADATA_PATH'] = '${libraryFilePath}'
+os.environ['FCODE_RETURN_FILE'] = '${this.returnValueFilePath}'
+os.environ['FCODE_ERROR_FILE'] = '${this.errorValueFilePath}'
+${this._options.jsonLogs ? `os.environ['FCODE_JSON_LOGS'] = 'true'` : ''}
+${Object.entries(this.getVariablesObject()).map(([key, value]) => `if '${key}' not in os.environ: os.environ['${key}'] = ${JSON.stringify(value)}`).join('\n')}
+
+${this._getMainBlock()}
+`);
+        return {
+            FCODE_EXECUTION_FILE: execFilePath,
+            FCODE_TMP_PATH: tempDir,
+        };
+    }
+}
+exports.default = PythonExecutionTask;

package/dist/core/executors/source-code-sanitizer.d.ts

@@ -0,0 +1,4 @@
+import { ProgrammingLanguage } from '../types';
+export declare function removeComments(sourceCode: string, programmingLanguage: ProgrammingLanguage): string;
+export declare function indentScript(str: string, count?: number, indent?: string): string;
+export declare function isLegacySourceCode(sourceCode: string, programmingLanguage: ProgrammingLanguage): boolean;

package/dist/core/executors/source-code-sanitizer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeComments = removeComments;
+exports.indentScript = indentScript;
+exports.isLegacySourceCode = isLegacySourceCode;
+const stripComments = require('strip-comments');
+const MULTILINE_STRING_PATTERN = '(^|[^"])(""".*?"""|\'\'\'.*?\'\'\')';
+function removeComments(sourceCode, programmingLanguage) {
+    if (!sourceCode || sourceCode.trim().length === 0) {
+        return '';
+    }
+    return stripComments(sourceCode.trim(), { language: programmingLanguage.toLowerCase(), preserveNewlines: true });
+}
+const cleanMultilineStrings = (sourceCode) => {
+    const MULTILINE_STRING_REGEX = new RegExp(MULTILINE_STRING_PATTERN, 'gs');
+    return sourceCode.replace(MULTILINE_STRING_REGEX, '$1"<multiline_string>"');
+};
+const unindentMultilineStrings = (sourceCode, indentationString) => {
+    const MULTILINE_STRING_REGEX = new RegExp(MULTILINE_STRING_PATTERN, 'gs');
+    let result = sourceCode;
+    const iterator = sourceCode.matchAll(MULTILINE_STRING_REGEX);
+    const matches = Array.from(iterator).reverse();
+    for (const match of matches) {
+        const unindentedMatch = match[0].replace(new RegExp(`\n${indentationString}`, 'gs'), '\n');
+        result = result.substring(0, match.index) + unindentedMatch + result.substring(match.index + match[0].length);
+    }
+    return result;
+};
+function indentScript(str, count = 4, indent = ' ') {
+    const indentationString = indent.repeat(count);
+    return unindentMultilineStrings(str.replaceAll(/^/gm, indentationString), indentationString);
+}
+function isLegacySourceCode(sourceCode, programmingLanguage) {
+    const code = removeComments(sourceCode, programmingLanguage);
+    if (programmingLanguage == 'PYTHON') {
+        const cleanCode = cleanMultilineStrings(code);
+        const regex = /^return[ \t]/m;
+        return regex.test(cleanCode);
+    }
+    else if (programmingLanguage == 'JAVASCRIPT') {
+        const regex = /^module\.exports\s*=+/;
+        return !code.split('\n').some((line) => regex.test(line));
+    }
+    return false;
+}

package/dist/core/resource-merger.d.ts

@@ -0,0 +1,14 @@
+import ResourceRepositoryBase from '../repositories/resource';
+import { MergedResource, Resource, ResourceStatus } from './types';
+export declare const mapResourceStatus: (remoteResource: Resource | undefined, localResource: Resource | undefined, existsMetadata: boolean) => Promise<ResourceStatus>;
+export default class ResourceMerger<R extends Resource> {
+    protected _repository: ResourceRepositoryBase<R>;
+    constructor(repository: ResourceRepositoryBase<R>);
+    protected logChanges(added: Array<R>, updated: Array<R>, overwritten: Array<R>, removed: Array<R>, remoteRemoved: Array<R>): void;
+    mergeForPull(remoteResources: Array<R>, localResources: Array<R>, force: boolean): Promise<void>;
+    reset(remoteResources: Array<R>, localResources: Array<R>): Promise<void>;
+    mergeStatus(remoteResources: Resource[], localResources: Resource[]): Promise<MergedResource[]>;
+    private confirmRemoveResourcePromt;
+    private confirmOverwriteResourcePrompt;
+    private overrideResource;
+}

package/dist/core/resource-merger.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapResourceStatus = void 0;
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+const resource_checker_1 = require("../services/resource-checker");
+const promise_1 = require("../utils/promise");
+const types_1 = require("./types");
+const mapResourceStatus = async (remoteResource, localResource, existsMetadata) => {
+    if (!localResource) {
+        if (existsMetadata) {
+            return types_1.ResourceStatus.LOCAL_REMOVED;
+        }
+        return types_1.ResourceStatus.REMOTE_NEW;
+    }
+    const isVariable = localResource instanceof types_1.Variable;
+    if (isVariable && !localResource.value && localResource.id) {
+        return types_1.ResourceStatus.LOCAL_REMOVED;
+    }
+    if (isVariable && !localResource.id && remoteResource) {
+        return types_1.ResourceStatus.CONFLICT;
+    }
+    if (!localResource.id) {
+        return types_1.ResourceStatus.LOCAL_NEW;
+    }
+    if (!remoteResource) {
+        return types_1.ResourceStatus.REMOTE_REMOVED;
+    }
+    if (isVariable) {
+        if (localResource.isSensitive !== remoteResource.isSensitive) {
+            return types_1.ResourceStatus.SENSITIVITY_CHANGED;
+        }
+        if (localResource.isSensitive) {
+            return types_1.ResourceStatus.SENSITIVE;
+        }
+    }
+    if ((await resource_checker_1.default.remoteResourceHasBeenModified(remoteResource, localResource)) &&
+        (await resource_checker_1.default.localResourceHasBeenModified(remoteResource, localResource))) {
+        return types_1.ResourceStatus.CONFLICT;
+    }
+    if ((await resource_checker_1.default.remoteResourceHasBeenModified(remoteResource, localResource)) &&
+        !(await resource_checker_1.default.localResourceHasBeenModified(remoteResource, localResource))) {
+        return types_1.ResourceStatus.OUT_OF_DATE;
+    }
+    if (await resource_checker_1.default.localResourceHasBeenModified(remoteResource, localResource)) {
+        return types_1.ResourceStatus.MODIFIED;
+    }
+    return types_1.ResourceStatus.UP_TO_DATE;
+};
+exports.mapResourceStatus = mapResourceStatus;
+class ResourceMerger {
+    constructor(repository) {
+        this._repository = repository;
+    }
+    // eslint-disable-next-line max-params
+    logChanges(added, updated, overwritten, removed, remoteRemoved) {
+        if (added.length > 0 || updated.length > 0 || overwritten.length > 0 || removed.length > 0 || remoteRemoved.length > 0) {
+            for (const resource of added) {
+                cli_1.default.log(`[✨ new]\t\t-> ${resource.slug}`);
+            }
+            for (const resource of updated) {
+                cli_1.default.log(`[⬇️ updated]\t-> ${resource.slug}`);
+            }
+            for (const resource of overwritten) {
+                cli_1.default.log(`[🔥 overwritten]\t-> ${resource.slug}`);
+            }
+            for (const resource of removed) {
+                cli_1.default.log(`[🗑️ removed]\t-> ${resource.slug}`);
+            }
+            if (remoteRemoved.length > 0) {
+                const removedResourcesAsString = remoteRemoved.map((v) => v.slug).join(', ');
+                const warningText = `\nℹ️ ${remoteRemoved.length} ${this._repository._repositoryName} removed from remote: ${removedResourcesAsString}`;
+                cli_1.default.log(color_1.default.yellow(warningText));
+            }
+        }
+        else {
+            cli_1.default.log(`- ${this._repository._repositoryName} are up to date.\n`);
+        }
+    }
+    async mergeForPull(remoteResources, localResources, force) {
+        const resourceRemovedInRemote = localResources.filter((localResource) => localResource.id && !remoteResources.some((remoteResource) => remoteResource.sameAs(localResource)));
+        const confirmedRemovedResources = (await (0, promise_1.chainedPromisesWithConfirmation)(resourceRemovedInRemote, this.confirmRemoveResourcePromt.bind(this), force));
+        const removed = resourceRemovedInRemote.filter((remoteResource) => confirmedRemovedResources.some((confirmedRemovedResource) => confirmedRemovedResource.sameAs(remoteResource)));
+        const remoteRemoved = resourceRemovedInRemote.filter((remoteResource) => !confirmedRemovedResources.some((confirmedRemovedResource) => confirmedRemovedResource.sameAs(remoteResource)));
+        let { newRemoteResources, newLocalResources, upToDateResources, conflictResources, modifiedResources, outOfDateResources, remoteRemovedResources, localRemovedResources, } = await resource_checker_1.default.categorizeResources(localResources, remoteResources, types_1.OnConflictResolution.KEEP_REMOTE, (slug) => this._repository.existsMetadata(slug));
+        const added = await (0, promise_1.chainedPromisesWithArgs)(newRemoteResources, this._repository.save.bind(this._repository));
+        const updated = await (0, promise_1.chainedPromisesWithArgs)(outOfDateResources, this.overrideResource.bind(this));
+        const overwritten = force
+            ? await (0, promise_1.chainedPromisesWithArgs)(conflictResources, this.overrideResource.bind(this))
+            : await (0, promise_1.chainedPromisesWithConfirmationAndArgs)(conflictResources, this.confirmOverwriteResourcePrompt.bind(this), force);
+        if (localResources.length > 0 || remoteResources.length > 0) {
+            this.logChanges(added, updated, overwritten, removed, remoteRemoved);
+        }
+        else {
+            cli_1.default.log(`🧐 no ${this._repository._repositoryName} found\n`);
+        }
+    }
+    async reset(remoteResources, localResources) {
+        let { newRemoteResources, newLocalResources, upToDateResources, conflictResources, modifiedResources: localModifiedResources, outOfDateResources, remoteRemovedResources, localRemovedResources, } = await resource_checker_1.default.categorizeResources(localResources, remoteResources, types_1.OnConflictResolution.KEEP_REMOTE, (slug) => this._repository.existsMetadata(slug));
+        const modifiedResources = localModifiedResources.map((localModifiedResource) => remoteResources.find((resource) => localModifiedResource.sameAs(resource)));
+        const added = await (0, promise_1.chainedPromisesWithArgs)([...newRemoteResources, ...localRemovedResources], this._repository.save.bind(this._repository));
+        const updated = await (0, promise_1.chainedPromisesWithArgs)(outOfDateResources, this.overrideResource.bind(this));
+        const overwritten = await (0, promise_1.chainedPromisesWithArgs)([...conflictResources, ...modifiedResources], this.overrideResource.bind(this));
+        const removed = await (0, promise_1.chainedPromisesWithArgs)([...remoteRemovedResources, ...newLocalResources], (item) => {
+            this._repository.remove(item.slug);
+            return Promise.resolve(item);
+        });
+        const remoteRemoved = [];
+        if (localResources.length > 0 || remoteResources.length > 0) {
+            this.logChanges(added, updated, overwritten, removed, remoteRemoved);
+        }
+        else {
+            cli_1.default.log(`🧐 no ${this._repository._repositoryName} found\n`);
+        }
+    }
+    async mergeStatus(remoteResources, localResources) {
+        const resourceList = [];
+        const allResourceSlugs = [...new Set([...localResources, ...remoteResources].map((resource) => resource.slug))];
+        for (const resourceSlug of allResourceSlugs) {
+            const remoteResource = remoteResources.find((resource) => resource.slug === resourceSlug);
+            const localResource = localResources.find((resource) => resource.slug === resourceSlug);
+            resourceList.push({
+                ...remoteResource,
+                ...localResource,
+                status: await (0, exports.mapResourceStatus)(remoteResource, localResource, await this._repository.existsMetadata(resourceSlug)),
+                sameAs: (remoteResource || localResource).sameAs.bind(localResource || remoteResource),
+            });
+        }
+        return resourceList;
+    }
+    async confirmRemoveResourcePromt(resource) {
+        if (await resource_checker_1.default.localResourceHasBeenModified(undefined, resource)) {
+            cli_1.default.log(`🗑️  '${color_1.default.red(resource.slug)}' has been removed from remote but has changes locally!`);
+            if (!(await cli_1.default.confirm('Do you want remove it locally? yes/no'))) {
+                return false;
+            }
+        }
+        await this._repository.remove(resource.slug);
+        return true;
+    }
+    async confirmOverwriteResourcePrompt(overwriteResource) {
+        cli_1.default.log(`🔥  '${color_1.default.red(overwriteResource.slug)}' has been modified both remote and local!`);
+        if (await cli_1.default.confirm('Do you want to override local changes? yes/no')) {
+            await this._repository.remove(overwriteResource.slug);
+            await this._repository.save(overwriteResource);
+            return true;
+        }
+        return false;
+    }
+    async overrideResource(resource) {
+        await this._repository.remove(resource.slug);
+        return this._repository.save(resource);
+    }
+}
+exports.default = ResourceMerger;

package/dist/core/resource-pusher.d.ts

@@ -0,0 +1,12 @@
+import ResourceRepositoryBase from '../repositories/resource';
+import FcodeGraphQLClient from '../services/fcode-graphql-client';
+import { Resource } from './types';
+export default class ResourcePusher<R extends Resource> {
+    private _repository;
+    private _fcodeGraphQLClient;
+    constructor(repository: ResourceRepositoryBase<R>, fcodeGraphQLClient: FcodeGraphQLClient);
+    push(remoteResources: Array<R>, localResources: Array<R>, force: boolean): Promise<void>;
+    pushResource(resource: R): Promise<R>;
+    removeResource(resource: R): Promise<R>;
+    private confirmPushResourcePromt;
+}

package/dist/core/resource-pusher.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+const resource_checker_1 = require("../services/resource-checker");
+const promise_1 = require("../utils/promise");
+const types_1 = require("./types");
+const variable_warnings_1 = require("../utils/variable-warnings");
+const global_1 = require("../config/global");
+const settings_1 = require("../config/settings");
+class ResourcePusher {
+    constructor(repository, fcodeGraphQLClient) {
+        this._repository = repository;
+        this._fcodeGraphQLClient = fcodeGraphQLClient;
+    }
+    async push(remoteResources, localResources, force) {
+        cli_1.default.log(`\n🌩️  Pushing ${this._repository._repositoryName}...`);
+        for (const resource of localResources.filter((resource) => resource.resolvingTeamSlug)) {
+            if (await resource_checker_1.default.localResourceHasBeenModified(undefined, resource)) {
+                cli_1.default.log(color_1.default.red(`🚨 '${resource.slug}' is inherited from team '${resource.resolvingTeamSlug}' and is read-only. ` +
+                    `Run 'fcode ${this._repository._repositoryName}:pull' to restore it before pushing.`));
+            }
+        }
+        localResources = localResources.filter((resource) => !resource.resolvingTeamSlug);
+        remoteResources = remoteResources.filter((resource) => !resource.resolvingTeamSlug);
+        if (this._repository._repositoryName === 'variables') {
+            const localVariables = localResources;
+            const remoteVariables = remoteResources;
+            const localVariablesFileName = await new global_1.default().getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+            (0, variable_warnings_1.warnSensitivityChanged)((0, variable_warnings_1.sensitivityChangedVariables)(localVariables, remoteVariables).map((variable) => variable.slug));
+            (0, variable_warnings_1.warnTamperedSensitive)(localVariables.filter((variable) => (0, variable_warnings_1.isTamperedSensitive)(variable)).map((variable) => variable.slug), localVariablesFileName);
+        }
+        let { newRemoteResources, newLocalResources, upToDateResources, conflictResources, modifiedResources, outOfDateResources, remoteRemovedResources, localRemovedResources, } = await resource_checker_1.default.categorizeResources(localResources, remoteResources, types_1.OnConflictResolution.KEEP_LOCAL, (slug) => this._repository.existsMetadata(slug));
+        const confirmedConflictPusheableResources = await (0, promise_1.chainedPromisesWithConfirmation)(conflictResources, (resource) => {
+            return this.confirmPushResourcePromt(resource, types_1.ResourceStatus.CONFLICT);
+        }, force);
+        const confirmedRemovedPusheableResources = await (0, promise_1.chainedPromisesWithConfirmation)(localRemovedResources, (resource) => {
+            return this.confirmPushResourcePromt(resource, types_1.ResourceStatus.LOCAL_REMOVED);
+        }, force);
+        const pushedResources = await (0, promise_1.chainedPromises)([...newLocalResources, ...modifiedResources, ...confirmedConflictPusheableResources], this.pushResource.bind(this));
+        const removedResources = await (0, promise_1.chainedPromises)(confirmedRemovedPusheableResources, this.removeResource.bind(this));
+        if ([...pushedResources, ...removedResources].length > 0) {
+            // eslint-disable-next-line unicorn/no-array-for-each
+            removedResources.forEach((resource) => {
+                cli_1.default.log(`[🗑️  removed] -> ${resource.slug} removed in remote.`);
+            });
+            pushedResources
+                .filter((resource) => !resource.errorPushing)
+                .forEach((resource) => {
+                if (confirmedConflictPusheableResources.some((confirmedPusheableResource) => confirmedPusheableResource.sameAs(resource))) {
+                    cli_1.default.log(`[🔥  overwritten] -> ${resource.slug} overwritten to remote.`);
+                }
+                else {
+                    cli_1.default.log(`[⬆️  uploaded] -> ${resource.slug} uploaded to remote.`);
+                }
+            });
+        }
+        else {
+            cli_1.default.log(`- No local changes to push.\n`);
+        }
+    }
+    async pushResource(resource) {
+        try {
+            if (this._repository._repositoryName === 'processes') {
+                const updatedProcess = await this._fcodeGraphQLClient.pushProcess(resource);
+                return this._repository.save(updatedProcess);
+            }
+            if (this._repository._repositoryName === 'modules') {
+                const updatedModule = await this._fcodeGraphQLClient.pushScriptLibrary(resource);
+                return this._repository.save(updatedModule);
+            }
+            if (this._repository._repositoryName === 'variables') {
+                const variable = resource;
+                if (variable.id) {
+                    if (variable.isSensitive) {
+                        cli_1.default.log(`[⏩ skipped] -> ${variable.slug} is sensitive; its value is immutable and cannot be pushed.`);
+                        return resource;
+                    }
+                    const updatedVariable = await this._fcodeGraphQLClient.updateVariable(variable);
+                    return this._repository.save(updatedVariable);
+                }
+                const createdVariable = await this._fcodeGraphQLClient.pushVariable(variable);
+                return this._repository.save(createdVariable);
+            }
+            if (this._repository._repositoryName === 'dependencies') {
+                const updatedProgrammingLanguageManifests = await this._fcodeGraphQLClient.pushProgrammingLanguageManifest(resource);
+                return this._repository.save(updatedProgrammingLanguageManifests);
+            }
+        }
+        catch (error) {
+            if (this._fcodeGraphQLClient.isDuplicatedError(error)) {
+                cli_1.default.log(color_1.default.red(`🚨 '${resource.slug}' couldn't be pushed as other ${this._repository._repositoryName} exists in remote with the same attributes`));
+                resource.errorPushing = true;
+            }
+            else if (this._fcodeGraphQLClient.isEmptyValueError(error)) {
+                cli_1.default.log(color_1.default.red(`🚨 '${resource.slug}' couldn't be pushed as the value is empty`));
+                resource.errorPushing = true;
+            }
+            else {
+                cli_1.default.log(color_1.default.red(`🚨 '${resource.slug}' couldn't be pushed. Error: ${error.message}`));
+                resource.errorPushing = true;
+            }
+        }
+        return resource;
+    }
+    async removeResource(resource) {
+        try {
+            if (this._repository._repositoryName === 'processes') {
+                await this._fcodeGraphQLClient.removeProcess(resource.id);
+            }
+            if (this._repository._repositoryName === 'modules') {
+                await this._fcodeGraphQLClient.removeScriptLibrary(resource.id);
+            }
+            if (this._repository._repositoryName === 'variables') {
+                await this._fcodeGraphQLClient.removeVariable(resource.id);
+            }
+            this._repository.removeMetadata(resource.slug);
+        }
+        catch (error) {
+            cli_1.default.log(color_1.default.red(`🚨 '${resource.slug}' couldn't be removed. Error: ${error.message}`));
+            resource.errorPushing = true;
+        }
+        return resource;
+    }
+    async confirmPushResourcePromt(resource, status) {
+        cli_1.default.log(`🔥  '${color_1.default.red(resource.slug)}' has been ${status === types_1.ResourceStatus.CONFLICT ? 'modified both remote and local' : 'removed from local'}!`);
+        if (await cli_1.default.confirm('Do you want force push to remote? yes/no')) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.default = ResourcePusher;

package/dist/core/resource-repository.d.ts

@@ -0,0 +1,8 @@
+import { Resource } from './types';
+export default interface ResourceRepository<R extends Resource> {
+    exists(slug: string): Promise<boolean>;
+    findAll(): Promise<Array<R>>;
+    find(slug: string): Promise<R>;
+    remove(slug: string): Promise<void>;
+    save(resource: R): Promise<R>;
+}

package/dist/core/resource-repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });