silgi 0.43.28 → 0.50.0

package/dist/cli/scan/scanExportFile.mjs

@@ -1,288 +0,0 @@
-import { isIgnored } from "../utils/ignore.mjs";
-import { consola as consola$1 } from "consola";
-import micromatch from "micromatch";
-import { basename, dirname, extname, join, relative, resolve } from "pathe";
-import { useSilgiCLI } from "silgi";
-import { hash, relativeWithDot, removeExtension } from "silgi/kit";
-import { withTrailingSlash } from "ufo";
-import { readFile, readdir } from "node:fs/promises";
-import { parseAsync } from "oxc-parser";
-import { glob } from "tinyglobby";
-
-//#region src/cli/scan/scanExportFile.ts
-const DEFAULT_FUNCTION_EXPORT_NAMES = [
-	"createSchema",
-	"createService",
-	"createWebSocket",
-	"createResolver",
-	"createShared",
-	"createMiddleware"
-];
-const DEFAULT_INTERFACE_EXTENDS_NAMES = ["ExtendShared", "ExtendContext"];
-function generateUniqueIdentifier(filePath, exportName) {
-	const fileBaseName = basename(filePath);
-	const uniqueString = `${fileBaseName}${exportName}`;
-	return hash(uniqueString);
-}
-function categorizeExports(exportedEntities, filePath, functionExportCategories = {
-	createService: "service",
-	createWebSocket: "websocket",
-	createSchema: "schema",
-	createShared: "shared",
-	createResolver: "resolver",
-	createMiddleware: "middleware"
-}, interfaceExportCategories = {
-	ExtendShared: "shared",
-	ExtendContext: "context"
-}) {
-	const runtimeExports = [];
-	const typeExports = [];
-	for (const [functionName, category] of Object.entries(functionExportCategories)) {
-		const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
-		for (const exportEntity of matchingExports) {
-			if (!exportEntity.name) continue;
-			runtimeExports.push({
-				exportName: exportEntity.name,
-				path: filePath,
-				uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
-				category
-			});
-		}
-	}
-	for (const [extensionName, category] of Object.entries(interfaceExportCategories)) {
-		const matchingExports = exportedEntities.filter((entity) => entity.declaration === "interface" && entity.extends?.includes(extensionName));
-		for (const exportEntity of matchingExports) {
-			if (!exportEntity.name) continue;
-			typeExports.push({
-				exportName: exportEntity.name,
-				path: filePath,
-				uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
-				category
-			});
-		}
-	}
-	return {
-		runtimeExports,
-		typeExports
-	};
-}
-function transformImportPath(path, packageName, relativeTo) {
-	let importPath = path;
-	if (packageName) {
-		const distMatch = importPath.match(/.*?(\/dist\/.*)/);
-		if (distMatch && distMatch[1]) {
-			importPath = packageName + distMatch[1].substring(5);
-			importPath = removeExtension(importPath, true);
-		}
-	} else if (relativeTo) importPath = removeExtension(relativeWithDot(relativeTo, path));
-	return importPath;
-}
-function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName) {
-	silgiInstance.hook("before:scan.ts", (options) => {
-		const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
-		for (const { exportName, path, uniqueId, category } of runtimeExports) {
-			if (!isWatchedPath(path, ignored)) silgiInstance.options.devServer.watch.push(path);
-			switch (category) {
-				case "service":
-					options.services.push(uniqueId);
-					break;
-				case "websocket":
-					options.services?.push?.(uniqueId);
-					break;
-				case "shared":
-					options.shareds.push(uniqueId);
-					break;
-				case "schema":
-					options.schemas.push(uniqueId);
-					break;
-				case "resolver":
-					options.resolvers.push(uniqueId);
-					break;
-				case "middleware":
-					options.middlewares?.push?.(uniqueId);
-					break;
-			}
-			options.addImportItem({
-				specifier: transformImportPath(path, packageName, silgiInstance.options.silgi.serverDir),
-				imports: [{
-					name: exportName,
-					as: uniqueId
-				}]
-			});
-		}
-	});
-	silgiInstance.hook("before:schema.ts", (options) => {
-		const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
-		for (const { exportName, path, uniqueId, category } of typeExports) {
-			if (!isWatchedPath(path, ignored)) silgiInstance.options.devServer.watch.push(path);
-			if (category === "shared" || category === "context") {
-				const targetCollection = category === "shared" ? options.shareds : options.contexts;
-				targetCollection.push({
-					key: uniqueId,
-					value: uniqueId
-				});
-			}
-			options.addImportItem({
-				imports: [{
-					name: exportName,
-					as: uniqueId
-				}],
-				specifier: transformImportPath(path, packageName, silgiInstance.options.build.typesDir)
-			});
-		}
-	});
-}
-async function verifyDirectoryCaseSensitivity(directoryPath, rootDirectory) {
-	const directoryName = basename(directoryPath);
-	const parentDirectory = dirname(directoryPath);
-	try {
-		const siblingEntries = await readdir(parentDirectory);
-		if (!siblingEntries.includes(directoryName)) {
-			const directoryNameLowerCase = directoryName.toLowerCase();
-			const caseInsensitiveMatch = siblingEntries.find((sibling) => sibling.toLowerCase() === directoryNameLowerCase);
-			if (caseInsensitiveMatch) {
-				const originalRelative = relative(rootDirectory, directoryPath);
-				const correctedRelative = relative(rootDirectory, join(parentDirectory, caseInsensitiveMatch));
-				consola$1.warn(`Components not scanned from \`~/${correctedRelative}\`. Did you mean to name the directory \`~/${originalRelative}\` instead?`);
-			}
-		}
-	} catch {}
-}
-async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNames = DEFAULT_FUNCTION_EXPORT_NAMES, interfaceExtendsNames = DEFAULT_INTERFACE_EXTENDS_NAMES) {
-	const exportEntities = [];
-	const fileContent = await readFile(absoluteFilePath, "utf-8");
-	const parsed = await parseAsync(absoluteFilePath, fileContent);
-	const variableDeclarations = new Map();
-	for (const node of parsed.program.body) {
-		if (node.type === "VariableDeclaration" && Array.isArray(node.declarations)) {
-			for (const decl of node.declarations) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier") variableDeclarations.set(decl.id.name, decl);
-		}
-		if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
-			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier") variableDeclarations.set(decl.id.name, decl);
-		}
-	}
-	for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "TSInterfaceDeclaration") {
-		const decl = node.declaration;
-		if (Array.isArray(decl.extends) && decl.extends.some((dec) => dec.type === "TSInterfaceHeritage" && dec.expression.type === "Identifier" && interfaceExtendsNames.includes(dec.expression.name))) exportEntities.push({
-			name: decl.id?.name,
-			type: "interface",
-			declaration: "interface",
-			extends: decl.extends.filter((e) => e.type === "TSInterfaceHeritage" && e.expression.type === "Identifier").map((e) => e.expression.type === "Identifier" ? e.expression.name : false).filter((name) => Boolean(name))
-		});
-	}
-	for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
-		const decls = node.declaration.declarations;
-		if (Array.isArray(decls)) {
-			for (const decl of decls) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier" && decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier" && functionExportNames.includes(decl.init.callee.name)) {
-				let servicePath;
-				let serviceMethod;
-				if (decl.init.callee.name === "createService" || decl.init.callee.name === "createWebSocket") {
-					const firstArg = decl.init.arguments?.[0];
-					if (firstArg && firstArg.type === "ObjectExpression" && Array.isArray(firstArg.properties)) {
-						for (const prop of firstArg.properties) if (prop.type === "Property" && prop.key.type === "Identifier") {
-							if (prop.key.name === "path" && prop.value.type === "Literal" && typeof prop.value.value === "string") servicePath = prop.value.value;
-							if (prop.key.name === "method" && prop.value.type === "Literal" && typeof prop.value.value === "string") serviceMethod = prop.value.value;
-						}
-					}
-				}
-				exportEntities.push({
-					name: decl.id.name,
-					type: "function",
-					funcName: decl.init.callee.name,
-					servicePath,
-					serviceMethod
-				});
-			}
-		}
-	}
-	for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && Array.isArray(node.specifiers) && node.specifiers.length > 0) {
-		for (const spec of node.specifiers) if (spec.type === "ExportSpecifier" && spec.local.type === "Identifier") {
-			const varName = spec.local.name;
-			const decl = variableDeclarations.get(varName);
-			if (decl && decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier" && functionExportNames.includes(decl.init.callee.name)) {
-				let servicePath;
-				let serviceMethod;
-				if (decl.init.callee.name === "createService" || decl.init.callee.name === "createWebSocket") {
-					const firstArg = decl.init.arguments?.[0];
-					if (firstArg && firstArg.type === "ObjectExpression" && Array.isArray(firstArg.properties)) {
-						for (const prop of firstArg.properties) if (prop.type === "Property" && prop.key.type === "Identifier") {
-							if (prop.key.name === "path" && prop.value.type === "Literal" && typeof prop.value.value === "string") servicePath = prop.value.value;
-							if (prop.key.name === "method" && prop.value.type === "Literal" && typeof prop.value.value === "string") serviceMethod = prop.value.value;
-						}
-					}
-				}
-				exportEntities.push({
-					name: varName,
-					type: "function",
-					funcName: decl.init.callee.name,
-					servicePath,
-					serviceMethod
-				});
-			}
-		}
-	}
-	return exportEntities;
-}
-async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
-	const processedFilePaths = new Set();
-	const alreadyScannedPaths = [];
-	const serverDirectory = path || silgiInstance.options.serverDir;
-	const functionExportNames = scanOptions.functionExportNames ?? DEFAULT_FUNCTION_EXPORT_NAMES;
-	const interfaceExtendsNames = scanOptions.interfaceExtendsNames ?? DEFAULT_INTERFACE_EXTENDS_NAMES;
-	const functionExportCategories = {};
-	functionExportNames.forEach((name) => {
-		if (name === "createService") functionExportCategories[name] = "service";
-		else if (name === "createWebSocket") functionExportCategories[name] = "websocket";
-		else if (name === "createSchema") functionExportCategories[name] = "schema";
-		else if (name === "createShared") functionExportCategories[name] = "shared";
-		else if (name === "createResolver") functionExportCategories[name] = "resolver";
-		else if (name === "createMiddleware") functionExportCategories[name] = "middleware";
-		else functionExportCategories[name] = name;
-	});
-	const interfaceExportCategories = {};
-	interfaceExtendsNames.forEach((name) => {
-		if (name === "ExtendShared") interfaceExportCategories[name] = "shared";
-		else if (name === "ExtendContext") interfaceExportCategories[name] = "context";
-		else interfaceExportCategories[name] = name;
-	});
-	if (!serverDirectory) {
-		consola$1.warn("No server directory specified for scanning");
-		return;
-	}
-	try {
-		const matchedFiles = await glob(serverDirectory, {
-			cwd: silgiInstance.options.rootDir,
-			ignore: silgiInstance.options.ignore
-		});
-		if (matchedFiles.length) await verifyDirectoryCaseSensitivity(serverDirectory, silgiInstance.options.rootDir);
-		for (const relativeFilePath of matchedFiles.sort()) {
-			const absoluteFilePath = resolve(silgiInstance.options.rootDir, relativeFilePath);
-			if (alreadyScannedPaths.find((path$1) => absoluteFilePath.startsWith(withTrailingSlash(path$1))) || isIgnored(absoluteFilePath, silgiInstance) || processedFilePaths.has(absoluteFilePath)) continue;
-			processedFilePaths.add(absoluteFilePath);
-			const fileExtension = extname(absoluteFilePath);
-			if (!silgiInstance.options.extensions?.includes(fileExtension)) continue;
-			try {
-				const exportEntities = await extractExportEntitiesFromFile(absoluteFilePath, functionExportNames, interfaceExtendsNames);
-				const seenServiceSignatures = new Map();
-				for (const entity of exportEntities) if ((entity.funcName === "createService" || entity.funcName === "createWebSocket") && entity.servicePath && entity.serviceMethod) {
-					const key = `${entity.serviceMethod}:${entity.servicePath}`;
-					if (seenServiceSignatures.has(key)) throw new Error(`Duplicate ${entity.funcName} detected for path "${entity.servicePath}" and method "${entity.serviceMethod}".\nFirst found in: ${seenServiceSignatures.get(key)}\nDuplicate in: ${absoluteFilePath}\nPlease ensure each service path/method combination is unique.`);
-					seenServiceSignatures.set(key, absoluteFilePath);
-				}
-				const allExportedEntities = exportEntities;
-				const { runtimeExports, typeExports } = categorizeExports(allExportedEntities, absoluteFilePath, functionExportCategories, interfaceExportCategories);
-				registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName);
-			} catch (error) {
-				consola$1.error(`Error processing file ${absoluteFilePath}:`, error);
-			}
-		}
-	} catch (error) {
-		consola$1.error("Error scanning export files:", error);
-	}
-}
-function isWatchedPath(path, ignoredPatterns) {
-	return micromatch.isMatch(path, ignoredPatterns);
-}
-
-//#endregion
-export { scanSilgiExports };

package/dist/cli/scan/writeCoreFile.mjs

@@ -1,22 +0,0 @@
-import { prepareCoreFile } from "./prepareCoreFile.mjs";
-import { join, resolve } from "pathe";
-import { writeFile } from "silgi/kit";
-
-//#region src/cli/scan/writeCoreFile.ts
-async function writeCoreFile(silgi) {
-	const coreContent = await prepareCoreFile(silgi);
-	const silgiDir = resolve(silgi.options.silgi.serverDir);
-	const buildFiles = [];
-	buildFiles.push({
-		path: join(silgiDir, "core.ts"),
-		contents: coreContent.join("\n")
-	});
-	buildFiles.push({
-		path: join(silgiDir, "meta.ts"),
-		contents: `export const meta = ${JSON.stringify(silgi.meta, null, 2)}`
-	});
-	for await (const file of buildFiles) if (!silgi.errors.length) await writeFile(resolve(silgi.options.build.dir, file.path), file.contents);
-}
-
-//#endregion
-export { writeCoreFile };

package/dist/cli/scan/writeTypesAndFiles.mjs

@@ -1,72 +0,0 @@
-import { silgiGenerateType } from "../config/types.mjs";
-import { prepareSchema } from "./prepareSchema.mjs";
-import { isAbsolute, join, relative, resolve } from "pathe";
-import { isDirectory, writeFile } from "silgi/kit";
-import { runtimeDir } from "silgi/runtime/meta";
-import { toExports } from "unimport";
-import { existsSync } from "node:fs";
-import { lookupNodeModuleSubpath, parseNodeModulePath, resolvePath } from "mlly";
-import { resolveAlias as resolveAlias$1 } from "pathe/utils";
-
-//#region src/cli/scan/writeTypesAndFiles.ts
-async function writeTypesAndFiles(silgi) {
-	silgi.hook("prepare:types", (opts) => {
-		opts.references.push({ path: "./schema.d.ts" });
-		opts.references.push({ path: "./silgi-routes.d.ts" });
-	});
-	const schemaContent = await prepareSchema(silgi);
-	const { declarations, tsConfig } = await silgiGenerateType(silgi);
-	const tsConfigPath = resolve(silgi.options.rootDir, silgi.options.typescript.tsconfigPath);
-	const typesDir = resolve(silgi.options.build.typesDir);
-	let autoImportedTypes = [];
-	let autoImportExports = "";
-	if (silgi.unimport) {
-		await silgi.unimport.init();
-		const allImports = await silgi.unimport.getImports();
-		autoImportExports = toExports(allImports).replace(/#internal\/nitro/g, relative(typesDir, runtimeDir));
-		const resolvedImportPathMap = new Map();
-		for (const i of allImports.filter((i$1) => !i$1.type)) {
-			if (resolvedImportPathMap.has(i.from)) continue;
-			let path = resolveAlias$1(i.from, silgi.options.alias);
-			if (isAbsolute(path)) {
-				const resolvedPath = await resolvePath(i.from, { url: silgi.options.nodeModulesDirs }).catch(() => null);
-				if (resolvedPath) {
-					const { dir, name } = parseNodeModulePath(resolvedPath);
-					if (!dir || !name) path = resolvedPath;
-					else {
-						const subpath = await lookupNodeModuleSubpath(resolvedPath);
-						path = join(dir, name, subpath || "");
-					}
-				}
-			}
-			if (existsSync(path) && !await isDirectory(path)) path = path.replace(/\.[a-z]+$/, "");
-			if (isAbsolute(path)) path = relative(typesDir, path);
-			resolvedImportPathMap.set(i.from, path);
-		}
-		autoImportedTypes = [silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
-			exportHelper: false,
-			resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
-		})).trim() : ""];
-	}
-	const buildFiles = [];
-	buildFiles.push({
-		path: join(typesDir, "silgi-imports.d.ts"),
-		contents: [...autoImportedTypes, autoImportExports || "export {}"].join("\n")
-	});
-	buildFiles.push({
-		path: join(typesDir, "schema.d.ts"),
-		contents: schemaContent.join("\n")
-	});
-	buildFiles.push({
-		path: join(typesDir, "silgi-config.d.ts"),
-		contents: declarations.join("\n")
-	});
-	buildFiles.push({
-		path: tsConfigPath,
-		contents: JSON.stringify(tsConfig, null, 2)
-	});
-	for await (const file of buildFiles) if (!silgi.errors.length) await writeFile(resolve(silgi.options.build.dir, file.path), file.contents);
-}
-
-//#endregion
-export { writeTypesAndFiles };

package/dist/cli/utils/cancel.mjs

@@ -1,14 +0,0 @@
-import { cancel, isCancel } from "@clack/prompts";
-
-//#region src/cli/utils/cancel.ts
-function cancelOnCancel({ value, message = "Cancelled", onBeforeExit, exitCode = 0 } = {}) {
-	const handleCancel = () => {
-		cancel(message);
-		onBeforeExit?.();
-		process.exit(exitCode);
-	};
-	if (!value || isCancel(value)) handleCancel();
-}
-
-//#endregion
-export { cancelOnCancel };

package/dist/cli/utils/common.mjs

@@ -1,15 +0,0 @@
-//#region src/cli/utils/common.ts
-const commonArgs = {
-	dir: {
-		type: "string",
-		description: "project root directory"
-	},
-	_dir: {
-		type: "positional",
-		default: ".",
-		description: "project root directory (prefer using `--dir`)"
-	}
-};
-
-//#endregion
-export { commonArgs };

package/dist/cli/utils/compatibility.mjs

@@ -1,33 +0,0 @@
-import { useSilgiCLI } from "silgi";
-import satisfies from "semver/functions/satisfies.js";
-import { version } from "silgi/meta";
-
-//#region src/cli/utils/compatibility.ts
-const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
-function normalizeSemanticVersion(version$1) {
-	return version$1.replace(SEMANTIC_VERSION_RE, "");
-}
-const SILGI_VERSION_RE = /^v/g;
-/**
-* Check version constraints and return incompatibility issues as an array
-*/
-async function checkSilgiCompatibility(constraints, silgi = useSilgiCLI()) {
-	const issues = [];
-	if (constraints.silgi) {
-		const _silgiVersion = version.replace(SILGI_VERSION_RE, "");
-		if (!satisfies(normalizeSemanticVersion(_silgiVersion), constraints.silgi, { includePrerelease: true })) issues.push({
-			name: "silgi",
-			message: `Silgi version \`${constraints.silgi}\` is required but currently using \`${version}\``
-		});
-	}
-	await silgi.callHook("kit:compatibility", constraints, issues);
-	issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
-	return issues;
-}
-function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
-	const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
-	return find?.installed ?? false;
-}
-
-//#endregion
-export { checkSilgiCompatibility, hasInstalledModule as hasInstalledModule$1 };

package/dist/cli/utils/debug.mjs

@@ -1,11 +0,0 @@
-import { useSilgiCLI } from "../../core/silgiApp.mjs";
-
-//#region src/cli/utils/debug.ts
-function debugMode(name) {
-	const silgi = useSilgiCLI();
-	if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) return true;
-	return false;
-}
-
-//#endregion
-export { debugMode };

package/dist/cli/utils/ignore.mjs

@@ -1,56 +0,0 @@
-import { join, relative, resolve } from "pathe";
-import { existsSync, readFileSync } from "node:fs";
-import ignore from "ignore";
-
-//#region src/cli/utils/ignore.ts
-const NEGATION_RE = /^(!?)(.*)$/;
-function resolveIgnorePatterns(silgi, relativePath) {
-	if (!silgi) return [];
-	const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
-	const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
-	if (existsSync(nuxtignoreFile)) {
-		const contents = readFileSync(nuxtignoreFile, "utf-8");
-		ignorePatterns.push(...contents.trim().split(/\r?\n/));
-	}
-	if (relativePath) return ignorePatterns.map((p) => {
-		const [_, negation = "", pattern] = p.match(NEGATION_RE) || [];
-		if (pattern && pattern[0] === "*") return p;
-		return negation + relative(relativePath, resolve(silgi.options.rootDir, pattern || p));
-	});
-	return ignorePatterns;
-}
-/**
-* Return a filter function to filter an array of paths
-*/
-function isIgnored(pathname, silgi, _stats) {
-	if (!silgi) return false;
-	if (!silgi._ignore) {
-		silgi._ignore = ignore(silgi.options.ignoreOptions);
-		silgi._ignore.add(resolveIgnorePatterns(silgi));
-	}
-	const relativePath = relative(silgi.options.rootDir, pathname);
-	if (relativePath[0] === "." && relativePath[1] === ".") return false;
-	return !!(relativePath && silgi._ignore.ignores(relativePath));
-}
-/**
-* This function turns string containing groups '**\/*.{spec,test}.{js,ts}' into an array of strings.
-* For example will '**\/*.{spec,test}.{js,ts}' be resolved to:
-* ['**\/*.spec.js', '**\/*.spec.ts', '**\/*.test.js', '**\/*.test.ts']
-* @param group string containing the group syntax
-* @returns {string[]} array of strings without the group syntax
-*/
-function resolveGroupSyntax(group) {
-	let groups = [group];
-	while (groups.some((group$1) => group$1.includes("{"))) groups = groups.flatMap((group$1) => {
-		const [head, ...tail] = group$1.split("{");
-		if (tail.length) {
-			const [body = "", ...rest] = tail.join("{").split("}");
-			return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
-		}
-		return group$1;
-	});
-	return groups;
-}
-
-//#endregion
-export { isIgnored };