@apisr/response 0.0.1 → 0.0.3

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;
 }

package/src/options/index.ts

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

package/src/response/base.ts

@@ -3,21 +3,24 @@ 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 interface Options {
+		headers?: RawHeaders;
+		status?: number;
+		statusText?: string;
+	}
 
-  export class Base<TPayload> extends Response {
-    public payload: TPayload | undefined;
+	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 ?? {};
+		constructor(
+			body?: ConstructorParameters<typeof Response>[0],
+			init?: (ResponseInit & { payload: TPayload }) | undefined
+		) {
+			const { payload, ..._init } = init ?? {};
 
-      super(body, _init);
+			super(body, _init);
 
-      this.payload = payload;
-    }
-  }
+			this.payload = payload;
+		}
+	}
 }

package/src/response/binary/index.ts

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

package/src/response/default.ts

@@ -1,8 +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>;
+	data: TData | null;
+	error: ErrorResponse.Base<any, any, any> | null;
+	metadata: Record<string, unknown>;
+	success: boolean;
 }

package/src/response/error/index.ts

@@ -1,42 +1,46 @@
 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 {
-  }
+	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

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

package/src/response/json/index.ts

@@ -1,44 +1,48 @@
 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
-    }
-  }
+	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

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

package/src/response/text/index.ts

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

package/src/types.ts

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

package/tests/json-symbol.test.ts

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