@factorialco/fcode-cli 1.1.0

package/dist/hooks/init/update.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const node_child_process_1 = require("node:child_process");
+const global_1 = require("../../config/global");
+const settings_1 = require("../../config/settings");
+const VERSION_CHECK_INTERVAL = 1000 * 60 * 60 * 6;
+const updateNotifier = async function ({ config, id }) {
+    const globalConfig = new global_1.default();
+    const disableUpdateNotifier = process.env.FCODE_DISABLE_UPDATE_NOTIFIER === 'true' ||
+        (await globalConfig.getSetting(settings_1.SettingKeys.DISABLE_UPDATE_NOTIFIER)) === 'true';
+    if (disableUpdateNotifier) {
+        return;
+    }
+    const versionCheckTime = (await globalConfig.get('versionCheckTime')) || 0;
+    const now = Date.now();
+    if (now - versionCheckTime > VERSION_CHECK_INTERVAL || id === '--version') {
+        try {
+            const lastestVersion = (0, node_child_process_1.execSync)('npm show @factorialco/fcode-cli version', { stdio: 'pipe' }).toString().trim();
+            await globalConfig.set('versionCheckTime', now);
+            if (config.version !== lastestVersion) {
+                console.log(`
+        ${color_1.default.cyan(`__     __         _____          _
+        \\ \\   / /        / ____|        | |
+         \\ \\_/ /__ _ __ | |     ___   __| | ___
+          \\   / _ \\ '_ \\| |    / _ \\ / _\` |/ _ \\
+           | |  __/ |_) | |___| (_) | (_| |  __/
+           |_|\\___| .__/ \\_____\\___/ \\__,_|\\___|
+                  | |
+                  |_|`)}
+
+        Update available ${color_1.default.red(config.version)} → ${color_1.default.greenBright(lastestVersion)}
+        Run ${color_1.default.bold('`npm i -g @factorialco/fcode-cli`')} to update
+        `);
+            }
+        }
+        catch {
+            console.log(`⚠️ ${color_1.default.red(' There was an error while attempting to check for updates.')}\n`);
+        }
+    }
+};
+exports.default = updateNotifier;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/repositories/process.d.ts

@@ -0,0 +1,36 @@
+import { Process, ResourceMetadata, VersionedProcess } from '../core/types';
+import ResourceRepositoryBase from './resource';
+declare class ProcessRepository extends ResourceRepositoryBase<Process> {
+    constructor();
+    protected buildResourcePath(process: Process, filename: string, version?: string): string;
+    protected resourceDirectoryName(process: Process): string;
+    protected getSourceCodeFileName(programmingLanguage: string): string;
+    findAll(): Promise<Array<Process>>;
+    private allFilesExist;
+    private mandatoryFilesExist;
+    ensureAllFilesExist(processSlug: string): void;
+    findSlugsNotAdded(): Promise<Array<string>>;
+    find(processSlug: string, version?: string): Promise<Process>;
+    private readMetadataFile;
+    private buildMetadata;
+    findParameters(processSlug: string): Promise<any>;
+    getLastFileModifiedDate(process: Process, filename: string): Promise<Date>;
+    protected getResourcePath(process: Process): string;
+    protected removeFiles(process: Process): Promise<void>;
+    protected resourceToMetadata(process: Process): ResourceMetadata;
+    metadataFromFiles(slug: string): Promise<ResourceMetadata>;
+    protected saveFiles(process: Process): Promise<void>;
+    private versionsDirectory;
+    private versionDirectory;
+    versionHasChanges(process: Process, version: VersionedProcess): Promise<boolean>;
+    getLocalVersionTags(process: Process): string[];
+    versionExistsLocally(process: Process, tag: string): boolean;
+    removeVersion(process: Process, tag: string): void;
+    saveVersion(process: Process, version: VersionedProcess): Promise<void>;
+    getVersions(process: Process): Promise<Array<VersionedProcess>>;
+    private dependenciesFile;
+    getProcessFullPath(processSlug: string, version?: string): Promise<string>;
+    private getProcessMetadata;
+    private processHash;
+}
+export default ProcessRepository;

package/dist/repositories/process.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const crypto = require("node:crypto");
+const path = require("node:path");
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+const errors_1 = require("../core/errors");
+const types_1 = require("../core/types");
+const process_parameters_sampler_1 = require("../services/process-parameters-sampler");
+const filenamify_1 = require("../utils/filenamify");
+const file_utils_1 = require("../utils/file-utils");
+const resource_1 = require("./resource");
+const resource_checker_1 = require("../services/resource-checker");
+const dependencies_1 = require("../core/utils/dependencies");
+const PROGRAMMING_LANGUAGE_DEPENDENCIES_FILE_NAME = {
+    JAVASCRIPT: 'package.json',
+    PYTHON: 'requirements.txt',
+};
+class ProcessRepository extends resource_1.default {
+    constructor() {
+        super({
+            name: 'processes',
+        });
+    }
+    buildResourcePath(process, filename, version) {
+        let directory = this.resourceDirectoryName(process);
+        if (version) {
+            directory = path.join(directory, 'versions', version);
+        }
+        return path.join(this._repositoryName, directory, filename);
+    }
+    resourceDirectoryName(process) {
+        return (0, filenamify_1.default)(process.slug);
+    }
+    getSourceCodeFileName(programmingLanguage) {
+        return programmingLanguage === 'PYTHON' ? 'main.py' : 'index.js';
+    }
+    async findAll() {
+        const { processes } = await this.workspaceConfig.getActiveTeam();
+        const existProcesses = await Object.keys(processes).reduce((promise, processSlug) => promise.then(async (existNames) => {
+            const exists = await this.exists(processSlug);
+            if (exists) {
+                return [...existNames, processSlug];
+            }
+            return existNames;
+        }), Promise.resolve([]));
+        const localProcesses = Promise.all(existProcesses.map((processSlug) => this.find(processSlug)));
+        return localProcesses;
+    }
+    allFilesExist(processSlug, version) {
+        const processDirectory = path.join(this._repositoryName, processSlug, version ? 'versions' : '', version || '');
+        const existsSourceCode = fs.pathExistsSync(path.join(processDirectory, 'index.js')) || fs.pathExistsSync(path.join(processDirectory, 'main.py'));
+        const existsReadme = fs.pathExistsSync(path.join(processDirectory, 'README.md'));
+        const existsParametersSchema = fs.pathExistsSync(path.join(processDirectory, 'parametersSchema.json'));
+        const existsMetadata = fs.pathExistsSync(path.join(processDirectory, 'metadata.json'));
+        return existsSourceCode && existsReadme && existsMetadata && existsParametersSchema;
+    }
+    mandatoryFilesExist(processSlug, version) {
+        const processDirectory = path.join(this._repositoryName, processSlug, version ? 'versions' : '', version || '');
+        const existsSourceCode = fs.pathExistsSync(path.join(processDirectory, 'index.js')) || fs.pathExistsSync(path.join(processDirectory, 'main.py'));
+        return existsSourceCode;
+    }
+    ensureAllFilesExist(processSlug) {
+        const processDirectory = path.join(this._repositoryName, processSlug);
+        const existsReadme = fs.pathExistsSync(path.join(processDirectory, 'README.md'));
+        const existsParametersSchema = fs.pathExistsSync(path.join(processDirectory, 'parametersSchema.json'));
+        const existsMetadata = fs.pathExistsSync(path.join(processDirectory, 'metadata.json'));
+        if (!existsReadme) {
+            cli_1.cli.log(color_1.default.green(`ℹ️  local process directory '${processSlug}' doesn't have a README.md file and will be created.`));
+            fs.writeFileSync(path.join(processDirectory, 'README.md'), '');
+        }
+        if (!existsParametersSchema) {
+            cli_1.cli.log(color_1.default.green(`ℹ️  local process directory '${processSlug}' doesn't have a parametersSchema.json file and will be created.`));
+            fs.writeFileSync(path.join(processDirectory, 'parametersSchema.json'), '{}');
+        }
+        if (!existsMetadata) {
+            cli_1.cli.log(color_1.default.green(`ℹ️  local process directory '${processSlug}' doesn't have a metadata.json file and will be created.`));
+            fs.writeFileSync(path.join(processDirectory, 'metadata.json'), JSON.stringify({ name: processSlug, tags: [] }, null, 2));
+        }
+    }
+    async findSlugsNotAdded() {
+        const slugsNotAdded = [];
+        for (const directory of fs.readdirSync(this._repositoryName)) {
+            if (!(await this.workspaceConfig.exists('processes', directory))) {
+                if (!this.validSlug(directory)) {
+                    cli_1.cli.log(color_1.default.yellow(`\n⚠️  local process directory '${directory}' doesn't have a valid format and will be ignored. ${this.slugFormatMessage()}`));
+                }
+                else if (!this.mandatoryFilesExist(directory)) {
+                    cli_1.cli.log(color_1.default.yellow(`\n⚠️  local process directory '${directory}' doesn't have all the required files and will be ignored.`));
+                }
+                else {
+                    slugsNotAdded.push(directory);
+                }
+            }
+        }
+        return slugsNotAdded;
+    }
+    async find(processSlug, version) {
+        const processMetadata = await this.getProcessMetadata(processSlug);
+        if (!processMetadata) {
+            throw new errors_1.LocalProcessNotFound(new Error('Process not found on team metadata'), processSlug);
+        }
+        const readProcessFile = (filename) => fs.readFileSync(this.buildResourcePath(processMetadata, filename, version));
+        try {
+            const sourceCodeFile = await readProcessFile(this.getSourceCodeFileName(processMetadata.script.programmingLanguage));
+            const sourceCode = sourceCodeFile.toString();
+            let readme = '';
+            try {
+                readme = (await readProcessFile('README.md')).toString();
+            }
+            catch { }
+            const metadata = this.readMetadataFile(processMetadata, processSlug, version);
+            let parametersSchema = {};
+            try {
+                parametersSchema = fs.readJsonSync(this.buildResourcePath(processMetadata, 'parametersSchema.json', version));
+            }
+            catch { }
+            const dependenciesFile = this.dependenciesFile(processMetadata);
+            const isDependenciesFilePresent = fs.existsSync(dependenciesFile);
+            const manifest = isDependenciesFilePresent
+                ? { dependencies: (0, dependencies_1.dependenciesFromFile)(processMetadata.script.programmingLanguage, fs.readFileSync(dependenciesFile).toString()) }
+                : null;
+            return new types_1.Process(processMetadata.id, processMetadata.slug, { parametersSchema, programmingLanguage: processMetadata.script.programmingLanguage, sourceCode }, readme, manifest, { dependencies: { scopedToProcess: isDependenciesFilePresent } }, metadata, processMetadata.resolvingTeamSlug);
+        }
+        catch {
+            throw new Error(`Process ${processSlug} not found!`);
+        }
+    }
+    readMetadataFile(processMetadata, processSlug, version) {
+        try {
+            const raw = fs.readJsonSync(this.buildResourcePath(processMetadata, 'metadata.json', version));
+            return {
+                name: raw.name ?? processSlug,
+                description: raw.description,
+                tags: Array.isArray(raw.tags) ? raw.tags : [],
+                webhook: raw.webhook,
+                form: raw.form,
+                visibility: raw.visibility,
+            };
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                cli_1.cli.log(color_1.default.yellow(`\n⚠️  local process directory '${processSlug}' doesn't have a valid metadata.json file.`));
+            }
+            return { name: processSlug, tags: [] };
+        }
+    }
+    buildMetadata(process) {
+        const metadata = { name: process.name, tags: process.tags ?? [] };
+        if (process.description !== undefined) {
+            metadata.description = process.description;
+        }
+        if (process.webhook !== undefined) {
+            metadata.webhook = process.webhook;
+        }
+        if (process.form !== undefined) {
+            metadata.form = process.form;
+        }
+        if (process.visibility !== undefined) {
+            metadata.visibility = process.visibility;
+        }
+        return metadata;
+    }
+    async findParameters(processSlug) {
+        const processMetadata = await this.getProcessMetadata(processSlug);
+        if (!processMetadata) {
+            throw new errors_1.LocalProcessNotFound(new Error('Process not found on team metadata'), processSlug);
+        }
+        let parameters = {};
+        try {
+            parameters = fs.readJsonSync(this.buildResourcePath(processMetadata, 'parameters.json'));
+        }
+        catch { }
+        return parameters;
+    }
+    async getLastFileModifiedDate(process, filename) {
+        return new Promise((resolve, reject) => {
+            fs.stat(this.buildResourcePath(process, filename), (error, stats) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stats.mtime);
+                }
+            });
+        });
+    }
+    getResourcePath(process) {
+        throw new Error('Method not implemented.');
+    }
+    async removeFiles(process) {
+        await new Promise((resolve, reject) => {
+            try {
+                const processDirectory = path.join(this._repositoryName, this.resourceDirectoryName(process));
+                fs.removeSync(path.join(processDirectory, this.getSourceCodeFileName(process.script.programmingLanguage)));
+                fs.removeSync(path.join(processDirectory, 'README.md'));
+                fs.removeSync(path.join(processDirectory, 'metadata.json'));
+                fs.removeSync(path.join(processDirectory, 'parametersSchema.json'));
+                fs.removeSync(path.join(processDirectory, 'parameters.json'));
+                fs.removeSync(this.dependenciesFile(process));
+                const versionsDirectory = this.versionsDirectory(process);
+                if (fs.existsSync(versionsDirectory)) {
+                    fs.removeSync(versionsDirectory);
+                }
+                this.removeDirectoryIfEmpty(processDirectory);
+                resolve(true);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    resourceToMetadata(process) {
+        return {
+            id: process.id,
+            slug: process.slug,
+            script: {
+                programmingLanguage: process.script.programmingLanguage,
+            },
+            ...(process.resolvingTeamSlug && { resolvingTeamSlug: process.resolvingTeamSlug }),
+        };
+    }
+    async metadataFromFiles(slug) {
+        const resourceDirectory = path.join(this._repositoryName, slug);
+        const programmingLanguage = fs.existsSync(path.join(resourceDirectory, 'index.js')) ? 'JAVASCRIPT' : 'PYTHON';
+        return {
+            slug,
+            script: {
+                programmingLanguage,
+            },
+            contentHash: '',
+        };
+    }
+    async saveFiles(process) {
+        const readOnly = Boolean(process.resolvingTeamSlug);
+        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, this.getSourceCodeFileName(process.script.programmingLanguage)), process.script.sourceCode || '', {
+            readOnly,
+        });
+        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'README.md'), process.readme || '', { readOnly });
+        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'metadata.json'), JSON.stringify(this.buildMetadata(process), null, 2), { readOnly });
+        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'parametersSchema.json'), JSON.stringify(process.script.parametersSchema, null, 2), { readOnly });
+        const parametersFilePath = this.buildResourcePath(process, 'parameters.json');
+        if (!fs.existsSync(parametersFilePath)) {
+            const parameters = (0, process_parameters_sampler_1.generateParametersSample)(process);
+            fs.outputFileSync(parametersFilePath, JSON.stringify(parameters, null, 2));
+        }
+        if (process.settings.dependencies.scopedToProcess) {
+            (0, file_utils_1.outputFileSyncIfChanged)(this.dependenciesFile(process), (0, dependencies_1.dependenciesToFile)(process.script.programmingLanguage, process.manifest?.dependencies), {
+                readOnly,
+            });
+        }
+    }
+    versionsDirectory(process) {
+        return path.join(this._repositoryName, this.resourceDirectoryName(process), 'versions');
+    }
+    versionDirectory(process, tag) {
+        return path.join(this.versionsDirectory(process), tag);
+    }
+    async versionHasChanges(process, version) {
+        const versionPath = this.versionDirectory(process, version.tag);
+        if (!fs.pathExistsSync(versionPath) || !this.allFilesExist(process.slug, version.tag)) {
+            return true;
+        }
+        const storedSourceCode = fs.readFileSync(path.join(versionPath, this.getSourceCodeFileName(process.script.programmingLanguage))).toString();
+        const storedReadme = fs.readFileSync(path.join(versionPath, 'README.md')).toString();
+        const storedParametersSchema = fs.readJsonSync(path.join(versionPath, 'parametersSchema.json'));
+        const storedVersion = new types_1.VersionedProcess(process.id, version.tag, { parametersSchema: storedParametersSchema, programmingLanguage: process.script.programmingLanguage, sourceCode: storedSourceCode }, storedReadme);
+        return !resource_checker_1.default.sameContent(storedVersion, version);
+    }
+    getLocalVersionTags(process) {
+        const versionsDir = this.versionsDirectory(process);
+        if (!fs.pathExistsSync(versionsDir))
+            return [];
+        return fs.readdirSync(versionsDir).filter((name) => this.validVersion(name));
+    }
+    versionExistsLocally(process, tag) {
+        return fs.pathExistsSync(this.versionDirectory(process, tag));
+    }
+    removeVersion(process, tag) {
+        fs.removeSync(this.versionDirectory(process, tag));
+    }
+    async saveVersion(process, version) {
+        const versionPath = this.versionDirectory(process, version.tag);
+        const sourceCodeFile = path.join(versionPath, this.getSourceCodeFileName(process.script.programmingLanguage));
+        const readmeFile = path.join(versionPath, 'README.md');
+        const parametersSchemaFile = path.join(versionPath, 'parametersSchema.json');
+        fs.outputFileSync(sourceCodeFile, version.script.sourceCode || '');
+        fs.outputFileSync(readmeFile, version.readme || '');
+        fs.writeJsonSync(parametersSchemaFile, version.script.parametersSchema, { spaces: 2 });
+        fs.chmodSync(sourceCodeFile, 0o444);
+        fs.chmodSync(readmeFile, 0o444);
+        fs.chmodSync(parametersSchemaFile, 0o444);
+    }
+    async getVersions(process) {
+        const versionsDirectory = this.versionsDirectory(process);
+        if (!fs.pathExistsSync(versionsDirectory)) {
+            return [];
+        }
+        const versions = [];
+        for (const version of fs.readdirSync(versionsDirectory)) {
+            if (!this.validVersion(version)) {
+                cli_1.cli.log(color_1.default.yellow(`\n⚠️  process version '${version}' doesn't have a valid format and will be ignored. ${this.versionFormatMessage()}`));
+                continue;
+            }
+            try {
+                const sourceCode = await fs
+                    .readFileSync(path.join(versionsDirectory, version, this.getSourceCodeFileName(process.script.programmingLanguage)))
+                    .toString();
+                const readme = await fs.readFileSync(path.join(versionsDirectory, version, 'README.md')).toString();
+                const parametersSchema = await fs.readJsonSync(path.join(versionsDirectory, version, 'parametersSchema.json'));
+                versions.push(new types_1.VersionedProcess(process.id, version, {
+                    parametersSchema: parametersSchema,
+                    programmingLanguage: process.script.programmingLanguage,
+                    sourceCode: sourceCode,
+                }, readme));
+            }
+            catch {
+                cli_1.cli.log(color_1.default.yellow(`\n⚠️  local version directory '${version}' doesn't have valid files and will be ignored.`));
+            }
+        }
+        return versions;
+    }
+    dependenciesFile(process) {
+        return path.join(this._repositoryName, this.resourceDirectoryName(process), PROGRAMMING_LANGUAGE_DEPENDENCIES_FILE_NAME[process.script.programmingLanguage]);
+    }
+    async getProcessFullPath(processSlug, version) {
+        const process = await this.find(processSlug, version);
+        return this.buildResourcePath(process, this.getSourceCodeFileName(process.script.programmingLanguage), version);
+    }
+    async getProcessMetadata(processSlug) {
+        const { processes } = await this.workspaceConfig.getActiveTeam();
+        return Object.values(processes).find((process) => process.slug === processSlug || this.processHash(process.slug) === processSlug);
+    }
+    processHash(processSlug) {
+        return crypto.createHash('sha1').update(processSlug).digest('hex');
+    }
+}
+exports.default = ProcessRepository;

package/dist/repositories/programming-language-manifest.d.ts

@@ -0,0 +1,17 @@
+import { ResourceMetadata, ProgrammingLanguageManifest } from '../core/types';
+import ResourceRepositoryBase from './resource';
+declare class ProgrammingLanguageManifestRepository extends ResourceRepositoryBase<ProgrammingLanguageManifest> {
+    constructor();
+    find(slug: string): Promise<ProgrammingLanguageManifest>;
+    protected getSourceCodeFileName(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    protected getResourceDirectory(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    protected getResourcePath(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    protected removeFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
+    protected resourceToMetadata(programmingLanguageManifest: ProgrammingLanguageManifest): ResourceMetadata;
+    protected saveFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
+    metadataFromFiles(slug: string): Promise<ResourceMetadata>;
+    validSlug(slug: string): boolean;
+    slugFormatMessage(): string;
+    findSlugsNotAdded(): Promise<Array<string>>;
+}
+export default ProgrammingLanguageManifestRepository;

package/dist/repositories/programming-language-manifest.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const path = require("node:path");
+const errors_1 = require("../core/errors");
+const types_1 = require("../core/types");
+const resource_1 = require("./resource");
+const dependencies_1 = require("../core/utils/dependencies");
+const file_utils_1 = require("../utils/file-utils");
+class ProgrammingLanguageManifestRepository extends resource_1.default {
+    constructor() {
+        super({
+            name: 'dependencies',
+        });
+    }
+    async find(slug) {
+        const { [this._repositoryName]: programmingLanguageManifests } = await this.workspaceConfig.getActiveTeam();
+        const programmingLanguageManifest = programmingLanguageManifests[slug];
+        if (!programmingLanguageManifest) {
+            throw new errors_1.LocalProgrammingLanguageManifestNotFound(new Error('Programming Language Manifest not found on team metadata'), slug);
+        }
+        const sourceCodeFileContent = fs.readFileSync(this.getResourcePath(programmingLanguageManifest));
+        try {
+            return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.slug, programmingLanguageManifest.programmingLanguage, (0, dependencies_1.dependenciesFromFile)(programmingLanguageManifest.programmingLanguage, sourceCodeFileContent.toString()));
+        }
+        catch (error) {
+            throw new errors_1.LocalProgrammingLanguageManifestNotFound(error, slug);
+        }
+    }
+    getSourceCodeFileName(programmingLanguageManifest) {
+        return programmingLanguageManifest.programmingLanguage === 'JAVASCRIPT' ? 'package.json' : 'requirements.txt';
+    }
+    getResourceDirectory(programmingLanguageManifest) {
+        return this._repositoryName;
+    }
+    getResourcePath(programmingLanguageManifest) {
+        return path.join(this.getResourceDirectory(programmingLanguageManifest), this.getSourceCodeFileName(programmingLanguageManifest));
+    }
+    async removeFiles(programmingLanguageManifest) {
+        await new Promise((resolve, reject) => {
+            try {
+                fs.removeSync(this.getResourcePath(programmingLanguageManifest));
+                this.removeDirectoryIfEmpty(this.getResourceDirectory(programmingLanguageManifest));
+                resolve(true);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    resourceToMetadata(programmingLanguageManifest) {
+        return {
+            id: programmingLanguageManifest.id,
+            slug: programmingLanguageManifest.programmingLanguage,
+            programmingLanguage: programmingLanguageManifest.programmingLanguage,
+        };
+    }
+    async saveFiles(programmingLanguageManifest) {
+        (0, file_utils_1.outputFileSyncIfChanged)(this.getResourcePath(programmingLanguageManifest), (0, dependencies_1.dependenciesToFile)(programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.dependencies));
+    }
+    async metadataFromFiles(slug) {
+        if (slug === 'JAVASCRIPT') {
+            return {
+                id: 'javascript',
+                programmingLanguage: 'JAVASCRIPT',
+                slug: 'JAVASCRIPT',
+            };
+        }
+        if (slug === 'PYTHON') {
+            return {
+                id: 'python',
+                programmingLanguage: 'PYTHON',
+                slug: 'PYTHON',
+            };
+        }
+        throw new Error('Invalid slug');
+    }
+    validSlug(slug) {
+        return slug === 'JAVASCRIPT' || slug === 'PYTHON';
+    }
+    slugFormatMessage() {
+        return 'Only JAVASCRIPT or PYTHON are allowed.';
+    }
+    async findSlugsNotAdded() {
+        const slugsNotAdded = [];
+        if (!(await this.workspaceConfig.exists('dependencies', 'JAVASCRIPT')) && fs.existsSync(path.join(this._repositoryName, 'package.json'))) {
+            slugsNotAdded.push('JAVASCRIPT');
+        }
+        if (!(await this.workspaceConfig.exists('dependencies', 'PYTHON')) && fs.existsSync(path.join(this._repositoryName, 'requirements.txt'))) {
+            slugsNotAdded.push('PYTHON');
+        }
+        return slugsNotAdded;
+    }
+}
+exports.default = ProgrammingLanguageManifestRepository;

package/dist/repositories/resource.d.ts

@@ -0,0 +1,29 @@
+import type { AddResourceOptions, Resource, ResourceMetadata, ResourceRepositoryOptions } from '../core/types';
+import WorkspaceConfig from '../config/workspace';
+import ResourceRepository from '../core/resource-repository';
+export declare abstract class ResourceRepositoryBase<R extends Resource> implements ResourceRepository<R> {
+    protected workspaceConfig: WorkspaceConfig;
+    _repositoryName: string;
+    constructor({ name }: ResourceRepositoryOptions);
+    exists(slug: string): Promise<boolean>;
+    findAll(): Promise<Array<R>>;
+    remove(slug: string): Promise<void>;
+    save(resource: R): Promise<R>;
+    saveAll(resources: R[]): Promise<R[]>;
+    saveMetadata(resource: R): Promise<R>;
+    existsMetadata(slug: string): Promise<boolean>;
+    removeMetadata(slug: string): Promise<void>;
+    validSlug(slug: string): boolean;
+    slugFormatMessage(): string;
+    validVersion(tag: string): boolean;
+    versionFormatMessage(): string;
+    abstract find(slug: string): Promise<R>;
+    abstract findSlugsNotAdded(): Promise<Array<string>>;
+    abstract metadataFromFiles(slug: string, opts?: AddResourceOptions): Promise<ResourceMetadata>;
+    protected abstract getResourcePath(resource: R): string;
+    protected abstract removeFiles(resource: R): Promise<void>;
+    protected abstract resourceToMetadata(resource: R): ResourceMetadata;
+    protected abstract saveFiles(resource: R): Promise<void>;
+    protected removeDirectoryIfEmpty(directoryPath: string): void;
+}
+export default ResourceRepositoryBase;

package/dist/repositories/resource.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceRepositoryBase = void 0;
+const fs = require("fs-extra");
+const workspace_1 = require("../config/workspace");
+const promise_1 = require("../utils/promise");
+class ResourceRepositoryBase {
+    constructor({ name }) {
+        this.workspaceConfig = new workspace_1.default();
+        this._repositoryName = name;
+    }
+    async exists(slug) {
+        try {
+            await this.find(slug);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async findAll() {
+        const { [this._repositoryName]: resources } = await this.workspaceConfig.getActiveTeam();
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const existResources = await Object.keys(resources).reduce((promise, slug) => promise.then(async (existIds) => {
+            const exists = await this.exists(slug);
+            if (exists) {
+                return [...existIds, slug];
+            }
+            return existIds;
+        }), Promise.resolve([]));
+        return Promise.all(existResources.map((slug) => this.find(slug)));
+    }
+    async remove(slug) {
+        const localResource = await this.find(slug);
+        await this.removeFiles(localResource);
+        await this.workspaceConfig.remove(this._repositoryName, slug);
+    }
+    async save(resource) {
+        await this.saveFiles(resource);
+        await this.saveMetadata(resource);
+        return resource;
+    }
+    async saveAll(resources) {
+        await (0, promise_1.chainedPromises)(resources, async (resource) => this.save(resource));
+        return resources;
+    }
+    async saveMetadata(resource) {
+        const team = await this.workspaceConfig.getActiveTeam();
+        const resourceMetadata = this.resourceToMetadata(resource);
+        resourceMetadata.contentHash = resource.contentHash;
+        await this.workspaceConfig.add(this._repositoryName, resourceMetadata);
+        return resource;
+    }
+    async existsMetadata(slug) {
+        return await this.workspaceConfig.exists(this._repositoryName, slug);
+    }
+    async removeMetadata(slug) {
+        await this.workspaceConfig.remove(this._repositoryName, slug);
+    }
+    validSlug(slug) {
+        return /^[a-z][a-z0-9-]*[a-z0-9]$/.test(slug);
+    }
+    slugFormatMessage() {
+        return 'It must start with a lowercase letter, followed by lowercase letters, numbers, or hyphens, and end with a lowercase letter or number.';
+    }
+    validVersion(tag) {
+        return /^[a-z0-9][a-z0-9.-]*$/.test(tag);
+    }
+    versionFormatMessage() {
+        return "It must start with a number or a letter in lowercase and then use numbers, letters, '-' or '.'";
+    }
+    removeDirectoryIfEmpty(directoryPath) {
+        if (fs.existsSync(directoryPath) && fs.readdirSync(directoryPath).length === 0) {
+            fs.removeSync(directoryPath);
+        }
+    }
+}
+exports.ResourceRepositoryBase = ResourceRepositoryBase;
+exports.default = ResourceRepositoryBase;