silgi 0.42.4 → 0.43.0

package/dist/cli/scan/writeTypesAndFiles.mjs

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,15 @@
+//#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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,56 @@
+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 };

package/dist/cli/utils/readScanFile.mjs

@@ -0,0 +1,58 @@
+import { consola as consola$1 } from "consola";
+import { resolve } from "pathe";
+import { createUnimport } from "unimport";
+import { promises } from "node:fs";
+import { createJiti } from "dev-jiti";
+
+//#region src/cli/utils/readScanFile.ts
+async function readScanFile(silgi) {
+	const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
+	const context = await promises.readFile(path, { encoding: "utf-8" });
+	silgi.unimport = createUnimport(silgi.options.imports || {});
+	await silgi.unimport.init();
+	const injectedResult = await silgi.unimport.injectImports(context, path);
+	if (!injectedResult) throw new Error("Failed to inject imports");
+	const jiti = createJiti(silgi.options.rootDir, {
+		fsCache: true,
+		moduleCache: false,
+		debug: silgi.options.debug === true,
+		alias: silgi.options.alias
+	});
+	try {
+		const scanFile = await jiti.evalModule(injectedResult.code, {
+			filename: path,
+			async: true,
+			conditions: silgi.options.conditions
+		}, async (data, name) => {
+			return (await silgi.unimport.injectImports(data, name)).code;
+		});
+		silgi.schemas = scanFile.schemas || {};
+		silgi.services = scanFile.services || {};
+		silgi.shareds = scanFile.shareds || {};
+		silgi.resolvers = scanFile.resolvers || {};
+		return {
+			context,
+			object: {
+				schemas: scanFile.schemas,
+				services: scanFile.services,
+				shareds: scanFile.shareds
+			},
+			path
+		};
+	} catch (error) {
+		if (silgi.options.debug) console.error("Failed to read scan.ts file:", error);
+		else consola$1.withTag("silgi").error(error);
+		return {
+			context,
+			object: {
+				schemas: {},
+				services: {},
+				shareds: {}
+			},
+			path
+		};
+	}
+}
+
+//#endregion
+export { readScanFile };

package/dist/cli/utils/storage.mjs

@@ -0,0 +1,23 @@
+import { replaceRuntimeValues } from "silgi";
+import { useRuntimeConfig } from "silgi/runtime";
+import { klona } from "klona";
+import { builtinDrivers, createStorage } from "unstorage";
+
+//#region src/cli/utils/storage.ts
+async function createStorageCLI(silgi) {
+	const storage = createStorage();
+	const runtime = useRuntimeConfig();
+	const mounts = klona({
+		...silgi.options.storage,
+		...silgi.options.devStorage
+	});
+	for (const [path, opts] of Object.entries(mounts)) if (opts.driver) {
+		const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+		const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
+		storage.mount(path, driver(processedOpts));
+	} else silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+	return storage;
+}
+
+//#endregion
+export { createStorageCLI };

package/dist/core/context.d.mts

@@ -0,0 +1,30 @@
+import { SilgiRuntimeConfig } from "silgi/types";
+
+//#region src/core/context.d.ts
+declare function updateRuntimeStorage(runtime: any): void;
+/** Direct access to the silgi context with asyncLocalStorage - see https://github.com/unjs/unctx. */
+
+/**
+* Get access to silgi instance.
+*
+* Throws an error if silgi instance is unavailable.
+* @example
+* ```js
+* const runtime = useRuntime()
+* ```
+*/
+declare function useRuntime(): SilgiRuntimeConfig;
+/**
+* Get access to Runtime instance.
+*
+* Returns null if Runtime instance is unavailable.
+* @example
+* ```js
+* const runtime = tryUseRuntime()
+* if (runtime) {
+*  // Do something
+* }
+* ```
+*/
+//#endregion
+export { updateRuntimeStorage as updateRuntimeStorage$1, useRuntime as useRuntime$1 };

package/dist/core/context.mjs

@@ -0,0 +1,32 @@
+import { createContext } from "unctx";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/core/context.ts
+/** async local storage for the name of the current silgi instance */
+const asyncRuntimeStorage = createContext({
+	asyncContext: true,
+	AsyncLocalStorage
+});
+function updateRuntimeStorage(runtime) {
+	if (asyncRuntimeStorage.tryUse()) {
+		asyncRuntimeStorage.unset();
+		asyncRuntimeStorage.set(runtime);
+	} else asyncRuntimeStorage.set(runtime);
+}
+/**
+* Get access to silgi instance.
+*
+* Throws an error if silgi instance is unavailable.
+* @example
+* ```js
+* const runtime = useRuntime()
+* ```
+*/
+function useRuntime() {
+	const instance = asyncRuntimeStorage.tryUse();
+	if (!instance) throw new Error("Runtime instance is unavailable!");
+	return instance;
+}
+
+//#endregion
+export { updateRuntimeStorage, useRuntime };

package/dist/core/createSilgi.d.mts

@@ -0,0 +1,6 @@
+import { Silgi, SilgiConfig } from "silgi/types";
+
+//#region src/core/createSilgi.d.ts
+declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
+//#endregion
+export { createSilgi as createSilgi$1 };

package/dist/core/createSilgi.mjs

@@ -0,0 +1,152 @@
+import { silgiCtx } from "./unctx.mjs";
+import { createStorage, useSilgiStorage } from "./utils/storage.mjs";
+import { createConsola } from "consola";
+import { createHooks } from "hookable";
+import { getServicePath } from "silgi/kit";
+import { sharedRuntimeConfig, useRuntimeConfig } from "silgi/runtime";
+import { defu } from "defu";
+import { toJsonSchema } from "@standard-community/standard-json";
+import { addRoute, createRouter } from "rou3";
+
+//#region src/core/createSilgi.ts
+async function runSilgiPlugins(silgi) {
+	for (const plugin of silgi.plugins) try {
+		await plugin(silgi);
+	} catch (error) {
+		silgi.captureError(silgi, error, { tags: ["plugin"] });
+		throw error;
+	}
+}
+async function createSilgi(config) {
+	const hooks = createHooks();
+	const silgi = {
+		router: void 0,
+		_middlewareRouter: void 0,
+		routerPrefixs: [],
+		schemas: config.schemas ?? {},
+		services: config.services ?? {},
+		resolvers: config.resolvers ?? [],
+		middlewares: config.middlewares ?? {},
+		globalMiddlewares: config.globalMiddlewares ?? [],
+		shared: config.shared ?? {},
+		plugins: config.plugins ?? [],
+		framework: config.framework ?? {},
+		storage: config.options.putStorage ?? void 0,
+		options: config.options ?? {},
+		hooks,
+		callHook: hooks.callHook,
+		addHooks: hooks.addHooks,
+		hook: hooks.hook,
+		ready: () => {
+			return hooks.callHook("ready", silgi);
+		},
+		envOptions: config.envOptions ?? {},
+		close: () => hooks.callHook("close", silgi),
+		logger: createConsola(defu(config.options?.consolaOptions ?? {}, { tag: "silgi" })).withTag("silgi"),
+		captureError: config.captureError ?? (() => {}),
+		websocket: config.websocket ?? void 0
+	};
+	sharedRuntimeConfig(silgi.options.runtimeConfig);
+	if (!silgi.router) silgi.router = createRouter();
+	for (const [_route, object] of Object.entries(silgi.services)) {
+		const { method, type } = getServicePath(_route);
+		if (!object) continue;
+		const path = String(object.path);
+		const routeParts = path.split("/").filter(Boolean);
+		if (routeParts.length > 0) {
+			const prefix = `/${routeParts[0]}`;
+			if (!silgi.routerPrefixs.includes(prefix)) silgi.routerPrefixs.push(`${type}:${prefix}`);
+		}
+		let routeWithParams = path;
+		let pathParamNames = {};
+		let queryParamNames = {};
+		if (object.pathParams) {
+			const jsonSchema = await toJsonSchema(object.pathParams);
+			if (jsonSchema && jsonSchema.properties) {
+				pathParamNames = Object.keys(jsonSchema.properties).reduce((acc, key) => {
+					const prop = jsonSchema.properties?.[key];
+					if (typeof prop === "object" && prop !== null && "type" in prop) acc[key] = prop.type ?? "string";
+					else acc[key] = "string";
+					return acc;
+				}, {});
+				const paramNames = Object.keys(jsonSchema.properties);
+				if (paramNames.length > 0) {
+					const routeParts$1 = routeWithParams.split("/");
+					const lastParts = routeParts$1.slice(-paramNames.length);
+					const alreadyHasParams = paramNames.every((name, idx) => lastParts[idx] === `:${name}`);
+					if (!alreadyHasParams) {
+						routeWithParams = routeWithParams.replace(/\/+$/, "");
+						for (const param of paramNames) routeWithParams += `/:${param}`;
+					}
+				}
+			}
+		}
+		if (object.queryParams) {
+			const jsonSchema = await toJsonSchema(object.queryParams);
+			if (jsonSchema && jsonSchema.properties) queryParamNames = Object.keys(jsonSchema.properties).reduce((acc, key) => {
+				const prop = jsonSchema.properties?.[key];
+				if (typeof prop === "object" && prop !== null && "type" in prop) acc[key] = prop.type ?? "string";
+				else acc[key] = "string";
+				return acc;
+			}, {});
+		}
+		addRoute(silgi.router, method, routeWithParams, {
+			method,
+			route: routeWithParams,
+			service: object,
+			queryParams: queryParamNames,
+			pathParams: pathParamNames
+		});
+	}
+	if (!silgi._middlewareRouter) silgi._middlewareRouter = createRouter();
+	for (const [route, routeObject] of Object.entries(silgi.middlewares)) {
+		let _key = "";
+		let _route = "";
+		if (route.includes(":")) {
+			const [methodPart, ...routeParts] = route.split(":");
+			_key = (methodPart ?? "").toUpperCase();
+			if (_key === "GLOBAL") _key = "";
+			_route = routeParts.join(":");
+		}
+		if (_route === "global") {
+			for (const method of routeObject.methods?.length ? routeObject.methods : ["ALL"]) silgi.globalMiddlewares.push({
+				middleware: routeObject.setup,
+				method: method === "ALL" ? "" : method.toUpperCase(),
+				route: _route
+			});
+			continue;
+		}
+		const methods = routeObject.methods?.length ? routeObject.methods : ["ALL"];
+		for (const method of methods) {
+			const globalMethod = method === "ALL" ? "" : method.toUpperCase();
+			addRoute(silgi._middlewareRouter, globalMethod, _route, {
+				middleware: routeObject.setup,
+				method,
+				route: _route
+			});
+		}
+	}
+	silgi.hooks.addHooks(silgi.options.hooks);
+	await runSilgiPlugins(silgi);
+	if (!silgi.storage) silgi.storage = await createStorage(silgi);
+	silgi.shared.storage = (...data) => {
+		return useSilgiStorage(...data);
+	};
+	silgi.shared.useRuntimeConfig = useRuntimeConfig;
+	if (silgiCtx.tryUse()) {
+		silgiCtx.unset();
+		silgiCtx.set(silgi);
+	} else {
+		silgiCtx.set(silgi);
+		silgi.hook("close", () => silgiCtx.unset());
+	}
+	hooks.hookOnce("close", async () => {
+		hooks.removeAllHooks();
+		await silgi.storage.dispose();
+	});
+	silgi.logger.info("Silgi Start");
+	return silgi;
+}
+
+//#endregion
+export { createSilgi };

package/dist/core/error.d.mts

@@ -0,0 +1,65 @@
+//#region src/core/error.d.ts
+/**
+* Silgi Runtime Error
+* @class
+* @extends Error
+* @property {number} statusCode - An integer indicating the HTTP response status code.
+* @property {string} statusMessage - A string representing the HTTP status message.
+* @property {boolean} fatal - Indicates if the error is a fatal error.
+* @property {boolean} unhandled - Indicates if the error was unhandled and auto-captured.
+* @property {DataT} data - An extra data that will be included in the response.
+*                         This can be used to pass additional information about the error.
+*/
+declare class SilgiError<DataT = unknown> extends Error {
+  static __silgi_error__: boolean;
+  statusCode: number;
+  fatal: boolean;
+  unhandled: boolean;
+  statusMessage?: string;
+  data?: DataT;
+  cause?: unknown;
+  constructor(message: string, opts?: {
+    cause?: unknown;
+  });
+  toJSON(): Pick<SilgiError<DataT>, "message" | "statusCode" | "statusMessage" | "data">;
+}
+/**
+* Creates a new `Error` that can be used to handle both internal and runtime errors.
+*
+* @param input {string | (Partial<SilgiError> & { status?: number; statusText?: string })} - The error message or an object containing error properties.
+* If a string is provided, it will be used as the error `message`.
+*
+* @example
+* // String error where `statusCode` defaults to `500`
+* throw createError("An error occurred");
+* // Object error
+* throw createError({
+*   statusCode: 400,
+*   statusMessage: "Bad Request",
+*   message: "Invalid input",
+*   data: { field: "email" }
+* });
+*
+*
+* @return {SilgiError} - An instance of SilgiError.
+*
+* @remarks
+* - Typically, `message` contains a brief, human-readable description of the error, while `statusMessage` is specific to HTTP responses and describes
+* the status text related to the response status code.
+* - In a client-server context, using a short `statusMessage` is recommended because it can be accessed on the client side. Otherwise, a `message`
+* passed to `createError` on the server will not propagate to the client.
+* - Consider avoiding putting dynamic user input in the `message` to prevent potential security issues.
+*/
+declare function createError<DataT = unknown>(input: string | (Partial<SilgiError<DataT>> & {
+  status?: number;
+  statusText?: string;
+})): SilgiError<DataT>;
+/**
+* Checks if the given input is an instance of SilgiError.
+*
+* @param input {*} - The input to check.
+* @return {boolean} - Returns true if the input is an instance of SilgiError, false otherwise.
+*/
+declare function isError<DataT = unknown>(input: any): input is SilgiError<DataT>;
+//#endregion
+export { SilgiError as SilgiError$1, createError as createError$1, isError as isError$1 };