silgi 0.42.5 → 0.43.0

package/dist/core/error.mjs

@@ -0,0 +1,106 @@
+import { hasProp } from "./utils/internal/object.mjs";
+import { sanitizeStatusCode, sanitizeStatusMessage } from "./utils/sanitize.mjs";
+import consola from "consola";
+import { isDevelopment } from "std-env";
+
+//#region src/core/error.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.
+*/
+var SilgiError = class extends Error {
+	static __silgi_error__ = true;
+	statusCode = 500;
+	fatal = false;
+	unhandled = false;
+	statusMessage;
+	data;
+	cause;
+	constructor(message, opts = {}) {
+		super(message, opts);
+		if (opts.cause && !this.cause) this.cause = opts.cause;
+		if (isDevelopment && opts.cause && opts.cause instanceof Error && opts.cause.stack && this.stack) {
+			this.stack += `\nCaused by: ${opts.cause.stack}`;
+			consola.warn(opts.cause);
+		}
+	}
+	toJSON() {
+		const obj = {
+			message: this.message,
+			statusCode: sanitizeStatusCode(this.statusCode, 500)
+		};
+		if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
+		if (this.data !== void 0) obj.data = this.data;
+		return obj;
+	}
+};
+/**
+* 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.
+*/
+function createError(input) {
+	if (typeof input === "string") return new SilgiError(input);
+	const cause = input.cause;
+	const err = new SilgiError(input.message ?? input.statusMessage ?? "", { cause: cause || input });
+	if (hasProp(input, "stack")) try {
+		Object.defineProperty(err, "stack", { get() {
+			return input.stack;
+		} });
+	} catch {
+		try {
+			err.stack = input.stack;
+		} catch {}
+	}
+	if (input.data) err.data = input.data;
+	const statusCode = input.statusCode ?? input.status ?? cause?.statusCode ?? cause?.status;
+	if (typeof statusCode === "number") err.statusCode = sanitizeStatusCode(statusCode);
+	const statusMessage = input.statusMessage ?? input.statusText ?? cause?.statusMessage ?? cause?.statusText;
+	if (statusMessage) err.statusMessage = sanitizeStatusMessage(statusMessage);
+	const fatal = input.fatal ?? cause?.fatal;
+	if (fatal !== void 0) err.fatal = fatal;
+	const unhandled = input.unhandled ?? cause?.unhandled;
+	if (unhandled !== void 0) err.unhandled = unhandled;
+	return err;
+}
+/**
+* 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.
+*/
+function isError(input) {
+	return input?.constructor?.__silgi_error__ === true;
+}
+
+//#endregion
+export { SilgiError, createError, isError };

package/dist/core/event.d.mts

@@ -0,0 +1,26 @@
+import { ServerRequest, ServerRuntimeContext } from "srvx";
+import { SilgiEvent, SilgiRuntimeContext } from "silgi/types";
+
+//#region src/core/event.d.ts
+declare class SilgiHttpEvent implements SilgiEvent {
+  static __is_event__: boolean;
+  req: ServerRequest;
+  url: URL;
+  context: SilgiRuntimeContext;
+  _res?: SilgiEventResponse;
+  constructor(req: ServerRequest, context?: SilgiRuntimeContext);
+  _chain: Promise<unknown> | undefined;
+  [x: string]: unknown;
+  get res(): SilgiEventResponse;
+  get runtime(): ServerRuntimeContext | undefined;
+  toString(): string;
+  toJSON(): string;
+}
+declare class SilgiEventResponse {
+  status?: number;
+  statusText?: string;
+  _headers?: Headers;
+  get headers(): Headers;
+}
+//#endregion
+export { SilgiHttpEvent as SilgiHttpEvent$1 };

package/dist/core/event.mjs

@@ -0,0 +1,44 @@
+import { EmptyObject } from "./utils/internal/obj.mjs";
+import { FastURL } from "srvx";
+
+//#region src/core/event.ts
+var SilgiHttpEvent = class {
+	static __is_event__ = true;
+	req;
+	url;
+	context;
+	_res;
+	constructor(req, context) {
+		this.context = context || new EmptyObject();
+		this.context.protocol = "HTTP";
+		this.req = req;
+		const _url = req._url;
+		this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+	}
+	_chain;
+	get res() {
+		if (!this._res) this._res = new SilgiEventResponse();
+		return this._res;
+	}
+	get runtime() {
+		return this.req.runtime;
+	}
+	toString() {
+		return `[${this.req.method}] ${this.req.url}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+};
+var SilgiEventResponse = class {
+	status;
+	statusText;
+	_headers;
+	get headers() {
+		if (!this._headers) this._headers = new Headers();
+		return this._headers;
+	}
+};
+
+//#endregion
+export { SilgiHttpEvent };

package/dist/core/index.d.mts

@@ -1,317 +1,25 @@
-import { SilgiRuntimeConfig, SilgiConfig, Silgi, SilgiEvent, SilgiRuntimeContext, WebSocketOptions, SilgiSchema, RouteEntry, CustomRequestInit, SilgiCLI, SilgiStorageBase, MergeAll, Resolvers, SilgiURL, BaseMethodSchema, HTTPMethod, StandardSchemaV1, ServiceSetup, WebSocketServiceSetup, Routers, SilgiRuntimeShareds, StorageConfig } from 'silgi/types';
-import { ServerRequest, ServerRuntimeContext } from 'srvx';
-import { UseContext } from 'unctx';
-import { Storage, StorageValue } from 'unstorage';
-export { c as createMiddleware } from '../shared/silgi.DTwQEdSr.mjs';
-
-declare function updateRuntimeStorage(runtime: any): void;
-/**
- * Get access to silgi instance.
- *
- * Throws an error if silgi instance is unavailable.
- * @example
- * ```js
- * const runtime = useRuntime()
- * ```
- */
-declare function useRuntime(): SilgiRuntimeConfig;
-
-declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
-
-/**
- * LICENSE: MIT
- * Credits:
- * - H3 - https://github.com/h3js/h3
- */
-/**
- * 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>;
-
-declare class SilgiHttpEvent implements SilgiEvent {
-    static __is_event__: boolean;
-    req: ServerRequest;
-    url: URL;
-    context: SilgiRuntimeContext;
-    _res?: SilgiEventResponse;
-    constructor(req: ServerRequest, context?: SilgiRuntimeContext);
-    _chain: Promise<unknown> | undefined;
-    [x: string]: unknown;
-    get res(): SilgiEventResponse;
-    get runtime(): ServerRuntimeContext | undefined;
-    toString(): string;
-    toJSON(): string;
-}
-declare class SilgiEventResponse {
-    status?: number;
-    statusText?: string;
-    _headers?: Headers;
-    get headers(): Headers;
-}
-
-type MaybePromise<T> = T | Promise<T>;
-interface SilgiHandlerConfig {
-    debug?: boolean;
-    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>;
-
-/**
- * Fetch API for Silgi framework
- */
-declare function silgiFetch<Schema extends SilgiSchema = SilgiSchema, Method extends RouteEntry<Schema>['method'] = RouteEntry<Schema>['method'], Path extends Extract<RouteEntry<Schema>, {
-    method: Method;
-}>['path'] = Extract<RouteEntry<Schema>, {
-    method: Method;
-}>['path'], Resolved extends boolean = true, HiddenParameters extends boolean = true>(_request: Path, options?: CustomRequestInit<Schema, Method, Path, Resolved, HiddenParameters>, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
-/**
- * Fetch API for Silgi framework using standard Request options
- */
-declare function silgiFetch(_request: Request | URL, options?: RequestInit & {
-    pathParams?: 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;
-
-declare const silgiCLICtx: UseContext<SilgiCLI>;
-declare function useSilgiCLI(): SilgiCLI;
-declare function tryUseSilgiCLI(): SilgiCLI | null;
-
-declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
-
-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;
-
-/**
- * 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>;
-}
-
-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;
-
-declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
-declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
-
-/**
- * Merges multiple service definition objects into a single object.
- * Performs a complete deep merge of all service definition objects.
- * @template T - A tuple type representing the array of service definition objects to merge.
- * @param {T} schemas - An array of service definition objects created by `createSchema`.
- * @returns {MergeAll<T>} A single object containing all merged service definitions.
- */
-declare function deepMergeObjects<T extends readonly Record<string, any>[]>(schemas: [...T]): MergeAll<T>;
-
-declare function createResolver(resolver: Resolvers): Resolvers;
-declare function getUrlPrefix(path: string, method?: string): SilgiURL;
-
-/**
- * Recursively replaces values starting with 'runtime.' with their actual values from runtime config
- */
-declare function replaceRuntimeValues(obj: any, runtime: any): any;
-
-/**
- * Creates a type-safe API route schema definition.
- *
- * This utility function helps you define API schemas with proper typing for
- * input, output, path parameters, and query parameters.
- *
- * @template Key - API key
- * @template Schema - Schema definition type
- *
- * @param params - Schema configuration parameters
- * @param params.key - Unique key for the schema
- * @param params.setup - Schema definition for the specified methods
- * @returns Route schema object with complete type information
- *
- * @example
- * // Define a user API schema
- * const userSchema = createSchema({
- *   key: '/api/v1/users',
- *   setup: {
- *     output: z.object({
- *       users: z.array(z.object({ id: z.string(), name: z.string() }))
- *     })
- *   }
- * });
- */
-declare function createSchema<Key extends string, Schema extends BaseMethodSchema>(params: {
-    key: Key;
-} & Schema): {
-    [K in Key]: Schema;
-};
-
-/**
- * ServiceSetup tipinden oluşan bir yardımcı fonksiyon.
- * Tip güvenliğini artırmak için ServiceSetup objesini doğrudan döndürür.
- */
-declare function defineServiceSetup<Method extends HTTPMethod, Path extends keyof Routers, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(setup: Omit<ServiceSetup<Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path'>): Omit<ServiceSetup<Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>, 'method' | 'path'>;
-declare function createService<Path extends string, Method extends HTTPMethod, Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1, PathParams extends StandardSchemaV1 | undefined | never = undefined, QueryParams extends StandardSchemaV1 | undefined | never = undefined, Resolved extends boolean = false, HiddenParameters extends boolean = false>(params: ServiceSetup<Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>): Record<`http:${Method}:${Path}`, ServiceSetup<Method, Path, Input, Output, PathParams, QueryParams, Resolved, HiddenParameters>>;
-declare function createWebSocket<Path extends string, Method extends HTTPMethod>(params: WebSocketServiceSetup<Method, Path>): Record<`websocket:${Method}:${Path}`, WebSocketServiceSetup<Method, Path>>;
-
-declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
-
-declare function createStorage(silgi: Silgi): Promise<Storage<StorageValue>>;
-declare function useSilgiStorage<T extends StorageValue = StorageValue>(base?: StorageConfig<T>['base'] | (string & {})): Storage<T>;
-
+import { updateRuntimeStorage$1 as updateRuntimeStorage, useRuntime$1 as useRuntime } from "./context.mjs";
+import { createSilgi$1 as createSilgi } from "./createSilgi.mjs";
+import { SilgiError$1 as SilgiError, createError$1 as createError, isError$1 as isError } from "./error.mjs";
+import { SilgiHttpEvent$1 as SilgiHttpEvent } from "./event.mjs";
+import { handleResponse$1 as handleResponse, kHandled$1 as kHandled, kNotFound$1 as kNotFound } from "./response.mjs";
+import { getWebsocket$1 as getWebsocket, handler$1 as handler, middleware$1 as middleware, silgiFetch$1 as silgiFetch } from "./silgi.mjs";
+import { silgiCLICtx$1 as silgiCLICtx, tryUseSilgiCLI$1 as tryUseSilgiCLI, useSilgiCLI$1 as useSilgiCLI } from "./silgiApp.mjs";
+import { storageMount$1 as storageMount } from "./storage.mjs";
+import { silgiCtx$1 as silgiCtx, tryUseSilgi$1 as tryUseSilgi, useSilgi$1 as useSilgi } from "./unctx.mjs";
+import { createEventStream$1 as createEventStream } from "./utils/event-stream.mjs";
+import { getEvent$1 as getEvent, getEventContext$1 as getEventContext } from "./utils/event.mjs";
+import { deepMergeObjects$1 as deepMergeObjects } from "./utils/merge.mjs";
+import { createMiddleware$1 as createMiddleware } from "./utils/middleware.mjs";
+import { createResolver$3 as createResolver, getUrlPrefix$1 as getUrlPrefix } from "./utils/resolver.mjs";
+import { replaceRuntimeValues$1 as replaceRuntimeValues } from "./utils/runtime.mjs";
+import { createSchema$1 as createSchema } from "./utils/schema.mjs";
+import { createService$1 as createService, createWebSocket$1 as createWebSocket, defineServiceSetup$1 as defineServiceSetup } from "./utils/service.mjs";
+import { createShared$1 as createShared } from "./utils/shared.mjs";
+import { createStorage$1 as createStorage, useSilgiStorage$1 as useSilgiStorage } from "./utils/storage.mjs";
+
+//#region src/core/index.d.ts
+// TODO: bunlari yinede destekle.
 declare const autoImportTypes: string[];
-
-export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };
+//#endregion
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };