@factorialco/fcode-cli 1.1.0

package/dist/config/remote.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("node:path");
+const fs = require("fs-extra");
+const node_crypto_1 = require("node:crypto");
+const hash = function (remote) {
+    return (0, node_crypto_1.createHash)('md5').update(remote).digest('hex');
+};
+class RemoteConfig {
+    static save(hash, team, configPath = process.cwd()) {
+        const sortedTeam = this.sortDeeply(team);
+        fs.writeJsonSync(RemoteConfig.configPath(hash, configPath), sortedTeam, { spaces: 2 });
+    }
+    static get(hash, configPath = process.cwd()) {
+        const path = RemoteConfig.configPath(hash, configPath);
+        if (fs.pathExistsSync(path)) {
+            return fs.readJsonSync(path);
+        }
+    }
+    static sortDeeply(config) {
+        for (let [key, value] of Object.entries(config)) {
+            if (Array.isArray(value)) {
+                config[key] = value.map((item) => (typeof item === 'object' && item !== null ? this.sortDeeply(item) : item));
+            }
+            else if (typeof value === 'object' && value !== null) {
+                config[key] = this.sortDeeply(value);
+            }
+        }
+        return this.sort(config);
+    }
+    static sort(config) {
+        if (Array.isArray(config)) {
+            return config;
+        }
+        return Object.keys(config)
+            .sort()
+            .reduce((obj, key) => {
+            obj[key] = config[key];
+            return obj;
+        }, {});
+    }
+    constructor(remote, configPath = process.cwd()) {
+        this.remote = remote;
+        this.hash = hash(remote);
+        this.configPath = RemoteConfig.configPath(this.hash, configPath);
+        this.createDir(this.configPath);
+        return this;
+    }
+    init() {
+        fs.writeJsonSync(this.configPath, { slug: this.remote, modules: {}, processes: {}, variables: {}, dependencies: {}, team: {} }, { spaces: 2 });
+    }
+    createDir(configPath) {
+        if (!fs.pathExistsSync(configPath)) {
+            fs.mkdirpSync(path.dirname(configPath));
+        }
+    }
+}
+RemoteConfig.FCODE_REMOTE_CONFIG_FILENAME = 'remote.<hash>.json';
+RemoteConfig.configPath = (hash, configPath = process.cwd()) => path.join(configPath, RemoteConfig.FCODE_REMOTE_CONFIG_FILENAME.replace('<hash>', hash));
+exports.default = RemoteConfig;

package/dist/config/settings.d.ts

@@ -0,0 +1,16 @@
+export interface SettingDefinition {
+    key: string;
+    default: string;
+    description?: string;
+}
+export declare enum SettingKeys {
+    DISABLE_UPDATE_NOTIFIER = "disableUpdateNotifier",
+    IGNORE_PROCESS_VERSIONS = "ignoreProcessVersions",
+    IGNORE_WORKSPACE_NOT_EMPTY = "ignoreWorkspaceNotEmpty",
+    IGNORE_FCODE_RUN_PROCESSES = "ignoreFcodeRunProcesses",
+    LOCAL_VARIABLES_FILE_NAME = "localVariablesFileName",
+    SKIP_SKILLS_SETUP = "skipSkillsSetup",
+    VARIABLES_FILE_NAME = "variablesFileName"
+}
+export declare const SETTINGS_DEFINITIONS: SettingDefinition[];
+export declare function getSettingDefault(key: string): string | undefined;

package/dist/config/settings.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTINGS_DEFINITIONS = exports.SettingKeys = void 0;
+exports.getSettingDefault = getSettingDefault;
+var SettingKeys;
+(function (SettingKeys) {
+    SettingKeys["DISABLE_UPDATE_NOTIFIER"] = "disableUpdateNotifier";
+    SettingKeys["IGNORE_PROCESS_VERSIONS"] = "ignoreProcessVersions";
+    SettingKeys["IGNORE_WORKSPACE_NOT_EMPTY"] = "ignoreWorkspaceNotEmpty";
+    SettingKeys["IGNORE_FCODE_RUN_PROCESSES"] = "ignoreFcodeRunProcesses";
+    SettingKeys["LOCAL_VARIABLES_FILE_NAME"] = "localVariablesFileName";
+    SettingKeys["SKIP_SKILLS_SETUP"] = "skipSkillsSetup";
+    SettingKeys["VARIABLES_FILE_NAME"] = "variablesFileName";
+})(SettingKeys || (exports.SettingKeys = SettingKeys = {}));
+exports.SETTINGS_DEFINITIONS = [
+    {
+        key: SettingKeys.IGNORE_WORKSPACE_NOT_EMPTY,
+        default: 'false',
+        description: 'Ignore workspace not empty error',
+    },
+    {
+        key: SettingKeys.DISABLE_UPDATE_NOTIFIER,
+        default: 'false',
+        description: 'Disable update notifier',
+    },
+    {
+        key: SettingKeys.SKIP_SKILLS_SETUP,
+        default: 'false',
+        description: 'Skip Factorial Code agent skills install on clone',
+    },
+    {
+        key: SettingKeys.IGNORE_FCODE_RUN_PROCESSES,
+        default: 'false',
+        description: 'Ignore Factorial Code run processes',
+    },
+    {
+        key: SettingKeys.IGNORE_PROCESS_VERSIONS,
+        default: 'false',
+        description: 'Ignore process versions',
+    },
+    {
+        key: SettingKeys.VARIABLES_FILE_NAME,
+        default: 'variables.env',
+        description: 'Variables file name',
+    },
+    {
+        key: SettingKeys.LOCAL_VARIABLES_FILE_NAME,
+        default: 'variables.local.env',
+        description: 'Local variables file name',
+    },
+];
+function getSettingDefault(key) {
+    return exports.SETTINGS_DEFINITIONS.find((def) => def.key === key)?.default;
+}

package/dist/config/workspace.d.ts

@@ -0,0 +1,28 @@
+import { ProgrammingLanguage, ResourceMetadata, TeamOrigin, type Resource, type TeamMetadata } from '../core/types';
+import Config from './index';
+export declare function unparseTeamOrigin({ url, slug }: TeamOrigin): string;
+declare class WorkspaceConfig extends Config {
+    private static CONFIG_PATH;
+    private static CONFIG_FILENAME;
+    constructor(configPath?: string);
+    init(origin: TeamOrigin): Promise<void>;
+    getTeamOrigin(): Promise<TeamOrigin>;
+    getActiveTeamSlug(): Promise<string>;
+    getActiveTeam(): Promise<TeamMetadata>;
+    getTeam(slug: string): Promise<TeamMetadata>;
+    getAllTeams(): Promise<TeamMetadata[]>;
+    private setTeam;
+    getAddedTeams(): Promise<string[]>;
+    setActiveTeam(slug: string): Promise<void>;
+    private getCollectionByType;
+    private getCollectionByClass;
+    exists(resourceType: string, slug: string): Promise<boolean>;
+    getInAnyTeam(resourceType: string, slug: string): Promise<Resource | null>;
+    getStoredHash(resource: Resource): Promise<string>;
+    getTeamStoredHash(): Promise<string | undefined>;
+    setTeamStoredHash(contentHash: string): Promise<void>;
+    add(resourceType: string, resourceMetadata: ResourceMetadata): Promise<void>;
+    remove(resourceType: string, slug: string): Promise<void>;
+}
+export default WorkspaceConfig;
+export declare const baseDependenciesPath: (programmingLanguage: ProgrammingLanguage) => string;

package/dist/config/workspace.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseDependenciesPath = void 0;
+exports.unparseTeamOrigin = unparseTeamOrigin;
+const path = require("node:path");
+const types_1 = require("../core/types");
+const remote_1 = require("./remote");
+const errors_1 = require("../core/errors");
+const index_1 = require("./index");
+const cli_1 = require("../utils/cli");
+const color_1 = require("@oclif/color");
+const global_1 = require("./global");
+function unparseTeamOrigin({ url, slug }) {
+    return url === global_1.FCODE_CLOUD_URL ? slug : `${url}/${slug}`;
+}
+class WorkspaceConfig extends index_1.default {
+    constructor(configPath = process.cwd()) {
+        super(path.join(configPath, WorkspaceConfig.CONFIG_PATH), WorkspaceConfig.CONFIG_FILENAME);
+    }
+    async init(origin) {
+        const team = unparseTeamOrigin(origin);
+        const remoteConfig = new remote_1.default(team, this.configDir);
+        await remoteConfig.init();
+        await index_1.default.initConfig(this.configPath, {
+            activeTeam: team,
+            teams: { [team]: remoteConfig.hash },
+        });
+    }
+    async getTeamOrigin() {
+        const team = await this.getActiveTeam();
+        return (0, global_1.parseTeamOrigin)(team.slug);
+    }
+    async getActiveTeamSlug() {
+        return (await this.get('activeTeam')) || '';
+    }
+    async getActiveTeam() {
+        const slug = await this.getActiveTeamSlug();
+        return this.getTeam(slug);
+    }
+    async getTeam(slug) {
+        if (!slug) {
+            throw new errors_1.NotFcodeWorkspace();
+        }
+        const config = await this.getAll();
+        const team = remote_1.default.get(config.teams[slug], this.configDir);
+        if (team) {
+            return team;
+        }
+        throw new errors_1.NotFcodeWorkspace();
+    }
+    async getAllTeams() {
+        const config = await this.getAll();
+        return Promise.all(Object.keys(config.teams).map(async (slug) => this.getTeam(slug)));
+    }
+    async setTeam(team) {
+        const config = await this.getAll();
+        const activeTeam = config.activeTeam;
+        if (!activeTeam) {
+            throw new errors_1.NotFcodeWorkspace();
+        }
+        const hash = config.teams[activeTeam];
+        await remote_1.default.save(hash, team, this.configDir);
+    }
+    async getAddedTeams() {
+        const config = await this.getAll();
+        return Object.keys(config.teams);
+    }
+    async setActiveTeam(slug) {
+        await this.set('activeTeam', slug);
+        const teams = (await this.get('teams')) || {};
+        if (!teams[slug]) {
+            const remoteConfig = new remote_1.default(slug, this.configDir);
+            await remoteConfig.init();
+            teams[slug] = remoteConfig.hash;
+            await this.set('teams', teams);
+        }
+    }
+    async getCollectionByType(team, resourceType) {
+        if (resourceType === 'processes') {
+            return team.processes;
+        }
+        else if (resourceType === 'modules') {
+            return team.modules;
+        }
+        else if (resourceType === 'variables') {
+            return team.variables;
+        }
+        else if (resourceType === 'dependencies') {
+            return team.dependencies;
+        }
+        throw new Error('Unknow resource type');
+    }
+    async getCollectionByClass(team, resource) {
+        if (resource instanceof types_1.Process) {
+            return team.processes;
+        }
+        else if (resource instanceof types_1.ScriptLibrary) {
+            return team.modules;
+        }
+        else if (resource instanceof types_1.Variable) {
+            return team.variables;
+        }
+        else if (resource instanceof types_1.ProgrammingLanguageManifest) {
+            return team.dependencies;
+        }
+        throw new Error('Unknow resource type');
+    }
+    async exists(resourceType, slug) {
+        return (await this.getCollectionByType(await this.getActiveTeam(), resourceType))[slug];
+    }
+    async getInAnyTeam(resourceType, slug) {
+        const teams = await this.getAllTeams();
+        for (const team of teams) {
+            const resource = (await this.getCollectionByType(team, resourceType))[slug];
+            if (resource) {
+                return resource;
+            }
+        }
+        return null;
+    }
+    async getStoredHash(resource) {
+        const metadata = (await this.getCollectionByClass(await this.getActiveTeam(), resource))[resource.slug];
+        return metadata?.contentHash;
+    }
+    async getTeamStoredHash() {
+        return (await this.getActiveTeam()).team?.contentHash;
+    }
+    async setTeamStoredHash(contentHash) {
+        const team = await this.getActiveTeam();
+        await this.setTeam({ ...team, team: { contentHash } });
+    }
+    async add(resourceType, resourceMetadata) {
+        const team = await this.getActiveTeam();
+        await this.setTeam({
+            ...team,
+            [resourceType]: {
+                ...team[resourceType],
+                [resourceMetadata.slug]: resourceMetadata,
+            },
+        });
+    }
+    async remove(resourceType, slug) {
+        const team = await this.getActiveTeam();
+        if (!team[resourceType][slug]) {
+            cli_1.default.log(color_1.default.red(`🧐 ${resourceType} not found for slug '${slug}'`));
+            return;
+        }
+        delete team[resourceType][slug];
+        await this.setTeam(team);
+    }
+}
+WorkspaceConfig.CONFIG_PATH = '.fcode';
+WorkspaceConfig.CONFIG_FILENAME = 'workspace.json';
+exports.default = WorkspaceConfig;
+const baseDependenciesPath = (programmingLanguage) => {
+    return path.join(path.join(index_1.default.FCODE_CONFIG_PATH, index_1.default.FCODE_DEPENDENCIES_FOLDER, programmingLanguage === 'JAVASCRIPT' ? 'node' : programmingLanguage.toLowerCase()));
+};
+exports.baseDependenciesPath = baseDependenciesPath;

package/dist/core/commands/api-client-command.d.ts

@@ -0,0 +1,6 @@
+import BaseCommand from './base-command';
+import FcodeGraphQLClient from '../../services/fcode-graphql-client';
+export default abstract class ApiClientCommand extends BaseCommand {
+    _fcodeGraphQLClient: FcodeGraphQLClient;
+    init(): Promise<void>;
+}

package/dist/core/commands/api-client-command.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("./base-command");
+const errors_1 = require("../errors");
+const fcode_graphql_client_1 = require("../../services/fcode-graphql-client");
+class ApiClientCommand extends base_command_1.default {
+    async init() {
+        await super.init();
+        try {
+            const { url, slug } = await this.workspaceConfig.getTeamOrigin();
+            const { token: { access_token: accessToken }, } = await this.globalConfig.getAuthInfo(url);
+            this._fcodeGraphQLClient = new fcode_graphql_client_1.default({
+                url,
+                accessToken,
+                teamSlug: slug,
+            });
+        }
+        catch (error) {
+            if (error instanceof errors_1.NotAuthenticated) {
+                this.error(error.message, {
+                    code: 'ERR_NOT_AUTHENTICATED',
+                    exit: 1,
+                    suggestions: ['fcode login'],
+                });
+            }
+            throw error;
+        }
+    }
+}
+exports.default = ApiClientCommand;

package/dist/core/commands/base-command.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+import GlobalConfig from '../../config/global';
+import WorkspaceConfig from '../../config/workspace';
+export default abstract class BaseCommand extends Command {
+    url?: string;
+    globalConfig: GlobalConfig;
+    workspaceConfig: WorkspaceConfig;
+    catch(error: any): Promise<any>;
+    init(url?: string): Promise<void>;
+    protected logActiveTeam(): Promise<void>;
+}

package/dist/core/commands/base-command.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const global_1 = require("../../config/global");
+const workspace_1 = require("../../config/workspace");
+const color_1 = require("@oclif/color");
+const errors_1 = require("../errors");
+const cli_1 = require("../../utils/cli");
+const url_utils_1 = require("../../utils/url-utils");
+class BaseCommand extends core_1.Command {
+    async catch(error) {
+        // do any extra work with error
+        if (error && error.response && error.response.status === 401) {
+            cli_1.default.error(`User authentication is invalid for current team.`);
+            return;
+        }
+        if (error instanceof errors_1.NotAuthenticated) {
+            let errorMessage = 'No session active. Logging you in';
+            const loginArgs = [];
+            let url = error.getUrl() || this.url;
+            if (!url || url === global_1.FCODE_CLOUD_URL) {
+                url = undefined;
+            }
+            else {
+                loginArgs.push('--url', url);
+                errorMessage += ` to ${url}`;
+                const { authUrl } = await new global_1.default().getAuthInfo(url);
+                if (!(0, url_utils_1.isDefaultAuthUrl)(authUrl, url)) {
+                    loginArgs.push('--authUrl', authUrl);
+                    if (authUrl) {
+                        errorMessage += ` (with authUrl ${authUrl})`;
+                    }
+                }
+            }
+            cli_1.default.error(`${errorMessage}...`);
+            await this.config.runCommand('login', loginArgs).catch((e) => cli_1.default.error(e.message));
+            cli_1.default.log('');
+            cli_1.default.log('🔁 Retrying command after login...');
+            cli_1.default.log('');
+            return this.run();
+        }
+        if (error instanceof errors_1.CLIError) {
+            cli_1.default.error(error);
+            return;
+        }
+        cli_1.default.error(error.message);
+    }
+    async init(url) {
+        this.url = url;
+        this.globalConfig = new global_1.default();
+        this.workspaceConfig = new workspace_1.default();
+        const workspaceUrl = url || (await this.workspaceConfig.getTeamOrigin()).url;
+        const { authUrl } = await this.globalConfig.getAuthInfo(workspaceUrl);
+        await this.config.runHook('auth', { argv: [workspaceUrl, authUrl], id: 'init' });
+    }
+    async logActiveTeam() {
+        const { slug, url } = await this.workspaceConfig.getTeamOrigin();
+        cli_1.default.log(color_1.default.magenta(`💻 Working on Factorial Code team '${slug}${url !== global_1.FCODE_CLOUD_URL ? ` (${url})` : ''}'.`));
+    }
+}
+exports.default = BaseCommand;

package/dist/core/commands/dependency-command.d.ts

@@ -0,0 +1,5 @@
+import { ProgrammingLanguageManifest } from '../types';
+import ResourceCommand from './resource-command';
+export default abstract class DependencyCommand extends ResourceCommand<ProgrammingLanguageManifest> {
+    init(): Promise<void>;
+}

package/dist/core/commands/dependency-command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const programming_language_manifest_1 = require("../../repositories/programming-language-manifest");
+const resource_merger_1 = require("../resource-merger");
+const resource_pusher_1 = require("../resource-pusher");
+const resource_command_1 = require("./resource-command");
+class DependencyCommand extends resource_command_1.default {
+    async init() {
+        await super.init();
+        this._resourceRepository = new programming_language_manifest_1.default();
+        this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
+        this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
+        this._resourceQuery = () => this._fcodeGraphQLClient.allProgrammingLanguageManifest.bind(this._fcodeGraphQLClient)();
+    }
+}
+exports.default = DependencyCommand;

package/dist/core/commands/modules-command.d.ts

@@ -0,0 +1,7 @@
+import { ScriptLibrary, VersionedScriptLibrary } from '../types';
+import ResourceCommand from './resource-command';
+export default abstract class ModulesCommand extends ResourceCommand<ScriptLibrary> {
+    _versionedResourceQuery: (id: string) => Promise<Array<VersionedScriptLibrary>>;
+    _pushVersionedResourceMutation: (versionedProcess: VersionedScriptLibrary) => Promise<void>;
+    init(): Promise<void>;
+}

package/dist/core/commands/modules-command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const script_library_1 = require("../../repositories/script-library");
+const resource_merger_1 = require("../resource-merger");
+const resource_pusher_1 = require("../resource-pusher");
+const resource_command_1 = require("./resource-command");
+class ModulesCommand extends resource_command_1.default {
+    async init() {
+        await super.init();
+        this._resourceRepository = new script_library_1.default();
+        this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
+        this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
+        this._resourceQuery = () => this._fcodeGraphQLClient.allScriptLibraries.bind(this._fcodeGraphQLClient)();
+        this._versionedResourceQuery = (id) => this._fcodeGraphQLClient.allVersionedScriptLibraries.bind(this._fcodeGraphQLClient)(id);
+        this._pushVersionedResourceMutation = (versionedScriptLibrary) => this._fcodeGraphQLClient.createVersionedScriptLibrary.bind(this._fcodeGraphQLClient)(versionedScriptLibrary);
+    }
+}
+exports.default = ModulesCommand;

package/dist/core/commands/processes-command.d.ts

@@ -0,0 +1,8 @@
+import { Process, VersionedProcess } from '../types';
+import ResourceCommand from './resource-command';
+export default abstract class ProcessesCommand extends ResourceCommand<Process> {
+    _versionedResourceQuery: (id: string) => Promise<Array<VersionedProcess>>;
+    _pushVersionedResourceMutation: (versionedProcess: VersionedProcess) => Promise<void>;
+    init(): Promise<void>;
+    getRemoteResources(): Promise<Array<Process>>;
+}

package/dist/core/commands/processes-command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("../../config/settings");
+const process_1 = require("../../repositories/process");
+const resource_merger_1 = require("../resource-merger");
+const resource_pusher_1 = require("../resource-pusher");
+const resource_command_1 = require("./resource-command");
+class ProcessesCommand extends resource_command_1.default {
+    async init() {
+        await super.init();
+        this._resourceRepository = new process_1.default();
+        this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
+        this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
+        this._resourceQuery = () => this._fcodeGraphQLClient.allProcesses.bind(this._fcodeGraphQLClient)();
+        this._versionedResourceQuery = (id) => this._fcodeGraphQLClient.allVersionedProcesses.bind(this._fcodeGraphQLClient)(id);
+        this._pushVersionedResourceMutation = (versionedProcess) => this._fcodeGraphQLClient.createVersionedProcesses.bind(this._fcodeGraphQLClient)(versionedProcess);
+    }
+    async getRemoteResources() {
+        const processes = await super.getRemoteResources();
+        const ignoreFcodeRunProcesses = (await this.globalConfig.getSetting(settings_1.SettingKeys.IGNORE_FCODE_RUN_PROCESSES)) === 'true';
+        if (ignoreFcodeRunProcesses) {
+            return processes.filter((process) => !process.tags?.includes('fc-run'));
+        }
+        return processes;
+    }
+}
+exports.default = ProcessesCommand;

package/dist/core/commands/resource-command.d.ts

@@ -0,0 +1,24 @@
+import type { AddResourceOptions, MergedResource, Resource } from '../types';
+import ResourceRepositoryBase from '../../repositories/resource';
+import ResourceMerger from '../resource-merger';
+import ResourcePusher from '../resource-pusher';
+import ApiClientCommand from './api-client-command';
+export default abstract class ResourceCommand<R extends Resource> extends ApiClientCommand {
+    _resourceMerger: ResourceMerger<R>;
+    _resourcePusher: ResourcePusher<R>;
+    _resourceQuery: () => Promise<Array<R>>;
+    _resourceRepository: ResourceRepositoryBase<R>;
+    protected resourceSlug: string;
+    protected filterResource: (slug: string) => boolean;
+    getLocalResources(): Promise<Array<R>>;
+    getRemoteResources(): Promise<Array<R>>;
+    findSlugsNotAdded(): Promise<Array<string>>;
+    init(): Promise<void>;
+    pullResources(): Promise<void>;
+    resetResources(): Promise<void>;
+    addResources(opts?: AddResourceOptions): Promise<void>;
+    removeResource(slug: string): Promise<void>;
+    pushResources(): Promise<void>;
+    resourcesLog(): Promise<void>;
+    resourcesTableLog(resources: Array<MergedResource>): Promise<void>;
+}

package/dist/core/commands/resource-command.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const cli_1 = require("../../utils/cli");
+const api_client_command_1 = require("./api-client-command");
+const colorize_resource_1 = require("../../utils/colorize-resource");
+class ResourceCommand extends api_client_command_1.default {
+    constructor() {
+        super(...arguments);
+        this.filterResource = (slug) => !this.resourceSlug || slug === this.resourceSlug;
+    }
+    async getLocalResources() {
+        const resources = await this._resourceRepository.findAll();
+        return resources.filter((resource) => this.filterResource(resource.slug));
+    }
+    async getRemoteResources() {
+        const resources = await this._resourceQuery();
+        return resources.filter((resource) => this.filterResource(resource.slug));
+    }
+    async findSlugsNotAdded() {
+        const slugsNotAdded = await this._resourceRepository.findSlugsNotAdded();
+        return slugsNotAdded.filter((slug) => this.filterResource(slug));
+    }
+    async init() {
+        await super.init();
+        const { argv: [resourceSlug], } = await this.parse(this.ctor);
+        this.resourceSlug = resourceSlug;
+    }
+    async pullResources() {
+        const { flags: { force }, } = await this.parse(this.ctor);
+        cli_1.default.log(color_1.default.cyan(`\n🗄️  pulling ${this._resourceRepository._repositoryName}...`));
+        await this._resourceMerger.mergeForPull(await this.getRemoteResources(), await this.getLocalResources(), force);
+    }
+    async resetResources() {
+        cli_1.default.log(color_1.default.cyan(`\n🧹  reseting ${this._resourceRepository._repositoryName}...`));
+        await this._resourceMerger.reset(await this.getRemoteResources(), await this.getLocalResources());
+    }
+    async addResources(opts) {
+        const slugsNotAdded = await this.findSlugsNotAdded();
+        if (!slugsNotAdded.length) {
+            cli_1.default.log(color_1.default.cyan(`🧐 no local ${this._resourceRepository._repositoryName} found to be added`));
+            return;
+        }
+        for (const slug of slugsNotAdded) {
+            cli_1.default.log(color_1.default.cyan(`✨ adding ${this._resourceRepository._repositoryName} '${slug}'...`));
+            if (this._resourceRepository._repositoryName === 'processes') {
+                this._resourceRepository.ensureAllFilesExist(slug);
+            }
+            await this.workspaceConfig.add(this._resourceRepository._repositoryName, await this._resourceRepository.metadataFromFiles(slug, opts));
+        }
+    }
+    async removeResource(slug) {
+        await this.workspaceConfig.remove(this._resourceRepository._repositoryName, slug);
+        cli_1.default.log(`\n🗑️  '${slug}' successfully removed from ${this._resourceRepository._repositoryName}`);
+    }
+    async pushResources() {
+        const { flags: { force }, } = await this.parse(this.ctor);
+        await this._resourcePusher.push(await this.getRemoteResources(), await this.getLocalResources(), force);
+    }
+    async resourcesLog() {
+        cli_1.default.log(color_1.default.cyan(`\n${this._resourceRepository._repositoryName} status`));
+        const mergedResources = await this._resourceMerger.mergeStatus(await this.getRemoteResources(), await this.getLocalResources());
+        if (mergedResources.length > 0) {
+            await this.resourcesTableLog(mergedResources);
+        }
+        else {
+            cli_1.default.log(`No ${this._resourceRepository._repositoryName} found`);
+        }
+        const slugsNotAdded = await this.findSlugsNotAdded();
+        if (slugsNotAdded.length > 0) {
+            const warningText = `\nℹ️  ${slugsNotAdded.length} ${this._resourceRepository._repositoryName} only existing in local: ${slugsNotAdded.join(', ')}\n   Use command 'fcode ${this._resourceRepository._repositoryName}:add' to keep track of these resources`;
+            cli_1.default.log(color_1.default.yellow(warningText));
+        }
+    }
+    async resourcesTableLog(resources) {
+        cli_1.default.table(resources, {
+            name: {
+                get({ slug, status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(slug, status);
+                },
+                header: 'name',
+            },
+            status: {
+                get({ status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(status, status);
+                },
+                header: 'status',
+            },
+        }, { sort: 'name' });
+    }
+}
+exports.default = ResourceCommand;

package/dist/core/commands/variables-command.d.ts

@@ -0,0 +1,5 @@
+import { Variable } from '../types';
+import ResourceCommand from './resource-command';
+export default abstract class VariablesCommand extends ResourceCommand<Variable> {
+    init(): Promise<void>;
+}

package/dist/core/commands/variables-command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const variable_1 = require("../../repositories/variable");
+const resource_merger_1 = require("../resource-merger");
+const resource_pusher_1 = require("../resource-pusher");
+const resource_command_1 = require("./resource-command");
+class VariablesCommand extends resource_command_1.default {
+    async init() {
+        await super.init();
+        this._resourceRepository = new variable_1.default();
+        this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
+        this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
+        this._resourceQuery = () => this._fcodeGraphQLClient.allVariables.bind(this._fcodeGraphQLClient)();
+    }
+}
+exports.default = VariablesCommand;