@apisr/response 0.0.1 → 0.0.3

package/dist/options/error.d.mts

@@ -0,0 +1,31 @@
+import { PromiseOr } from "../types.mjs";
+import { Headers } from "../headers.mjs";
+import { Options } from "./base.mjs";
+import { DefaultError } from "../error/index.mjs";
+
+//#region src/options/error.d.ts
+declare namespace ErrorOptions {
+  interface Base<TSchema extends Schema = Schema> {
+    headers?: Headers<Infer<TSchema>>;
+    mapDefaultError?: (error: DefaultError) => TSchema extends undefined ? DefaultError : Infer<TSchema>;
+    mapError?: (ctx: {
+      error: Error | null;
+      meta: unknown;
+      parsedError?: TSchema extends undefined ? DefaultError : Infer<TSchema>;
+    }) => PromiseOr<TSchema extends undefined ? DefaultError : Infer<TSchema>>;
+    onFailedSchemaValidation?: (ctx: {
+      data: unknown;
+    }) => PromiseOr<TSchema extends undefined ? DefaultError : Infer<TSchema>>;
+    schema?: TSchema;
+    validationType?: ValidationType;
+  }
+  type InferedSchemaFromBase<TError extends Base> = InferOr<ExtractSchema<TError>, DefaultError>;
+  type InferedSchema<TOptions extends Options> = TOptions["error"] extends undefined ? DefaultError : InferOr<ExtractSchema<TOptions["error"]>, DefaultError>;
+}
+declare function error<TSchema extends Schema>(opts: ErrorOptions.Base<TSchema> & {
+  schema?: TSchema;
+}): ErrorOptions.Base<TSchema> & {
+  schema?: TSchema;
+};
+//#endregion
+export { ErrorOptions, error };

package/dist/options/error.mjs

@@ -0,0 +1,7 @@
+//#region src/options/error.ts
+function error(opts) {
+	return opts;
+}
+
+//#endregion
+export { error };

package/dist/options/index.d.mts

@@ -0,0 +1,15 @@
+import { BinaryOptions, binary } from "./binary.mjs";
+import { ErrorOptions, error } from "./error.mjs";
+import { JsonOptions, json } from "./json.mjs";
+import { MetaOptions, meta } from "./meta.mjs";
+import { Options } from "./base.mjs";
+
+//#region src/options/index.d.ts
+declare const options: {
+  json: typeof json;
+  meta: typeof meta;
+  error: typeof error;
+  binary: typeof binary;
+};
+//#endregion
+export { options };

package/dist/options/index.mjs

@@ -0,0 +1,15 @@
+import { binary } from "./binary.mjs";
+import { error } from "./error.mjs";
+import { json } from "./json.mjs";
+import { meta } from "./meta.mjs";
+
+//#region src/options/index.ts
+const options = {
+	json,
+	meta,
+	error,
+	binary
+};
+
+//#endregion
+export { options };

package/dist/options/json.d.mts

@@ -0,0 +1,19 @@
+import { PromiseOr } from "../types.mjs";
+import { Headers } from "../headers.mjs";
+import { JsonResponse } from "../response/json/index.mjs";
+import { Options } from "./base.mjs";
+
+//#region src/options/json.d.ts
+declare namespace JsonOptions {
+  interface Base<TSchema extends Schema = Schema> {
+    headers?: Headers<Infer<TSchema>>;
+    mapData?: (data: Infer<TSchema>) => PromiseOr<Infer<TSchema>>;
+    schema?: TSchema;
+    validationType?: ValidationType;
+  }
+  type InferedSchemaFromBase<TJson extends Base> = InferOr<ExtractSchema<TJson>, JsonResponse.DefaultSchema>;
+  type InferedSchema<TOptions extends Options> = TOptions["json"] extends undefined ? JsonResponse.DefaultSchema : InferOr<Exclude<ExtractSchema<TOptions["json"]>, undefined>, JsonResponse.DefaultSchema>;
+}
+declare function json<TSchema extends Schema>(opts: JsonOptions.Base<TSchema>): JsonOptions.Base<TSchema>;
+//#endregion
+export { JsonOptions, json };

package/dist/options/json.mjs

@@ -0,0 +1,7 @@
+//#region src/options/json.ts
+function json(opts) {
+	return opts;
+}
+
+//#endregion
+export { json };

package/dist/options/meta.d.mts

@@ -0,0 +1,20 @@
+import { FunctionObject } from "../types.mjs";
+import { DefaultMeta } from "../response/meta/index.mjs";
+import { Options } from "./base.mjs";
+
+//#region src/options/meta.d.ts
+declare namespace MetaOptions {
+  interface Base<TSchema extends Schema = Schema> {
+    default?: FunctionObject<Infer<TSchema>, never>;
+    schema?: TSchema;
+    validationType?: ValidationType;
+  }
+  type InferedSchema<TOptions extends Options> = TOptions["meta"] extends undefined ? DefaultMeta : InferOr<ExtractSchema<TOptions["meta"]>, DefaultMeta>;
+}
+declare function meta<TSchema extends Schema>(opts: MetaOptions.Base<TSchema> & {
+  schema?: TSchema;
+}): MetaOptions.Base<TSchema> & {
+  schema?: TSchema;
+};
+//#endregion
+export { MetaOptions, meta };

package/dist/options/meta.mjs

@@ -0,0 +1,7 @@
+//#region src/options/meta.ts
+function meta(opts) {
+	return opts;
+}
+
+//#endregion
+export { meta };

package/dist/response/base.d.mts

@@ -0,0 +1,19 @@
+import { RawHeaders } from "../headers.mjs";
+
+//#region src/response/base.d.ts
+type ResponseTypes = "json" | "binary" | "text" | "error";
+declare namespace BaseResponse {
+  interface Options {
+    headers?: RawHeaders;
+    status?: number;
+    statusText?: string;
+  }
+  class Base<TPayload> extends Response {
+    payload: TPayload | undefined;
+    constructor(body?: ConstructorParameters<typeof Response>[0], init?: (ResponseInit & {
+      payload: TPayload;
+    }) | undefined);
+  }
+}
+//#endregion
+export { BaseResponse, ResponseTypes };

package/dist/response/base.mjs

@@ -0,0 +1,16 @@
+//#region src/response/base.ts
+let BaseResponse;
+(function(_BaseResponse) {
+	class Base extends Response {
+		payload;
+		constructor(body, init) {
+			const { payload, ..._init } = init ?? {};
+			super(body, _init);
+			this.payload = payload;
+		}
+	}
+	_BaseResponse.Base = Base;
+})(BaseResponse || (BaseResponse = {}));
+
+//#endregion
+export { BaseResponse };

package/dist/response/binary/index.d.mts

@@ -0,0 +1,10 @@
+import { BaseResponse } from "../base.mjs";
+
+//#region src/response/binary/index.d.ts
+type Binary = Blob | ArrayBuffer | Uint8Array | ReadableStream;
+declare namespace BinaryResponse {
+  class Base extends Response {}
+  interface Options extends BaseResponse.Options {}
+}
+//#endregion
+export { Binary, BinaryResponse };

package/dist/response/binary/index.mjs

@@ -0,0 +1,9 @@
+//#region src/response/binary/index.ts
+let BinaryResponse;
+(function(_BinaryResponse) {
+	class Base extends Response {}
+	_BinaryResponse.Base = Base;
+})(BinaryResponse || (BinaryResponse = {}));
+
+//#endregion
+export { BinaryResponse };

package/dist/response/default.d.mts

@@ -0,0 +1,11 @@
+import { ErrorResponse } from "./error/index.mjs";
+
+//#region src/response/default.d.ts
+interface DefaultResponse<TData = unknown> {
+  data: TData | null;
+  error: ErrorResponse.Base<any, any, any> | null;
+  metadata: Record<string, unknown>;
+  success: boolean;
+}
+//#endregion
+export { DefaultResponse };

package/dist/response/error/index.d.mts

@@ -0,0 +1,28 @@
+import { BaseResponse } from "../base.mjs";
+
+//#region src/response/error/index.d.ts
+declare namespace ErrorResponse {
+  class Base<TName extends string, TMeta extends Record<string, any>, TOutput extends Record<string, any>> extends Error {
+    name: TName;
+    meta: TMeta;
+    output: TOutput;
+    status: number;
+    statusText: string;
+    constructor({
+      meta,
+      name,
+      output,
+      status,
+      statusText
+    }: {
+      name: TName;
+      meta: TMeta;
+      output: TOutput;
+      status: number;
+      statusText: string;
+    });
+  }
+  interface Options extends BaseResponse.Options {}
+}
+//#endregion
+export { ErrorResponse };

package/dist/response/error/index.mjs

@@ -0,0 +1,23 @@
+//#region src/response/error/index.ts
+let ErrorResponse;
+(function(_ErrorResponse) {
+	class Base extends Error {
+		name;
+		meta;
+		output;
+		status;
+		statusText;
+		constructor({ meta, name, output, status, statusText }) {
+			super();
+			this.status = status;
+			this.statusText = statusText;
+			this.name = name;
+			this.meta = meta;
+			this.output = output;
+		}
+	}
+	_ErrorResponse.Base = Base;
+})(ErrorResponse || (ErrorResponse = {}));
+
+//#endregion
+export { ErrorResponse };

package/dist/response/index.mjs

@@ -0,0 +1,7 @@
+import { BaseResponse } from "./base.mjs";
+import { BinaryResponse } from "./binary/index.mjs";
+import { ErrorResponse } from "./error/index.mjs";
+import { JsonResponse } from "./json/index.mjs";
+import { TextResponse } from "./text/index.mjs";
+
+export {  };

package/dist/response/json/index.d.mts

@@ -0,0 +1,22 @@
+import { BaseResponse } from "../base.mjs";
+
+//#region src/response/json/index.d.ts
+declare namespace JsonResponse {
+  class Base<TOutput> extends Response {
+    private _output;
+    constructor(body: ConstructorParameters<typeof Response>[0], _init?: ConstructorParameters<typeof Response>[1] & {
+      output: TOutput;
+    });
+    get output(): TOutput | undefined;
+    json: () => Promise<TOutput>;
+  }
+  interface Options extends BaseResponse.Options {}
+  type DefaultInputSchema = Record<string, any>;
+  type DefaultSchema = {
+    data: Record<string, any>;
+    success: boolean;
+  };
+  function defaultOnDataOutput(input: DefaultInputSchema): DefaultSchema;
+}
+//#endregion
+export { JsonResponse };

package/dist/response/json/index.mjs

@@ -0,0 +1,29 @@
+//#region src/response/json/index.ts
+let JsonResponse;
+(function(_JsonResponse) {
+	class Base extends Response {
+		_output;
+		constructor(body, _init) {
+			const { output, ...init } = _init ?? {};
+			super(body, init);
+			this._output = output;
+		}
+		get output() {
+			return this._output;
+		}
+		json = () => {
+			return Response.prototype.json.call(this);
+		};
+	}
+	_JsonResponse.Base = Base;
+	function defaultOnDataOutput(input) {
+		return {
+			data: input,
+			success: true
+		};
+	}
+	_JsonResponse.defaultOnDataOutput = defaultOnDataOutput;
+})(JsonResponse || (JsonResponse = {}));
+
+//#endregion
+export { JsonResponse };

package/dist/response/meta/index.d.mts

@@ -0,0 +1,7 @@
+//#region src/response/meta/index.d.ts
+type DefaultMeta = {
+  requestId: string;
+  timestamp: number;
+};
+//#endregion
+export { DefaultMeta };

package/dist/response/text/index.d.mts

@@ -0,0 +1,9 @@
+import { BaseResponse } from "../base.mjs";
+
+//#region src/response/text/index.d.ts
+declare namespace TextResponse {
+  class Base extends Response {}
+  interface Options extends BaseResponse.Options {}
+}
+//#endregion
+export { TextResponse };

package/dist/response/text/index.mjs

@@ -0,0 +1,9 @@
+//#region src/response/text/index.ts
+let TextResponse;
+(function(_TextResponse) {
+	class Base extends Response {}
+	_TextResponse.Base = Base;
+})(TextResponse || (TextResponse = {}));
+
+//#endregion
+export { TextResponse };

package/dist/schema/dist/index.mjs

@@ -0,0 +1,19 @@
+import { resolveZodSchemaFromSources, z } from "./zod/dist/index.mjs";
+
+//#region ../schema/dist/index.mjs
+function checkSchema(schema, input, options) {
+	const validationType = options?.validationType ?? "parse";
+	let resolved = input;
+	if (options?.sources && schema instanceof z.ZodObject) resolved = {
+		...typeof input === "object" && input !== null ? input : {},
+		...resolveZodSchemaFromSources(schema, options.sources)
+	};
+	if (validationType === "parse") return schema.parse(resolved) ?? null;
+	if (validationType === "safeParse") {
+		const { data } = schema.safeParse(resolved);
+		return data ?? null;
+	}
+}
+
+//#endregion
+export { checkSchema };

package/dist/schema/dist/zod/dist/index.mjs

@@ -0,0 +1,111 @@
+import z, { default as z$1 } from "zod";
+
+//#region ../schema/dist/zod/dist/index.mjs
+/**
+* Extracts `from` metadata from each field of a zod object schema.
+*
+* @example
+* ```ts
+* const schema = z.object({
+*   name: z.string().from("body"),
+*   id: z.string().from("params"),
+*   token: z.string().from("headers", { key: "authorization" }),
+* });
+*
+* resolveZodSchemaMeta(schema);
+* // => {
+* //   name:  { from: "body" },
+* //   id:    { from: "params" },
+* //   token: { from: "headers", key: "authorization" },
+* // }
+* ```
+*/
+function resolveZodSchemaMeta(schema) {
+	const shape = schema._zod.def.shape;
+	const result = {};
+	for (const fieldName in shape) {
+		const fieldSchema = shape[fieldName];
+		const meta = resolveFieldMeta(fieldSchema);
+		if (meta) result[fieldName] = meta;
+	}
+	return result;
+}
+function resolveFieldMeta(schema) {
+	const meta = z$1.globalRegistry.get(schema);
+	if (meta && typeof meta.from === "string") {
+		const key = meta.key ?? meta.fromKey;
+		return {
+			from: meta.from,
+			...key !== void 0 ? { key } : {}
+		};
+	}
+	const def = schema._zod?.def;
+	if (def?.innerType) return resolveFieldMeta(def.innerType);
+}
+/**
+* Resolves field values from dynamic sources based on the schema's `from` metadata.
+*
+* Sources is a map where keys match possible `from` values
+* (e.g. `"query"`, `"params"`, `"body"`, `"headers"`, `"handler.payload"`)
+* and values are the corresponding data objects.
+*
+* @example
+* ```ts
+* const schema = z.object({
+*   name: z.string().from("body"),
+*   id: z.string().from("params"),
+*   search: z.string().from("query"),
+*   auth: z.string().from("headers", { key: "authorization" }),
+*   prev: z.string().from("handler.payload", { key: "name" }),
+* });
+*
+* const resolved = resolveZodSchemaFromSources(schema, {
+*   body:   { name: "John" },
+*   params: { id: "42" },
+*   query:  { search: "test" },
+*   headers: { authorization: "Bearer ..." },
+*   "handler.payload": { name: "prev-value" },
+* });
+* // => { name: "John", id: "42", search: "test", auth: "Bearer ...", prev: "prev-value" }
+* ```
+*/
+function resolveZodSchemaFromSources(schema, sources) {
+	const fieldsMeta = resolveZodSchemaMeta(schema);
+	const result = {};
+	for (const [fieldName, meta] of Object.entries(fieldsMeta)) {
+		const source = sources[meta.from];
+		if (!source) continue;
+		const keys = meta.key ? Array.isArray(meta.key) ? meta.key : [meta.key] : [fieldName];
+		for (const k of keys) {
+			const value = getNestedValue(source, k);
+			if (value !== void 0) {
+				result[fieldName] = value;
+				break;
+			}
+		}
+	}
+	return result;
+}
+function getNestedValue(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+}
+function extendZod(zod) {
+	if (typeof zod.ZodType.prototype.from !== "undefined") return zod;
+	zod.ZodType.prototype.from = function(from, options) {
+		return this.meta({
+			from,
+			...options ?? {}
+		});
+	};
+	return zod;
+}
+extendZod(z);
+
+//#endregion
+export { resolveZodSchemaFromSources, z };

package/dist/symbol.d.mts

@@ -0,0 +1,4 @@
+//#region src/symbol.d.ts
+declare const responseSymbol: unique symbol;
+//#endregion
+export { responseSymbol };

package/dist/symbol.mjs

@@ -0,0 +1,5 @@
+//#region src/symbol.ts
+const responseSymbol = Symbol("_response");
+
+//#endregion
+export { responseSymbol };

package/dist/types.d.mts

@@ -0,0 +1,6 @@
+//#region src/types.d.ts
+type AnyObject = Record<string, any>;
+type FunctionObject<TResult, TFnArg = never> = TResult | (TFnArg extends never ? () => TResult : (arg: TFnArg) => TResult);
+type PromiseOr<T> = PromiseLike<T> | T;
+//#endregion
+export { AnyObject, FunctionObject, PromiseOr };

package/dist/zod/dist/index.mjs

@@ -0,0 +1,17 @@
+import z, { default as z$1 } from "zod";
+
+//#region ../zod/dist/index.mjs
+function extendZod(zod) {
+	if (typeof zod.ZodType.prototype.from !== "undefined") return zod;
+	zod.ZodType.prototype.from = function(from, options) {
+		return this.meta({
+			from,
+			...options ?? {}
+		});
+	};
+	return zod;
+}
+const zod = extendZod(z);
+
+//#endregion
+export { zod };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apisr/response",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "module": "src/index.ts",
   "devDependencies": {
     "@repo/eslint-config": "*",
@@ -12,8 +12,8 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@apisr/schema": "",
-    "@apisr/zod": ""
+    "@apisr/schema": "^0.0.2",
+    "@apisr/zod": "^0.0.2"
   },
   "private": false,
   "scripts": {

package/src/error/default.ts

@@ -6,6 +6,13 @@ export function generateDefaultErrors<TOptions extends Options>(
 	_mapDefaultError: ErrorOptions.Base["mapDefaultError"]
 ): ErrorRegistry<TOptions> {
 	const mapDefaultError = _mapDefaultError ?? ((err) => err);
+	const resolveCause = (input: unknown): unknown => {
+		if (typeof input !== "object" || input === null || !("cause" in input)) {
+			return undefined;
+		}
+
+		return (input as { cause?: unknown }).cause;
+	};
 
 	const inputSchema = z
 		.object({
@@ -20,7 +27,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Unauthorized",
 					code: "UNAUTHORIZED",
 					name: "UnauthorizedError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -35,7 +42,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Forbidden",
 					code: "FORBIDDEN",
 					name: "ForbiddenError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -50,7 +57,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Not Found",
 					code: "NOT_FOUND",
 					name: "NotFoundError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -65,7 +72,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Bad Request",
 					code: "BAD_REQUEST",
 					name: "BadRequestError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -80,7 +87,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Conflict",
 					code: "CONFLICT",
 					name: "ConflictError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -95,7 +102,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Too Many Requests",
 					code: "TOO_MANY_REQUESTS",
 					name: "TooManyRequestsError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,
@@ -110,7 +117,7 @@ export function generateDefaultErrors<TOptions extends Options>(
 					message: "Internal Server Error",
 					code: "INTERNAL_SERVER_ERROR",
 					name: "InternalServerError",
-					cause: input.cause,
+					cause: resolveCause(input),
 				}),
 			options: {
 				input: inputSchema,

package/src/error/index.ts

@@ -28,6 +28,22 @@ export type DefaultError = {
 	stack?: string[];
 };
 
+type InferErrorHandlerInput<
+	THandlerOptions extends ErrorHandlerOptions | undefined,
+> = THandlerOptions extends {
+	input: infer TSchema;
+}
+	? TSchema extends Schema
+		? Infer<TSchema>
+		: never
+	: THandlerOptions extends {
+				input?: infer TSchema;
+			}
+		? TSchema extends Schema
+			? Infer<TSchema> | undefined
+			: undefined
+		: never;
+
 export type ErrorHandler<
 	TOptions extends Options,
 	THandlerOptions extends ErrorHandlerOptions | undefined,
@@ -35,9 +51,7 @@ export type ErrorHandler<
 	meta: TOptions["meta"] extends undefined
 		? never
 		: Infer<ExtractSchema<TOptions["meta"]>>;
-	input: THandlerOptions extends undefined
-		? never
-		: Infer<Exclude<THandlerOptions, undefined>["input"]>;
+	input: InferErrorHandlerInput<THandlerOptions>;
 }) => ErrorOptions.InferedSchema<TOptions>;
 
 export interface ErrorHandlerOptions<TSchema extends Schema = Schema> {