silgi 0.43.28 → 0.50.0

package/dist/cli/module/install.mjs

@@ -1,49 +0,0 @@
-import { hasInstalledModule$1 as hasInstalledModule } from "../utils/compatibility.mjs";
-import { useSilgiCLI } from "silgi";
-import { createJiti } from "dev-jiti";
-
-//#region src/cli/module/install.ts
-async function loadSilgiModuleInstance(silgiModule) {
-	if (typeof silgiModule === "string") throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-	if (typeof silgiModule !== "function") throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-	return { silgiModule };
-}
-async function installModules(silgi, prepare = false) {
-	silgi.options.isPreparingModules = prepare;
-	const jiti = createJiti(silgi.options.rootDir, {
-		alias: silgi.options.alias,
-		fsCache: true,
-		moduleCache: true
-	});
-	for (const module of silgi.scanModules) {
-		if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) {}
-		try {
-			const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
-				default: true,
-				conditions: silgi.options.conditions
-			}) : module.module;
-			if (silgiModule.name !== "silgiNormalizedModule") {
-				silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
-				continue;
-			}
-			await installModule(silgiModule, silgi, prepare);
-		} catch (err) {
-			silgi.logger.error(err);
-		}
-	}
-	silgi.options.isPreparingModules = false;
-}
-/** Installs a module on a Nuxt instance. */
-async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions, prepare = false) {
-	const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-	const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
-	if (res === false) return false;
-	const metaData = await silgiModule.getMeta?.();
-	if (prepare) return metaData;
-	const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
-	if (installedModule) installedModule.installed = true;
-	else throw new Error(`Module ${metaData?.name} not found`);
-}
-
-//#endregion
-export { installModules };

package/dist/cli/module/scan.mjs

@@ -1,193 +0,0 @@
-import { scanSilgiExports } from "../scan/scanExportFile.mjs";
-import { consola as consola$1 } from "consola";
-import { resolve } from "pathe";
-import { directoryToURL, resolveAlias } from "silgi/kit";
-import { scanExports } from "unimport";
-import { existsSync, promises } from "node:fs";
-import { isRelative } from "ufo";
-import { defu } from "defu";
-import { createJiti } from "dev-jiti";
-import { fileURLToPath } from "node:url";
-import { resolveModuleURL } from "exsolve";
-
-//#region src/cli/module/scan.ts
-const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
-async function _resolveSilgiModule(silgiModule, silgi) {
-	let resolvedModulePath;
-	let buildTimeModuleMeta = {};
-	const jiti = createJiti(silgi.options.rootDir, {
-		alias: silgi.options.alias,
-		fsCache: true,
-		moduleCache: true
-	});
-	if (typeof silgiModule === "string") {
-		silgiModule = resolveAlias(silgiModule, silgi.options.alias);
-		if (isRelative(silgiModule)) silgiModule = resolve(silgi.options.rootDir, silgiModule);
-		try {
-			const src = resolveModuleURL(silgiModule, {
-				from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
-				suffixes: [
-					"silgi",
-					"silgi/index",
-					"module",
-					"module/index",
-					"",
-					"index"
-				],
-				extensions: [
-					".js",
-					".mjs",
-					".cjs",
-					".ts",
-					".mts",
-					".cts"
-				]
-			});
-			resolvedModulePath = fileURLToPath(src);
-			const resolvedSilgiModule = await jiti.import(src, { default: true });
-			if (typeof resolvedSilgiModule !== "function") throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
-			silgiModule = await jiti.import(src, {
-				default: true,
-				conditions: silgi.options.conditions
-			});
-			const moduleMetadataPath = new URL("module.json", src);
-			if (existsSync(moduleMetadataPath)) buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-			else if (typeof silgiModule === "function") {
-				const meta = await silgiModule.getMeta?.();
-				const _exports = await scanExports(resolvedModulePath, true);
-				buildTimeModuleMeta = {
-					...meta,
-					exports: _exports.map(({ from,...rest }) => rest)
-				};
-			}
-			const runtimeFolder = new URL("runtime", src);
-			await scanSilgiExports(runtimeFolder.pathname, buildTimeModuleMeta._packageName);
-		} catch (error) {
-			const code = error.code;
-			if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-			if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-				const module = MissingModuleMatcher.exec(error.message)?.[1];
-				if (module && !module.includes(silgiModule)) throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
-			}
-		}
-	}
-	if (!buildTimeModuleMeta) throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
-	if (typeof silgiModule === "function") {
-		if (!buildTimeModuleMeta.configKey) {
-			const meta = await silgiModule.getMeta?.();
-			buildTimeModuleMeta = {
-				...meta,
-				exports: []
-			};
-		}
-		if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
-		const options = await silgiModule.getOptions?.() || {};
-		if (options) silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(silgi.options._c12.config[buildTimeModuleMeta.configKey] || {}, options || {});
-		else throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-		silgi.scanModules.push({
-			meta: buildTimeModuleMeta,
-			entryPath: resolvedModulePath || void 0,
-			installed: false,
-			options,
-			module: silgiModule
-		});
-	}
-}
-async function scanModules(silgi) {
-	const _modules = [...silgi.options._modules, ...silgi.options.modules];
-	for await (const mod of _modules) await _resolveSilgiModule(mod, silgi);
-	const moduleMap = new Map(silgi.scanModules.map((m) => [m.meta?.configKey, m]));
-	const graphData = createDependencyGraph(silgi.scanModules);
-	const sortedKeys = topologicalSort(graphData);
-	const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
-	silgi.scanModules = modules;
-}
-function createDependencyGraph(modules) {
-	const graph = new Map();
-	const inDegree = new Map();
-	modules.forEach((module) => {
-		const key = module.meta?.configKey;
-		if (key) {
-			graph.set(key, new Set());
-			inDegree.set(key, 0);
-		}
-	});
-	modules.forEach((module) => {
-		const key = module.meta?.configKey;
-		if (!key) return;
-		const requiredDeps = module.meta?.requiredDependencies || [];
-		const beforeDeps = module.meta?.beforeDependencies || [];
-		const afterDeps = module.meta?.afterDependencies || [];
-		const processedDeps = new Set();
-		requiredDeps.forEach((dep) => {
-			if (!graph.has(dep)) throw new Error(`Required dependency "${dep}" for module "${key}" is missing`);
-			graph.get(dep)?.add(key);
-			inDegree.set(key, (inDegree.get(key) || 0) + 1);
-			processedDeps.add(dep);
-		});
-		beforeDeps.forEach((dep) => {
-			if (!graph.has(dep)) return;
-			graph.get(key)?.add(dep);
-			inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
-		});
-		afterDeps.forEach((dep) => {
-			if (processedDeps.has(dep)) return;
-			if (!graph.has(dep)) return;
-			graph.get(dep)?.add(key);
-			inDegree.set(key, (inDegree.get(key) || 0) + 1);
-		});
-	});
-	return {
-		graph,
-		inDegree
-	};
-}
-function findCyclicDependencies(graph) {
-	const visited = new Set();
-	const recursionStack = new Set();
-	const cycles = [];
-	function dfs(node, path = []) {
-		visited.add(node);
-		recursionStack.add(node);
-		path.push(node);
-		for (const neighbor of graph.get(node) || []) if (recursionStack.has(neighbor)) {
-			const cycleStart = path.indexOf(neighbor);
-			if (cycleStart !== -1) cycles.push([...path.slice(cycleStart), neighbor]);
-		} else if (!visited.has(neighbor)) dfs(neighbor, [...path]);
-		recursionStack.delete(node);
-		path.pop();
-	}
-	for (const node of graph.keys()) if (!visited.has(node)) dfs(node, []);
-	return cycles;
-}
-function topologicalSort(graphData) {
-	const { graph, inDegree } = graphData;
-	const order = [];
-	const queue = [];
-	for (const [node, degree] of inDegree.entries()) if (degree === 0) queue.push(node);
-	if (queue.length === 0) {}
-	while (queue.length > 0) {
-		const node = queue.shift();
-		order.push(node);
-		const neighbors = Array.from(graph.get(node) || []);
-		for (const neighbor of neighbors) {
-			const newDegree = (inDegree.get(neighbor) || 0) - 1;
-			inDegree.set(neighbor, newDegree);
-			if (newDegree === 0) queue.push(neighbor);
-		}
-	}
-	if (order.length !== graph.size) {
-		const cycles = findCyclicDependencies(graph);
-		if (cycles.length > 0) {
-			const cycleStr = cycles.map((cycle) => `  ${cycle.join(" -> ")}`).join("\n");
-			throw new Error(`Circular dependencies detected:\n${cycleStr}`);
-		} else {
-			const unresolvedModules = Array.from(graph.keys()).filter((key) => !order.includes(key));
-			throw new Error(`Unable to resolve dependencies for modules: ${unresolvedModules.join(", ")}`);
-		}
-	}
-	return order;
-}
-
-//#endregion
-export { scanModules };

package/dist/cli/scan/prepareCommands.mjs

@@ -1,40 +0,0 @@
-import { useSilgiCLI } from "../../core/silgiApp.mjs";
-import { debugMode } from "../utils/debug.mjs";
-import { writeTemplate } from "silgi/kit";
-import { genAugmentation } from "knitwork";
-
-//#region src/cli/scan/prepareCommands.ts
-async function prepareCommands(silgi = useSilgiCLI()) {
-	const commands = [];
-	await silgi.callHook("prepare:commands", commands);
-	if (debugMode("command")) writeTemplate({
-		filename: "cli.json",
-		where: ".silgi",
-		write: true,
-		getContents: () => JSON.stringify(commands, null, 2)
-	});
-	silgi.hook("prepare:types", async ({ references }) => {
-		const allTags = commands.reduce((acc, commandGroup) => {
-			Object.values(commandGroup).forEach((command) => {
-				if (command.tags) command.tags.forEach((tag) => acc.add(tag));
-			});
-			return acc;
-		}, new Set());
-		const data = [
-			genAugmentation("silgi/types", { SilgiCommands: { ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"])) } }),
-			"",
-			"export {}"
-		];
-		writeTemplate({
-			filename: "types/commands.d.ts",
-			write: true,
-			where: ".silgi",
-			getContents: () => data.join("\n")
-		});
-		references.push({ path: "./commands.d.ts" });
-	});
-	silgi.options.commands = commands;
-}
-
-//#endregion
-export { prepareCommands };

package/dist/cli/scan/prepareConfigs.mjs

@@ -1,33 +0,0 @@
-import { useCLIRuntimeConfig } from "../core/runtimeConfig.mjs";
-import { resolve } from "pathe";
-import { useSilgiCLI } from "silgi";
-import { baseHeaderBannerComment, genEnsureSafeVar, writeFile } from "silgi/kit";
-import { genObjectFromRawEntries } from "knitwork";
-
-//#region src/cli/scan/prepareConfigs.ts
-async function prepareConfigs(silgi = useSilgiCLI()) {
-	useCLIRuntimeConfig();
-	const _data = { runtimeConfig: {} };
-	for (const module of silgi.scanModules) if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) for (const key of module.meta.cliToRuntimeOptionsKeys) _data[module.meta.configKey] = {
-		..._data[module.meta.configKey],
-		[key]: module.options[key]
-	};
-	else _data[module.meta.configKey] = {};
-	await silgi.callHook("prepare:configs.ts", _data);
-	const importData = [
-		"import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
-		"import { useRuntimeConfig } from 'silgi/runtime'",
-		"",
-		`export const runtimeConfig: SilgiRuntimeConfig = ${genObjectFromRawEntries(Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]), "")}`,
-		"",
-		"export const localConfig = useRuntimeConfig(undefined, runtimeConfig)",
-		""
-	];
-	delete _data.runtimeConfig;
-	importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(Object.entries(_data).map(([key, value]) => [key, genEnsureSafeVar(value)]))}`);
-	importData.unshift(...baseHeaderBannerComment);
-	await writeFile(resolve(silgi.options.silgi.serverDir, "configs.ts"), importData.join("\n"));
-}
-
-//#endregion
-export { prepareConfigs };

package/dist/cli/scan/prepareCoreFile.mjs

@@ -1,118 +0,0 @@
-import { addImports, baseHeaderBannerComment, hash, toArray } from "silgi/kit";
-import { genImport, genObjectFromRawEntries, genTypeImport } from "knitwork";
-
-//#region src/cli/scan/prepareCoreFile.ts
-async function prepareCoreFile(silgi) {
-	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-		imports: [
-			{
-				specifier: "silgi/runtime",
-				imports: [{ name: "mergeDeep" }]
-			},
-			{
-				specifier: "silgi",
-				imports: [{ name: "createSilgi" }]
-			},
-			{
-				specifier: "./scan",
-				imports: [
-					{ name: "services" },
-					{ name: "shareds" },
-					{ name: "schemas" },
-					{ name: "middlewares" },
-					{ name: "resolvers" }
-				]
-			},
-			{
-				specifier: "./configs",
-				imports: [{ name: "cliConfigs" }]
-			},
-			{
-				specifier: "./meta",
-				imports: [{ name: "meta" }]
-			}
-		],
-		typeImports: [{
-			specifier: "silgi/types",
-			imports: [{ name: "SilgiRuntimeOptions" }, { name: "BuildSilgi" }]
-		}]
-	});
-	const before = [];
-	const after = [];
-	const _data = {
-		silgiConfigs: [],
-		addImportItem,
-		addImportItemType,
-		addBuildFunction: (data) => {
-			for (const item of toArray(data)) {
-				if (item.where === "after") if (item.custom) after.push(item.custom);
-				else after.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
-				if (item.where === "before") if (item.custom) before.push(item.custom);
-				else before.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
-			}
-		}
-	};
-	await silgi.callHook("before:core.ts", _data);
-	const plugins = [];
-	for (const plugin of silgi.options.plugins) {
-		const pluginImportName = hash(plugin.packageImport);
-		addImportItem({
-			specifier: plugin.packageImport,
-			imports: pluginImportName
-		});
-		plugins.push(pluginImportName);
-	}
-	const importsContent = [
-		...genImports.map(({ specifier, imports, options }) => {
-			return genImport(specifier, imports, options);
-		}),
-		...genTypeImports.map(({ specifier, imports }) => {
-			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-		}),
-		""
-	];
-	const importData = [
-		"",
-		"export async function buildSilgi(option?: BuildSilgi) {",
-		"",
-		"// buildSilgiBefore",
-		...before,
-		"",
-		"const silgi = await createSilgi({",
-		" framework: option?.framework,",
-		" shared: shareds,",
-		" services: services,",
-		" middlewares: middlewares,",
-		" schemas: schemas,",
-		" resolvers: resolvers,",
-		` plugins: [${plugins.join(", ")}],`,
-		"",
-		_data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
-			const code = genObjectFromRawEntries(Object.entries(item));
-			return ` ${code.slice(1, -1).trim()},`;
-		}).filter(Boolean).join("\n") : "",
-		"",
-		" options: mergeDeep(cliConfigs, {",
-		"   runtimeConfig: {} as SilgiRuntimeOptions,",
-		"   meta: meta,",
-		`   present: '${silgi.options.preset}',`,
-		"   ...option?.modules,",
-		"   ...option?.options,",
-		"   }) as any,",
-		" })",
-		"",
-		"// buildSilgiAfter",
-		...after,
-		"",
-		"  return silgi",
-		"}",
-		""
-	];
-	await silgi.callHook("after:core.ts", importData);
-	importData.unshift(...importsContent);
-	importData.unshift(...baseHeaderBannerComment);
-	return importData;
-}
-
-//#endregion
-export { prepareCoreFile };

package/dist/cli/scan/prepareScanFile.mjs

@@ -1,59 +0,0 @@
-import { resolve } from "pathe";
-import { addImports, baseHeaderBannerComment, writeFile } from "silgi/kit";
-import { genImport, genTypeImport } from "knitwork";
-
-//#region src/cli/scan/prepareScanFile.ts
-async function prepareScanFile(silgi) {
-	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({});
-	const scanned = {
-		services: [],
-		shareds: [],
-		resolvers: [],
-		schemas: [],
-		middlewares: [],
-		addImportItem,
-		addImportItemType
-	};
-	await silgi.callHook("before:scan.ts", scanned);
-	const importsContent = [
-		...genImports.map(({ specifier, imports, options }) => {
-			return genImport(specifier, imports, options);
-		}),
-		...genTypeImports.map(({ specifier, imports }) => {
-			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-		}),
-		""
-	];
-	const generateExport = (name, items, defaultEmpty = "{}", asArray = false) => {
-		const hasItems = items.length > 0;
-		if (asArray) return [
-			`export const ${name} = [`,
-			...items.map((item) => `  ${item},`),
-			"]",
-			""
-		];
-		if (hasItems) return [
-			`export const ${name} = {`,
-			...items.map((item) => `  ...${item},`),
-			"}",
-			""
-		];
-		else return [`export const ${name} = ${defaultEmpty}`, ""];
-	};
-	const importData = [
-		"",
-		...generateExport("schemas", scanned.schemas),
-		...generateExport("services", scanned.services),
-		...generateExport("shareds", scanned.shareds, "undefined"),
-		...generateExport("resolvers", scanned.resolvers, "[]", true),
-		...generateExport("middlewares", scanned.middlewares)
-	];
-	await silgi.callHook("after:scan.ts", importData);
-	importData.unshift(...importsContent);
-	importData.unshift(...baseHeaderBannerComment);
-	await writeFile(resolve(silgi.options.silgi.serverDir, "scan.ts"), importData.join("\n"));
-	return importData;
-}
-
-//#endregion
-export { prepareScanFile };

package/dist/cli/scan/prepareSchema.mjs

@@ -1,128 +0,0 @@
-import { addImports, getServicePath, relativeWithDot } from "silgi/kit";
-import { genAugmentation, genImport, genTypeImport } from "knitwork";
-import { generateTypes, resolveSchema } from "untyped";
-
-//#region src/cli/scan/prepareSchema.ts
-async function prepareSchema(silgi) {
-	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-		imports: [],
-		typeImports: [{
-			specifier: "silgi/types",
-			imports: [{ name: "URIsTypes" }, { name: "SilgiRuntimeContext" }]
-		}]
-	});
-	const data = {
-		addImportItem,
-		addImportItemType,
-		options: [],
-		contexts: [],
-		setupModuleOption: [],
-		shareds: [],
-		resolvers: [],
-		events: [],
-		hooks: [],
-		runtimeHooks: [],
-		runtimeOptions: [],
-		methods: [],
-		routeRules: [],
-		metaDatas: []
-	};
-	await silgi.callHook("before:schema.ts", data);
-	const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
-	let addSilgiContext = false;
-	const importsContent = [
-		...genImports.map(({ specifier, imports, options }) => {
-			return genImport(specifier, imports, options);
-		}),
-		...genTypeImports.map(({ specifier, imports }) => {
-			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-		}),
-		""
-	];
-	const importData = [
-		"",
-		`type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
-		`type BaseServices = typeof import('${silgiScanTS}')['services']`,
-		`type ResolversExtend = ${data.resolvers?.length ? data.resolvers.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		"",
-		`type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
-		"",
-		data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
-      ${data.events.map((item) => {
-			if (item.isSilgiContext) addSilgiContext = true;
-			return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiRuntimeContext" : "";
-		}).join(",\n")}
-}` : "interface SilgiModuleEventsExtends {}",
-		"",
-		`type SetupModuleOptionExtend = ${data.setupModuleOption?.length ? data.setupModuleOption.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type SilgiModuleSharedExtends = ${data.shareds.length ? data.shareds.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type SilgiModuleOptionExtend = ${data.options?.length ? data.options.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type RouteRulesExtend = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type MetaDataExtend = ${data.metaDatas?.length ? data.metaDatas.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(await resolveSchema({ ...Object.fromEntries(Object.entries(silgi.options.runtimeConfig).filter(([key]) => ![
-			"app",
-			"nitro",
-			"nuxt"
-		].includes(key))) }), {
-			interfaceName: "SilgiRuntimeConfigExtends",
-			addExport: false,
-			addDefaults: false,
-			allowExtraKeys: false,
-			indentation: 0
-		}) : "",
-		"",
-		generateTypes(await resolveSchema({ ...silgi.services ? Object.values(silgi.services).reduce((acc, service) => {
-			const { route } = getServicePath(service.path);
-			if (route) acc[route] = "";
-			return acc;
-		}, {}) : {} }), {
-			interfaceName: "RoutersExtend",
-			addExport: false,
-			addDefaults: false,
-			allowExtraKeys: false,
-			indentation: 0
-		}),
-		"",
-		`type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		`type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-		"",
-		genAugmentation("silgi/types", {
-			SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
-			ServicesObject: [{}, { extends: ["BaseServices"] }],
-			SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
-			SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
-			SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
-			SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
-			SetupModuleOption: [{}, { extends: ["SetupModuleOptionExtend"] }],
-			SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
-			SilgiRuntimeHooks: [{}, { extends: ["SilgiRuntimeHooksExtends"] }],
-			SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
-			SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
-			SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
-			Resolvers: [{}, { extends: ["ResolversExtend"] }],
-			SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
-			RouteRules: [{}, { extends: ["RouteRulesExtend"] }],
-			MetaData: [{}, { extends: ["MetaDataExtend"] }],
-			Routers: [{}, { extends: ["RoutersExtend"] }]
-		}).replace(/,\s*/g, "\n"),
-		"",
-		"export {}"
-	];
-	await silgi.callHook("after:schema.ts", importData);
-	importData.unshift(...importsContent);
-	return importData;
-}
-
-//#endregion
-export { prepareSchema };