@apisr/response 0.0.1

package/src/index.ts

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

package/src/options/base.ts

@@ -0,0 +1,36 @@
+import type { MetaOptions } from "@/options/meta";
+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 { BaseResponse, ResponseTypes } from "@/response/base";
+import type { Binary } from "@/response/binary";
+import type { PromiseOr } from "@/types";
+import type { DefaultResponse } from "@/response/default";
+
+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
+> {
+  headers?: Headers<{
+    type: ResponseTypes;
+    data: any;
+  }>;
+
+  meta?: TMeta;
+  error?: TError;
+  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>;
+}

package/src/options/binary.ts

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

package/src/options/error.ts

@@ -0,0 +1,53 @@
+import type {
+	ExtractSchema,
+	Infer,
+	InferOr,
+	Schema,
+	ValidationType,
+} from "@apisr/schema";
+import type { DefaultError } from "@/error";
+import type { Headers } from "@/headers";
+import type { Options } from "@/options/base";
+import type { PromiseOr } from "@/types";
+
+export namespace ErrorOptions {
+	export 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;
+	}
+
+	export type InferedSchemaFromBase<TError extends Base> = InferOr<
+		ExtractSchema<TError>,
+		DefaultError
+	>;
+
+	export type InferedSchema<TOptions extends Options> =
+		TOptions["error"] extends undefined
+			? DefaultError
+			: InferOr<ExtractSchema<TOptions["error"]>, DefaultError>;
+}
+
+export function error<TSchema extends Schema>(
+	opts: ErrorOptions.Base<TSchema> & {
+		schema?: TSchema;
+	}
+): ErrorOptions.Base<TSchema> & {
+	schema?: TSchema;
+} {
+	return opts;
+}

package/src/options/index.ts

@@ -0,0 +1,17 @@
+export * from "./base";
+export * from "./json"
+export * from "./meta"
+export * from "./error"
+export * from "./binary"
+
+import { json } from "./json"
+import { meta } from "./meta"
+import { error } from "./error"
+import { binary } from "./binary"
+
+export const options = {
+  json,
+  meta,
+  error,
+  binary
+};

package/src/options/json.ts

@@ -0,0 +1,45 @@
+import type {
+	ExtractSchema,
+	Infer,
+	InferOr,
+	Schema,
+	ValidationType,
+} from "@apisr/schema";
+import type { Headers } from "@/headers";
+import type { JsonResponse } from "@/response/json";
+import type { PromiseOr } from "@/types";
+import type { Options } from "./base";
+
+export namespace JsonOptions {
+	export interface Base<TSchema extends Schema = Schema> {
+		headers?: Headers<Infer<TSchema>>;
+
+		mapData?: (data: Infer<TSchema>) => PromiseOr<Infer<TSchema>>;
+
+		schema?: TSchema;
+		validationType?: ValidationType;
+	}
+
+	export type InferedSchemaFromBase<TJson extends Base> = InferOr<
+		ExtractSchema<TJson>,
+		JsonResponse.DefaultSchema
+	>;
+
+	// export type InferedInputSchema<TOptions extends Options> = (TOptions["json"] extends undefined
+	//   ? JsonResponse.DefaultInputSchema
+	//   : InferOr<Exclude<ExtractSchemaFromKey<TOptions["json"], "inputSchema">, undefined>, JsonResponse.DefaultInputSchema>);
+
+	export type InferedSchema<TOptions extends Options> =
+		TOptions["json"] extends undefined
+			? JsonResponse.DefaultSchema
+			: InferOr<
+					Exclude<ExtractSchema<TOptions["json"]>, undefined>,
+					JsonResponse.DefaultSchema
+				>;
+}
+
+export function json<TSchema extends Schema>(
+	opts: JsonOptions.Base<TSchema>
+): JsonOptions.Base<TSchema> {
+	return opts;
+}

package/src/options/meta.ts

@@ -0,0 +1,33 @@
+import type {
+	ExtractSchema,
+	Infer,
+	InferOr,
+	Schema,
+	ValidationType,
+} from "@apisr/schema";
+import type { DefaultMeta } from "@/response/meta";
+import type { FunctionObject } from "@/types";
+import type { Options } from "./base";
+
+export namespace MetaOptions {
+	export interface Base<TSchema extends Schema = Schema> {
+		default?: FunctionObject<Infer<TSchema>, never>;
+		schema?: TSchema;
+		validationType?: ValidationType;
+	}
+
+	export type InferedSchema<TOptions extends Options> =
+		TOptions["meta"] extends undefined
+			? DefaultMeta
+			: InferOr<ExtractSchema<TOptions["meta"]>, DefaultMeta>;
+}
+
+export function meta<TSchema extends Schema>(
+	opts: MetaOptions.Base<TSchema> & {
+		schema?: TSchema;
+	}
+): MetaOptions.Base<TSchema> & {
+	schema?: TSchema;
+} {
+	return opts;
+}

package/src/response/base.ts

@@ -0,0 +1,23 @@
+import type { RawHeaders } from "@/headers";
+
+export type ResponseTypes = "json" | "binary" | "text" | "error";
+
+export namespace BaseResponse {
+  export interface Options {
+    status?: number;
+    statusText?: string;
+    headers?: RawHeaders;
+  }
+
+  export class Base<TPayload> extends Response {
+    public payload: TPayload | undefined;
+
+    constructor(body?: ConstructorParameters<typeof Response>[0], init?: (ResponseInit & { payload: TPayload }) | undefined) {
+      const { payload, ..._init } = init ?? {};
+
+      super(body, _init);
+
+      this.payload = payload;
+    }
+  }
+}

package/src/response/binary/index.ts

@@ -0,0 +1,11 @@
+import type { BaseResponse } from "../base";
+
+export type Binary = Blob | ArrayBuffer | Uint8Array | ReadableStream;
+
+export namespace BinaryResponse {
+  export class Base extends Response {
+  }
+
+  export interface Options extends BaseResponse.Options {
+  }
+}

package/src/response/default.ts

@@ -0,0 +1,8 @@
+import type { ErrorResponse } from "./error";
+
+export interface DefaultResponse<TData = unknown> {
+  success: boolean;
+  error: ErrorResponse.Base<any, any, any> | null;
+  data: TData | null;
+  metadata: Record<string, unknown>;
+}

package/src/response/error/index.ts

@@ -0,0 +1,42 @@
+import type { BaseResponse } from "../base";
+
+export namespace ErrorResponse {
+  export class Base<
+    TName extends string,
+    TMeta extends Record<string, any>,
+    TOutput extends Record<string, any>
+  > extends Error {
+    public override name: TName;
+    public meta: TMeta;
+    public output: TOutput;
+    public status: number;
+    public statusText: string;
+
+    constructor({ meta, name, output, status, statusText }: {
+      // Name of error in response handler
+      name: TName;
+
+      // Meta of response
+      meta: TMeta;
+
+      // Output of handler
+      output: TOutput;
+
+      status: number;
+      statusText: string;
+    }) {
+      super();
+
+      this.status = status;
+      this.statusText = statusText;
+
+      this.name = name;
+      this.meta = meta;
+      this.output = output;
+    }
+  }
+
+
+  export interface Options extends BaseResponse.Options {
+  }
+}

package/src/response/index.ts

@@ -0,0 +1,7 @@
+export * from "./base";
+export * from "./default";
+export * from "./error";
+export * from "./json";
+export * from "./binary";
+export * from "./meta";
+export * from "./text";

package/src/response/json/index.ts

@@ -0,0 +1,44 @@
+import type { BaseResponse } from "../base";
+
+export namespace JsonResponse {
+  export class Base<TOutput> extends Response {
+    private _output: TOutput | undefined;
+
+    constructor(body: ConstructorParameters<typeof Response>[0], _init?: ConstructorParameters<typeof Response>[1] & {
+      output: TOutput;
+    }) {
+      const { output, ...init } = _init ?? {};
+
+      super(body, init);
+
+      this._output = output;
+    }
+
+    get output(): TOutput | undefined {
+      return this._output;
+    }
+
+    override json: () => Promise<TOutput> = () => {
+      return Response.prototype.json.call(this) as Promise<TOutput>;
+    };
+  }
+  // export type Base = Record<string, any> & {
+  //   [responseSymbol]: () => Response;
+  // }
+
+  export interface Options extends BaseResponse.Options {
+  }
+
+  export type DefaultInputSchema = Record<string, any>;
+  export type DefaultSchema = {
+    data: Record<string, any>;
+    success: boolean;
+  };
+
+  export function defaultOnDataOutput(input: DefaultInputSchema): DefaultSchema {
+    return {
+      data: input,
+      success: true
+    }
+  }
+}

package/src/response/meta/index.ts

@@ -0,0 +1,4 @@
+export type DefaultMeta = {
+  requestId: string;
+  timestamp: number;
+}

package/src/response/text/index.ts

@@ -0,0 +1,9 @@
+import type { BaseResponse } from "../base";
+
+export namespace TextResponse {
+  export class Base extends Response {
+  }
+
+  export interface Options extends BaseResponse.Options {
+  }
+}

package/src/symbol.ts

@@ -0,0 +1 @@
+export const responseSymbol = Symbol("_response");

package/src/types.ts

@@ -0,0 +1,9 @@
+export type AnyObject = Record<string, any>;
+export type FunctionObject<TResult extends any, TFnArg = never> = TResult | (
+  (TFnArg extends never
+    ? (() => TResult)
+    : ((arg: TFnArg) => TResult))
+);
+
+export type PromiseOr<T> = PromiseLike<T> | T;
+// export type IfUndefined<> =

package/tests/index.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, test } from "bun:test";
+import { z } from "@apisr/zod";
+import { createResponseHandler } from "@/index";
+
+type TestErrorOutput = {
+	name: string;
+	details: string;
+};
+
+describe("@apisr/response ResponseHandler", () => {
+	test("json() validates output schema, sets content-type and merges headers", () => {
+		const handler = createResponseHandler((options) => ({
+			json: options.json({
+				schema: z.object({
+					msg: z.string(),
+				}),
+				mapData: (input) => ({
+					msg: input?.msg,
+				}),
+				headers: (data) => ({
+					"x-data": data?.msg,
+				}),
+			}),
+		}));
+
+		const res = handler.json({ msg: "hello" }, { headers: { "x-opt": "1" } });
+
+		expect(res).toBeInstanceOf(Response);
+		expect(res.status).toBe(200);
+		expect(res.headers.get("content-type")).toBe("application/json");
+		expect(res.headers.get("x-opt")).toBe("1");
+		expect(res.headers.get("x-data")).toBe("hello");
+	});
+
+	test("text() returns Response with provided body and init options", async () => {
+		const handler = createResponseHandler({});
+		const res = handler.text("ok", { status: 201, headers: { "x-t": "1" } });
+
+		expect(res).toBeInstanceOf(Response);
+		expect(res.status).toBe(201);
+		expect(res.headers.get("x-t")).toBe("1");
+		expect(await res.text()).toBe("ok");
+	});
+
+	test("binary() applies onData, merges headers and returns Response", async () => {
+		const handler = createResponseHandler({
+			binary: {
+				mapData: (data) => data,
+				headers: () => ({
+					"content-type": "application/octet-stream",
+					"x-bin": "1",
+				}),
+			},
+		});
+
+		const body = new Uint8Array([1, 2, 3]);
+		const res = handler.binary(body, {
+			status: 202,
+			headers: { "x-opt": "1" },
+		});
+
+		expect(res).toBeInstanceOf(Response);
+		expect(res.status).toBe(202);
+		expect(res.headers.get("x-opt")).toBe("1");
+		expect(res.headers.get("x-bin")).toBe("1");
+		expect(res.headers.get("content-type")).toBe("application/octet-stream");
+
+		const ab = await res.arrayBuffer();
+		expect(new Uint8Array(ab)).toEqual(body);
+	});
+
+	test("withMeta() validates meta and fail() includes prepared meta", () => {
+		const handler = createResponseHandler({
+			meta: {
+				schema: z.object({
+					raw: z.boolean(),
+					version: z.number().optional(),
+				}),
+				default: { raw: false },
+			},
+			error: {
+				schema: z.object({
+					name: z.string(),
+					details: z.string(),
+				}),
+			},
+		})
+			.defineError("E_META", ({ meta }) => ({
+				name: "E_META",
+				details: String(meta.raw),
+			}))
+			.withMeta({ raw: true });
+
+		const err = handler.fail("E_META");
+		const output = err.output as TestErrorOutput;
+
+		expect(err.name).toBe("E_META");
+		expect(err.meta.raw).toBe(true);
+		expect(output.name).toBe("E_META");
+		expect(output.details).toBe("true");
+	});
+
+	test("defineError() supports static handler and fail() returns its output", () => {
+		const handler = createResponseHandler({
+			error: {
+				schema: z.object({
+					name: z.string(),
+					details: z.string(),
+				}),
+			},
+		}).defineError("STATIC", { name: "STATIC", details: "d" });
+
+		const err = handler.fail("STATIC");
+		const output = err.output as TestErrorOutput;
+		expect(err.name).toBe("STATIC");
+		expect(output).toEqual({ name: "STATIC", details: "d" });
+	});
+
+	test("fail() validates error input schema", () => {
+		const handler = createResponseHandler({
+			error: {
+				schema: z.object({
+					name: z.string(),
+					details: z.string(),
+				}),
+			},
+		}).defineError(
+			"E_INPUT",
+			({ input }) => ({
+				name: "E_INPUT",
+				details: String(input?.raw2),
+			}),
+			{
+				input: z.object({
+					raw2: z.boolean(),
+				}),
+			}
+		);
+
+		const err = handler.fail("E_INPUT", { raw2: true });
+		const output = err.output as unknown as TestErrorOutput;
+		expect(output.details).toBe("true");
+
+		expect(() => handler.fail("E_INPUT", { raw2: "nope" } as any)).toThrow();
+	});
+
+	test("defineError() supports dynamic handler and fail() returns its output", () => {
+		const handler = createResponseHandler({
+			error: {
+				schema: z.object({
+					name: z.string(),
+					details: z.string(),
+				}),
+			},
+		}).defineError(
+			"DYNAMIC",
+			({ input, meta }) => {
+				return {
+					name: "DYNAMIC",
+					details: String(input.raw2),
+				};
+			},
+			{
+				input: z.object({
+					raw2: z.boolean(),
+				}),
+			}
+		);
+
+		const err = handler.fail("DYNAMIC", { raw2: true });
+		const output = err.output as unknown as TestErrorOutput;
+		expect(err.name).toBe("DYNAMIC");
+		expect(output.details).toBe("true");
+	});
+
+	test("withMeta() affects meta for subsequent fail() calls", () => {
+		const handler = createResponseHandler({
+			meta: {
+				schema: z.object({
+					raw: z.boolean(),
+				}),
+				default: { raw: false },
+			},
+			error: {
+				schema: z.object({
+					name: z.string(),
+					details: z.string(),
+				}),
+			},
+		})
+			.defineError("META", ({ meta }) => {
+				return {
+					name: "META",
+					details: String(meta.raw),
+				};
+			})
+			.withMeta({ raw: true });
+
+		const err = handler.fail("META");
+		const output = err.output as TestErrorOutput;
+		expect(err.name).toBe("META");
+		expect(output.details).toBe("true");
+	});
+});

package/tests/json-symbol.test.ts

@@ -0,0 +1,14 @@
+import { test } from "bun:test";
+
+const jsonSymbol = Symbol("_json");
+
+test("json symbol stringify", () => {
+  const obj = {
+    id: 123,
+    [jsonSymbol]: () => new Response()
+  }
+
+  const str = JSON.stringify(obj, null, 2);
+
+  console.log(str);
+})

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	entry: "./src/index.ts",
+	dts: true,
+	format: "esm",
+	outDir: "./dist",
+	clean: true,
+	unbundle: true,
+	noExternal: [/@apisr\/.*/],
+	external: ["zod"],
+});