@appweaver/cli 1.0.0

package/utils/process-util.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcess = runProcess;
+exports.assertEnv = assertEnv;
+exports.assertEnvs = assertEnvs;
+exports.isBunProcess = isBunProcess;
+const node_child_process_1 = require("node:child_process");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const common_1 = require("@appweaver/common");
+/**
+ * Executes a shell command with optional arguments and configuration parameters.
+ *
+ * @param {string} cmd - The command to execute.
+ * @param {string[]} [args=[]] - An array of arguments to pass to the command.
+ * @param {Object} [params={ quiet: false }] - Configurations for how the process should run.
+ * @param {boolean} [params.quiet=false] - If true, suppresses the process output.
+ * @param {AbortSignal} [params.signal] - Optional AbortSignal to terminate the running process.
+ * @return {Promise<number>} A promise that resolves with the exit code of the process or 1 on error.
+ */
+function runProcess(cmd, args = [], params = {}) {
+    const { quiet = false, signal } = params;
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            return resolve(0);
+        }
+        const command = args.length > 0 ? `${cmd} ${args.join(' ')}` : cmd;
+        const child = (0, node_child_process_1.spawn)(command, {
+            stdio: quiet ? 'ignore' : 'inherit',
+            shell: true,
+            env: { ...process.env, WEAVER_CLI: undefined }
+        });
+        if (signal) {
+            const abortHandler = () => {
+                if (child.pid) {
+                    (0, tree_kill_1.default)(child.pid, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(0);
+                        }
+                    });
+                }
+            };
+            signal.addEventListener('abort', abortHandler, { once: true });
+        }
+        child.on('error', reject);
+        child.on('close', (code) => {
+            resolve(code ?? 99);
+        });
+    });
+}
+/**
+ * Verifies that the application's runtime environment matches the specified environment.
+ * Terminates the process with an error message if the environments do not match.
+ *
+ * @param {string} env - The expected environment (e.g., 'production', 'development').
+ * @param {string} message - The error message to display if the environment does not match.
+ */
+function assertEnv(env, message) {
+    if (common_1.config.APP_ENV !== env) {
+        console.error(message);
+        process.exit(1);
+    }
+}
+/**
+ * Verifies that the application's runtime environment matches one of the specified environments.
+ * Terminates the process with an error message if the environment does not match any of the provided options.
+ *
+ * @param {string[]} envs - An array of expected environments (e.g., ['prod', 'dev', 'test']).
+ * @param {string} message - The error message to display if the environment does not match any of the provided options.
+ */
+function assertEnvs(envs, message) {
+    if (!envs.includes(common_1.config.APP_ENV)) {
+        console.error(message);
+        process.exit(1);
+    }
+}
+/**
+ * Checks if the current environment is a Bun.js process.
+ *
+ * This method determines whether the global `Bun` object is defined,
+ * which indicates the code is running in a Bun.js runtime environment.
+ *
+ * @return {boolean} Returns `true` if the `Bun` object is defined, otherwise `false`.
+ */
+function isBunProcess() {
+    return typeof Bun !== 'undefined';
+}

package/weaver.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/weaver.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+process.env.WEAVER_CLI = 'true';
+const node_child_process_1 = require("node:child_process");
+const common_1 = require("@appweaver/common");
+const utils_1 = require("./utils");
+// Restart the same process if the Bun runtime is configured and Bun is
+// available on the host machine
+if (!(0, utils_1.isBunProcess)() && common_1.config.APP_RUNTIME === common_1.Runtime.Bun) {
+    const check = (0, node_child_process_1.spawnSync)('bun --version', {
+        stdio: 'ignore',
+        shell: true
+    });
+    if (check.status === 0) {
+        const result = (0, node_child_process_1.spawnSync)(`bun ${process.argv.slice(1).join(' ')}`, {
+            stdio: 'inherit',
+            shell: true
+        });
+        process.exit(result.status ?? 1);
+    }
+    // Bun isn't found — fall through to Node execution
+}
+// These imports should be added after resolving current runtime to avoid
+// unnecessary loading of all dependencies
+const commander_1 = require("commander");
+const build_1 = require("./build");
+const generate_1 = require("./generate");
+const migrate_1 = require("./migrate");
+const migration_1 = require("./migration");
+const openapi_1 = require("./openapi");
+const seed_1 = require("./seed");
+const start_1 = require("./start");
+const testing_1 = require("./testing");
+const update_1 = require("./update");
+const pkg = (0, utils_1.loadCliPackageJson)();
+const program = new commander_1.Command();
+program
+    .name('weaver')
+    .description('Appweaver CLI - Build and manage your application')
+    .version(pkg.version, '-v, --version', 'Output the current version.')
+    .helpOption('-h, --help', 'Output usage information.')
+    .usage('<command> [options]');
+(0, build_1.buildCommand)(program);
+(0, generate_1.generateCommand)(program);
+(0, migrate_1.migrateCommand)(program);
+(0, migration_1.migrationCommand)(program);
+(0, openapi_1.openapiCommand)(program);
+(0, seed_1.seedCommand)(program);
+(0, start_1.startCommand)(program);
+(0, testing_1.testingCommand)(program);
+(0, update_1.updateCommand)(program);
+program.parse();