@foal/cli 5.1.3 → 5.2.1

package/lib/cli.d.ts

@@ -0,0 +1,6 @@
+/**
+ * FoalTS
+ * Copyright(c) 2017-2025 Loïc Poullain
+ * Released under the MIT License.
+ */
+export {};

package/lib/cli.js

@@ -0,0 +1,208 @@
+"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 services_1 = require("./services");
+const commands_1 = require("./commands");
+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(async (name, options) => {
+    const fileSystem = new services_1.FileSystemService();
+    const logger = new services_1.LoggerService();
+    const generator = new services_1.Generator(fileSystem, logger);
+    const createAppCommandService = new commands_1.CreateAppCommandService(generator);
+    await createAppCommandService.run({
+        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(async () => {
+    const cryptoService = new services_1.CryptoService();
+    const loggerService = new services_1.LoggerService();
+    const createSecretCommandService = new commands_1.CreateSecretCommandService(cryptoService, loggerService);
+    await createSecretCommandService.run();
+});
+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(async (name) => {
+    const utilService = new services_1.UtilService();
+    const runScriptCommandService = new commands_1.RunScriptCommandService(utilService);
+    await runScriptCommandService.run(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':
+            const fileSystem = new services_1.FileSystemService();
+            const logger = new services_1.LoggerService();
+            const generator = new services_1.Generator(fileSystem, logger);
+            const connectAngularCommandService = new commands_1.ConnectAngularCommandService(generator);
+            connectAngularCommandService.run(path);
+            break;
+        case 'react':
+            const reactFileSystem = new services_1.FileSystemService();
+            const reactLogger = new services_1.LoggerService();
+            const reactGenerator = new services_1.Generator(reactFileSystem, reactLogger);
+            const connectReactCommandService = new commands_1.ConnectReactCommandService(reactGenerator);
+            connectReactCommandService.run(path);
+            break;
+        case 'vue':
+            const vueFileSystem = new services_1.FileSystemService();
+            const vueLogger = new services_1.LoggerService();
+            const vueGenerator = new services_1.Generator(vueFileSystem, vueLogger);
+            const connectVueCommandService = new commands_1.ConnectVueCommandService(vueGenerator);
+            connectVueCommandService.run(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':
+                const controllerFileSystem = new services_1.FileSystemService();
+                const controllerLogger = new services_1.LoggerService();
+                const controllerGenerator = new services_1.Generator(controllerFileSystem, controllerLogger);
+                const createControllerCommandService = new commands_1.CreateControllerCommandService(controllerGenerator);
+                createControllerCommandService.run({ name, register: options.register });
+                break;
+            case 'entity':
+                const entityFileSystem = new services_1.FileSystemService();
+                const entityLogger = new services_1.LoggerService();
+                const entityGenerator = new services_1.Generator(entityFileSystem, entityLogger);
+                const createEntityCommandService = new commands_1.CreateEntityCommandService(entityGenerator);
+                createEntityCommandService.run({ name });
+                break;
+            case 'rest-api':
+                const restApiFileSystem = new services_1.FileSystemService();
+                const restApiLogger = new services_1.LoggerService();
+                const restApiGenerator = new services_1.Generator(restApiFileSystem, restApiLogger);
+                const createRestApiCommandService = new commands_1.CreateRestApiCommandService(restApiGenerator);
+                createRestApiCommandService.run({ name, register: options.register, auth: options.auth });
+                break;
+            case 'hook':
+                const hookFileSystem = new services_1.FileSystemService();
+                const hookLogger = new services_1.LoggerService();
+                const hookGenerator = new services_1.Generator(hookFileSystem, hookLogger);
+                const createHookCommandService = new commands_1.CreateHookCommandService(hookGenerator);
+                createHookCommandService.run({ name });
+                break;
+            case 'script':
+                const scriptFileSystem = new services_1.FileSystemService();
+                const scriptLogger = new services_1.LoggerService();
+                const scriptGenerator = new services_1.Generator(scriptFileSystem, scriptLogger);
+                const createScriptCommandService = new commands_1.CreateScriptCommandService(scriptGenerator);
+                createScriptCommandService.run({ name });
+                break;
+            case 'service':
+                const serviceFileSystem = new services_1.FileSystemService();
+                const serviceLogger = new services_1.LoggerService();
+                const serviceGenerator = new services_1.Generator(serviceFileSystem, serviceLogger);
+                const createServiceCommandService = new commands_1.CreateServiceCommandService(serviceGenerator);
+                createServiceCommandService.run({ 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 services_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 {
+        const rmdirCommandService = new commands_1.RmdirCommandService();
+        await rmdirCommandService.run(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) => {
+    const upgradeFileSystem = new services_1.FileSystemService();
+    const upgradeLogger = new services_1.LoggerService();
+    const upgradeGenerator = new services_1.Generator(upgradeFileSystem, upgradeLogger);
+    const upgradeCommandService = new commands_1.UpgradeCommandService(upgradeGenerator);
+    await upgradeCommandService.run({ 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);

package/lib/commands/connectors/connect-angular/connect-angular-command.service.d.ts

@@ -0,0 +1,15 @@
+import { Generator } from '../../../services';
+/**
+ * Service for connecting an Angular frontend to a FoalTS application.
+ */
+export declare class ConnectAngularCommandService {
+    private generator;
+    constructor(generator: Generator);
+    /**
+     * Configure an Angular project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the Angular project directory
+     * @returns {void}
+     */
+    run(path: string): void;
+}

package/lib/commands/connectors/connect-angular/connect-angular-command.service.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectAngularCommandService = void 0;
+const path_1 = require("path");
+const safe_1 = require("colors/safe");
+/**
+ * Service for connecting an Angular frontend to a FoalTS application.
+ */
+class ConnectAngularCommandService {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Configure an Angular project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the Angular project directory
+     * @returns {void}
+     */
+    run(path) {
+        if (!this.generator.exists(path)) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} does not exist.`));
+            }
+            return;
+        }
+        if (!this.generator.exists((0, path_1.join)(path, 'angular.json'))) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} is not an Angular project (missing angular.json).`));
+            }
+            return;
+        }
+        if (!this.generator.exists((0, path_1.join)(path, 'package.json'))) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} is not an Angular project (missing package.json).`));
+            }
+            return;
+        }
+        this.generator
+            .cd(path)
+            .copyTemplate('angular/proxy.conf.json', 'src/proxy.conf.json')
+            .modify('package.json', content => {
+            const pkg = JSON.parse(content);
+            pkg.scripts.build = 'ng build --prod';
+            return JSON.stringify(pkg, null, 2);
+        })
+            .modify('angular.json', content => {
+            const config = JSON.parse(content);
+            const projectName = Object.keys(config.projects)[0];
+            // Proxy configuration
+            config.projects[projectName].architect ||= {};
+            config.projects[projectName].architect.serve ||= {};
+            config.projects[projectName].architect.serve.options ||= {};
+            config.projects[projectName].architect.serve.options.proxyConfig = 'src/proxy.conf.json';
+            // Output build directory
+            const outputPath = (0, path_1.join)((0, path_1.relative)(path, process.cwd()), 'public')
+                // Make projects generated on Windows build on Unix.
+                .replace(/\\/g, '/');
+            config.projects[projectName].architect.build ||= {};
+            config.projects[projectName].architect.build.options ||= {};
+            config.projects[projectName].architect.build.options.outputPath = outputPath;
+            return JSON.stringify(config, null, 2);
+        });
+    }
+}
+exports.ConnectAngularCommandService = ConnectAngularCommandService;

package/lib/commands/connectors/connect-angular/index.d.ts

@@ -0,0 +1 @@
+export { ConnectAngularCommandService } from './connect-angular-command.service';

package/lib/commands/connectors/connect-angular/index.js

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

package/lib/commands/connectors/connect-react/connect-react-command.service.d.ts

@@ -0,0 +1,15 @@
+import { Generator } from '../../../services';
+/**
+ * Service for connecting a React frontend to a FoalTS application.
+ */
+export declare class ConnectReactCommandService {
+    private generator;
+    constructor(generator: Generator);
+    /**
+     * Configure a React project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the React project directory
+     * @returns {void}
+     */
+    run(path: string): void;
+}

package/lib/commands/connectors/connect-react/connect-react-command.service.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectReactCommandService = void 0;
+const path_1 = require("path");
+const safe_1 = require("colors/safe");
+/**
+ * Service for connecting a React frontend to a FoalTS application.
+ */
+class ConnectReactCommandService {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Configure a React project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the React project directory
+     * @returns {void}
+     */
+    run(path) {
+        if (!this.generator.exists(path)) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} does not exist.`));
+            }
+            return;
+        }
+        if (!this.generator.exists((0, path_1.join)(path, 'package.json'))) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} is not a React project (missing package.json).`));
+            }
+            return;
+        }
+        const outputPath = (0, path_1.join)((0, path_1.relative)(path, process.cwd()), 'public')
+            // Make projects generated on Windows build on Unix.
+            .replace(/\\/g, '/');
+        this.generator
+            .cd(path)
+            .modify('package.json', content => {
+            const pkg = JSON.parse(content);
+            pkg.proxy = 'http://localhost:3001';
+            return JSON.stringify(pkg, null, 2);
+        })
+            .copyTemplate('react/env.development', '.env.development')
+            .render('react/env', '.env', { path: outputPath });
+    }
+}
+exports.ConnectReactCommandService = ConnectReactCommandService;

package/lib/commands/connectors/connect-react/index.d.ts

@@ -0,0 +1 @@
+export { ConnectReactCommandService } from './connect-react-command.service';

package/lib/commands/connectors/connect-react/index.js

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

package/lib/commands/connectors/connect-vue/connect-vue-command.service.d.ts

@@ -0,0 +1,15 @@
+import { Generator } from '../../../services';
+/**
+ * Service for connecting a Vue frontend to a FoalTS application.
+ */
+export declare class ConnectVueCommandService {
+    private generator;
+    constructor(generator: Generator);
+    /**
+     * Configure a Vue project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the Vue project directory
+     * @returns {void}
+     */
+    run(path: string): void;
+}

package/lib/commands/connectors/connect-vue/connect-vue-command.service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectVueCommandService = void 0;
+const path_1 = require("path");
+const safe_1 = require("colors/safe");
+/**
+ * Service for connecting a Vue frontend to a FoalTS application.
+ */
+class ConnectVueCommandService {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Configure a Vue project to interact with a FoalTS application.
+     *
+     * @param {string} path - The path to the Vue project directory
+     * @returns {void}
+     */
+    run(path) {
+        if (!this.generator.exists(path)) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} does not exist.`));
+            }
+            return;
+        }
+        if (!this.generator.exists((0, path_1.join)(path, 'package.json'))) {
+            if (process.env.P1Z7kEbSUUPMxF8GqPwD8Gx_FOAL_CLI_TEST !== 'true') {
+                console.log((0, safe_1.red)(`  The directory ${path} is not a Vue project (missing package.json).`));
+            }
+            return;
+        }
+        this.generator
+            .cd(path)
+            .modify('package.json', content => {
+            const pkg = JSON.parse(content);
+            pkg.vue = pkg.vue || {};
+            // Proxy configuration
+            pkg.vue.devServer = pkg.vue.devServer || {};
+            pkg.vue.devServer.proxy = pkg.vue.devServer.proxy || {};
+            pkg.vue.devServer.proxy['^/api'] = { target: 'http://localhost:3001' };
+            // Output build directory
+            const outputPath = (0, path_1.join)((0, path_1.relative)(path, process.cwd()), 'public')
+                // Make projects generated on Windows build on Unix.
+                .replace(/\\/g, '/');
+            pkg.vue.outputDir = outputPath;
+            return JSON.stringify(pkg, null, 2);
+        });
+    }
+}
+exports.ConnectVueCommandService = ConnectVueCommandService;

package/lib/commands/connectors/connect-vue/index.d.ts

@@ -0,0 +1 @@
+export { ConnectVueCommandService } from './connect-vue-command.service';

package/lib/commands/connectors/connect-vue/index.js

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

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

@@ -0,0 +1,3 @@
+export { ConnectAngularCommandService } from './connect-angular';
+export { ConnectReactCommandService } from './connect-react';
+export { ConnectVueCommandService } from './connect-vue';

package/lib/commands/connectors/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectVueCommandService = exports.ConnectReactCommandService = exports.ConnectAngularCommandService = void 0;
+var connect_angular_1 = require("./connect-angular");
+Object.defineProperty(exports, "ConnectAngularCommandService", { enumerable: true, get: function () { return connect_angular_1.ConnectAngularCommandService; } });
+var connect_react_1 = require("./connect-react");
+Object.defineProperty(exports, "ConnectReactCommandService", { enumerable: true, get: function () { return connect_react_1.ConnectReactCommandService; } });
+var connect_vue_1 = require("./connect-vue");
+Object.defineProperty(exports, "ConnectVueCommandService", { enumerable: true, get: function () { return connect_vue_1.ConnectVueCommandService; } });

package/lib/commands/create-secret/create-secret-command.service.d.ts

@@ -0,0 +1,7 @@
+import { CryptoService, LoggerService } from '../../services';
+export declare class CreateSecretCommandService {
+    private cryptoService;
+    private loggerService;
+    constructor(cryptoService: CryptoService, loggerService: LoggerService);
+    run(): Promise<void>;
+}

package/lib/commands/create-secret/create-secret-command.service.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSecretCommandService = void 0;
+class CreateSecretCommandService {
+    cryptoService;
+    loggerService;
+    constructor(cryptoService, loggerService) {
+        this.cryptoService = cryptoService;
+        this.loggerService = loggerService;
+    }
+    async run() {
+        const secret = await this.cryptoService.createSecret();
+        this.loggerService.info(`New secret: ${secret}`);
+    }
+}
+exports.CreateSecretCommandService = CreateSecretCommandService;

package/lib/commands/create-secret/index.d.ts

@@ -0,0 +1 @@
+export { CreateSecretCommandService } from './create-secret-command.service';

package/lib/commands/create-secret/index.js

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

package/lib/commands/generators/create-app/create-app-command.service.d.ts

@@ -0,0 +1,25 @@
+import { Generator } from '../../../services';
+/**
+ * Service for creating a new FoalTS application.
+ */
+export declare class CreateAppCommandService {
+    private generator;
+    constructor(generator: Generator);
+    /**
+     * Create a new FoalTS application.
+     *
+     * @param {string} name - The name of the application
+     * @param {boolean} autoInstall - Whether to automatically install dependencies
+     * @param {boolean} initRepo - Whether to initialize a git repository
+     * @param {boolean} mongodb - Whether to use MongoDB instead of SQLite
+     * @param {boolean} yaml - Whether to use YAML configuration instead of JSON
+     * @returns {Promise<void>}
+     */
+    run({ name, autoInstall, initRepo, mongodb, yaml }: {
+        name: string;
+        autoInstall?: boolean;
+        initRepo?: boolean;
+        mongodb?: boolean;
+        yaml?: boolean;
+    }): Promise<void>;
+}