silgi 0.43.28 → 0.50.0

package/dist/core/orchestrate.mjs

@@ -1,115 +0,0 @@
-import { normalizeResult, useSilgi } from "./unctx.mjs";
-import { createError } from "./error.mjs";
-import { generateStorageKey, useSilgiStorage } from "./utils/storage.mjs";
-import { parseRequestInput } from "./utils/internal/req.mjs";
-import { getQuery, getRouterParams } from "./utils/request.mjs";
-import { getUrlPrefix } from "./utils/resolver.mjs";
-import { silgiFetch } from "./silgi.mjs";
-import consola from "consola";
-
-//#region src/core/orchestrate.ts
-async function orchestrate(route, event) {
-	const silgiCtx = useSilgi();
-	const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
-	const input = route.service?.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req);
-	const hookContext = { earlyReturnValue: false };
-	const routerParams = input.path || getRouterParams(event);
-	const queryParams = input.query || getQuery(event);
-	const inputData = {
-		args: input,
-		query: queryParams,
-		path: routerParams
-	};
-	try {
-		if (!route.service) throw createError({
-			statusCode: 404,
-			statusMessage: "Service not found"
-		});
-		const cachePromise = cacheExecute(input, route, silgiURL, event);
-		const beforeHookPromise = silgiCtx.callHook("fetch:before", {
-			url: silgiURL,
-			input,
-			event,
-			route,
-			hookContext
-		});
-		const cacheData = await cachePromise;
-		await beforeHookPromise;
-		if (hookContext.earlyReturnValue !== false) return hookContext.earlyReturnValue;
-		if (cacheData?.success) {
-			await silgiCtx.callHook("fetch:after", {
-				event,
-				url: silgiURL,
-				input,
-				result: cacheData.data,
-				success: true,
-				cached: true,
-				route,
-				hookContext
-			});
-			return cacheData.data;
-		}
-		silgiCtx.shared.$fetch = silgiFetch;
-		silgiCtx.shared.silgi = silgiCtx;
-		const result = await route.service?.handler?.(inputData, silgiCtx.shared, event);
-		await silgiCtx.callHook("fetch:after", {
-			event,
-			url: silgiURL,
-			input: inputData,
-			result,
-			success: true,
-			route,
-			hookContext
-		});
-		if (route.service?.storage && cacheData?.cachedKey) await useSilgiStorage(route.service.storage.base).setItem(cacheData.cachedKey, result, route.service.storage.options);
-		return result;
-	} catch (err) {
-		consola.error("Error in orchestrate:", err);
-		await silgiCtx.callHook("fetch:error", {
-			event,
-			input: inputData,
-			error: err instanceof Error ? err : new Error(String(err)),
-			url: silgiURL,
-			route,
-			hookContext
-		});
-		silgiCtx.captureError(silgiCtx, createError({
-			message: err instanceof Error ? err.message : String(err),
-			statusCode: 500,
-			statusMessage: "Internal Server Error",
-			cause: err
-		}), {
-			event,
-			tags: ["execute"]
-		});
-		throw err;
-	}
-}
-async function cacheExecute(input, route, silgiURL, event) {
-	if (!route.service || !route.service.storage) return;
-	const cacheKey = route.service.storage ? await generateStorageKey({
-		url: silgiURL,
-		input,
-		keyGenerator: route.service.storage.key,
-		storageOptions: route.service.storage,
-		requestId: event?.requestId
-	}) : null;
-	if (cacheKey) {
-		const cachedResult = await useSilgiStorage(route.service.storage.base).getItem(cacheKey);
-		if (cachedResult !== null) return {
-			success: true,
-			data: normalizeResult(cachedResult),
-			cached: true,
-			cachedKey: cacheKey
-		};
-	}
-	return {
-		success: false,
-		data: null,
-		cached: false,
-		cachedKey: cacheKey
-	};
-}
-
-//#endregion
-export { orchestrate };

package/dist/core/response.d.mts

@@ -1,20 +0,0 @@
-import { SilgiError$1 as SilgiError } from "./error.mjs";
-import { SilgiEvent } from "silgi/types";
-
-//#region src/core/response.d.ts
-type MaybePromise<T> = T | Promise<T>;
-interface SilgiHandlerConfig {
-  debug?: boolean;
-  // websocket?: WebSocketOptions;
-  onError?: (error: SilgiError, event: SilgiEvent) => MaybePromise<void | unknown>;
-  onRequest?: (event: SilgiEvent) => MaybePromise<void>;
-  onBeforeResponse?: (event: SilgiEvent, response: Response | PreparedResponse) => MaybePromise<void>;
-}
-type PreparedResponse = ResponseInit & {
-  body?: BodyInit | null;
-};
-declare const kNotFound: symbol;
-declare const kHandled: symbol;
-declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHandlerConfig): Response | Promise<Response>;
-//#endregion
-export { handleResponse as handleResponse$1, kHandled as kHandled$1, kNotFound as kNotFound$1 };

package/dist/core/response.mjs

@@ -1,105 +0,0 @@
-import { isJSONSerializable } from "./utils/internal/object.mjs";
-import { createError } from "./error.mjs";
-import { FastResponse } from "srvx";
-
-//#region src/core/response.ts
-const kNotFound = /* @__PURE__ */ Symbol.for("silgi.notFound");
-const kHandled = /* @__PURE__ */ Symbol.for("silgi.handled");
-function handleResponse(val, event, config) {
-	if (val && val instanceof Promise) return val.catch((error) => error).then((resolvedVal) => handleResponse(resolvedVal, event, config));
-	const response = prepareResponse(val, event, config);
-	if (response instanceof Promise) return handleResponse(response, event, config);
-	const { onBeforeResponse } = config;
-	return onBeforeResponse ? Promise.resolve(onBeforeResponse(event, response)).then(() => response) : response;
-}
-function prepareResponse(val, event, config, nested) {
-	if (val === kHandled) return new FastResponse(null);
-	if (val === kNotFound) val = createError({
-		statusCode: 404,
-		statusMessage: `Cannot find any route matching [${event.req.method}] ${event.url}`
-	});
-	if (val && val instanceof Error) {
-		const error = createError(val);
-		const { onError } = config;
-		return onError && !nested ? Promise.resolve(onError(error, event)).catch((error$1) => error$1).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
-	}
-	const eventHeaders = event.res._headers;
-	if (!(val instanceof Response)) {
-		const res = prepareResponseBody(val, event, config);
-		const status = event.res.status;
-		return new FastResponse(nullBody(event.req.method, status) ? null : res.body, {
-			status,
-			statusText: event.res.statusText,
-			headers: res.headers && eventHeaders ? mergeHeaders(res.headers, eventHeaders) : res.headers || eventHeaders
-		});
-	}
-	if (!eventHeaders) return val;
-	return new FastResponse(nullBody(event.req.method, val.status) ? null : val.body, {
-		status: val.status,
-		statusText: val.statusText,
-		headers: mergeHeaders(eventHeaders, val.headers)
-	});
-}
-function nullBody(method, status) {
-	return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
-}
-function mergeHeaders(base, merge) {
-	const mergedHeaders = new Headers(base);
-	for (const [name, value] of merge) if (name === "set-cookie") mergedHeaders.append(name, value);
-	else mergedHeaders.set(name, value);
-	return mergedHeaders;
-}
-const emptyHeaders = new Headers({ "content-length": "0" });
-const jsonHeaders = new Headers({ "content-type": "application/json;charset=UTF-8" });
-function prepareResponseBody(val, event, config) {
-	if (val === null || val === void 0) return {
-		body: "",
-		headers: emptyHeaders
-	};
-	const valType = typeof val;
-	if (valType === "string") return { body: val };
-	if (val instanceof Uint8Array) {
-		event.res.headers.set("content-length", val.byteLength.toString());
-		return { body: val };
-	}
-	if (isJSONSerializable(val, valType)) return {
-		body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
-		headers: jsonHeaders
-	};
-	if (valType === "bigint") return {
-		body: val.toString(),
-		headers: jsonHeaders
-	};
-	if (val instanceof Blob) {
-		const headers = {
-			"content-type": val.type,
-			"content-length": val.size.toString()
-		};
-		if ("name" in val) {
-			const filename = encodeURIComponent(val.name);
-			headers["content-disposition"] = `filename="${filename}"; filename*=UTF-8''${filename}`;
-		}
-		return {
-			body: val.stream(),
-			headers
-		};
-	}
-	if (valType === "symbol") return { body: val.toString() };
-	if (valType === "function") return { body: `${val.name}()` };
-	return { body: val };
-}
-function errorResponse(error, debug) {
-	return new FastResponse(JSON.stringify({
-		statusCode: error.statusCode,
-		statusMessage: error.statusMessage,
-		data: error.data,
-		stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
-	}, null, 2), {
-		status: error.statusCode,
-		statusText: error.statusMessage,
-		headers: { "content-type": "application/json; charset=utf-8" }
-	});
-}
-
-//#endregion
-export { handleResponse, kHandled, kNotFound };

package/dist/core/silgi.d.mts

@@ -1,19 +0,0 @@
-import { MiddlewareSetup, ServiceSetup, ServicesObject, Silgi, SilgiEvent, SilgiRuntimeContext, StandardSchemaV1, WebSocketOptions } from "silgi/types";
-
-//#region src/core/silgi.d.ts
-
-/**
-* Fetch API for Silgi framework
-*/
-declare function silgiFetch<Service extends ServicesObject = ServicesObject, Path extends keyof Service = keyof Service>(_request: Path, options?: RequestInit, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
-/**
-* Fetch API for Silgi framework using standard Request options
-*/
-declare function silgiFetch(_request: Request | URL, options?: RequestInit & {
-  path?: Record<string, any>;
-}, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
-declare function middleware(event: SilgiEvent): Promise<any>;
-declare function handler(event: SilgiEvent): Promise<any>;
-declare function getWebsocket(silgi?: Silgi): WebSocketOptions;
-//#endregion
-export { getWebsocket as getWebsocket$1, handler as handler$1, middleware as middleware$1, silgiFetch as silgiFetch$1 };

package/dist/core/silgi.mjs

@@ -1,141 +0,0 @@
-import { useSilgi } from "./unctx.mjs";
-import { createError, isError } from "./error.mjs";
-import { SilgiHttpEvent } from "./event.mjs";
-import { handleResponse, kNotFound } from "./response.mjs";
-import { orchestrate } from "./orchestrate.mjs";
-import { findAllRoutes, findRoute } from "rou3";
-
-//#region src/core/silgi.ts
-function getHeader(name, headers) {
-	if (!headers) return;
-	if (headers instanceof Headers) return headers.get(name);
-	const lName = name.toLowerCase();
-	if (Array.isArray(headers)) return headers.find((h) => h[0] === name || lName === h[0].toLowerCase())?.[1];
-	return headers[name] || headers[lName];
-}
-function substitutePathParams(path, pathParams) {
-	if (!pathParams) return path;
-	return path.replace(/:(\w+)/g, (_, key) => {
-		if (key in pathParams) return encodeURIComponent(pathParams[key]);
-		return `:${key}`;
-	});
-}
-function withDuplexIfBody(options) {
-	if (!options) return options;
-	if (options.body && !("duplex" in options)) return {
-		...options,
-		duplex: "half"
-	};
-	return options;
-}
-async function silgiFetch(_request, options, context) {
-	let request;
-	if (typeof _request === "string") {
-		_request = substitutePathParams(_request, options?.pathParams);
-		let url = _request;
-		if (url[0] === "/") {
-			const host = getHeader("Host", options?.headers) || ".";
-			const proto = getHeader("X-Forwarded-Proto", options?.headers) === "https" ? "https" : "http";
-			url = `${proto}://${host}${url}`;
-		}
-		request = new Request(url, withDuplexIfBody(options));
-	} else if (options || _request instanceof URL) request = new Request(_request, withDuplexIfBody(options));
-	else request = _request;
-	const silgiEvent = new SilgiHttpEvent(request, context);
-	let handlerRes;
-	try {
-		handlerRes = handler(silgiEvent);
-	} catch (error) {
-		handlerRes = Promise.reject(error);
-	}
-	return handleResponse(handlerRes, silgiEvent, {});
-}
-async function middleware(event) {
-	const silgiContext = useSilgi();
-	event._chain = Promise.resolve(await silgiContext.callHook("request:on", event));
-	let _chain = void 0;
-	const _middleware = silgiContext.globalMiddlewares;
-	if (_middleware) {
-		_chain = _chain || Promise.resolve();
-		for (const m of _middleware) _chain = _chain.then(async (_previous) => {
-			if (_previous !== void 0 && _previous !== kNotFound) return _previous;
-			if (!(m.method === event.req.method) || !m.middleware) return;
-			try {
-				await silgiContext.callHook("middleware:global:on", event, m.middleware);
-			} catch (error) {
-				if (isError(error)) throw error;
-				throw createError({
-					message: "Middleware error",
-					statusCode: 500,
-					statusMessage: "Middleware error",
-					cause: error
-				});
-			}
-			return m.middleware.handler?.(event, silgiContext);
-		});
-	}
-	const _mRouter = silgiContext._middlewareRouter;
-	if (_mRouter) {
-		const matches = findAllRoutes(_mRouter, event.req.method, event.url.pathname);
-		if (matches.length > 0) {
-			_chain = _chain || Promise.resolve();
-			for (const match of matches) _chain = _chain.then(async (_previous) => {
-				if (_previous !== void 0 && _previous !== kNotFound) return _previous;
-				if (!(match.data.method === event.req.method) || !match.data.middleware) return;
-				event.context.params = match.params;
-				event.context.matchedRoute = match.data;
-				try {
-					await silgiContext.callHook("middleware:router:on", event, match.data.middleware);
-				} catch (error) {
-					if (isError(error)) throw error;
-					throw createError({
-						message: "Middleware error",
-						statusCode: 500,
-						statusMessage: "Middleware error",
-						cause: error
-					});
-				}
-				return match.data.middleware.handler?.(event, silgiContext);
-			});
-		}
-	}
-	event._chain = _chain;
-	if (event._chain) {
-		const data = await event._chain;
-		if (data !== void 0 && data !== kNotFound) return data;
-	}
-}
-async function handler(event) {
-	await middleware(event);
-	const silgiContext = useSilgi();
-	if (silgiContext.router) {
-		const match = findRoute(silgiContext.router, event.req.method, event.url.pathname);
-		if (match) if (event._chain) return event._chain.then(async (_previous) => {
-			if (_previous !== void 0 && _previous !== kNotFound) return _previous;
-			event.context.params = match.params;
-			event.context.matchedRoute = match.data;
-			return orchestrate(match.data, event);
-		});
-		else {
-			event.context.params = match.params;
-			event.context.matchedRoute = match.data;
-			return orchestrate(match.data, event);
-		}
-	}
-	return event._chain ? event._chain.then((_previous) => _previous === void 0 ? kNotFound : _previous) : kNotFound;
-}
-function getWebsocket(silgi = useSilgi()) {
-	return {
-		...silgi.options.websocket,
-		resolve: async (request) => {
-			const _method = request.method || "GET";
-			const event = new SilgiHttpEvent(request, {});
-			const silgiContext = useSilgi();
-			const handler$1 = silgiContext.router && findRoute(silgiContext.router, event.req.method, event.url.pathname);
-			return handler$1?.data.service?.websocket || {};
-		}
-	};
-}
-
-//#endregion
-export { getWebsocket, handler, middleware, silgiFetch };

package/dist/core/silgiApp.d.mts

@@ -1,9 +0,0 @@
-import { UseContext } from "unctx";
-import { SilgiCLI } from "silgi/types";
-
-//#region src/core/silgiApp.d.ts
-declare const silgiCLICtx: UseContext<SilgiCLI>;
-declare function useSilgiCLI(): SilgiCLI;
-declare function tryUseSilgiCLI(): SilgiCLI | null;
-//#endregion
-export { silgiCLICtx as silgiCLICtx$1, tryUseSilgiCLI as tryUseSilgiCLI$1, useSilgiCLI as useSilgiCLI$1 };

package/dist/core/silgiApp.mjs

@@ -1,23 +0,0 @@
-import consola from "consola";
-import { getContext } from "unctx";
-
-//#region src/core/silgiApp.ts
-const silgiCLICtx = getContext("silgiCLI");
-function useSilgiCLI() {
-	const instance = silgiCLICtx.tryUse();
-	if (!instance) throw new Error("Silgi instance is unavailable!");
-	return instance;
-}
-async function silgiCLIIClose() {
-	const silgi = silgiCLICtx.tryUse();
-	if (!silgi) return;
-	await silgi.close();
-	await silgi.callHook("close", silgi);
-	consola.withTag("silgi").success("Process terminated");
-}
-function tryUseSilgiCLI() {
-	return silgiCLICtx.tryUse();
-}
-
-//#endregion
-export { silgiCLICtx, silgiCLIIClose, tryUseSilgiCLI, useSilgiCLI };

package/dist/core/unctx.d.mts

@@ -1,21 +0,0 @@
-import { UseContext } from "unctx";
-import { Silgi } from "silgi/types";
-
-//#region src/core/unctx.d.ts
-declare const silgiCtx: UseContext<Silgi>;
-declare function useSilgi(): Silgi;
-/**
-* Get access to Nuxt instance.
-*
-* Returns null if Nuxt instance is unavailable.
-* @example
-* ```js
-* const silgi = tryUseSilgi()
-* if (silgi) {
-*  // Do something
-* }
-* ```
-*/
-declare function tryUseSilgi(): Silgi | null;
-//#endregion
-export { silgiCtx as silgiCtx$1, tryUseSilgi as tryUseSilgi$1, useSilgi as useSilgi$1 };

package/dist/core/unctx.mjs

@@ -1,35 +0,0 @@
-import { getContext } from "unctx";
-
-//#region src/core/unctx.ts
-const silgiCtx = getContext("silgi");
-function useSilgi() {
-	const instance = silgiCtx.tryUse();
-	if (!instance) throw new Error("Silgi instance is unavailable!");
-	return instance;
-}
-function normalizeResult(result) {
-	if (Array.isArray(result)) return [...result];
-	if (result && typeof result === "object") {
-		if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) return Object.values(result);
-		return { ...result };
-	}
-	return result;
-}
-/**
-* Get access to Nuxt instance.
-*
-* Returns null if Nuxt instance is unavailable.
-* @example
-* ```js
-* const silgi = tryUseSilgi()
-* if (silgi) {
-*  // Do something
-* }
-* ```
-*/
-function tryUseSilgi() {
-	return silgiCtx.tryUse();
-}
-
-//#endregion
-export { normalizeResult, silgiCtx, tryUseSilgi, useSilgi };

package/dist/core/utils/event-stream.d.mts

@@ -1,53 +0,0 @@
-import { EventStream$1 as EventStream } from "./internal/event-stream.mjs";
-import { SilgiEvent } from "silgi/types";
-
-//#region src/core/utils/event-stream.d.ts
-interface EventStreamOptions {
-  /**
-  * Automatically close the writable stream when the request is closed
-  *
-  * Default is `true`
-  */
-  autoclose?: boolean;
-}
-/**
-* See https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#fields
-*/
-interface EventStreamMessage {
-  id?: string;
-  event?: string;
-  retry?: number;
-  data: string;
-}
-/**
-* Initialize an EventStream instance for creating [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-*
-* @experimental This function is experimental and might be unstable in some environments.
-*
-* @example
-*
-* ```ts
-* import { createEventStream, sendEventStream } from "h3";
-*
-* app.get("/sse", (event) => {
-*   const eventStream = createEventStream(event);
-*
-*   // Send a message every second
-*   const interval = setInterval(async () => {
-*     await eventStream.push("Hello world");
-*   }, 1000);
-*
-*   // cleanup the interval and close the stream when the connection is terminated
-*   eventStream.onClosed(async () => {
-*     console.log("closing SSE...");
-*     clearInterval(interval);
-*     await eventStream.close();
-*   });
-*
-*   return eventStream.send();
-* });
-* ```
-*/
-declare function createEventStream(event: SilgiEvent, opts?: EventStreamOptions): EventStream;
-//#endregion
-export { EventStreamMessage, EventStreamOptions, createEventStream as createEventStream$1 };

package/dist/core/utils/event-stream.mjs

@@ -1,38 +0,0 @@
-import { EventStream } from "./internal/event-stream.mjs";
-
-//#region src/core/utils/event-stream.ts
-/**
-* Initialize an EventStream instance for creating [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-*
-* @experimental This function is experimental and might be unstable in some environments.
-*
-* @example
-*
-* ```ts
-* import { createEventStream, sendEventStream } from "h3";
-*
-* app.get("/sse", (event) => {
-*   const eventStream = createEventStream(event);
-*
-*   // Send a message every second
-*   const interval = setInterval(async () => {
-*     await eventStream.push("Hello world");
-*   }, 1000);
-*
-*   // cleanup the interval and close the stream when the connection is terminated
-*   eventStream.onClosed(async () => {
-*     console.log("closing SSE...");
-*     clearInterval(interval);
-*     await eventStream.close();
-*   });
-*
-*   return eventStream.send();
-* });
-* ```
-*/
-function createEventStream(event, opts) {
-	return new EventStream(event, opts);
-}
-
-//#endregion
-export { createEventStream };

package/dist/core/utils/event.d.mts

@@ -1,8 +0,0 @@
-import { SilgiEvent, SilgiRuntimeContext } from "silgi/types";
-
-//#region src/core/utils/event.d.ts
-// import { isRuntimePresents } from 'silgi/kit'
-declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
-declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
-//#endregion
-export { getEvent as getEvent$1, getEventContext as getEventContext$1 };

package/dist/core/utils/event.mjs

@@ -1,12 +0,0 @@
-//#region src/core/utils/event.ts
-function getEvent(event) {
-	if (event?.event) return getEvent(event.event);
-	return event;
-}
-function getEventContext(event) {
-	const _event = getEvent(event);
-	return _event.context;
-}
-
-//#endregion
-export { getEvent, getEventContext };

package/dist/core/utils/internal/event-stream.d.mts

@@ -1,45 +0,0 @@
-import { EventStreamMessage, EventStreamOptions } from "../event-stream.mjs";
-import { SilgiEvent } from "silgi/types";
-
-//#region src/core/utils/internal/event-stream.d.ts
-
-/**
-* A helper class for [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format)
-*/
-declare class EventStream {
-  private readonly _event;
-  private readonly _transformStream;
-  private readonly _writer;
-  private readonly _encoder;
-  private _writerIsClosed;
-  private _paused;
-  private _unsentData;
-  private _disposed;
-  private _handled;
-  constructor(event: SilgiEvent, opts?: EventStreamOptions);
-  /**
-  * Publish new event(s) for the client
-  */
-  push(message: string): Promise<void>;
-  push(message: string[]): Promise<void>;
-  push(message: EventStreamMessage): Promise<void>;
-  push(message: EventStreamMessage[]): Promise<void>;
-  private _sendEvent;
-  private _sendEvents;
-  pause(): void;
-  get isPaused(): boolean;
-  resume(): Promise<void>;
-  flush(): Promise<void>;
-  /**
-  * Close the stream and the connection if the stream is being sent to the client
-  */
-  close(): Promise<void>;
-  /**
-  * Triggers callback when the writable stream is closed.
-  * It is also triggered after calling the `close()` method.
-  */
-  onClosed(cb: () => any): void;
-  send(): Promise<BodyInit>;
-}
-//#endregion
-export { EventStream as EventStream$1 };