silgi 0.43.28 → 0.50.0

package/dist/cli/core/env.mjs

@@ -1,68 +0,0 @@
-import { resolve } from "pathe";
-import { existsSync, promises } from "node:fs";
-import * as dotenv from "dotenv";
-
-//#region src/cli/core/env.ts
-/**
-* Load and interpolate environment variables into `process.env`.
-* If you need more control (or access to the values), consider using `loadDotenv` instead
-*
-*/
-async function setupDotenv(options) {
-	const targetEnvironment = options.env ?? process.env;
-	const environment = await loadDotenv({
-		cwd: options.cwd,
-		fileName: options.fileName ?? ".env",
-		env: targetEnvironment,
-		interpolate: options.interpolate ?? true
-	});
-	for (const key in environment) if (!key.startsWith("_") && targetEnvironment[key] === void 0) targetEnvironment[key] = environment[key];
-	return environment;
-}
-/** Load environment variables into an object. */
-async function loadDotenv(options) {
-	const environment = Object.create(null);
-	const dotenvFile = resolve(options.cwd, options.fileName);
-	if (existsSync(dotenvFile)) {
-		const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
-		Object.assign(environment, parsed);
-	}
-	if (!options.env?._applied) {
-		Object.assign(environment, options.env);
-		environment._applied = true;
-	}
-	if (options.interpolate) interpolate(environment);
-	return environment;
-}
-function interpolate(target, source = {}, parse$1 = (v) => v) {
-	function getValue(key) {
-		return source[key] === void 0 ? target[key] : source[key];
-	}
-	function interpolate$1(value, parents = []) {
-		if (typeof value !== "string") return value;
-		const matches = value.match(/(.?\$\{?[\w:]*\}?)/g) || [];
-		return parse$1(matches.reduce((newValue, match) => {
-			const parts = /(.?)\$\{?([\w:]+)?\}?/.exec(match) || [];
-			const prefix = parts[1];
-			let value$1, replacePart;
-			if (prefix === "\\") {
-				replacePart = parts[0] || "";
-				value$1 = replacePart.replace(String.raw`\$`, "$");
-			} else {
-				const key = parts[2];
-				replacePart = (parts[0] || "").slice((prefix || "").length);
-				if (key && parents.includes(key)) {
-					console.warn(`Please avoid recursive environment variables ( loop: ${parents.join(" > ")} > ${key} )`);
-					return "";
-				}
-				value$1 = key ? getValue(key) : void 0;
-				value$1 = interpolate$1(value$1, key ? [...parents, key] : parents);
-			}
-			return value$1 === void 0 ? newValue : newValue.replace(replacePart, value$1);
-		}, value));
-	}
-	for (const key in target) target[key] = interpolate$1(getValue(key));
-}
-
-//#endregion
-export { setupDotenv };

package/dist/cli/core/installPackage.mjs

@@ -1,60 +0,0 @@
-import { useSilgiCLI } from "../../core/silgiApp.mjs";
-import { addNPMPackage, writeTemplate } from "silgi/kit";
-
-//#region src/cli/core/installPackage.ts
-/**
-* Install packages for the Silgi CLI.
-*
-* @param silgi - The SilgiCLI instance.
-* @default
-*/
-async function installPackages(silgi = useSilgiCLI()) {
-	await addNPMPackage([{
-		name: "zod-to-json-schema",
-		isDev: false,
-		when: silgi.options.schemaVendor === "zod"
-	}, {
-		name: "@valibot/to-json-schema",
-		isDev: false,
-		when: silgi.options.schemaVendor === "valibot"
-	}]);
-	await addNPMPackage([
-		{
-			name: "@fastify/deepmerge",
-			isDev: false
-		},
-		{
-			name: "@silgi/ecosystem",
-			isDev: false
-		},
-		{
-			name: "unadapter",
-			isDev: false
-		},
-		{
-			name: "apiful",
-			isDev: false
-		}
-	]);
-	const packages = {
-		dependencies: { ...silgi.options.installPackages?.dependencies },
-		devDependencies: { ...silgi.options.installPackages?.devDependencies }
-	};
-	if (silgi.options.preset === "npm-package") {
-		packages.devDependencies = {
-			...packages.devDependencies,
-			...packages.dependencies
-		};
-		packages.dependencies = {};
-	}
-	if (silgi.options.debug === true || silgi.options.debug?.install) writeTemplate({
-		filename: "install.json",
-		where: ".silgi",
-		write: true,
-		getContents: () => JSON.stringify(packages, null, 2)
-	});
-	return packages;
-}
-
-//#endregion
-export { installPackages };

package/dist/cli/core/runtimeConfig.mjs

@@ -1,70 +0,0 @@
-import { useSilgiCLI } from "silgi";
-import { writeTemplate } from "silgi/kit";
-import { initRuntimeConfig } from "silgi/runtime";
-import { snakeCase } from "scule";
-
-//#region src/cli/core/runtimeConfig.ts
-function useCLIRuntimeConfig(silgi = useSilgiCLI()) {
-	const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
-	silgi.hook("prepare:configs.ts", (data) => {
-		data.runtimeConfig = safeRuntimeConfig;
-		silgi.options.envOptions = silgi.options.envOptions;
-	});
-	writeTemplate({
-		filename: "env.example",
-		write: true,
-		where: ".silgi",
-		getContents() {
-			const flattenedConfig = flattenObject(safeRuntimeConfig);
-			const groupedVars = {};
-			Object.entries(flattenedConfig).forEach(([key, { value, originalPath }]) => {
-				const shouldExclude = silgi.options.codegen.env.safeList.some((safePath) => {
-					if (safePath.length !== originalPath.length) return false;
-					return safePath.every((segment, index) => segment.toLowerCase() === originalPath[index]?.toLowerCase());
-				});
-				if (shouldExclude) return;
-				if (originalPath.length > 0) {
-					const firstKey = originalPath[0];
-					if (typeof firstKey === "string") {
-						const categoryName = extractCategoryFromCamel(firstKey);
-						if (!groupedVars[categoryName]) groupedVars[categoryName] = {};
-						groupedVars[categoryName][key] = value;
-					}
-				} else {
-					if (!groupedVars.OTHER) groupedVars.OTHER = {};
-					groupedVars.OTHER[key] = value;
-				}
-			});
-			return Object.entries(groupedVars).map(([category, vars]) => {
-				const varsContent = Object.entries(vars).map(([key, value]) => `${key}=${value}`).join("\n");
-				return `# ${category}\n${varsContent}`;
-			}).join("\n\n");
-		}
-	});
-	const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
-	silgi.options.runtimeConfig = safeRuntimeConfig;
-	return _sharedRuntimeConfig;
-}
-function extractCategoryFromCamel(str) {
-	if (/^[a-z]+[A-Z]/.test(str)) {
-		const matches = str.match(/^([a-z]+)([A-Z][a-z0-9]*)?/);
-		if (matches && matches[1] && matches[2]) return `${matches[1].toUpperCase()}_${matches[2].toUpperCase()}`;
-	}
-	return str.toUpperCase();
-}
-function flattenObject(obj, prefix = "SILGI", originalPath = []) {
-	return Object.entries(obj).reduce((acc, [key, value]) => {
-		const formattedKey = snakeCase(key).toUpperCase();
-		const newKey = `${prefix}_${formattedKey}`;
-		const newPath = [...originalPath, key];
-		if (typeof value === "object" && value !== null) Object.assign(acc, flattenObject(value, newKey, newPath));
-		else acc[newKey] = {
-			value,
-			originalPath: newPath
-		};
-		return acc;
-	}, {});
-}
-
-//#endregion
-export { useCLIRuntimeConfig };

package/dist/cli/core/scan.mjs

@@ -1,35 +0,0 @@
-import { join, relative } from "pathe";
-import { glob } from "tinyglobby";
-
-//#region src/cli/core/scan.ts
-const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-async function scanAndSyncOptions(silgi) {
-	const scannedModules = await scanModules(silgi);
-	silgi.options.modules = silgi.options.modules || [];
-	for (const modPath of scannedModules) if (!silgi.options.modules.includes(modPath)) silgi.options.modules.push(modPath);
-}
-async function scanModules(silgi) {
-	const files = await scanFiles(silgi, "silgi/modules");
-	return files.map((f) => f.fullPath);
-}
-async function scanFiles(silgi, name) {
-	const files = await Promise.all(silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))).then((r) => r.flat());
-	return files;
-}
-async function scanDir(silgi, dir, name) {
-	const fileNames = await glob(join(name, GLOB_SCAN_PATTERN), {
-		cwd: dir,
-		dot: true,
-		ignore: silgi.options.ignore,
-		absolute: true
-	});
-	return fileNames.map((fullPath) => {
-		return {
-			fullPath,
-			path: relative(join(dir, name), fullPath)
-		};
-	}).sort((a, b) => a.path.localeCompare(b.path));
-}
-
-//#endregion
-export { scanAndSyncOptions };

package/dist/cli/core/silgi.mjs

@@ -1,111 +0,0 @@
-import { prepareEnv } from "../commands/env.mjs";
-import { loadOptions } from "../config/loader.mjs";
-import { frameworkSetup } from "../framework/index.mjs";
-import { registerModuleExportScan } from "../module/exportScan.mjs";
-import { installModules } from "../module/install.mjs";
-import { scanSilgiExports } from "../scan/scanExportFile.mjs";
-import { scanModules } from "../module/scan.mjs";
-import { prepareConfigs } from "../scan/prepareConfigs.mjs";
-import { prepareScanFile } from "../scan/prepareScanFile.mjs";
-import { readScanFile } from "../utils/readScanFile.mjs";
-import { createStorageCLI } from "../utils/storage.mjs";
-import { scanAndSyncOptions } from "./scan.mjs";
-import { consola as consola$1 } from "consola";
-import { join } from "pathe";
-import { autoImportTypes, silgiCLICtx } from "silgi";
-import { createDebugger, createHooks } from "hookable";
-import { resolveSilgiPath } from "silgi/kit";
-import { sharedRuntimeConfig, useRuntimeConfig } from "silgi/runtime";
-import { runtimeDir } from "silgi/runtime/meta";
-import { createUnimport } from "unimport";
-
-//#region src/cli/core/silgi.ts
-async function createSilgiCLI(config = {}, opts = {}) {
-	const options = await loadOptions(config, opts);
-	await prepareEnv(options);
-	const hooks = createHooks();
-	const silgi = {
-		services: {},
-		middleware: [],
-		shareds: {},
-		schemas: {},
-		resolvers: [],
-		unimport: void 0,
-		options,
-		hooks,
-		errors: [],
-		_requiredModules: {},
-		logger: opts.consola || consola$1.withTag("silgi"),
-		close: () => silgi.hooks.callHook("close", silgi),
-		storage: void 0,
-		scanModules: [],
-		templates: [],
-		callHook: hooks.callHook,
-		addHooks: hooks.addHooks,
-		hook: hooks.hook,
-		adapters: {},
-		useLocalConfig: () => useRuntimeConfig(void 0, options.runtimeConfig),
-		meta: {}
-	};
-	if (silgiCLICtx.tryUse()) {
-		silgiCLICtx.unset();
-		silgiCLICtx.set(silgi);
-	} else {
-		silgiCLICtx.set(silgi);
-		silgi.hook("close", () => silgiCLICtx.unset());
-	}
-	if (silgi.options.debug) {
-		createDebugger(silgi.hooks, { tag: "silgi" });
-		silgi.options.plugins.push({
-			path: join(runtimeDir, "internal/debug"),
-			packageImport: "silgi/runtime/internal/debug"
-		});
-	}
-	await scanAndSyncOptions(silgi);
-	await scanSilgiExports();
-	await scanModules(silgi);
-	await installModules(silgi, true);
-	await prepareConfigs();
-	sharedRuntimeConfig(silgi.options.runtimeConfig, silgi.options.dev);
-	if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) for (const [key, value] of Object.entries(silgi.options.adapters)) if (typeof value === "function") {
-		const resolved = value(silgi);
-		silgi.adapters[key] = resolved instanceof Promise ? await resolved : resolved;
-	} else silgi.adapters[key] = value;
-	await prepareScanFile(silgi);
-	await readScanFile(silgi);
-	await installModules(silgi);
-	for (const framework of frameworkSetup) await framework(silgi);
-	silgi.storage = await createStorageCLI(silgi);
-	silgi.hooks.hook("close", async () => {
-		await silgi.storage.dispose();
-	});
-	if (silgi.options.logLevel !== void 0) silgi.logger.level = silgi.options.logLevel;
-	silgi.hooks.addHooks(silgi.options.hooks);
-	if (silgi.options.imports) {
-		silgi.options.imports.dirs ??= [];
-		silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
-			if (typeof dir === "string") {
-				if (dir.startsWith("!")) return `!${resolveSilgiPath(dir.slice(1), options, silgi.options.rootDir)}`;
-				return resolveSilgiPath(dir, options, silgi.options.rootDir);
-			}
-			return dir;
-		});
-		silgi.options.imports.presets.push({
-			from: "silgi/types",
-			imports: autoImportTypes.map((type) => type),
-			type: true
-		});
-		silgi.options.imports.presets.push({
-			from: "silgi/runtime/internal/ofetch",
-			imports: ["createSilgiFetch", "silgi$fetch"]
-		});
-		silgi.unimport = createUnimport(silgi.options.imports);
-		await silgi.unimport.init();
-	}
-	await registerModuleExportScan(silgi);
-	await silgi.hooks.callHook("ready", silgi);
-	return silgi;
-}
-
-//#endregion
-export { createSilgiCLI };

package/dist/cli/framework/emptyFramework.mjs

@@ -1,7 +0,0 @@
-//#region src/cli/framework/emptyFramework.ts
-async function emptyFramework(silgi) {
-	if (silgi.options.preset === "npm-package" || !silgi.options.preset) {}
-}
-
-//#endregion
-export { emptyFramework };

package/dist/cli/framework/h3.mjs

@@ -1,55 +0,0 @@
-import { addCoreFile, isPresents, writeTemplate } from "silgi/kit";
-
-//#region src/cli/framework/h3.ts
-async function h3Framework(silgi, skip = false) {
-	if (!isPresents(["h3"]) && skip === false) return;
-	silgi.hook("before:schema.ts", (data) => {
-		data.addImportItemType([{
-			imports: [{ name: "H3Event" }],
-			specifier: "h3"
-		}, {
-			imports: [{ name: "NitroApp" }],
-			specifier: "nitropack/types"
-		}]);
-	});
-	silgi.hook("prepare:types", (opts) => {
-		writeTemplate({
-			filename: "types/h3.d.ts",
-			where: ".silgi",
-			getContents: () => {
-				return [
-					"import type { SilgiRuntimeContext } from 'silgi/types'",
-					"",
-					"declare module \"h3\" {",
-					"  interface H3EventContext extends SilgiRuntimeContext {}",
-					"}",
-					""
-				].join("\n");
-			}
-		});
-		opts.references.push({ path: "./h3.d.ts" });
-	});
-	addCoreFile({ before: ({ silgiConfigs }) => {
-		silgiConfigs.push({ captureError: `(silgi, error, context = {}) => {
-          const promise = silgi.hooks
-            .callHookParallel('error', silgi, error, context)
-            .catch((error_) => {
-              console.error('Error while capturing another error', error_)
-            })
-    
-          if (context.event && isEvent(context.event)) {
-            const errors = context.event.context.nitro?.errors
-            if (errors) {
-              errors.push({ error, context })
-            }
-            if (context.event.waitUntil) {
-              context.event.waitUntil(promise)
-            }
-          }
-        }` });
-	} });
-	if (silgi.options.imports !== false) silgi.options.imports.presets ??= [];
-}
-
-//#endregion
-export { h3Framework };

package/dist/cli/framework/index.mjs

@@ -1,15 +0,0 @@
-import { emptyFramework } from "./emptyFramework.mjs";
-import { h3Framework } from "./h3.mjs";
-import { nitroFramework } from "./nitro.mjs";
-import { nuxtFramework } from "./nuxt.mjs";
-
-//#region src/cli/framework/index.ts
-const frameworkSetup = [
-	emptyFramework,
-	h3Framework,
-	nitroFramework,
-	nuxtFramework
-];
-
-//#endregion
-export { frameworkSetup };

package/dist/cli/framework/nitro.mjs

@@ -1,24 +0,0 @@
-import { h3Framework } from "./h3.mjs";
-import { join } from "pathe";
-import { isPresents } from "silgi/kit";
-import { runtimeDir } from "silgi/runtime/meta";
-
-//#region src/cli/framework/nitro.ts
-async function nitroFramework(silgi, skip = false) {
-	if (!isPresents(["nitro"]) && skip === false) return;
-	silgi.hook("before:schema.ts", (data) => {
-		data.addImportItemType({
-			imports: [{ name: "NitroApp" }],
-			specifier: "nitropack/types"
-		});
-	});
-	silgi.options.plugins.push({
-		packageImport: "silgi/runtime/internal/nitro",
-		path: join(runtimeDir, "internal/nitro")
-	});
-	if (silgi.options.imports !== false) silgi.options.imports.presets ??= [];
-	await h3Framework(silgi, true);
-}
-
-//#endregion
-export { nitroFramework };

package/dist/cli/framework/nuxt.mjs

@@ -1,10 +0,0 @@
-import { nitroFramework } from "./nitro.mjs";
-
-//#region src/cli/framework/nuxt.ts
-async function nuxtFramework(silgi, skip = false) {
-	if (silgi.options.preset !== "nuxt" && skip === false) return;
-	await nitroFramework(silgi, true);
-}
-
-//#endregion
-export { nuxtFramework };

package/dist/cli/index.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/cli/index.mjs

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { package_default } from "../package.mjs";
-import { defineCommand, runMain } from "citty";
-
-//#region src/cli/index.ts
-const main = defineCommand({
-	meta: {
-		name: "Silgi",
-		version: package_default.version,
-		description: "Silgi CLI"
-	},
-	args: { version: {
-		alias: "v",
-		description: "Show version"
-	} },
-	subCommands: {
-		prepare: () => import("./commands/prepare.mjs").then((m) => m.default),
-		init: () => import("./commands/init.mjs").then((m) => m.default),
-		commands: () => import("./commands/commands.mjs").then((m) => m.default),
-		install: () => import("./commands/install.mjs").then((m) => m.default),
-		watch: () => import("./commands/watch.mjs").then((m) => m.default),
-		reset: () => import("./commands/reset.mjs").then((m) => m.default),
-		run: () => import("./commands/run.mjs").then((m) => m.default)
-	},
-	run() {}
-});
-runMain(main);
-
-//#endregion

package/dist/cli/module/exportScan.mjs

@@ -1,180 +0,0 @@
-import { hash, relativeWithDot } from "silgi/kit";
-import { promises } from "node:fs";
-import { findExports, findTypeExports } from "mlly";
-import { dirname, join } from "node:path";
-
-//#region src/cli/module/exportScan.ts
-async function registerModuleExportScan(silgi) {
-	silgi.hook("before:schema.ts", async (options) => {
-		for (const module of silgi.scanModules) {
-			const moduleReExports = [];
-			if (!module.entryPath) continue;
-			const path = module.meta._packageName ? join(dirname(module.entryPath), "types/index.d.mts") : join(dirname(module.entryPath), "types/index.ts");
-			const moduleTypes = await promises.readFile(path, "utf8").catch(() => "");
-			const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
-			for (const e of findTypeExports(normalisedModuleTypes)) moduleReExports.push(e);
-			for (const e of findExports(normalisedModuleTypes)) moduleReExports.push(e);
-			const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
-			const configKey = module.meta.configKey;
-			const moduleName = module.meta.name || module.meta._packageName;
-			const specifier = module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, join(dirname(module.entryPath), "types/index"));
-			if (hasTypeExport("ModuleOptions")) {
-				const importName = hash(`${configKey}ModuleOptions`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleOptions"
-					}],
-					specifier
-				});
-				options.options.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleRuntimeOptions")) {
-				const importName = hash(`${configKey}ModuleRuntimeOptions`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleRuntimeOptions"
-					}],
-					specifier
-				});
-				options.runtimeOptions.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleRuntimeShareds")) {
-				const importName = hash(`${configKey}ModuleRuntimeShareds`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleRuntimeShareds"
-					}],
-					specifier
-				});
-				options.shareds.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleEvents")) {
-				const importName = hash(`${configKey}ModuleEvents`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleEvents"
-					}],
-					specifier
-				});
-				options.events.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleRuntimeContexts")) {
-				const importName = hash(`${configKey}ModuleRuntimeContexts`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleRuntimeContexts"
-					}],
-					specifier
-				});
-				options.contexts.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleHooks")) {
-				const importName = hash(`${configKey}ModuleHooks`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleHooks"
-					}],
-					specifier
-				});
-				options.hooks.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleRuntimeHooks")) {
-				const importName = hash(`${configKey}RuntimeHooks`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleRuntimeHooks"
-					}],
-					specifier
-				});
-				options.runtimeHooks.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("SetupModuleOption")) {
-				const importName = hash(`${configKey}SetupModuleOption`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "SetupModuleOption"
-					}],
-					specifier
-				});
-				options.setupModuleOption.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("ModuleRuntimeMethods")) {
-				const importName = hash(`${configKey}ModuleRuntimeMethods`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "ModuleRuntimeMethods"
-					}],
-					specifier
-				});
-				options.methods.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("RouteRules")) {
-				const importName = hash(`${configKey}RouteRules`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "RouteRules"
-					}],
-					specifier
-				});
-				options.routeRules.push({
-					key: configKey,
-					value: importName
-				});
-			}
-			if (hasTypeExport("MetaData")) {
-				const importName = hash(`${configKey}MetaData`);
-				options.addImportItemType({
-					imports: [{
-						as: importName,
-						name: "MetaData"
-					}],
-					specifier
-				});
-				options.metaDatas.push({
-					key: configKey,
-					value: importName
-				});
-			}
-		}
-	});
-}
-
-//#endregion
-export { registerModuleExportScan };