@warlock.js/core 4.2.1 → 4.2.2

package/esm/cli/commands/generate/utils/path-resolver.mjs

@@ -0,0 +1,56 @@
+import { appPath } from "../../../../utils/paths.mjs";
+import "../../../../utils/index.mjs";
+import { ensureDirectoryAsync as ensureDirectoryAsync$1 } from "./writer.mjs";
+import { directoryExistsAsync, fileExistsAsync } from "@warlock.js/fs";
+import path from "node:path";
+
+//#region ../@warlock.js/core/src/cli/commands/generate/utils/path-resolver.ts
+/**
+* Resolve module path
+* Returns absolute path to module directory
+*/
+function resolveModulePath(module) {
+	return appPath(module);
+}
+/**
+* Resolve component path within a module
+* @param module - Module name (e.g., "users")
+* @param type - Component type (e.g., "controllers", "services")
+* @param name - Component name (e.g., "create-user")
+* @param extension - File extension (default: ".ts")
+*/
+function resolveComponentPath(module, type, name, extension = ".ts") {
+	return path.join(resolveModulePath(module), type, `${name}${extension}`);
+}
+/**
+* Check if module exists
+*
+* A module is a DIRECTORY under the app path, so this uses
+* `directoryExistsAsync` — `fileExistsAsync` would resolve `false` for a folder
+* and wrongly gate every module-scoped generator behind "module does not exist".
+*/
+async function moduleExists(module) {
+	return await directoryExistsAsync(resolveModulePath(module));
+}
+/**
+* Check if file exists
+*/
+async function componentExists(module, type, name, extension = ".ts") {
+	return await fileExistsAsync(resolveComponentPath(module, type, name, extension));
+}
+/**
+* Ensure directory exists, create if missing
+*/
+async function ensureDirectory(dirPath) {
+	await ensureDirectoryAsync$1(dirPath);
+}
+/**
+* Ensure component directory exists
+*/
+async function ensureComponentDirectory(module, type) {
+	await ensureDirectory(path.join(resolveModulePath(module), type));
+}
+
+//#endregion
+export { componentExists, ensureComponentDirectory, moduleExists, resolveComponentPath, resolveModulePath };
+//# sourceMappingURL=path-resolver.mjs.map

package/esm/cli/commands/generate/utils/path-resolver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-resolver.mjs","names":["ensureDirectoryAsync"],"sources":["../../../../../../../../../../@warlock.js/core/src/cli/commands/generate/utils/path-resolver.ts"],"sourcesContent":["import { directoryExistsAsync, fileExistsAsync } from \"@warlock.js/fs\";\r\nimport path from \"node:path\";\r\nimport { appPath } from \"../../../../utils\";\r\nimport { ensureDirectoryAsync } from \"./writer\";\r\n\r\n/**\r\n * Resolve module path\r\n * Returns absolute path to module directory\r\n */\r\nexport function resolveModulePath(module: string): string {\r\n  return appPath(module);\r\n}\r\n\r\n/**\r\n * Resolve component path within a module\r\n * @param module - Module name (e.g., \"users\")\r\n * @param type - Component type (e.g., \"controllers\", \"services\")\r\n * @param name - Component name (e.g., \"create-user\")\r\n * @param extension - File extension (default: \".ts\")\r\n */\r\nexport function resolveComponentPath(\r\n  module: string,\r\n  type: string,\r\n  name: string,\r\n  extension = \".ts\",\r\n): string {\r\n  return path.join(resolveModulePath(module), type, `${name}${extension}`);\r\n}\r\n\r\n/**\r\n * Check if module exists\r\n *\r\n * A module is a DIRECTORY under the app path, so this uses\r\n * `directoryExistsAsync` — `fileExistsAsync` would resolve `false` for a folder\r\n * and wrongly gate every module-scoped generator behind \"module does not exist\".\r\n */\r\nexport async function moduleExists(module: string): Promise<boolean> {\r\n  return await directoryExistsAsync(resolveModulePath(module));\r\n}\r\n\r\n/**\r\n * Check if file exists\r\n */\r\nexport async function componentExists(\r\n  module: string,\r\n  type: string,\r\n  name: string,\r\n  extension = \".ts\",\r\n): Promise<boolean> {\r\n  return (await fileExistsAsync(resolveComponentPath(module, type, name, extension))) as boolean;\r\n}\r\n\r\n/**\r\n * Ensure directory exists, create if missing\r\n */\r\nexport async function ensureDirectory(dirPath: string): Promise<void> {\r\n  await ensureDirectoryAsync(dirPath);\r\n}\r\n\r\n/**\r\n * Ensure component directory exists\r\n */\r\nexport async function ensureComponentDirectory(module: string, type: string): Promise<void> {\r\n  const dirPath = path.join(resolveModulePath(module), type);\r\n  await ensureDirectory(dirPath);\r\n}\r\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,kBAAkB,QAAwB;CACxD,OAAO,QAAQ,MAAM;AACvB;;;;;;;;AASA,SAAgB,qBACd,QACA,MACA,MACA,YAAY,OACJ;CACR,OAAO,KAAK,KAAK,kBAAkB,MAAM,GAAG,MAAM,GAAG,OAAO,WAAW;AACzE;;;;;;;;AASA,eAAsB,aAAa,QAAkC;CACnE,OAAO,MAAM,qBAAqB,kBAAkB,MAAM,CAAC;AAC7D;;;;AAKA,eAAsB,gBACpB,QACA,MACA,MACA,YAAY,OACM;CAClB,OAAQ,MAAM,gBAAgB,qBAAqB,QAAQ,MAAM,MAAM,SAAS,CAAC;AACnF;;;;AAKA,eAAsB,gBAAgB,SAAgC;CACpE,MAAMA,uBAAqB,OAAO;AACpC;;;;AAKA,eAAsB,yBAAyB,QAAgB,MAA6B;CAE1F,MAAM,gBADU,KAAK,KAAK,kBAAkB,MAAM,GAAG,IACzB,CAAC;AAC/B"}

package/esm/cli/commands/generate/utils/prompt.mjs

@@ -0,0 +1,28 @@
+import readline from "node:readline";
+
+//#region ../@warlock.js/core/src/cli/commands/generate/utils/prompt.ts
+/**
+* Prompt user for confirmation
+*/
+async function confirm(message, defaultValue = false) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve) => {
+		const defaultText = defaultValue ? "Y/n" : "y/N";
+		rl.question(`${message} (${defaultText}): `, (answer) => {
+			rl.close();
+			if (!answer.trim()) {
+				resolve(defaultValue);
+				return;
+			}
+			const normalized = answer.toLowerCase().trim();
+			resolve(normalized === "y" || normalized === "yes");
+		});
+	});
+}
+
+//#endregion
+export { confirm };
+//# sourceMappingURL=prompt.mjs.map

package/esm/cli/commands/generate/utils/prompt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/core/src/cli/commands/generate/utils/prompt.ts"],"sourcesContent":["import readline from \"node:readline\";\n\n/**\n * Prompt user for confirmation\n */\nexport async function confirm(message: string, defaultValue = false): Promise<boolean> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    const defaultText = defaultValue ? \"Y/n\" : \"y/N\";\n    rl.question(`${message} (${defaultText}): `, (answer) => {\n      rl.close();\n\n      if (!answer.trim()) {\n        resolve(defaultValue);\n        return;\n      }\n\n      const normalized = answer.toLowerCase().trim();\n      resolve(normalized === \"y\" || normalized === \"yes\");\n    });\n  });\n}\n\n/**\n * Prompt user for text input\n */\nexport async function input(message: string, defaultValue?: string): Promise<string> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    const prompt = defaultValue ? `${message} (${defaultValue}): ` : `${message}: `;\n\n    rl.question(prompt, (answer) => {\n      rl.close();\n      resolve(answer.trim() || defaultValue || \"\");\n    });\n  });\n}\n\n/**\n * Prompt user to select from choices\n */\nexport async function select(message: string, choices: string[]): Promise<string> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    console.log(message);\n    choices.forEach((choice, index) => {\n      console.log(`  ${index + 1}. ${choice}`);\n    });\n\n    rl.question(\"Select (1-\" + choices.length + \"): \", (answer) => {\n      rl.close();\n\n      const index = parseInt(answer.trim(), 10) - 1;\n\n      if (index >= 0 && index < choices.length) {\n        resolve(choices[index]);\n      } else {\n        resolve(choices[0]);\n      }\n    });\n  });\n}\n"],"mappings":";;;;;;AAKA,eAAsB,QAAQ,SAAiB,eAAe,OAAyB;CACrF,MAAM,KAAK,SAAS,gBAAgB;EAClC,OAAO,QAAQ;EACf,QAAQ,QAAQ;CAClB,CAAC;CAED,OAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,cAAc,eAAe,QAAQ;EAC3C,GAAG,SAAS,GAAG,QAAQ,IAAI,YAAY,OAAO,WAAW;GACvD,GAAG,MAAM;GAET,IAAI,CAAC,OAAO,KAAK,GAAG;IAClB,QAAQ,YAAY;IACpB;GACF;GAEA,MAAM,aAAa,OAAO,YAAY,CAAC,CAAC,KAAK;GAC7C,QAAQ,eAAe,OAAO,eAAe,KAAK;EACpD,CAAC;CACH,CAAC;AACH"}

package/esm/cli/commands/generate/utils/writer.mjs

@@ -0,0 +1,60 @@
+import { colors } from "@mongez/copper";
+import { ensureDirectoryAsync, putFileAsync } from "@warlock.js/fs";
+import path from "node:path";
+
+//#region ../@warlock.js/core/src/cli/commands/generate/utils/writer.ts
+/**
+* Dry-run state for the `generate.*` command family.
+*
+* When enabled (via `--dry-run`), every generator write becomes a no-op
+* that instead reports the file it *would* have created — letting a
+* developer preview a scaffold (especially `generate.module --crud`,
+* which writes ~25 files) before anything touches disk.
+*
+* The flag is process-wide module state: the CLI runs one command per
+* process, and a top-level generator (e.g. `generateModule`) sets it
+* once, so nested helpers (`createMigrationFile`, `ensureComponentDirectory`)
+* inherit it without threading a parameter through every signature.
+*/
+let dryRun = false;
+/**
+* Toggle dry-run mode. Call once at the start of a generator action,
+* e.g. `setDryRun(Boolean(data.options.dryRun))`.
+*/
+function setDryRun(value) {
+	dryRun = value;
+	if (value) console.log(colors.yellowBright("\n○ Dry run — previewing planned files. Nothing will be written.\n"));
+}
+/** Render an absolute path relative to the cwd for tidy logs. */
+function relativePath(target) {
+	return path.relative(process.cwd(), target) || target;
+}
+/**
+* Write a generated file — or, in dry-run, report what *would* be
+* written. Owns the per-file log so call sites stay a single line.
+*
+* @example
+* await putFileAsync(controllerPath, controllerContent);
+* // normal:  ✓ created src/app/users/controllers/create-user.controller.ts
+* // dry-run: ○ would create src/app/users/controllers/create-user.controller.ts
+*/
+async function putFileAsync$1(target, content) {
+	if (dryRun) {
+		console.log(`${colors.cyan("○")} would create ${colors.gray(relativePath(target))}`);
+		return;
+	}
+	await putFileAsync(target, content);
+	console.log(`${colors.green("✓")} created ${colors.gray(relativePath(target))}`);
+}
+/**
+* Ensure a directory exists. Silent no-op in dry-run so a preview never
+* leaves empty folders behind.
+*/
+async function ensureDirectoryAsync$1(target) {
+	if (dryRun) return;
+	await ensureDirectoryAsync(target);
+}
+
+//#endregion
+export { ensureDirectoryAsync$1 as ensureDirectoryAsync, putFileAsync$1 as putFileAsync, setDryRun };
+//# sourceMappingURL=writer.mjs.map

package/esm/cli/commands/generate/utils/writer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.mjs","names":["putFileAsync","fsPutFileAsync","ensureDirectoryAsync","fsEnsureDirectoryAsync"],"sources":["../../../../../../../../../../@warlock.js/core/src/cli/commands/generate/utils/writer.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport {\n  ensureDirectoryAsync as fsEnsureDirectoryAsync,\n  putFileAsync as fsPutFileAsync,\n} from \"@warlock.js/fs\";\nimport path from \"node:path\";\n\n/**\n * Dry-run state for the `generate.*` command family.\n *\n * When enabled (via `--dry-run`), every generator write becomes a no-op\n * that instead reports the file it *would* have created — letting a\n * developer preview a scaffold (especially `generate.module --crud`,\n * which writes ~25 files) before anything touches disk.\n *\n * The flag is process-wide module state: the CLI runs one command per\n * process, and a top-level generator (e.g. `generateModule`) sets it\n * once, so nested helpers (`createMigrationFile`, `ensureComponentDirectory`)\n * inherit it without threading a parameter through every signature.\n */\nlet dryRun = false;\n\n/**\n * Toggle dry-run mode. Call once at the start of a generator action,\n * e.g. `setDryRun(Boolean(data.options.dryRun))`.\n */\nexport function setDryRun(value: boolean): void {\n  dryRun = value;\n\n  if (value) {\n    console.log(\n      colors.yellowBright(\"\\n○ Dry run — previewing planned files. Nothing will be written.\\n\"),\n    );\n  }\n}\n\nexport function isDryRun(): boolean {\n  return dryRun;\n}\n\n/** Render an absolute path relative to the cwd for tidy logs. */\nfunction relativePath(target: string): string {\n  return path.relative(process.cwd(), target) || target;\n}\n\n/**\n * Write a generated file — or, in dry-run, report what *would* be\n * written. Owns the per-file log so call sites stay a single line.\n *\n * @example\n * await putFileAsync(controllerPath, controllerContent);\n * // normal:  ✓ created src/app/users/controllers/create-user.controller.ts\n * // dry-run: ○ would create src/app/users/controllers/create-user.controller.ts\n */\nexport async function putFileAsync(target: string, content: string): Promise<void> {\n  if (dryRun) {\n    console.log(`${colors.cyan(\"○\")} would create ${colors.gray(relativePath(target))}`);\n    return;\n  }\n\n  await fsPutFileAsync(target, content);\n  console.log(`${colors.green(\"✓\")} created ${colors.gray(relativePath(target))}`);\n}\n\n/**\n * Ensure a directory exists. Silent no-op in dry-run so a preview never\n * leaves empty folders behind.\n */\nexport async function ensureDirectoryAsync(target: string): Promise<void> {\n  if (dryRun) return;\n\n  await fsEnsureDirectoryAsync(target);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAI,SAAS;;;;;AAMb,SAAgB,UAAU,OAAsB;CAC9C,SAAS;CAET,IAAI,OACF,QAAQ,IACN,OAAO,aAAa,oEAAoE,CAC1F;AAEJ;;AAOA,SAAS,aAAa,QAAwB;CAC5C,OAAO,KAAK,SAAS,QAAQ,IAAI,GAAG,MAAM,KAAK;AACjD;;;;;;;;;;AAWA,eAAsBA,eAAa,QAAgB,SAAgC;CACjF,IAAI,QAAQ;EACV,QAAQ,IAAI,GAAG,OAAO,KAAK,GAAG,EAAE,gBAAgB,OAAO,KAAK,aAAa,MAAM,CAAC,GAAG;EACnF;CACF;CAEA,MAAMC,aAAe,QAAQ,OAAO;CACpC,QAAQ,IAAI,GAAG,OAAO,MAAM,GAAG,EAAE,WAAW,OAAO,KAAK,aAAa,MAAM,CAAC,GAAG;AACjF;;;;;AAMA,eAAsBC,uBAAqB,QAA+B;CACxE,IAAI,QAAQ;CAEZ,MAAMC,qBAAuB,MAAM;AACrC"}

package/esm/cli/commands/migrate.command.mjs

@@ -0,0 +1,60 @@
+import { command } from "../cli-command.mjs";
+import { migrateAction } from "../../database/migrate-action.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/migrate.command.ts
+const migrateCommand = command({
+	action: migrateAction,
+	name: "migrate",
+	description: "Run database migrations",
+	preload: {
+		config: ["database", "log"],
+		env: true,
+		connectors: ["database", "logger"]
+	},
+	options: [
+		{
+			text: "--fresh, -f",
+			description: "Drop all tables and re-run migrations",
+			type: "boolean"
+		},
+		{
+			text: "--rollback, -r",
+			description: "Rollback migrations, drop all tables",
+			type: "boolean"
+		},
+		{
+			text: "--path, -p",
+			description: "Migration file path, if not provided, all migrations will be wroking",
+			type: "string"
+		},
+		{
+			text: "--list, -l",
+			description: "List all executed migrations",
+			type: "boolean"
+		},
+		{
+			text: "--all, -a",
+			description: "List all migrations files in the app",
+			type: "boolean"
+		},
+		{
+			text: "--sql, -s",
+			description: "Export all migrations as phase-ordered SQL files instead of executing them",
+			type: "boolean"
+		},
+		{
+			text: "--pending-only",
+			description: "When used with --sql, exports only pending migrations instead of all",
+			type: "boolean"
+		},
+		{
+			text: "--compact, -c",
+			description: "When used with --sql, strips out generated comments and blank lines to reduce file size",
+			type: "boolean"
+		}
+	]
+});
+
+//#endregion
+export { migrateCommand };
+//# sourceMappingURL=migrate.command.mjs.map

package/esm/cli/commands/migrate.command.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/migrate.command.ts"],"sourcesContent":["import { migrateAction } from \"../../database/migrate-action\";\nimport { command } from \"../cli-command\";\n\nexport const migrateCommand = command({\n  action: migrateAction,\n  name: \"migrate\",\n  description: \"Run database migrations\",\n  preload: {\n    config: [\"database\", \"log\"],\n    env: true,\n    connectors: [\"database\", \"logger\"],\n  },\n  options: [\n    {\n      text: \"--fresh, -f\",\n      description: \"Drop all tables and re-run migrations\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--rollback, -r\",\n      description: \"Rollback migrations, drop all tables\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--path, -p\",\n      description: \"Migration file path, if not provided, all migrations will be wroking\",\n      type: \"string\",\n    },\n    {\n      text: \"--list, -l\",\n      description: \"List all executed migrations\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--all, -a\",\n      description: \"List all migrations files in the app\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--sql, -s\",\n      description: \"Export all migrations as phase-ordered SQL files instead of executing them\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--pending-only\",\n      description: \"When used with --sql, exports only pending migrations instead of all\",\n      type: \"boolean\",\n    },\n    {\n      text: \"--compact, -c\",\n      description:\n        \"When used with --sql, strips out generated comments and blank lines to reduce file size\",\n      type: \"boolean\",\n    },\n  ],\n});\n"],"mappings":";;;;AAGA,MAAa,iBAAiB,QAAQ;CACpC,QAAQ;CACR,MAAM;CACN,aAAa;CACb,SAAS;EACP,QAAQ,CAAC,YAAY,KAAK;EAC1B,KAAK;EACL,YAAY,CAAC,YAAY,QAAQ;CACnC;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aACE;GACF,MAAM;EACR;CACF;AACF,CAAC"}

package/esm/cli/commands/seed.command.mjs

@@ -0,0 +1,41 @@
+import { command } from "../cli-command.mjs";
+import { seedCommandAction } from "../../database/seed-command-action.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/seed.command.ts
+const seedCommand = command({
+	action: seedCommandAction,
+	name: "seed",
+	description: "Run database seeds",
+	preload: {
+		config: true,
+		env: true,
+		bootstrap: true,
+		connectors: [
+			"database",
+			"cache",
+			"logger"
+		]
+	},
+	options: [
+		{
+			text: "--fresh, -f",
+			description: "Drop all tables records and run seeds",
+			type: "boolean"
+		},
+		{
+			text: "--list, -l",
+			description: "Display the seeds list in order without execution",
+			type: "boolean"
+		},
+		{
+			text: "--transaction, -t",
+			description: "Run seeds in a transaction",
+			type: "boolean",
+			defaultValue: true
+		}
+	]
+});
+
+//#endregion
+export { seedCommand };
+//# sourceMappingURL=seed.command.mjs.map

package/esm/cli/commands/seed.command.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/seed.command.ts"],"sourcesContent":["import { seedCommandAction } from \"../../database/seed-command-action\";\r\nimport { command } from \"../cli-command\";\r\n\r\nexport const seedCommand = command({\r\n  action: seedCommandAction,\r\n  name: \"seed\",\r\n  description: \"Run database seeds\",\r\n  preload: {\r\n    config: true,\r\n    env: true,\r\n    bootstrap: true,\r\n    connectors: [\"database\", \"cache\", \"logger\"],\r\n  },\r\n  options: [\r\n    {\r\n      text: \"--fresh, -f\",\r\n      description: \"Drop all tables records and run seeds\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--list, -l\",\r\n      description: \"Display the seeds list in order without execution\",\r\n      type: \"boolean\",\r\n    },\r\n    {\r\n      text: \"--transaction, -t\",\r\n      description: \"Run seeds in a transaction\",\r\n      type: \"boolean\",\r\n      defaultValue: true,\r\n    },\r\n  ],\r\n});\r\n"],"mappings":";;;;AAGA,MAAa,cAAc,QAAQ;CACjC,QAAQ;CACR,MAAM;CACN,aAAa;CACb,SAAS;EACP,QAAQ;EACR,KAAK;EACL,WAAW;EACX,YAAY;GAAC;GAAY;GAAS;EAAQ;CAC5C;CACA,SAAS;EACP;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;EACR;EACA;GACE,MAAM;GACN,aAAa;GACb,MAAM;GACN,cAAc;EAChB;CACF;AACF,CAAC"}

package/esm/cli/commands/start-production.command.mjs

@@ -0,0 +1,50 @@
+import { command } from "../cli-command.mjs";
+import { displayStartupBanner } from "../cli-commands.utils.mjs";
+import { resolveBuildConfig } from "../../production/resolve-build-config.mjs";
+import { spawn } from "child_process";
+
+//#region ../@warlock.js/core/src/cli/commands/start-production.command.ts
+const startProductionCommand = command({
+	name: "start",
+	description: "Start production server",
+	persistent: true,
+	preload: { warlockConfig: true },
+	preAction: async () => {
+		displayStartupBanner({ environment: "production" });
+	},
+	action: async () => {
+		const { entryPath, sourcemap } = resolveBuildConfig();
+		const nodeArgs = [];
+		if (sourcemap !== false) nodeArgs.push("--enable-source-maps");
+		nodeArgs.push(entryPath);
+		const startIndex = process.argv.findIndex((arg) => arg === "start");
+		if (startIndex !== -1 && startIndex < process.argv.length - 1) {
+			const extraArgs = process.argv.slice(startIndex + 1);
+			nodeArgs.push(...extraArgs);
+		}
+		console.log(`🚀 Starting production server...\n`);
+		const child = spawn("node", nodeArgs, {
+			stdio: "inherit",
+			cwd: process.cwd(),
+			env: process.env,
+			detached: false
+		});
+		let isShuttingDown = false;
+		const forwardSignal = (signal) => {
+			if (isShuttingDown) return;
+			isShuttingDown = true;
+			child.kill(signal);
+		};
+		process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+		process.on("SIGINT", () => {
+			isShuttingDown = true;
+		});
+		child.on("exit", (code) => {
+			process.exit(code ?? 0);
+		});
+	}
+});
+
+//#endregion
+export { startProductionCommand };
+//# sourceMappingURL=start-production.command.mjs.map

package/esm/cli/commands/start-production.command.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-production.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/start-production.command.ts"],"sourcesContent":["import { spawn } from \"child_process\";\r\nimport { resolveBuildConfig } from \"../../production/resolve-build-config\";\r\nimport { command } from \"../cli-command\";\r\nimport { displayStartupBanner } from \"../cli-commands.utils\";\r\n\r\nexport const startProductionCommand = command({\r\n  name: \"start\",\r\n  description: \"Start production server\",\r\n  persistent: true,\r\n  preload: {\r\n    warlockConfig: true,\r\n  },\r\n  preAction: async () => {\r\n    displayStartupBanner({ environment: \"production\" });\r\n  },\r\n  action: async () => {\r\n    const { entryPath, sourcemap } = resolveBuildConfig();\r\n\r\n    // Build node args\r\n    const nodeArgs: string[] = [];\r\n\r\n    // Enable source maps if configured\r\n    if (sourcemap !== false) {\r\n      nodeArgs.push(\"--enable-source-maps\");\r\n    }\r\n\r\n    // Add entry file\r\n    nodeArgs.push(entryPath);\r\n\r\n    // Pass through any additional flags after \"start\" command\r\n    // process.argv = [node, cli.ts, start, ...extra]\r\n    const startIndex = process.argv.findIndex((arg) => arg === \"start\");\r\n    if (startIndex !== -1 && startIndex < process.argv.length - 1) {\r\n      const extraArgs = process.argv.slice(startIndex + 1);\r\n      nodeArgs.push(...extraArgs);\r\n    }\r\n\r\n    console.log(`🚀 Starting production server...\\n`);\r\n\r\n    // Spawn child process\r\n    // On Windows, we need to be careful with signals - the console sends Ctrl+C\r\n    // to all processes in the group, so we just need to not interfere\r\n    const child = spawn(\"node\", nodeArgs, {\r\n      stdio: \"inherit\",\r\n      cwd: process.cwd(),\r\n      env: process.env,\r\n      // Important: keep child in same process group for proper signal handling\r\n      detached: false,\r\n    });\r\n\r\n    // Track if we're shutting down to prevent double-exit\r\n    let isShuttingDown = false;\r\n\r\n    // Forward signals to child (needed for SIGTERM, helpful for explicit forwarding)\r\n    const forwardSignal = (signal: NodeJS.Signals) => {\r\n      if (isShuttingDown) return;\r\n      isShuttingDown = true;\r\n\r\n      // Send signal to child\r\n      child.kill(signal);\r\n    };\r\n\r\n    // On SIGTERM, forward it (SIGTERM doesn't auto-propagate like SIGINT on Windows)\r\n    process.on(\"SIGTERM\", () => forwardSignal(\"SIGTERM\"));\r\n\r\n    // On SIGINT (Ctrl+C), mark as shutting down but let child handle it naturally\r\n    // On Windows, Ctrl+C is sent to both processes, so child already gets it\r\n    process.on(\"SIGINT\", () => {\r\n      isShuttingDown = true;\r\n      // Give child a chance to exit gracefully before we do anything\r\n    });\r\n\r\n    // Exit with child's exit code\r\n    child.on(\"exit\", (code) => {\r\n      process.exit(code ?? 0);\r\n    });\r\n  },\r\n});\r\n"],"mappings":";;;;;;AAKA,MAAa,yBAAyB,QAAQ;CAC5C,MAAM;CACN,aAAa;CACb,YAAY;CACZ,SAAS,EACP,eAAe,KACjB;CACA,WAAW,YAAY;EACrB,qBAAqB,EAAE,aAAa,aAAa,CAAC;CACpD;CACA,QAAQ,YAAY;EAClB,MAAM,EAAE,WAAW,cAAc,mBAAmB;EAGpD,MAAM,WAAqB,CAAC;EAG5B,IAAI,cAAc,OAChB,SAAS,KAAK,sBAAsB;EAItC,SAAS,KAAK,SAAS;EAIvB,MAAM,aAAa,QAAQ,KAAK,WAAW,QAAQ,QAAQ,OAAO;EAClE,IAAI,eAAe,MAAM,aAAa,QAAQ,KAAK,SAAS,GAAG;GAC7D,MAAM,YAAY,QAAQ,KAAK,MAAM,aAAa,CAAC;GACnD,SAAS,KAAK,GAAG,SAAS;EAC5B;EAEA,QAAQ,IAAI,oCAAoC;EAKhD,MAAM,QAAQ,MAAM,QAAQ,UAAU;GACpC,OAAO;GACP,KAAK,QAAQ,IAAI;GACjB,KAAK,QAAQ;GAEb,UAAU;EACZ,CAAC;EAGD,IAAI,iBAAiB;EAGrB,MAAM,iBAAiB,WAA2B;GAChD,IAAI,gBAAgB;GACpB,iBAAiB;GAGjB,MAAM,KAAK,MAAM;EACnB;EAGA,QAAQ,GAAG,iBAAiB,cAAc,SAAS,CAAC;EAIpD,QAAQ,GAAG,gBAAgB;GACzB,iBAAiB;EAEnB,CAAC;EAGD,MAAM,GAAG,SAAS,SAAS;GACzB,QAAQ,KAAK,QAAQ,CAAC;EACxB,CAAC;CACH;AACF,CAAC"}

package/esm/cli/commands/storage-put.action.mjs

@@ -0,0 +1,75 @@
+import { config } from "../../config/config-getter.mjs";
+import "../../config/index.mjs";
+import { storage } from "../../storage/storage.mjs";
+import "../../storage/index.mjs";
+import path from "path";
+import fs from "fs/promises";
+
+//#region ../@warlock.js/core/src/cli/commands/storage-put.action.ts
+/**
+* Action for `warlock storage.put <localPath> [destination] [--driver <name>] [--concurrency <n>]`
+*
+* Uploads a local file or directory into any configured storage driver.
+* Auto-detects whether <localPath> is a file or directory and calls the
+* appropriate storage method.
+*
+* @example
+* # Upload entire uploads directory to R2 (root of bucket)
+* warlock storage.put ./uploads --driver r2
+*
+* @example
+* # Upload to a specific destination prefix
+* warlock storage.put ./uploads backups/2026 --driver r2
+*
+* @example
+* # Single file upload with custom concurrency
+* warlock storage.put ./public/logo.png assets/logo.png --driver s3
+*/
+async function storagePutAction({ args, options }) {
+	const [localPath, destination = ""] = args;
+	if (!localPath) {
+		console.error("✖  Missing required argument: <localPath>");
+		console.error("   Usage: warlock storage.put <localPath> [destination] [--driver <name>]");
+		process.exit(1);
+	}
+	const absolutePath = path.resolve(process.cwd(), localPath);
+	const driverName = options.driver;
+	const concurrency = options.concurrency ? Number(options.concurrency) : 5;
+	let stat;
+	try {
+		stat = await fs.stat(absolutePath);
+	} catch {
+		console.error(`✖  Path not found: ${absolutePath}`);
+		process.exit(1);
+	}
+	const store = driverName ? storage.use(driverName) : storage;
+	const driverLabel = driverName ?? config.get("storage.default");
+	console.log(`\n  Driver    : ${driverLabel}`);
+	console.log(`  Source    : ${absolutePath}`);
+	console.log(`  Dest      : ${destination || "(root)"}\n`);
+	if (stat.isDirectory()) {
+		const result = await store.putDirectory(absolutePath, destination, {
+			concurrency,
+			filter: (_, rel) => !path.basename(rel).startsWith("."),
+			onProgress: (done, total, file) => {
+				process.stdout.write(`\r  Progress  : ${done}/${total}  ${file.path}`);
+			}
+		});
+		process.stdout.write("\n");
+		console.log(`\n  ✔  ${result.uploaded.length} file(s) uploaded`);
+		if (result.failed.length > 0) {
+			console.warn(`\n  ⚠  ${result.failed.length} file(s) failed:`);
+			for (const { localPath: fp, error } of result.failed) console.warn(`     - ${fp}: ${error.message}`);
+		}
+	} else {
+		const storagePath = destination || path.basename(absolutePath);
+		console.log(`  Uploading : ${path.basename(absolutePath)} → ${storagePath}`);
+		const file = await store.put(absolutePath, storagePath);
+		console.log(`\n  ✔  Uploaded: ${file.url}`);
+	}
+	console.log();
+}
+
+//#endregion
+export { storagePutAction };
+//# sourceMappingURL=storage-put.action.mjs.map

package/esm/cli/commands/storage-put.action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-put.action.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/storage-put.action.ts"],"sourcesContent":["import fs from \"fs/promises\";\nimport path from \"path\";\nimport { config } from \"../../config\";\nimport { storage } from \"../../storage\";\nimport type { CommandActionData } from \"../types\";\n\n/**\n * Action for `warlock storage.put <localPath> [destination] [--driver <name>] [--concurrency <n>]`\n *\n * Uploads a local file or directory into any configured storage driver.\n * Auto-detects whether <localPath> is a file or directory and calls the\n * appropriate storage method.\n *\n * @example\n * # Upload entire uploads directory to R2 (root of bucket)\n * warlock storage.put ./uploads --driver r2\n *\n * @example\n * # Upload to a specific destination prefix\n * warlock storage.put ./uploads backups/2026 --driver r2\n *\n * @example\n * # Single file upload with custom concurrency\n * warlock storage.put ./public/logo.png assets/logo.png --driver s3\n */\nexport async function storagePutAction({ args, options }: CommandActionData): Promise<void> {\n  const [localPath, destination = \"\"] = args;\n\n  if (!localPath) {\n    console.error(\"✖  Missing required argument: <localPath>\");\n    console.error(\"   Usage: warlock storage.put <localPath> [destination] [--driver <name>]\");\n    process.exit(1);\n  }\n\n  // Resolve to absolute path relative to CWD\n  const absolutePath = path.resolve(process.cwd(), localPath);\n  const driverName = options.driver as string | undefined;\n  const concurrency = options.concurrency ? Number(options.concurrency) : 5;\n\n  // Verify the local path exists\n  let stat: Awaited<ReturnType<typeof fs.stat>>;\n  try {\n    stat = await fs.stat(absolutePath);\n  } catch {\n    console.error(`✖  Path not found: ${absolutePath}`);\n    process.exit(1);\n  }\n\n  // Select the driver — use named driver or fall back to default\n  const store = driverName ? storage.use(driverName) : storage;\n  const driverLabel = driverName ?? config.get(\"storage.default\");\n\n  console.log(`\\n  Driver    : ${driverLabel}`);\n  console.log(`  Source    : ${absolutePath}`);\n  console.log(`  Dest      : ${destination || \"(root)\"}\\n`);\n\n  if (stat.isDirectory()) {\n    // ── Directory upload ────────────────────────────────────────────────────\n    const result = await store.putDirectory(absolutePath, destination, {\n      concurrency,\n      // Skip hidden files (e.g. .DS_Store) by default\n      filter: (_, rel) => !path.basename(rel).startsWith(\".\"),\n      onProgress: (done, total, file) => {\n        process.stdout.write(`\\r  Progress  : ${done}/${total}  ${file.path}`);\n      },\n    });\n\n    // Clear the progress line and print summary\n    process.stdout.write(\"\\n\");\n    console.log(`\\n  ✔  ${result.uploaded.length} file(s) uploaded`);\n\n    if (result.failed.length > 0) {\n      console.warn(`\\n  ⚠  ${result.failed.length} file(s) failed:`);\n      for (const { localPath: fp, error } of result.failed) {\n        console.warn(`     - ${fp}: ${error.message}`);\n      }\n    }\n  } else {\n    // ── Single file upload ──────────────────────────────────────────────────\n    // Destination is used as the storage path; if empty, fall back to filename\n    const storagePath = destination || path.basename(absolutePath);\n\n    console.log(`  Uploading : ${path.basename(absolutePath)} → ${storagePath}`);\n\n    const file = await store.put(absolutePath, storagePath);\n\n    console.log(`\\n  ✔  Uploaded: ${file.url}`);\n  }\n\n  console.log();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,eAAsB,iBAAiB,EAAE,MAAM,WAA6C;CAC1F,MAAM,CAAC,WAAW,cAAc,MAAM;CAEtC,IAAI,CAAC,WAAW;EACd,QAAQ,MAAM,2CAA2C;EACzD,QAAQ,MAAM,2EAA2E;EACzF,QAAQ,KAAK,CAAC;CAChB;CAGA,MAAM,eAAe,KAAK,QAAQ,QAAQ,IAAI,GAAG,SAAS;CAC1D,MAAM,aAAa,QAAQ;CAC3B,MAAM,cAAc,QAAQ,cAAc,OAAO,QAAQ,WAAW,IAAI;CAGxE,IAAI;CACJ,IAAI;EACF,OAAO,MAAM,GAAG,KAAK,YAAY;CACnC,QAAQ;EACN,QAAQ,MAAM,sBAAsB,cAAc;EAClD,QAAQ,KAAK,CAAC;CAChB;CAGA,MAAM,QAAQ,aAAa,QAAQ,IAAI,UAAU,IAAI;CACrD,MAAM,cAAc,cAAc,OAAO,IAAI,iBAAiB;CAE9D,QAAQ,IAAI,mBAAmB,aAAa;CAC5C,QAAQ,IAAI,iBAAiB,cAAc;CAC3C,QAAQ,IAAI,iBAAiB,eAAe,SAAS,GAAG;CAExD,IAAI,KAAK,YAAY,GAAG;EAEtB,MAAM,SAAS,MAAM,MAAM,aAAa,cAAc,aAAa;GACjE;GAEA,SAAS,GAAG,QAAQ,CAAC,KAAK,SAAS,GAAG,CAAC,CAAC,WAAW,GAAG;GACtD,aAAa,MAAM,OAAO,SAAS;IACjC,QAAQ,OAAO,MAAM,mBAAmB,KAAK,GAAG,MAAM,IAAI,KAAK,MAAM;GACvE;EACF,CAAC;EAGD,QAAQ,OAAO,MAAM,IAAI;EACzB,QAAQ,IAAI,UAAU,OAAO,SAAS,OAAO,kBAAkB;EAE/D,IAAI,OAAO,OAAO,SAAS,GAAG;GAC5B,QAAQ,KAAK,UAAU,OAAO,OAAO,OAAO,iBAAiB;GAC7D,KAAK,MAAM,EAAE,WAAW,IAAI,WAAW,OAAO,QAC5C,QAAQ,KAAK,UAAU,GAAG,IAAI,MAAM,SAAS;EAEjD;CACF,OAAO;EAGL,MAAM,cAAc,eAAe,KAAK,SAAS,YAAY;EAE7D,QAAQ,IAAI,iBAAiB,KAAK,SAAS,YAAY,EAAE,KAAK,aAAa;EAE3E,MAAM,OAAO,MAAM,MAAM,IAAI,cAAc,WAAW;EAEtD,QAAQ,IAAI,oBAAoB,KAAK,KAAK;CAC5C;CAEA,QAAQ,IAAI;AACd"}

package/esm/cli/commands/storage-put.command.mjs

@@ -0,0 +1,46 @@
+import { command } from "../cli-command.mjs";
+import { storagePutAction } from "./storage-put.action.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/storage-put.command.ts
+/**
+* `storage.put` CLI command
+*
+* Uploads a local file or directory to any configured storage driver.
+* Auto-detects file vs directory and streams each file (no full buffer in memory).
+*
+* @example
+* # Upload full uploads/ directory to R2 (migrating from local to cloud)
+* warlock storage.put ./uploads --driver r2
+*
+* @example
+* # Upload under a specific prefix
+* warlock storage.put ./uploads backups/2026 --driver r2
+*
+* @example
+* # Single file upload to default driver
+* warlock storage.put ./public/logo.png assets/logo.png
+*/
+const storagePutCommand = command({
+	name: "storage.put <localPath> [destination]",
+	alias: "sput",
+	action: storagePutAction,
+	description: "Upload a local file or directory to storage",
+	preload: {
+		env: true,
+		config: ["storage"],
+		connectors: ["storage"]
+	},
+	options: [{
+		text: "--driver, -d",
+		description: "Storage driver name (as defined in config). Defaults to the configured default driver."
+	}, {
+		text: "--concurrency, -c",
+		description: "Number of concurrent uploads when uploading a directory",
+		type: "number",
+		defaultValue: 5
+	}]
+});
+
+//#endregion
+export { storagePutCommand };
+//# sourceMappingURL=storage-put.command.mjs.map

package/esm/cli/commands/storage-put.command.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-put.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/storage-put.command.ts"],"sourcesContent":["import { command } from \"../cli-command\";\nimport { storagePutAction } from \"./storage-put.action\";\n\n/**\n * `storage.put` CLI command\n *\n * Uploads a local file or directory to any configured storage driver.\n * Auto-detects file vs directory and streams each file (no full buffer in memory).\n *\n * @example\n * # Upload full uploads/ directory to R2 (migrating from local to cloud)\n * warlock storage.put ./uploads --driver r2\n *\n * @example\n * # Upload under a specific prefix\n * warlock storage.put ./uploads backups/2026 --driver r2\n *\n * @example\n * # Single file upload to default driver\n * warlock storage.put ./public/logo.png assets/logo.png\n */\nexport const storagePutCommand = command({\n  name: \"storage.put <localPath> [destination]\",\n  alias: \"sput\",\n  action: storagePutAction,\n  description: \"Upload a local file or directory to storage\",\n  preload: {\n    env: true,\n    config: [\"storage\"],\n    connectors: [\"storage\"],\n  },\n  options: [\n    {\n      text: \"--driver, -d\",\n      description:\n        \"Storage driver name (as defined in config). Defaults to the configured default driver.\",\n    },\n    {\n      text: \"--concurrency, -c\",\n      description: \"Number of concurrent uploads when uploading a directory\",\n      type: \"number\",\n      defaultValue: 5,\n    },\n  ],\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,oBAAoB,QAAQ;CACvC,MAAM;CACN,OAAO;CACP,QAAQ;CACR,aAAa;CACb,SAAS;EACP,KAAK;EACL,QAAQ,CAAC,SAAS;EAClB,YAAY,CAAC,SAAS;CACxB;CACA,SAAS,CACP;EACE,MAAM;EACN,aACE;CACJ,GACA;EACE,MAAM;EACN,aAAa;EACb,MAAM;EACN,cAAc;CAChB,CACF;AACF,CAAC"}

package/esm/cli/commands/typings-generator.command.mjs

@@ -0,0 +1,38 @@
+import { srcPath } from "../../utils/paths.mjs";
+import "../../utils/index.mjs";
+import { command } from "../cli-command.mjs";
+import { Path } from "../../dev-server/path.mjs";
+import { getFilesFromDirectory } from "../../dev-server/utils.mjs";
+import { filesOrchestrator } from "../../dev-server/files-orchestrator.mjs";
+import { typeGenerator } from "../../dev-server/type-generator.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands/typings-generator.command.ts
+const typingsGeneratorCommand = command({
+	name: "generate.typings",
+	description: "Generate type definitions for the project",
+	options: [{
+		text: "--files, -f",
+		description: "Files to generate typings for, if not passed, it will generate typings for all files"
+	}],
+	action: async ({ options }) => {
+		const configFilesPaths = [];
+		if (options.files) {
+			const files = String(options.files).split(",").map((file) => {
+				if (file.startsWith("./")) return Path.toAbsolute(file);
+				return file;
+			});
+			if (files?.length) configFilesPaths.push(...files);
+		}
+		if (configFilesPaths.length === 0) {
+			const configFiles = await getFilesFromDirectory(srcPath("config"));
+			configFilesPaths.push(...configFiles);
+		}
+		const failed = (await Promise.allSettled(configFilesPaths.map((path) => filesOrchestrator.add(Path.toRelative(path))))).filter((r) => r.status === "rejected");
+		if (failed.length) console.warn(`Failed to process ${failed.length} files`);
+		await typeGenerator.generateAll();
+	}
+});
+
+//#endregion
+export { typingsGeneratorCommand };
+//# sourceMappingURL=typings-generator.command.mjs.map

package/esm/cli/commands/typings-generator.command.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typings-generator.command.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/cli/commands/typings-generator.command.ts"],"sourcesContent":["import { filesOrchestrator } from \"../../dev-server/files-orchestrator\";\nimport { Path } from \"../../dev-server/path\";\nimport { typeGenerator } from \"../../dev-server/type-generator\";\nimport { getFilesFromDirectory } from \"../../dev-server/utils\";\nimport { srcPath } from \"../../utils\";\nimport { command } from \"../cli-command\";\n\nexport const typingsGeneratorCommand = command({\n  name: \"generate.typings\",\n  description: \"Generate type definitions for the project\",\n  options: [\n    {\n      text: \"--files, -f\",\n      description:\n        \"Files to generate typings for, if not passed, it will generate typings for all files\",\n    },\n  ],\n  action: async ({ options }) => {\n    const configFilesPaths: string[] = [];\n    if (options.files) {\n      const files = String(options.files)\n        .split(\",\")\n        .map((file) => {\n          if (file.startsWith(\"./\")) {\n            return Path.toAbsolute(file);\n          }\n\n          return file;\n        });\n\n      if (files?.length) {\n        configFilesPaths.push(...files);\n      }\n    }\n\n    if (configFilesPaths.length === 0) {\n      // grab all config files\n      const configFiles = await getFilesFromDirectory(srcPath(\"config\"));\n      configFilesPaths.push(...configFiles);\n    }\n\n    const results = await Promise.allSettled(\n      configFilesPaths.map((path) => filesOrchestrator.add(Path.toRelative(path))),\n    );\n\n    const failed = results.filter((r) => r.status === \"rejected\");\n\n    if (failed.length) {\n      console.warn(`Failed to process ${failed.length} files`);\n    }\n\n    await typeGenerator.generateAll();\n  },\n});\n"],"mappings":";;;;;;;;;AAOA,MAAa,0BAA0B,QAAQ;CAC7C,MAAM;CACN,aAAa;CACb,SAAS,CACP;EACE,MAAM;EACN,aACE;CACJ,CACF;CACA,QAAQ,OAAO,EAAE,cAAc;EAC7B,MAAM,mBAA6B,CAAC;EACpC,IAAI,QAAQ,OAAO;GACjB,MAAM,QAAQ,OAAO,QAAQ,KAAK,CAAC,CAChC,MAAM,GAAG,CAAC,CACV,KAAK,SAAS;IACb,IAAI,KAAK,WAAW,IAAI,GACtB,OAAO,KAAK,WAAW,IAAI;IAG7B,OAAO;GACT,CAAC;GAEH,IAAI,OAAO,QACT,iBAAiB,KAAK,GAAG,KAAK;EAElC;EAEA,IAAI,iBAAiB,WAAW,GAAG;GAEjC,MAAM,cAAc,MAAM,sBAAsB,QAAQ,QAAQ,CAAC;GACjE,iBAAiB,KAAK,GAAG,WAAW;EACtC;EAMA,MAAM,UAAS,MAJO,QAAQ,WAC5B,iBAAiB,KAAK,SAAS,kBAAkB,IAAI,KAAK,WAAW,IAAI,CAAC,CAAC,CAC7E,EAEsB,CAAC,QAAQ,MAAM,EAAE,WAAW,UAAU;EAE5D,IAAI,OAAO,QACT,QAAQ,KAAK,qBAAqB,OAAO,OAAO,OAAO;EAGzD,MAAM,cAAc,YAAY;CAClC;AACF,CAAC"}

package/esm/cli/commands-loader.mjs

@@ -0,0 +1,50 @@
+import { srcPath } from "../utils/paths.mjs";
+import "../utils/index.mjs";
+import { Path } from "../dev-server/path.mjs";
+import { getFilesFromDirectory } from "../dev-server/utils.mjs";
+import { filesOrchestrator } from "../dev-server/files-orchestrator.mjs";
+import { isMatchingCommandName } from "./cli-commands.utils.mjs";
+
+//#region ../@warlock.js/core/src/cli/commands-loader.ts
+var CLICommandsLoader = class {
+	/**
+	* Locate command by name
+	*/
+	async locate(commandName) {
+		const relativeFiles = (await getFilesFromDirectory(srcPath("app"), "**/commands/*.{ts,tsx}")).map((path) => Path.toRelative(path));
+		for (const relativeFile of relativeFiles) {
+			const command = await this.load(relativeFile);
+			if (command) {
+				command.$relativePath(relativeFile);
+				if (isMatchingCommandName(command.name, commandName)) return command;
+			}
+		}
+	}
+	/**
+	* Scan all project commands and return them
+	* Used for warm cache functionality
+	*/
+	async scanAll() {
+		const relativeFiles = (await getFilesFromDirectory(srcPath("app"), "**/commands/*.{ts,tsx}")).map((path) => Path.toRelative(path));
+		const commands = [];
+		for (const relativeFile of relativeFiles) {
+			const command = await this.load(relativeFile);
+			if (command) {
+				command.$relativePath(relativeFile);
+				commands.push(command);
+			}
+		}
+		return commands;
+	}
+	/**
+	* Load command from a relative path
+	*/
+	async load(relativePath) {
+		return (await filesOrchestrator.load(relativePath))?.default;
+	}
+};
+const cliCommandsLoader = new CLICommandsLoader();
+
+//#endregion
+export { cliCommandsLoader };
+//# sourceMappingURL=commands-loader.mjs.map

package/esm/cli/commands-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands-loader.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/cli/commands-loader.ts"],"sourcesContent":["import { filesOrchestrator } from \"../dev-server/files-orchestrator\";\nimport { Path } from \"../dev-server/path\";\nimport { getFilesFromDirectory } from \"../dev-server/utils\";\nimport { srcPath } from \"../utils\";\nimport { CLICommand } from \"./cli-command\";\nimport { isMatchingCommandName } from \"./cli-commands.utils\";\n\nexport class CLICommandsLoader {\n  /**\n   * Locate command by name\n   */\n  public async locate(commandName: string): Promise<CLICommand | undefined> {\n    const files = await getFilesFromDirectory(srcPath(\"app\"), \"**/commands/*.{ts,tsx}\");\n    // now convert them into relative paths\n    const relativeFiles = files.map((path) => Path.toRelative(path));\n\n    for (const relativeFile of relativeFiles) {\n      const command = await this.load(relativeFile);\n      if (command) {\n        command.$relativePath(relativeFile);\n        if (isMatchingCommandName(command.name, commandName)) {\n          return command;\n        }\n      }\n    }\n\n    return;\n  }\n\n  /**\n   * Scan all project commands and return them\n   * Used for warm cache functionality\n   */\n  public async scanAll(): Promise<CLICommand[]> {\n    const files = await getFilesFromDirectory(srcPath(\"app\"), \"**/commands/*.{ts,tsx}\");\n    const relativeFiles = files.map((path) => Path.toRelative(path));\n    const commands: CLICommand[] = [];\n\n    for (const relativeFile of relativeFiles) {\n      const command = await this.load(relativeFile);\n      if (command) {\n        command.$relativePath(relativeFile);\n        commands.push(command);\n      }\n    }\n\n    return commands;\n  }\n\n  /**\n   * Load command from a relative path\n   */\n  public async load(relativePath: string): Promise<CLICommand | undefined> {\n    const output = await filesOrchestrator.load<{ default: CLICommand }>(relativePath);\n\n    return output?.default;\n  }\n}\n\nexport const cliCommandsLoader = new CLICommandsLoader();\n"],"mappings":";;;;;;;;AAOA,IAAa,oBAAb,MAA+B;;;;CAI7B,MAAa,OAAO,aAAsD;EAGxE,MAAM,iBAAgB,MAFF,sBAAsB,QAAQ,KAAK,GAAG,wBAAwB,EAEvD,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;EAE/D,KAAK,MAAM,gBAAgB,eAAe;GACxC,MAAM,UAAU,MAAM,KAAK,KAAK,YAAY;GAC5C,IAAI,SAAS;IACX,QAAQ,cAAc,YAAY;IAClC,IAAI,sBAAsB,QAAQ,MAAM,WAAW,GACjD,OAAO;GAEX;EACF;CAGF;;;;;CAMA,MAAa,UAAiC;EAE5C,MAAM,iBAAgB,MADF,sBAAsB,QAAQ,KAAK,GAAG,wBAAwB,EACvD,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;EAC/D,MAAM,WAAyB,CAAC;EAEhC,KAAK,MAAM,gBAAgB,eAAe;GACxC,MAAM,UAAU,MAAM,KAAK,KAAK,YAAY;GAC5C,IAAI,SAAS;IACX,QAAQ,cAAc,YAAY;IAClC,SAAS,KAAK,OAAO;GACvB;EACF;EAEA,OAAO;CACT;;;;CAKA,MAAa,KAAK,cAAuD;EAGvE,QAAO,MAFc,kBAAkB,KAA8B,YAAY,EAEpE,EAAE;CACjB;AACF;AAEA,MAAa,oBAAoB,IAAI,kBAAkB"}

package/esm/cli/framework-cli-commands.mjs

@@ -0,0 +1,37 @@
+import { addCommand } from "./commands/add.command.mjs";
+import { buildCommand } from "./commands/build.command.mjs";
+import { createDatabaseCommand } from "./commands/create-database.command.mjs";
+import { devServerCommand } from "./commands/dev-server.command.mjs";
+import { dropTablesCommand } from "./commands/drop-tables.command.mjs";
+import { generateCommand, generateControllerCommand, generateMigrationCommand, generateModelCommand, generateModuleCommand, generateRepositoryCommand, generateResourceCommand, generateServiceCommand } from "./commands/generate/generate.command.mjs";
+import { migrateCommand } from "./commands/migrate.command.mjs";
+import { seedCommand } from "./commands/seed.command.mjs";
+import { startProductionCommand } from "./commands/start-production.command.mjs";
+import { storagePutCommand } from "./commands/storage-put.command.mjs";
+import { typingsGeneratorCommand } from "./commands/typings-generator.command.mjs";
+
+//#region ../@warlock.js/core/src/cli/framework-cli-commands.ts
+const frameworkCommands = [
+	devServerCommand,
+	typingsGeneratorCommand,
+	buildCommand,
+	startProductionCommand,
+	migrateCommand,
+	seedCommand,
+	createDatabaseCommand,
+	dropTablesCommand,
+	addCommand,
+	generateCommand,
+	generateModuleCommand,
+	generateControllerCommand,
+	generateServiceCommand,
+	generateModelCommand,
+	generateRepositoryCommand,
+	generateResourceCommand,
+	generateMigrationCommand,
+	storagePutCommand
+];
+
+//#endregion
+export { frameworkCommands };
+//# sourceMappingURL=framework-cli-commands.mjs.map

package/esm/cli/framework-cli-commands.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-cli-commands.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/cli/framework-cli-commands.ts"],"sourcesContent":["import { addCommand } from \"./commands/add.command\";\r\nimport { buildCommand } from \"./commands/build.command\";\r\nimport { createDatabaseCommand } from \"./commands/create-database.command\";\r\nimport { devServerCommand } from \"./commands/dev-server.command\";\r\nimport { dropTablesCommand } from \"./commands/drop-tables.command\";\r\nimport {\r\n  generateCommand,\r\n  generateControllerCommand,\r\n  generateMigrationCommand,\r\n  generateModelCommand,\r\n  generateModuleCommand,\r\n  generateRepositoryCommand,\r\n  generateResourceCommand,\r\n  generateServiceCommand,\r\n} from \"./commands/generate/generate.command\";\r\nimport { migrateCommand } from \"./commands/migrate.command\";\r\nimport { seedCommand } from \"./commands/seed.command\";\r\nimport { startProductionCommand } from \"./commands/start-production.command\";\r\nimport { storagePutCommand } from \"./commands/storage-put.command\";\r\nimport { typingsGeneratorCommand } from \"./commands/typings-generator.command\";\r\n\r\nexport const frameworkCommands = [\r\n  // development commands\r\n  devServerCommand,\r\n  typingsGeneratorCommand,\r\n\r\n  // production commands\r\n  buildCommand,\r\n  startProductionCommand,\r\n\r\n  // database commands\r\n  migrateCommand,\r\n  seedCommand,\r\n  createDatabaseCommand,\r\n  dropTablesCommand,\r\n\r\n  // generation/installation commands\r\n  addCommand,\r\n\r\n  // scaffolding commands\r\n  generateCommand,\r\n  generateModuleCommand,\r\n  generateControllerCommand,\r\n  generateServiceCommand,\r\n  generateModelCommand,\r\n  generateRepositoryCommand,\r\n  generateResourceCommand,\r\n  generateMigrationCommand,\r\n\r\n  // storage commands\r\n  storagePutCommand,\r\n];\r\n"],"mappings":";;;;;;;;;;;;;AAqBA,MAAa,oBAAoB;CAE/B;CACA;CAGA;CACA;CAGA;CACA;CACA;CACA;CAGA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;AACF"}