silgi 0.42.5 → 0.43.0

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,11 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+export { __export };

package/dist/build.d.mts

@@ -1,11 +1,3 @@
-import { FSWatcher } from 'chokidar';
-import { SilgiCLIConfig, SilgiCLI } from 'silgi/types';
-
-declare function watchDev(): Promise<{
-    watcher: FSWatcher | undefined;
-    close: () => Promise<void>;
-}>;
-
-declare function prepareBuild(config?: SilgiCLIConfig): Promise<SilgiCLI>;
-
-export { prepareBuild, watchDev };
+import { watchDev$1 as watchDev } from "./cli/build/dev.mjs";
+import { prepareBuild$1 as prepareBuild } from "./cli/build/prepare.mjs";
+export { prepareBuild, watchDev };

package/dist/build.mjs

@@ -1,48 +1,4 @@
-export { p as prepareBuild, w as watchDev } from './cli/dev.mjs';
-import 'chokidar';
-import 'consola';
-import 'pathe';
-import 'perfect-debounce';
-import './_chunks/silgiApp.mjs';
-import 'unctx';
-import 'silgi';
-import './cli/build.mjs';
-import 'hookable';
-import 'silgi/kit';
-import 'silgi/runtime';
-import 'silgi/runtime/meta';
-import 'unimport';
-import '@clack/prompts';
-import 'node:fs';
-import 'dotenv';
-import 'knitwork';
-import 'node:path';
-import 'mlly';
-import 'dev-jiti';
-import './cli/compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'silgi/meta';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'ufo';
-import 'node:fs/promises';
-import 'micromatch';
-import 'oxc-parser';
-import 'tinyglobby';
-import 'ignore';
-import 'scule';
-import 'klona';
-import 'unstorage';
-import './cli/loader.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
-import 'apiful/openapi';
-import 'pathe/utils';
-import 'untyped';
-import './cli/types.mjs';
+import { prepareBuild } from "./cli/build/prepare.mjs";
+import { watchDev } from "./cli/build/dev.mjs";
+
+export { prepareBuild, watchDev };

package/dist/cli/build/build.mjs

@@ -0,0 +1,17 @@
+import { generateApiFul } from "../core/apiful.mjs";
+import { generateApp } from "../core/app.mjs";
+import { prepareCommands } from "../scan/prepareCommands.mjs";
+import { writeCoreFile } from "../scan/writeCoreFile.mjs";
+import { writeTypesAndFiles } from "../scan/writeTypesAndFiles.mjs";
+
+//#region src/cli/build/build.ts
+async function build(silgi) {
+	await generateApiFul(silgi);
+	await prepareCommands(silgi);
+	await writeCoreFile(silgi);
+	await writeTypesAndFiles(silgi);
+	await generateApp(silgi);
+}
+
+//#endregion
+export { build };

package/dist/cli/build/dev.d.mts

@@ -0,0 +1,9 @@
+import { FSWatcher } from "chokidar";
+
+//#region src/cli/build/dev.d.ts
+declare function watchDev(): Promise<{
+  watcher: FSWatcher | undefined;
+  close: () => Promise<void>;
+}>;
+//#endregion
+export { watchDev as watchDev$1 };

package/dist/cli/build/dev.mjs

@@ -0,0 +1,59 @@
+import { silgiCLIIClose, useSilgiCLI } from "../../core/silgiApp.mjs";
+import { reloadScan } from "../core/devServer.mjs";
+import { prepareBuild } from "./prepare.mjs";
+import { watch } from "chokidar";
+import consola from "consola";
+import { basename } from "pathe";
+import { debounce } from "perfect-debounce";
+
+//#region src/cli/build/dev.ts
+async function watchDev() {
+	const silgi = useSilgiCLI();
+	let watcher;
+	async function load() {
+		await prepareBuild({
+			commandType: "prepare",
+			activeEnvironment: silgi.options.activeEnvironment || ".env",
+			dev: true
+		});
+	}
+	const reload = debounce(load);
+	const watchReloadEvents = new Set([
+		"add",
+		"addDir",
+		"unlink",
+		"unlinkDir",
+		"change"
+	]);
+	if (silgi.options.devServer.watch.length > 0) {
+		silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)];
+		watcher = watch(silgi.options.devServer.watch, silgi.options.watchOptions);
+		watcher.on("all", async (event, path, stats) => {
+			if (!watchReloadEvents.has(event)) return;
+			const startTime = performance.now();
+			silgi.errors = [];
+			try {
+				await reloadScan(path, stats);
+				await reload();
+			} catch (error) {
+				consola.withTag("silgi").error(error);
+			}
+			silgi.errors = [];
+			const endTime = performance.now();
+			const elapsedTime = Math.round(endTime - startTime);
+			silgi.logger.success(`${basename(path)} - ${elapsedTime}ms`);
+		}).on("error", (error) => {
+			consola.withTag("silgi").error(error);
+		});
+	}
+	async function close() {
+		await silgiCLIIClose();
+	}
+	return {
+		watcher,
+		close
+	};
+}
+
+//#endregion
+export { watchDev };

package/dist/cli/build/prepare.d.mts

@@ -0,0 +1,6 @@
+import { SilgiCLI, SilgiCLIConfig } from "silgi/types";
+
+//#region src/cli/build/prepare.d.ts
+declare function prepareBuild(config?: SilgiCLIConfig): Promise<SilgiCLI>;
+//#endregion
+export { prepareBuild as prepareBuild$1 };

package/dist/cli/build/prepare.mjs

@@ -0,0 +1,15 @@
+import { createSilgiCLI } from "../core/silgi.mjs";
+import { build } from "./build.mjs";
+
+//#region src/cli/build/prepare.ts
+async function prepareBuild(config) {
+	const silgi = await createSilgiCLI({
+		commandType: config?.commandType || "prepare",
+		...config
+	});
+	await build(silgi);
+	return silgi;
+}
+
+//#endregion
+export { prepareBuild };

package/dist/cli/commands/commands.mjs

@@ -0,0 +1,90 @@
+import { silgiCLIIClose } from "../../core/silgiApp.mjs";
+import { prepareEnv } from "./env.mjs";
+import { loadOptions } from "../config/loader.mjs";
+import { cancelOnCancel } from "../utils/cancel.mjs";
+import { commonArgs } from "../utils/common.mjs";
+import prepare_default from "./prepare.mjs";
+import { consola as consola$1 } from "consola";
+import { useSilgiCLI } from "silgi";
+import * as p from "@clack/prompts";
+import { createJiti } from "dev-jiti";
+import { version } from "silgi/meta";
+import { defineCommand, runCommand } from "citty";
+import { execSync } from "node:child_process";
+
+//#region src/cli/commands/commands.ts
+const command = defineCommand({
+	meta: {
+		name: "run",
+		description: "Run a command from the CLI",
+		version
+	},
+	args: {
+		...commonArgs,
+		preset: {
+			type: "string",
+			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+		},
+		tag: { type: "string" },
+		prepare: {
+			type: "boolean",
+			description: "Run in silgi development mode",
+			default: true
+		}
+	},
+	async run({ args }) {
+		if (args.prepare) await runCommand(prepare_default, { rawArgs: ["--commandType", "commands"] });
+		const silgi = useSilgiCLI();
+		if (!silgi) throw new Error("Silgi is not initialized");
+		const commands = silgi.options.commands;
+		const tags = args.tag?.split(",").map((t) => t.trim());
+		const silgiConfig = await loadOptions({});
+		await prepareEnv(silgiConfig);
+		let selectedCommands = [];
+		if (tags?.length) selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
+		else selectedCommands = commands.filter((cmd) => cmd.when !== false);
+		if (!selectedCommands.length) return;
+		const multiSelect = await p.groupMultiselect({
+			message: "Select commands to run",
+			required: true,
+			options: { ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
+				const groupKey = cmd.group || "";
+				if (!acc[groupKey]) acc[groupKey] = [];
+				acc[groupKey].push({
+					label: cmd.name,
+					value: cmd,
+					hint: cmd.description
+				});
+				return acc;
+			}, {}) }
+		});
+		cancelOnCancel({ value: multiSelect });
+		selectedCommands = multiSelect;
+		const spinner = p.spinner({ indicator: "dots" });
+		for (const cmd of selectedCommands) {
+			const data = cmd.getContents({ app: silgi });
+			spinner.start(`[${cmd.group}] ${cmd.name}...`);
+			if (cmd.type === "command") execSync(data, { stdio: "inherit" });
+			if (cmd.type === "function") {
+				const jiti = createJiti(import.meta.url, { alias: silgiConfig.alias });
+				let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
+				cleanHandler = `import { silgiCLICtx } from 'silgi' 
+        ${cleanHandler}
+`;
+				await jiti.evalModule(cleanHandler, {
+					filename: import.meta.url,
+					async: true,
+					conditions: silgiConfig.conditions,
+					forceTranspile: true
+				});
+			}
+			spinner.stop();
+			consola$1.success(`[${cmd.group}] ${cmd.name} done`);
+		}
+		await silgiCLIIClose();
+	}
+});
+var commands_default = command;
+
+//#endregion
+export { commands_default as default };

package/dist/cli/commands/env.mjs

@@ -0,0 +1,53 @@
+import { setupDotenv } from "../core/env.mjs";
+import * as p from "@clack/prompts";
+
+//#region src/cli/commands/env.ts
+let initialized = false;
+async function prepareEnv(silgiConfig) {
+	if (initialized) return;
+	initialized = true;
+	const customEnvironments = silgiConfig.environments;
+	const environment = silgiConfig.activeEnvironment ? silgiConfig.activeEnvironment : await p.select({
+		message: "Select an environment",
+		options: customEnvironments?.length > 0 ? customEnvironments.map((env) => ({
+			label: env.fileName,
+			value: env.fileName
+		})) : [
+			{
+				label: "Development (.env)",
+				value: ".env"
+			},
+			{
+				label: "Docker (.env.docker)",
+				value: "docker"
+			},
+			{
+				label: "Staging (.env.staging)",
+				value: "staging"
+			},
+			{
+				label: "Testing (.env.testing)",
+				value: "testing"
+			},
+			{
+				label: "Production (.env.prod)",
+				value: "prod"
+			}
+		]
+	});
+	const findEnv = customEnvironments?.find((env) => env.fileName === environment);
+	if (findEnv) await setupDotenv({
+		cwd: findEnv.cwd || silgiConfig.rootDir,
+		interpolate: findEnv.interpolate,
+		fileName: findEnv.fileName,
+		env: findEnv.env
+	});
+	else await setupDotenv({
+		cwd: silgiConfig.rootDir,
+		interpolate: true,
+		fileName: environment === ".env" ? ".env" : `.env.${environment}`
+	});
+}
+
+//#endregion
+export { prepareEnv };

package/dist/cli/commands/init.mjs

@@ -0,0 +1,84 @@
+import { cancelOnCancel } from "../utils/cancel.mjs";
+import prepare_default from "./prepare.mjs";
+import consola from "consola";
+import { dirname } from "pathe";
+import * as p from "@clack/prompts";
+import { writeFileSync } from "node:fs";
+import fsp from "node:fs/promises";
+import { defineCommand, runCommand } from "citty";
+
+//#region src/cli/commands/init.ts
+const command = defineCommand({
+	meta: {
+		name: "Silgi Init",
+		description: "Initialize silgi config",
+		version: "0.1.0"
+	},
+	args: {},
+	async run() {
+		p.intro("Initializing silgi config");
+		const framework = await p.select({
+			message: "Choose a framework",
+			options: [
+				{
+					label: "Nitro",
+					value: "nitro"
+				},
+				{
+					label: "Nuxt",
+					value: "nuxt"
+				},
+				{
+					label: "H3",
+					value: "h3"
+				},
+				{
+					label: "NPM Package",
+					value: "npm-package"
+				}
+			],
+			initialValue: "h3"
+		});
+		cancelOnCancel({ value: framework });
+		const context = [
+			`import { defineSilgiConfig } from 'silgi/config'`,
+			"",
+			"export default defineSilgiConfig({",
+			`  preset: '${framework}',`,
+			`  compatibilityDate: '${new Date().toISOString().split("T")[0]}',`,
+			"",
+			"})",
+			""
+		];
+		if (framework === "nitro" || framework === "nuxt") {
+			const plugin = [
+				`import { buildSilgi } from '../silgi/core'`,
+				"",
+				"export default defineNitroPlugin(async (nitro) => {",
+				"",
+				"  await buildSilgi({",
+				"    framework: {",
+				"      nitro,",
+				"    },",
+				"    options: {",
+				"      putStorage: useStorage(),",
+				"      runtimeConfig: useRuntimeConfig(),",
+				"    },",
+				"  })",
+				"})",
+				""
+			];
+			const file = "server/plugins/silgi.ts";
+			await fsp.mkdir(dirname(file), { recursive: true });
+			writeFileSync(file, plugin.join("\n"));
+			consola.success("Silgi plugin created, see server/plugins/silgi.ts");
+			runCommand(prepare_default, { rawArgs: ["--env", ".env"] });
+		}
+		writeFileSync("silgi.config.ts", context.join("\n"));
+		consola.success("Silgi config created, see silgi.config.ts");
+	}
+});
+var init_default = command;
+
+//#endregion
+export { init_default as default };

package/dist/cli/commands/install.mjs

@@ -0,0 +1,52 @@
+import { commonArgs } from "../utils/common.mjs";
+import prepare_default from "./prepare.mjs";
+import { installPackages } from "../core/installPackage.mjs";
+import { consola as consola$1 } from "consola";
+import { version } from "silgi/meta";
+import { defineCommand, runCommand } from "citty";
+import { execSync } from "node:child_process";
+
+//#region src/cli/commands/install.ts
+const command = defineCommand({
+	meta: {
+		name: "install",
+		description: "Install dependencies from the install.json file.",
+		version
+	},
+	args: {
+		...commonArgs,
+		preset: {
+			type: "string",
+			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+		}
+	},
+	async run() {
+		await runCommand(prepare_default, { rawArgs: ["--commandType", "install"] }).catch(() => {});
+		const packages = await installPackages();
+		const commandArgs = process.argv.slice(process.argv.indexOf("install") + 1);
+		const extraArgs = commandArgs.length ? ` ${commandArgs.join(" ")}` : "";
+		if (Object.keys(packages).length === 0) {
+			consola$1.info("Empty command list, maybe forgot pnpm silgi prepare?");
+			return;
+		}
+		const cleanPackageName = (name, version$1) => {
+			const cleanVersion = version$1.replace(/^(>=|<=|>|<)/, "^");
+			return `${name}@${cleanVersion}`;
+		};
+		const deps = Object.entries(packages.dependencies || {}).map(([name, version$1]) => cleanPackageName(name, version$1)).join(" ");
+		const devDeps = Object.entries(packages.devDependencies || {}).map(([name, version$1]) => cleanPackageName(name, version$1)).join(" ");
+		if (deps) {
+			consola$1.info("Installing dependencies...");
+			execSync(`ni ${deps}${extraArgs}`, { stdio: "inherit" });
+		}
+		if (devDeps) {
+			consola$1.info("Installing dev dependencies...");
+			execSync(`ni ${devDeps}${extraArgs} -D`, { stdio: "inherit" });
+		}
+		consola$1.success("All dependencies installed successfully.");
+	}
+});
+var install_default = command;
+
+//#endregion
+export { install_default as default };

package/dist/cli/commands/prepare.mjs

@@ -0,0 +1,65 @@
+import { createSilgiCLI } from "../core/silgi.mjs";
+import { build } from "../build/build.mjs";
+import { commonArgs } from "../utils/common.mjs";
+import commands_default from "./commands.mjs";
+import { resolve } from "pathe";
+import { readPackageJSON } from "pkg-types";
+import { version } from "silgi/meta";
+import { defineCommand, runCommand } from "citty";
+
+//#region src/cli/commands/prepare.ts
+const command = defineCommand({
+	meta: {
+		name: "prepare",
+		description: "Generate types for the project",
+		version
+	},
+	args: {
+		...commonArgs,
+		preset: {
+			type: "string",
+			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+		},
+		stub: {
+			type: "boolean",
+			description: "Run in silgi development mode"
+		},
+		dev: {
+			type: "boolean",
+			description: "Run in silgi development mode"
+		},
+		env: {
+			type: "string",
+			description: "The environment to use"
+		},
+		commandType: {
+			type: "string",
+			description: "The command type to run"
+		}
+	},
+	async run({ args }) {
+		const rootDir = resolve(args.dir || args._dir || ".");
+		const packageJson = await readPackageJSON(rootDir);
+		const packageName = packageJson.name || "";
+		const silgi = await createSilgiCLI({
+			rootDir,
+			dev: args.dev || args.stub,
+			stub: args.stub,
+			preset: args.preset,
+			commandType: args.commandType || "prepare",
+			activeEnvironment: args.env,
+			package: { name: packageName }
+		});
+		await build(silgi);
+		if (args.commandType !== "commands") await runCommand(commands_default, { rawArgs: [
+			"--tag",
+			"init",
+			"--prepare",
+			"false"
+		] });
+	}
+});
+var prepare_default = command;
+
+//#endregion
+export { prepare_default as default };

package/dist/cli/commands/reset.mjs

@@ -0,0 +1,46 @@
+import { loadOptions } from "../config/loader.mjs";
+import { commonArgs } from "../utils/common.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { version } from "silgi/meta";
+import fsp from "node:fs/promises";
+import { defineCommand } from "citty";
+
+//#region src/cli/commands/reset.ts
+const command = defineCommand({
+	meta: {
+		name: "prepare",
+		description: "Generate types for the project",
+		version
+	},
+	args: { ...commonArgs },
+	async run({ args }) {
+		const rootDir = resolve(args.dir || args._dir || ".");
+		const options = await loadOptions({ rootDir }, {});
+		const serverDir = options.silgi.serverDir;
+		const vfs = join(serverDir, "vfs");
+		const configs = join(serverDir, "configs.ts");
+		const core = join(serverDir, "core.ts");
+		const scan = join(serverDir, "scan.ts");
+		const meta = join(serverDir, "meta.ts");
+		const silgiDir = options.build.dir;
+		for (const file of [
+			vfs,
+			configs,
+			core,
+			scan,
+			silgiDir,
+			meta
+		]) try {
+			await fsp.rm(file, {
+				force: true,
+				recursive: true
+			});
+			consola.success(`Removed ${file.replace(rootDir, "")}`);
+		} catch {}
+	}
+});
+var reset_default = command;
+
+//#endregion
+export { reset_default as default };