@apisr/response 0.0.1 → 0.0.2

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 { MetaOptions, meta } from "./meta.mjs";
+import { ErrorOptions, error } from "./error.mjs";
+import { JsonOptions, json } from "./json.mjs";
+import { BinaryOptions, binary } from "./binary.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 { json } from "./json.mjs";
+import { meta } from "./meta.mjs";
+import { error } from "./error.mjs";
+import { binary } from "./binary.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 { DefaultMeta } from "../response/meta/index.mjs";
+import { FunctionObject } from "../types.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 {
+    status?: number;
+    statusText?: string;
+    headers?: RawHeaders;
+  }
+  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> {
+  success: boolean;
+  error: ErrorResponse.Base<any, any, any> | null;
+  data: TData | null;
+  metadata: Record<string, unknown>;
+}
+//#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,124 @@
+import z from "zod";
+
+//#region ../schema/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.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);
+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;
+	else if (validationType === "safeParse") {
+		const { data } = schema.safeParse(resolved);
+		return data ?? null;
+	}
+}
+
+//#endregion
+export { checkSchema };

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 extends any, 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$1);
+
+//#endregion
+export { zod };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apisr/response",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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/headers.ts

@@ -4,18 +4,18 @@ export type RawHeaders = Record<string, string>;
 export type Headers<T> = FunctionObject<RawHeaders, T>;
 
 export function resolveHeaders(
-  headers: Headers<any> | undefined,
-  input: unknown
+	headers: Headers<any> | undefined,
+	input: unknown
 ): RawHeaders | null {
-  const result =
-    typeof headers === "function"
-      ? (headers as (arg: unknown) => RawHeaders)(input)
-      : headers;
+	const result =
+		typeof headers === "function"
+			? (headers as (arg: unknown) => RawHeaders)(input)
+			: headers;
 
-  if (!headers) {
-    return null;
-  }
+	if (!headers) {
+		return null;
+	}
 
-  // @ts-ignore
-  return result;
+	// @ts-expect-error
+	return result;
 }

package/src/index.ts

@@ -1,7 +1,7 @@
+export * from "./error";
 export * from "./handler";
 export * from "./headers";
+export * from "./options";
+export * from "./response";
 export * from "./symbol";
 export * from "./types";
-export * from "./response";
-export * from "./options";
-export * from "./error";

package/src/options/base.ts

@@ -1,36 +1,35 @@
-import type { MetaOptions } from "@/options/meta";
+import type { Headers } from "@/headers";
+import type { BinaryOptions } from "@/options/binary";
 import type { ErrorOptions } from "@/options/error";
 import type { JsonOptions } from "@/options/json";
-import type { BinaryOptions } from "@/options/binary";
-import type { Headers } from "@/headers";
+import type { MetaOptions } from "@/options/meta";
 import type { BaseResponse, ResponseTypes } from "@/response/base";
 import type { Binary } from "@/response/binary";
-import type { PromiseOr } from "@/types";
 import type { DefaultResponse } from "@/response/default";
+import type { PromiseOr } from "@/types";
 
 export interface Options<
-  TMeta extends MetaOptions.Base = MetaOptions.Base,
-  TError extends ErrorOptions.Base = ErrorOptions.Base,
-  TJson extends JsonOptions.Base = JsonOptions.Base,
-  TBinary extends BinaryOptions.Base = BinaryOptions.Base
+	TMeta extends MetaOptions.Base = MetaOptions.Base,
+	TError extends ErrorOptions.Base = ErrorOptions.Base,
+	TJson extends JsonOptions.Base = JsonOptions.Base,
+	TBinary extends BinaryOptions.Base = BinaryOptions.Base,
 > {
-  headers?: Headers<{
-    type: ResponseTypes;
-    data: any;
-  }>;
-
-  meta?: TMeta;
-  error?: TError;
-  json?: TJson;
+	binary?: TBinary;
+	error?: TError;
+	headers?: Headers<{
+		type: ResponseTypes;
+		data: any;
+	}>;
+	json?: TJson;
 
-  binary?: TBinary;
+	mapResponse?(data: {
+		data: JsonOptions.InferedSchemaFromBase<TJson> | Binary | string;
+		error: ErrorOptions.InferedSchemaFromBase<TError>;
+		// headers: RawHeaders;
+		// status: number | undefined;
+		// statusText: string | undefined;
+		response: BaseResponse.Base<DefaultResponse>;
+	}): PromiseOr<Response>;
 
-  mapResponse?(data: {
-    data: JsonOptions.InferedSchemaFromBase<TJson> | Binary | string;
-    error: ErrorOptions.InferedSchemaFromBase<TError>;
-    // headers: RawHeaders;
-    // status: number | undefined;
-    // statusText: string | undefined;
-    response: BaseResponse.Base<DefaultResponse>;
-  }): PromiseOr<Response>;
+	meta?: TMeta;
 }

package/src/options/binary.ts

@@ -2,13 +2,13 @@ import type { Headers } from "@/headers";
 import type { Binary } from "@/response/binary";
 
 export namespace BinaryOptions {
-  export interface Base {
-    headers?: Headers<Binary>;
+	export interface Base {
+		headers?: Headers<Binary>;
 
-    mapData?: (data: Binary) => Binary;
-  }
+		mapData?: (data: Binary) => Binary;
+	}
 }
 
 export function binary<T extends BinaryOptions.Base>(opts: T): T {
-  return opts;
+	return opts;
 }