@foal/cli 5.1.3 → 5.2.0

package/lib/commands/generators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateServiceCommandService = exports.CreateScriptCommandService = exports.CreateRestApiCommandService = exports.CreateHookCommandService = exports.CreateEntityCommandService = exports.CreateControllerCommandService = exports.CreateAppCommandService = void 0;
+var create_app_1 = require("./create-app");
+Object.defineProperty(exports, "CreateAppCommandService", { enumerable: true, get: function () { return create_app_1.CreateAppCommandService; } });
+var create_controller_1 = require("./create-controller");
+Object.defineProperty(exports, "CreateControllerCommandService", { enumerable: true, get: function () { return create_controller_1.CreateControllerCommandService; } });
+var create_entity_1 = require("./create-entity");
+Object.defineProperty(exports, "CreateEntityCommandService", { enumerable: true, get: function () { return create_entity_1.CreateEntityCommandService; } });
+var create_hook_1 = require("./create-hook");
+Object.defineProperty(exports, "CreateHookCommandService", { enumerable: true, get: function () { return create_hook_1.CreateHookCommandService; } });
+var create_rest_api_1 = require("./create-rest-api");
+Object.defineProperty(exports, "CreateRestApiCommandService", { enumerable: true, get: function () { return create_rest_api_1.CreateRestApiCommandService; } });
+var create_script_1 = require("./create-script");
+Object.defineProperty(exports, "CreateScriptCommandService", { enumerable: true, get: function () { return create_script_1.CreateScriptCommandService; } });
+var create_service_1 = require("./create-service");
+Object.defineProperty(exports, "CreateServiceCommandService", { enumerable: true, get: function () { return create_service_1.CreateServiceCommandService; } });

package/lib/commands/index.d.ts

@@ -0,0 +1,6 @@
+export { ConnectAngularCommandService, ConnectReactCommandService, ConnectVueCommandService, } from './connectors';
+export { CreateAppCommandService, CreateControllerCommandService, CreateEntityCommandService, CreateHookCommandService, CreateRestApiCommandService, CreateScriptCommandService, CreateServiceCommandService, } from './generators';
+export { CreateSecretCommandService } from './create-secret';
+export { RmdirCommandService } from './rmdir';
+export { RunScriptCommandService } from './run-script';
+export { UpgradeCommandService } from './upgrade';

package/lib/commands/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpgradeCommandService = exports.RunScriptCommandService = exports.RmdirCommandService = exports.CreateSecretCommandService = exports.CreateServiceCommandService = exports.CreateScriptCommandService = exports.CreateRestApiCommandService = exports.CreateHookCommandService = exports.CreateEntityCommandService = exports.CreateControllerCommandService = exports.CreateAppCommandService = exports.ConnectVueCommandService = exports.ConnectReactCommandService = exports.ConnectAngularCommandService = void 0;
+var connectors_1 = require("./connectors");
+Object.defineProperty(exports, "ConnectAngularCommandService", { enumerable: true, get: function () { return connectors_1.ConnectAngularCommandService; } });
+Object.defineProperty(exports, "ConnectReactCommandService", { enumerable: true, get: function () { return connectors_1.ConnectReactCommandService; } });
+Object.defineProperty(exports, "ConnectVueCommandService", { enumerable: true, get: function () { return connectors_1.ConnectVueCommandService; } });
+var generators_1 = require("./generators");
+Object.defineProperty(exports, "CreateAppCommandService", { enumerable: true, get: function () { return generators_1.CreateAppCommandService; } });
+Object.defineProperty(exports, "CreateControllerCommandService", { enumerable: true, get: function () { return generators_1.CreateControllerCommandService; } });
+Object.defineProperty(exports, "CreateEntityCommandService", { enumerable: true, get: function () { return generators_1.CreateEntityCommandService; } });
+Object.defineProperty(exports, "CreateHookCommandService", { enumerable: true, get: function () { return generators_1.CreateHookCommandService; } });
+Object.defineProperty(exports, "CreateRestApiCommandService", { enumerable: true, get: function () { return generators_1.CreateRestApiCommandService; } });
+Object.defineProperty(exports, "CreateScriptCommandService", { enumerable: true, get: function () { return generators_1.CreateScriptCommandService; } });
+Object.defineProperty(exports, "CreateServiceCommandService", { enumerable: true, get: function () { return generators_1.CreateServiceCommandService; } });
+var create_secret_1 = require("./create-secret");
+Object.defineProperty(exports, "CreateSecretCommandService", { enumerable: true, get: function () { return create_secret_1.CreateSecretCommandService; } });
+var rmdir_1 = require("./rmdir");
+Object.defineProperty(exports, "RmdirCommandService", { enumerable: true, get: function () { return rmdir_1.RmdirCommandService; } });
+var run_script_1 = require("./run-script");
+Object.defineProperty(exports, "RunScriptCommandService", { enumerable: true, get: function () { return run_script_1.RunScriptCommandService; } });
+var upgrade_1 = require("./upgrade");
+Object.defineProperty(exports, "UpgradeCommandService", { enumerable: true, get: function () { return upgrade_1.UpgradeCommandService; } });

package/lib/commands/rmdir/index.d.ts

@@ -0,0 +1 @@
+export { RmdirCommandService } from './rmdir-command.service';

package/lib/commands/rmdir/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RmdirCommandService = void 0;
+var rmdir_command_service_1 = require("./rmdir-command.service");
+Object.defineProperty(exports, "RmdirCommandService", { enumerable: true, get: function () { return rmdir_command_service_1.RmdirCommandService; } });

package/lib/commands/rmdir/rmdir-command.service.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Service for removing directories and all their contents.
+ */
+export declare class RmdirCommandService {
+    /**
+     * Remove a directory and all its contents, including any subdirectories and files.
+     *
+     * @param {string} path - The path of the directory
+     * @returns {Promise<void>}
+     */
+    run(path: string): Promise<void>;
+}

package/lib/commands/rmdir/rmdir-command.service.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RmdirCommandService = void 0;
+// std
+const promises_1 = require("node:fs/promises");
+/**
+ * Service for removing directories and all their contents.
+ */
+class RmdirCommandService {
+    /**
+     * Remove a directory and all its contents, including any subdirectories and files.
+     *
+     * @param {string} path - The path of the directory
+     * @returns {Promise<void>}
+     */
+    async run(path) {
+        try {
+            await (0, promises_1.readdir)(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return;
+            }
+            throw error;
+        }
+        await (0, promises_1.rm)(path, { recursive: true });
+    }
+}
+exports.RmdirCommandService = RmdirCommandService;

package/lib/commands/run-script/index.d.ts

@@ -0,0 +1 @@
+export { RunScriptCommandService } from './run-script-command.service';

package/lib/commands/run-script/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunScriptCommandService = void 0;
+var run_script_command_service_1 = require("./run-script-command.service");
+Object.defineProperty(exports, "RunScriptCommandService", { enumerable: true, get: function () { return run_script_command_service_1.RunScriptCommandService; } });

package/lib/commands/run-script/run-script-command.service.d.ts

@@ -0,0 +1,10 @@
+import type { Logger, ServiceManager } from '@foal/core';
+import { UtilService } from '../../services';
+export declare class RunScriptCommandService {
+    private utilService;
+    constructor(utilService: UtilService);
+    run(name: string, argv: string[]): Promise<void>;
+    execScript({ name }: {
+        name: string;
+    }, argv: string[], services: ServiceManager, logger: Logger): Promise<void>;
+}

package/lib/commands/run-script/run-script-command.service.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunScriptCommandService = void 0;
+// std
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+// 3p
+const ajv_1 = require("ajv");
+const ajv_formats_1 = require("ajv-formats");
+class RunScriptCommandService {
+    utilService;
+    constructor(utilService) {
+        this.utilService = utilService;
+    }
+    async run(name, argv) {
+        try {
+            const { Logger, ServiceManager } = require(require.resolve('@foal/core', {
+                paths: [process.cwd()],
+            }));
+            const services = new ServiceManager();
+            const logger = services.get(Logger);
+            logger.initLogContext(() => this.execScript({ name }, argv, services, logger).catch(error => console.error(error)));
+        }
+        catch (error) {
+            if (error.code === 'MODULE_NOT_FOUND') {
+                console.error('@foal/core module not found. Are you sure you are in a FoalTS project?');
+                return;
+            }
+            throw error;
+        }
+    }
+    async execScript({ name }, argv, services, logger) {
+        logger.addLogContext({
+            scriptId: (0, crypto_1.randomUUID)(),
+            scriptName: name
+        });
+        if (!(0, fs_1.existsSync)(`build/scripts/${name}.js`)) {
+            if ((0, fs_1.existsSync)(`src/scripts/${name}.ts`)) {
+                logger.error(`Script "${name}" not found in build/scripts/ but found in src/scripts/. Did you forget to build it?`);
+            }
+            else {
+                logger.error(`Script "${name}" not found.`);
+            }
+            return;
+        }
+        const { main, schema } = require(require.resolve(`./build/scripts/${name}`, {
+            paths: [process.cwd()],
+        }));
+        if (!main) {
+            logger.error(`No "main" function found in script "${name}".`);
+            return;
+        }
+        const args = this.utilService.getCommandLineArguments(argv);
+        if (schema) {
+            const ajv = new ajv_1.default({ useDefaults: true, allErrors: true });
+            (0, ajv_formats_1.default)(ajv);
+            if (!ajv.validate(schema, args)) {
+                ajv.errors.forEach(err => {
+                    if (err.instancePath) {
+                        logger.error(`Script argument "${err.instancePath.split('/')[1]}" ${err.message}.`);
+                    }
+                    else {
+                        logger.error(`Script arguments ${err.message}.`);
+                    }
+                });
+                return;
+            }
+        }
+        try {
+            await main(args, services, logger);
+            logger.info(`Script "${name}" completed.`);
+        }
+        catch (error) {
+            logger.error(error.message, { error });
+            logger.error(`Script "${name}" failed.`);
+        }
+    }
+}
+exports.RunScriptCommandService = RunScriptCommandService;

package/lib/commands/upgrade/index.d.ts

@@ -0,0 +1 @@
+export { UpgradeCommandService } from './upgrade-command.service';

package/lib/commands/upgrade/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpgradeCommandService = void 0;
+var upgrade_command_service_1 = require("./upgrade-command.service");
+Object.defineProperty(exports, "UpgradeCommandService", { enumerable: true, get: function () { return upgrade_command_service_1.UpgradeCommandService; } });

package/lib/commands/upgrade/upgrade-command.service.d.ts

@@ -0,0 +1,24 @@
+import { Generator } from '../../services';
+declare function getLatestVersion(): Promise<string>;
+/**
+ * Service for upgrading FoalTS dependencies.
+ */
+export declare class UpgradeCommandService {
+    private generator;
+    constructor(generator: Generator);
+    /**
+     * Upgrade all @foal/* dependencies to the specified version (or latest if not specified).
+     *
+     * @param {string} version - Optional specific version to upgrade to
+     * @param {boolean} autoInstall - Whether to automatically install dependencies
+     * @param {() => Promise<string>} getLatestVersionFn - Optional function to get latest version (for testing)
+     * @returns {Promise<void>}
+     */
+    run({ version, autoInstall }: {
+        version?: string;
+        autoInstall?: boolean;
+    }, options?: {
+        getLatestVersion: typeof getLatestVersion;
+    }): Promise<void>;
+}
+export {};

package/lib/commands/upgrade/upgrade-command.service.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpgradeCommandService = void 0;
+const utils_1 = require("../generators/utils");
+async function getLatestVersion() {
+    const response = await fetch('https://registry.npmjs.org/@foal/core/latest');
+    const { version } = await response.json();
+    return version;
+}
+/**
+ * Service for upgrading FoalTS dependencies.
+ */
+class UpgradeCommandService {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Upgrade all @foal/* dependencies to the specified version (or latest if not specified).
+     *
+     * @param {string} version - Optional specific version to upgrade to
+     * @param {boolean} autoInstall - Whether to automatically install dependencies
+     * @param {() => Promise<string>} getLatestVersionFn - Optional function to get latest version (for testing)
+     * @returns {Promise<void>}
+     */
+    async run({ version, autoInstall }, options = { getLatestVersion }) {
+        version ??= await options.getLatestVersion();
+        utils_1.logger.log();
+        utils_1.logger.log(`  Upgrading @foal/* dependencies to version ${version}...`);
+        utils_1.logger.log();
+        const dependencies = this.generator.getProjectDependencies();
+        for (const dependency of dependencies) {
+            if (dependency.name.startsWith('@foal/')) {
+                this.generator.setOrUpdateProjectDependency(dependency.name, version);
+            }
+        }
+        const devDependencies = this.generator.getProjectDevDependencies();
+        for (const devDependency of devDependencies) {
+            if (devDependency.name.startsWith('@foal/')) {
+                this.generator.setOrUpdateProjectDevDependency(devDependency.name, version);
+            }
+        }
+        if (autoInstall) {
+            await (0, utils_1.installDependencies)();
+            utils_1.logger.log();
+        }
+    }
+}
+exports.UpgradeCommandService = UpgradeCommandService;

package/lib/index.d.ts

@@ -1,7 +1,2 @@
 #!/usr/bin/env node
-/**
- * FoalTS
- * Copyright(c) 2017-2025 Loïc Poullain
- * Released under the MIT License.
- */
-export {};
+import './cli';

package/lib/index.js

@@ -1,160 +1,4 @@
 #!/usr/bin/env node
 "use strict";
-/**
- * FoalTS
- * Copyright(c) 2017-2025 Loïc Poullain
- * Released under the MIT License.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-// 3p
-const safe_1 = require("colors/safe");
-const commander_1 = require("commander");
-// FoalTS
-const create_secret_1 = require("./create-secret");
-const generate_1 = require("./generate");
-const file_system_1 = require("./generate/file-system");
-const rmdir_1 = require("./rmdir");
-const run_1 = require("./run");
-function displayError(...lines) {
-    console.error();
-    lines.forEach(line => console.error((0, safe_1.red)(line)));
-    console.error();
-    process.exitCode = 1;
-}
-// tslint:disable-next-line:no-var-requires
-const pkg = require('../package.json');
-commander_1.program
-    .version(pkg.version, '-v, --version');
-commander_1.program
-    .command('createapp')
-    .argument('<name>', 'Name of the application')
-    .description('Create a new project.')
-    .option('-G, --no-git', 'Don\'t initialize a git repository')
-    .option('-I, --no-install', 'Don\'t autoinstall packages using yarn or npm (uses first available)')
-    .option('-m, --mongodb', 'Generate a new project using MongoDB instead of SQLite', false)
-    .option('-y, --yaml', 'Generate a new project using YAML configuration instead of JSON', false)
-    .action((name, options) => {
-    (0, generate_1.createApp)({
-        autoInstall: options.install,
-        initRepo: options.git,
-        mongodb: options.mongodb,
-        name,
-        yaml: options.yaml
-    });
-});
-commander_1.program
-    .command('createsecret')
-    .description('Create a 256-bit random secret encoded in base64.')
-    .action(() => (0, create_secret_1.createSecret)().then(secret => console.log(secret)));
-commander_1.program
-    .command('run')
-    .argument('<name>', 'Name of the script to run')
-    .argument('[args...]', 'Script arguments (key=value format)')
-    .description('Run a shell script.')
-    .action((name) => {
-    (0, run_1.runScript)({ name }, process.argv);
-});
-commander_1.program
-    .command('connect')
-    .argument('<framework>', 'Frontend framework to connect to')
-    .argument('<path>', 'Path to the frontend project')
-    .description('Configure your frontend to interact with your application.')
-    .addHelpText('after', `
-Available frameworks:
-  - angular
-  - react
-  - vue
-  `)
-    .action(async (framework, path) => {
-    switch (framework) {
-        case 'angular':
-            (0, generate_1.connectAngular)(path);
-            break;
-        case 'react':
-            (0, generate_1.connectReact)(path);
-            break;
-        case 'vue':
-            (0, generate_1.connectVue)(path);
-            break;
-        default:
-            displayError(`Unknown framework ${(0, safe_1.yellow)(framework)}. Please provide a valid one:`, '', '  - angular', '  - react', '  - vue');
-    }
-});
-const generateTypes = [
-    'controller', 'entity', 'rest-api', 'hook', 'script', 'service'
-];
-commander_1.program
-    .command('generate')
-    .argument('<type>', 'Type of the file to generate')
-    .argument('<name>', 'Name of the file to generate')
-    .description('Generate and/or modify files.')
-    .option('-r, --register', 'Register the controller into app.controller.ts (only available if type=controller|rest-api)', false)
-    .option('-a, --auth', 'Add an owner to the entities of the generated REST API (only available if type=rest-api)', false)
-    .alias('g')
-    .addHelpText('after', `
-Available types:
-${generateTypes.map(t => `  - ${t}`).join('\n')}
-  `)
-    .action(async (type, name, options) => {
-    try {
-        switch (type) {
-            case 'controller':
-                (0, generate_1.createController)({ name, register: options.register });
-                break;
-            case 'entity':
-                (0, generate_1.createEntity)({ name });
-                break;
-            case 'rest-api':
-                (0, generate_1.createRestApi)({ name, register: options.register, auth: options.auth });
-                break;
-            case 'hook':
-                (0, generate_1.createHook)({ name });
-                break;
-            case 'script':
-                (0, generate_1.createScript)({ name });
-                break;
-            case 'service':
-                (0, generate_1.createService)({ name });
-                break;
-            default:
-                displayError(`Unknown type ${(0, safe_1.yellow)(type)}. Please provide a valid one:`, '', ...generateTypes.map(t => `  - ${t}`));
-        }
-    }
-    catch (error) {
-        if (error instanceof file_system_1.ClientError) {
-            displayError(error.message);
-            return;
-        }
-        throw error;
-    }
-});
-commander_1.program
-    .command('rmdir')
-    .argument('<name>', 'Name of the directory to remove')
-    .description('Remove a directory and all its contents, including any subdirectories and files.')
-    .action(async (name) => {
-    try {
-        await (0, rmdir_1.rmdir)(name);
-    }
-    catch (error) {
-        if (error.code === 'ENOTDIR') {
-            displayError(error.message);
-            return;
-        }
-        throw error;
-    }
-});
-commander_1.program
-    .command('upgrade')
-    .argument('[version]', 'Name of the specific version to upgrade to')
-    .description('Upgrade the project to the latest version of FoalTS. If a version is provided, upgrade to that version.')
-    .option('-I, --no-install', 'Don\'t autoinstall packages using yarn or npm (uses first available)')
-    .action(async (version, options) => {
-    await (0, generate_1.upgrade)({ version, autoInstall: options.install });
-});
-commander_1.program
-    .on('command:*', (commands) => {
-    commander_1.program.outputHelp();
-    displayError(`Unknown command ${(0, safe_1.yellow)(commands[0])}.`);
-});
-commander_1.program.parse(process.argv);
+require("./cli");

package/lib/services/crypto/crypto.service.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Service for cryptographic operations.
+ */
+export declare class CryptoService {
+    /**
+     * Create a random 256-bit secret encoded in base64.
+     *
+     * @returns {Promise<string>} The base64 string.
+     */
+    createSecret(): Promise<string>;
+}

package/lib/services/crypto/crypto.service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoService = void 0;
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+/**
+ * Service for cryptographic operations.
+ */
+class CryptoService {
+    /**
+     * Create a random 256-bit secret encoded in base64.
+     *
+     * @returns {Promise<string>} The base64 string.
+     */
+    async createSecret() {
+        const buff = await (0, util_1.promisify)(crypto_1.randomBytes)(32);
+        return buff.toString('base64');
+    }
+}
+exports.CryptoService = CryptoService;

package/lib/services/crypto/index.d.ts

@@ -0,0 +1 @@
+export { CryptoService } from './crypto.service';

package/lib/services/crypto/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoService = void 0;
+var crypto_service_1 = require("./crypto.service");
+Object.defineProperty(exports, "CryptoService", { enumerable: true, get: function () { return crypto_service_1.CryptoService; } });

package/lib/services/file-system/file-system.service.d.ts

@@ -0,0 +1,24 @@
+export declare class FileSystemService {
+    private readonly testDir;
+    private isTestingEnvironment;
+    setUp(): void;
+    tearDown(): void;
+    computePath(path: string): string;
+    mkdir(path: string): void;
+    rmdir(path: string): void;
+    writeFile(path: string, content: string): void;
+    readFile(path: string): string;
+    readBinaryFile(path: string): Buffer;
+    readFileFromTemplates(path: string): string;
+    readFileFromSpecs(path: string): string;
+    readBinaryFileFromSpecs(path: string): Buffer;
+    deleteFile(path: string): void;
+    copyFile(src: string, dest: string): void;
+    copyFileFromTemplates(src: string, dest: string): void;
+    copyFileFromFixtures(src: string, dest: string): void;
+    exists(path: string): boolean;
+    existsTemplate(path: string): boolean;
+    existsFixture(path: string): boolean;
+    existsSpec(path: string): boolean;
+    isDirectoryEmpty(path: string): boolean;
+}

package/lib/services/file-system/file-system.service.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemService = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class FileSystemService {
+    testDir = 'test-generators/subdir';
+    isTestingEnvironment() {
+        return process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST === 'true';
+    }
+    setUp() {
+        if (!this.isTestingEnvironment()) {
+            throw new Error('Impossible to create the test directory in a non-testing environment.');
+        }
+        (0, fs_1.mkdirSync)(this.testDir, { recursive: true });
+    }
+    tearDown() {
+        if (!this.isTestingEnvironment()) {
+            throw new Error('Impossible to remove the test directory in a non-testing environment.');
+        }
+        const [firstDir] = this.testDir.split('/');
+        (0, fs_1.rmSync)(firstDir, { recursive: true, force: true });
+    }
+    computePath(path) {
+        if (!this.isTestingEnvironment()) {
+            return path;
+        }
+        if (!(0, fs_1.existsSync)(this.testDir)) {
+            throw new Error('The testing environment is not set up.');
+        }
+        return (0, path_1.join)(this.testDir, path);
+    }
+    mkdir(path) {
+        (0, fs_1.mkdirSync)(this.computePath(path), { recursive: true });
+    }
+    rmdir(path) {
+        (0, fs_1.rmSync)(this.computePath(path), { recursive: true });
+    }
+    writeFile(path, content) {
+        (0, fs_1.writeFileSync)(this.computePath(path), content, 'utf8');
+    }
+    readFile(path) {
+        return (0, fs_1.readFileSync)(this.computePath(path), 'utf8');
+    }
+    readBinaryFile(path) {
+        return (0, fs_1.readFileSync)(this.computePath(path));
+    }
+    readFileFromTemplates(path) {
+        return (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../..', 'templates', path), 'utf8');
+    }
+    readFileFromSpecs(path) {
+        return (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../..', 'specs', path), 'utf8');
+    }
+    readBinaryFileFromSpecs(path) {
+        return (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../..', 'specs', path));
+    }
+    deleteFile(path) {
+        (0, fs_1.unlinkSync)(this.computePath(path));
+    }
+    copyFile(src, dest) {
+        (0, fs_1.copyFileSync)(this.computePath(src), this.computePath(dest));
+    }
+    copyFileFromTemplates(src, dest) {
+        (0, fs_1.copyFileSync)((0, path_1.join)(__dirname, '../../..', 'templates', src), this.computePath(dest));
+    }
+    copyFileFromFixtures(src, dest) {
+        (0, fs_1.copyFileSync)((0, path_1.join)(__dirname, '../../..', 'fixtures', src), this.computePath(dest));
+    }
+    exists(path) {
+        return (0, fs_1.existsSync)(this.computePath(path));
+    }
+    existsTemplate(path) {
+        return (0, fs_1.existsSync)((0, path_1.join)(__dirname, '../../..', 'templates', path));
+    }
+    existsFixture(path) {
+        return (0, fs_1.existsSync)((0, path_1.join)(__dirname, '../../..', 'fixtures', path));
+    }
+    existsSpec(path) {
+        return (0, fs_1.existsSync)((0, path_1.join)(__dirname, '../../..', 'specs', path));
+    }
+    isDirectoryEmpty(path) {
+        const dirPath = this.computePath(path);
+        if (!(0, fs_1.existsSync)(dirPath)) {
+            throw new Error(`Directory does not exist: ${path}`);
+        }
+        return (0, fs_1.readdirSync)(dirPath).length === 0;
+    }
+}
+exports.FileSystemService = FileSystemService;

package/lib/services/file-system/index.d.ts

@@ -0,0 +1 @@
+export { FileSystemService } from './file-system.service';

package/lib/services/file-system/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemService = void 0;
+var file_system_service_1 = require("./file-system.service");
+Object.defineProperty(exports, "FileSystemService", { enumerable: true, get: function () { return file_system_service_1.FileSystemService; } });