@thestarweb/star-framework-app-web 0.1.0

package/src/interceptor/middleware-to-interceptor/mook-req.ts

@@ -0,0 +1,218 @@
+import { IncomingHttpHeaders } from "node:http";
+import {
+	Duplex,
+	PipeOptions,
+	Readable,
+	ReadableIteratorOptions,
+	ReadableOperatorOptions,
+} from "node:stream";
+import { CallProp } from "../../server/types.js";
+import { Abortable } from "node:events";
+import { ByteReadableStream } from "node:stream/iter";
+import { WritableStream, TransformStream } from "node:stream/web";
+
+export class MookReq {
+	constructor(req: CallProp) {
+		this.headers = req.header;
+		this.headersDistinct = req.header;
+		this.rawHeaders = [];
+		this.url = req.url.pathname + req.url.search;
+		this.method = req.method;
+	}
+	destroy(error?: Error): this {
+		throw new Error("Method not implemented.");
+	}
+	addListener(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	emit(eventName: unknown, ...args: unknown[]): boolean {
+		throw new Error("Method not implemented.");
+	}
+	listenerCount(eventName: unknown, listener?: unknown): number {
+		throw new Error("Method not implemented.");
+	}
+	listeners(eventName: unknown) {
+		throw new Error("Method not implemented.");
+	}
+	off(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	on(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	once(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	prependListener(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	prependOnceListener(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	rawListeners(eventName: unknown) {
+		throw new Error("Method not implemented.");
+	}
+	removeAllListeners(eventName?: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	removeListener(eventName: unknown, listener: unknown): this {
+		throw new Error("Method not implemented.");
+	}
+	readableAborted = false;
+	readable = false;
+	readableDidRead = true;
+	readableEncoding = null;
+	readableEnded = true;
+	readableFlowing = false;
+	readableHighWaterMark = 16 * 1024;
+	readableLength = 0;
+	readableObjectMode = false;
+	destroyed = false;
+	closed = false;
+	errored = null;
+	_construct?(callback: (error?: Error | null) => void): void {
+		throw new Error("Method not implemented.");
+	}
+	_read(size: number): void {
+		throw new Error("Method not implemented.");
+	}
+	read(size?: number) {
+		throw new Error("Method not implemented.");
+	}
+	setEncoding(encoding: BufferEncoding): this {
+		throw new Error("Method not implemented.");
+	}
+	pause(): this {
+		throw new Error("Method not implemented.");
+	}
+	resume(): this {
+		throw new Error("Method not implemented.");
+	}
+	isPaused(): boolean {
+		throw new Error("Method not implemented.");
+	}
+	unpipe(destination?: NodeJS.WritableStream): this {
+		throw new Error("Method not implemented.");
+	}
+	unshift(chunk: any, encoding?: BufferEncoding): void {
+		throw new Error("Method not implemented.");
+	}
+	wrap(stream: NodeJS.ReadableStream): this {
+		throw new Error("Method not implemented.");
+	}
+	push(chunk: any, encoding?: BufferEncoding): boolean {
+		throw new Error("Method not implemented.");
+	}
+	compose(
+		stream:
+			| NodeJS.WritableStream
+			| WritableStream
+			| TransformStream
+			| ((source: any) => void),
+		options?: Abortable,
+	): Duplex {
+		throw new Error("Method not implemented.");
+	}
+	iterator(options?: ReadableIteratorOptions): NodeJS.AsyncIterator<any> {
+		throw new Error("Method not implemented.");
+	}
+	map(
+		fn: (data: any, options?: Abortable) => any,
+		options?: ReadableOperatorOptions,
+	): Readable {
+		throw new Error("Method not implemented.");
+	}
+	filter(
+		fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+		options?: ReadableOperatorOptions,
+	): Readable {
+		throw new Error("Method not implemented.");
+	}
+	forEach(
+		fn: (data: any, options?: Abortable) => void | Promise<void>,
+		options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
+	): Promise<void> {
+		throw new Error("Method not implemented.");
+	}
+	toArray(options?: Abortable): Promise<any[]> {
+		throw new Error("Method not implemented.");
+	}
+	some(
+		fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+		options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
+	): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	find(fn: unknown, options?: unknown) {
+		throw new Error("Method not implemented.");
+	}
+	every(
+		fn: (data: any, options?: Abortable) => boolean | Promise<boolean>,
+		options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
+	): Promise<boolean> {
+		throw new Error("Method not implemented.");
+	}
+	flatMap(
+		fn: (data: any, options?: Abortable) => any,
+		options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">,
+	): Readable {
+		throw new Error("Method not implemented.");
+	}
+	drop(limit: number, options?: Abortable): Readable {
+		throw new Error("Method not implemented.");
+	}
+	take(limit: number, options?: Abortable): Readable {
+		throw new Error("Method not implemented.");
+	}
+	reduce(fn: unknown, initial?: unknown, options?: unknown): any {
+		throw new Error("Method not implemented.");
+	}
+	_destroy(
+		error: Error | null,
+		callback: (error?: Error | null) => void,
+	): void {
+		throw new Error("Method not implemented.");
+	}
+	[Symbol.asyncIterator](): NodeJS.AsyncIterator<any> {
+		throw new Error("Method not implemented.");
+	}
+	[Symbol.asyncDispose](): Promise<void> {
+		throw new Error("Method not implemented.");
+	}
+	pipe<T extends NodeJS.WritableStream>(
+		destination: T,
+		options?: PipeOptions,
+	): T {
+		throw new Error("Method not implemented.");
+	}
+	eventNames(): (string | symbol)[] {
+		throw new Error("Method not implemented.");
+	}
+	getMaxListeners(): number {
+		throw new Error("Method not implemented.");
+	}
+	setMaxListeners(n: number): this {
+		throw new Error("Method not implemented.");
+	}
+	aborted = false;
+	httpVersion = "1.1";
+	httpVersionMajor = 1;
+	httpVersionMinor = 1;
+	complete = false;
+	connection = null as any;
+	socket = null as any;
+	headers: IncomingHttpHeaders;
+	headersDistinct: NodeJS.Dict<string[]>;
+	rawHeaders: string[];
+	trailers: NodeJS.Dict<string> = {};
+	trailersDistinct = {};
+	rawTrailers = [];
+	setTimeout(msecs: number, callback?: () => void): this {
+		throw new Error("Method not implemented.");
+	}
+	signal: AbortSignal = null as any;
+	method?: string | undefined;
+	url?: string | undefined;
+	statusCode?: number | undefined;
+	statusMessage?: string | undefined;
+}

package/src/interceptor/types.ts

@@ -0,0 +1,7 @@
+import { ResponseWithMeta } from "../return-types/response-with-meta.js";
+import { CallProp } from "../server/types.js";
+
+export type Interceptor = (
+	req: CallProp,
+	next: (req: CallProp) => ResponseWithMeta | Promise<ResponseWithMeta>,
+) => ResponseWithMeta | Promise<ResponseWithMeta>;

package/src/params/index.ts

@@ -0,0 +1,12 @@
+import {
+	ParamMetaHelper,
+	RootParamType,
+} from "@thestarweb/star-framework-param-helper";
+export const paramMeta = new ParamMetaHelper("http", {
+	body: RootParamType.Any,
+	header: RootParamType.SingleObject,
+	query: RootParamType.Any,
+});
+export const Body = paramMeta.createDecorator("body");
+export const Header = paramMeta.createDecorator("header");
+export const Query = paramMeta.createDecorator("query");

package/src/request/index.ts

@@ -0,0 +1,65 @@
+interface Prop {
+	body?: any;
+	query?: any;
+	header?: Record<string, string>;
+	param?: any;
+}
+type APIType = Record<Method, { [k: string]: { prop: Prop; return: any } }>;
+declare module "@thestarweb/star-framework-app-web" {
+	interface ProjectApi extends APIType {}
+}
+import { ProjectApi } from "@thestarweb/star-framework-app-web";
+import { Method } from "../route/types.js";
+import { stringify } from "qs";
+
+export class SFWebRequest<API extends APIType = ProjectApi> {
+	constructor(public readonly baseUrl: string = "/") {}
+	private async _request(
+		method: Method,
+		path: string,
+		prop: Prop,
+	): Promise<any> {
+		let url = path.startsWith("self:")
+			? path.replace(/^self:\//, this.baseUrl)
+			: path;
+		if (prop.query) {
+			url += stringify(prop.query);
+		}
+		const res = await fetch(url, {
+			method,
+			body: JSON.stringify(prop.body),
+			headers: { "content-type": "application/json", ...prop.header },
+		});
+		if (!res.ok) {
+			throw new Error("request fail");
+		}
+		if (res.headers.get("content-type") === "application/json") {
+			return await res.json();
+		}
+		return res;
+	}
+	async get<P extends string & keyof API["GET"]>(
+		path: `self:${P}`,
+		prop: API["GET"][P]["prop"],
+	): Promise<API["GET"][P]["return"]> {
+		return await this._request("GET", path as string, prop);
+	}
+	async post<P extends keyof ProjectApi["POST"]>(
+		path: `self:${P}`,
+		prop: API["POST"][P]["prop"],
+	): Promise<API["POST"][P]["return"]> {
+		return await this._request("POST", path as string, prop);
+	}
+	async put<P extends keyof ProjectApi["PUT"]>(
+		path: `self:${P}`,
+		prop: API["PUT"][P]["prop"],
+	): Promise<API["PUT"][P]["return"]> {
+		return await this._request("PUT", path as string, prop);
+	}
+	async delete<P extends keyof ProjectApi["DELETE"]>(
+		path: `self:${P}`,
+		prop: API["DELETE"][P]["prop"],
+	): Promise<API["DELETE"][P]["return"]> {
+		return await this._request("PUT", path as string, prop);
+	}
+}

package/src/return-types/index.ts

@@ -0,0 +1 @@
+export * from "./response-with-meta.js";

package/src/return-types/response-with-meta.ts

@@ -0,0 +1,17 @@
+export class ResponseWithMeta {
+	code?: number;
+	header?: Record<string, string | string[]>;
+	data: any;
+	constructor(data: any, meta?: Partial<Omit<ResponseWithMeta, "data">>) {
+		Object.assign(this, meta);
+		this.data = data;
+		this.__ResponseWithMetaFlag = ResponseWithMeta.__ResponseWithMetaFlag;
+		Object.freeze(this);
+	}
+	public readonly __ResponseWithMetaFlag: string;
+	private static readonly __ResponseWithMetaFlag = "ResponseWithMeta";
+	static isResponseWithMeta(data: any): data is ResponseWithMeta {
+		if (!data || typeof data !== "object") return false;
+		return data.__ResponseWithMetaFlag === this.__ResponseWithMetaFlag;
+	}
+}

package/src/route/index.ts

@@ -0,0 +1,43 @@
+import {
+	RouteMetadata,
+	type RouteMetadataRouteType,
+} from "@thestarweb/star-framework-route";
+import {
+	CommonRouteOption,
+	DeleteRouteOption,
+	GetRouteOption,
+	Method,
+	PostRouteOption,
+	PutRouteOption,
+	SubRouteOption,
+} from "./types.js";
+
+const routeMetadata = new RouteMetadata<
+	Method,
+	CommonRouteOption,
+	{
+		POST: PostRouteOption;
+		GET: GetRouteOption;
+		PUT: PutRouteOption;
+		DELETE: DeleteRouteOption;
+	},
+	SubRouteOption
+>("web");
+export type RouteType<M extends Method> = RouteMetadataRouteType<
+	typeof routeMetadata,
+	M
+>;
+
+export const Get = routeMetadata.route("GET");
+export const Post = routeMetadata.route("POST");
+export const Put = routeMetadata.route("PUT");
+export const Delete = routeMetadata.route("DELETE");
+export const SubRoute = routeMetadata.subRoute.bind(routeMetadata);
+
+export function getFlatRoute(obj: object) {
+	return routeMetadata.routeFinderFlat(obj);
+}
+
+export function parseRoute(obj: object) {
+	return routeMetadata.parse(obj);
+}

package/src/route/types.ts

@@ -0,0 +1,11 @@
+import { ViewInfo } from "../view/index.js";
+
+export type Method = "GET" | "POST" | "PUT" | "DELETE";
+export interface CommonRouteOption {}
+export interface GetRouteOption {
+	view: ViewInfo;
+}
+export interface PostRouteOption {}
+export interface PutRouteOption {}
+export interface DeleteRouteOption {}
+export interface SubRouteOption {}

package/src/server/body/helper.ts

@@ -0,0 +1,110 @@
+export class ReaderHelper {
+	reader: ReadableStreamDefaultReader<Uint8Array>;
+	constructor(rawStream: ReadableStream<Uint8Array>) {
+		this.reader = rawStream.getReader();
+	}
+	buff: Uint8Array | null = null;
+	done = false;
+	totalIndex = 0;
+	async _readFromRaw(errorOnEOF = true) {
+		if (this.buff) {
+			const { buff } = this;
+			this.buff = null;
+			return buff;
+		}
+		const res = await this.reader.read();
+		if (res.done) {
+			this.done = true;
+			if (errorOnEOF) throw new Error("EOF");
+		}
+		return res.value!;
+	}
+	async streamReadUntil(read: (arr: Uint8Array) => number, errorOnEOF = true) {
+		while (true) {
+			const buff = await this._readFromRaw(errorOnEOF);
+			if (!buff) return;
+			const index = read(buff);
+			if (index === 0) {
+				this.buff = buff;
+				return;
+			} else if (index > 0 && index < buff.length) {
+				this.buff = buff.subarray(index);
+				return;
+			} else if (index === buff.length) {
+				this.buff = null;
+				return;
+			}
+		}
+	}
+	async streamReadLength(
+		length: number,
+		callback: (block: Uint8Array) => void,
+	) {
+		return this.streamReadUntil((block) => {
+			if (length <= block.length) {
+				callback(block.subarray(0, length));
+				return length;
+			}
+			callback(block);
+			length -= block.length;
+			return -1;
+		});
+	}
+	async readAsABuff(length: number) {
+		const res = new Uint8Array(length);
+		let offset = 0;
+		this.streamReadLength(length, (block) => {
+			res.set(block, offset);
+			offset += block.length;
+		});
+		return res;
+	}
+	async readAsString(length: number, decoder: TextDecoder) {
+		const s: string[] = [];
+		await this.streamReadLength(length, (block) => {
+			s.push(decoder.decode(block, { stream: true }));
+		});
+		return s.join("");
+	}
+	async readChar() {
+		let res = 0;
+		await this.streamReadUntil((arr) => {
+			if (arr.length > 0) {
+				res = arr[0];
+				return 1;
+			}
+			return -1;
+		});
+		return res;
+	}
+	async viewChar() {
+		let res = 0;
+		await this.streamReadUntil((arr) => {
+			if (arr.length > 0) {
+				res = arr[0];
+				return 0;
+			}
+			return -1;
+		});
+		return res;
+	}
+	async skipChar(char: number[]) {
+		await this.streamReadUntil((buff) => {
+			for (let i = 0; i < buff.length; i++) {
+				if (!char.includes(buff[i])) {
+					return i;
+				}
+			}
+			return -1;
+		}, false);
+	}
+}
+export function mergeUint8Array(data: Uint8Array[]) {
+	const ret = new Uint8Array(data.reduce((size, a) => size + a.length, 0));
+	let offset = 0;
+	for (const arr of data) {
+		ret.set(arr, offset);
+		offset += arr.length;
+	}
+	return ret;
+}