@thestarweb/star-framework-app-web 0.1.0

package/src/server/body/json.ts

@@ -0,0 +1,217 @@
+import {
+	ParamType,
+	ParamTypeEnum,
+} from "@thestarweb/star-framework-param-helper";
+import { mergeUint8Array, ReaderHelper } from "./helper.js";
+import { bodyParse } from "./types.js";
+
+const charCodeQuote = '"'.charCodeAt(0);
+const charCodeOpenCornerBracket = "[".charCodeAt(0);
+const charCodeCloseCornerBracket = "]".charCodeAt(0);
+const charCodeOpenCurlyBracket = "{".charCodeAt(0);
+const charCodeCloseCurlyBracket = "}".charCodeAt(0);
+const charCodeReverseSlash = "\\".charCodeAt(0);
+const charCodeTab = "\t".charCodeAt(0);
+const charCodeReturn = "\r".charCodeAt(0);
+const charCodeNewLine = "\n".charCodeAt(0);
+const charCodeSpace = " ".charCodeAt(0);
+const charCodesSkip = [
+	charCodeTab,
+	charCodeReturn,
+	charCodeNewLine,
+	charCodeSpace,
+];
+const charCodeR = "r".charCodeAt(0);
+const charCodeN = "n".charCodeAt(0);
+const charCodeT = "t".charCodeAt(0);
+const charCodeU = "u".charCodeAt(0);
+const charCodeF = "f".charCodeAt(0);
+const charCode0 = "0".charCodeAt(0);
+const charCode9 = "9".charCodeAt(0);
+const charCodeDot = ".".charCodeAt(0);
+const charCodeComma = ",".charCodeAt(0);
+const charCodeColon = ":".charCodeAt(0);
+const decoder = new TextDecoder();
+
+let defAny: ParamType = { type: ParamTypeEnum.Any };
+export const JSONBody: bodyParse = (headrer, targetType) => {
+	if (headrer["content-type"]?.startsWith("application/json")) {
+		return (stream) => {
+			const helper = new ReaderHelper(stream);
+			function charError(char: number, expectation?: string[]) {
+				throw new Error(
+					`unexpectation ${String.fromCharCode(char)}(char code ${char})${expectation ? `, expectation ${expectation.join(",")}` : ""}, at ${helper.totalIndex}`,
+				);
+			}
+			async function match(head: string, find: string) {
+				const dataString = await helper.readAsString(find.length, decoder);
+				if (dataString !== find) {
+					throw new Error(
+						`unexpectation ${head}${dataString}, expectation ${head}${find})}, at ${helper.totalIndex}`,
+					);
+				}
+			}
+			async function readString() {
+				const strings: string[] = [];
+				let loop = true;
+				while (loop) {
+					await helper.streamReadUntil((buff) => {
+						for (var i = 0; i < buff.length; i++) {
+							const item = buff[i];
+							if (item == charCodeQuote) {
+								strings.push(
+									decoder.decode(buff.subarray(0, i), { stream: true }),
+								);
+								loop = false;
+								return i + 1;
+							}
+							if (item === charCodeReverseSlash) {
+								strings.push(
+									decoder.decode(buff.subarray(0, i), { stream: true }),
+								);
+								return i + 1;
+							}
+						}
+						strings.push(decoder.decode(buff, { stream: true }));
+						return -1;
+					});
+					if (loop) {
+						const char = await helper.readChar();
+						switch (char) {
+							case charCodeReverseSlash:
+								strings.push("\\");
+								break;
+
+							case charCodeT:
+								strings.push("\t");
+								break;
+							case charCodeR:
+								strings.push("\r");
+								break;
+							case charCodeN:
+								strings.push("\n");
+								break;
+
+							case charCodeU:
+								// t = charCodeReturn;
+								throw new Error("暂时不支持\\u编码");
+								break;
+							default:
+								charError(char, ["r", "n", "t", "\\"]);
+						}
+					}
+				}
+				return strings.join("");
+			}
+			async function readArray(targetType: ParamType, path: string[]) {
+				let t: ParamType | ParamType[] = defAny;
+				if (targetType.type == ParamTypeEnum.Array) {
+					t = targetType.items;
+				}
+				const res = [];
+
+				await helper.skipChar(charCodesSkip);
+				if ((await helper.viewChar()) === charCodeCloseCornerBracket) {
+					await helper.readChar();
+					return [];
+				}
+				while (true) {
+					const ret = await start(Array.isArray(t) ? t[res.length] : t, [
+						...path,
+						`${res.length}`,
+					]);
+					res.push(ret);
+					await helper.skipChar(charCodesSkip);
+					const nextChar = await helper.readChar();
+					if (nextChar === charCodeCloseCornerBracket) {
+						return res;
+					}
+					if (nextChar != charCodeComma) {
+						charError(nextChar, [",", "]"]);
+					}
+				}
+			}
+			async function readObject(targetType: ParamType, path: string[]) {
+				const obj: any = {};
+				let needComma = false;
+				while (true) {
+					await helper.skipChar(charCodesSkip);
+					const char = await helper.readChar();
+					if (char == charCodeCloseCurlyBracket) {
+						return obj;
+					}
+					if (needComma) {
+						if (char === charCodeComma) {
+							needComma = false;
+						} else {
+							charError(char, [",", "}"]);
+						}
+					} else {
+						if (char === charCodeQuote) {
+							const key = await readString();
+							await helper.skipChar(charCodesSkip);
+
+							const char = await helper.readChar();
+							if (char !== charCodeColon) charError(char, [":"]);
+							obj[key] = await start(defAny, [...path, key]);
+							needComma = true;
+						} else {
+							charError(char, ['"', "}"]);
+						}
+					}
+				}
+			}
+			async function start(
+				targetType: ParamType,
+				path: string[] = [],
+				endFlag?: number,
+			): Promise<any> {
+				await helper.skipChar(charCodesSkip);
+				const char = await helper.readChar();
+				switch (char) {
+					case charCodeQuote:
+						return await readString();
+					case charCodeOpenCornerBracket:
+						return await readArray(targetType, path);
+					case charCodeOpenCurlyBracket:
+						return await readObject(targetType, path);
+
+					case charCodeN: {
+						await match("n", "ull");
+						return null;
+					}
+					case charCodeT:
+						await match("t", "rue");
+						return true;
+					case charCodeF:
+						await match("f", "alse");
+						return false;
+					default:
+						if (char >= charCode0 && char <= charCode9) {
+							const text = [String.fromCharCode(char)];
+							const hasDot = false;
+							await helper.streamReadUntil((arr) => {
+								for (let i = 0; i < arr.length; i++) {
+									const item = arr[i];
+									if (item >= charCode0 && item <= charCode9) {
+										continue;
+									}
+									if (arr[i] === charCodeDot && !hasDot) {
+										continue;
+									}
+									text.push(decoder.decode(arr.subarray(0, i)));
+									return i;
+								}
+								text.push(decoder.decode(arr));
+								return -1;
+							}, false);
+							return parseFloat(text.join(""));
+						}
+						charError(char, ["{", "[", '"', "null", "true", "false", "number"]);
+				}
+			}
+			return start(targetType);
+		};
+	}
+	return null;
+};

package/src/server/body/types.ts

@@ -0,0 +1,6 @@
+import { ParamType } from "@thestarweb/star-framework-param-helper";
+
+export type bodyParse = (
+	header: Record<string, any>,
+	paramType: ParamType,
+) => ((stream: ReadableStream<Uint8Array>) => Promise<any>) | null;

package/src/server/dump-api-type.ts

@@ -0,0 +1,64 @@
+import { getConfig } from "@thestarweb/star-framework-cli";
+import { getFlatRoute } from "../route/index.js";
+import { dirname, relative } from "path";
+import { writeFile } from "fs/promises";
+import { paramMeta } from "../params/index.js";
+import { dumpTSType } from "@thestarweb/star-framework-param-helper";
+
+export async function dumpRouteType(file: string, obj: object) {
+	const routes = getFlatRoute(obj);
+	const config = getConfig()!;
+	const data = [];
+	let rPath = relative(dirname(file), config.entry).replaceAll("\\", "/");
+	if (!rPath.startsWith(".")) {
+		rPath = `./${rPath}`;
+	}
+	data.push(`import App from ${JSON.stringify(rPath)};`);
+	data.push(`declare module '@thestarweb/star-framework-app-web'{`);
+	data.push(`\tinterface ProjectApi{`);
+	Object.keys(routes).forEach((type) => {
+		if (type === "__SF:NotFind") return;
+		data.push(`\t\t${type}:{`);
+		routes[type as keyof typeof routes]!.forEach((meta, path) => {
+			if (!meta.finalRoute) return;
+			data.push(`\t\t\t${JSON.stringify(path)}:{`);
+			const { obj, propertyKey } = meta.finalRoute;
+			if (typeof (obj as any)[propertyKey] === "function") {
+				data.push(`\t\t\t\tprop:{`);
+				const param = paramMeta.getParamMetadata(
+					meta.finalRoute.obj,
+					meta.finalRoute.propertyKey,
+				);
+				if (param.types.body) {
+					data.push(
+						`\t\t\t\t\tbody${param.types.body.required ? "" : "?"}:${dumpTSType(param.types.body.type)},`,
+					);
+				}
+				if (param.types.query) {
+					data.push(
+						`\t\t\t\t\tquery${param.types.query.required ? "" : "?"}:${dumpTSType(param.types.query.type)},`,
+					);
+				}
+				if (param.types.header) {
+					data.push(
+						`\t\t\t\t\theader${param.types.header.required ? "" : "?"}:${dumpTSType(param.types.header.type)},`,
+					);
+				}
+				data.push(`\t\t\t\t},`);
+				data.push(
+					`\t\t\t\treturn:ReturnType<App${meta.allRoute.map((r) => `[${JSON.stringify(r.propertyKey)}]`).join("")}>`,
+				);
+			} else {
+				data.push(`\t\t\t\tprop:{},`);
+				data.push(
+					`\t\t\t\treturn:App${meta.allRoute.map((r) => `[${JSON.stringify(r.propertyKey)}]`).join("")}`,
+				);
+			}
+			data.push(`\t\t\t},`);
+		});
+		data.push(`\t\t}`);
+	});
+	data.push(`\t}`);
+	data.push(`}`);
+	await writeFile(file, data.join("\n"));
+}

package/src/server/index.ts

@@ -0,0 +1,113 @@
+import { PassThrough, Readable } from "stream";
+import { parse } from "qs";
+import { paramMeta } from "../params/index.js";
+import { ResponseWithMeta } from "../return-types/index.js";
+import { PassThroughReadable } from "./utils/pass-through-readable.js";
+import { getInterceptors, Interceptor } from "../interceptor/index.js";
+import { parseRoute } from "../route/index.js";
+import { createServerRender } from "../view/utils/index.js";
+import { CallProp } from "./types.js";
+import {
+	ServerInstance,
+	ServerRuntimeContext,
+} from "@thestarweb/star-framework-web-runtime-node";
+import { Method } from "../route/types.js";
+import { JSONBody } from "./body/json.js";
+
+export function createServerFactory(object: any) {
+	const handles = [JSONBody];
+	return (context: ServerRuntimeContext) => {
+		const routes = parseRoute(object);
+		const serverRender = createServerRender(context);
+		const ins: ServerInstance = {
+			async onRequert(method, url, reqHeader, rawBody, context) {
+				const urlObj =
+					typeof url === "string" ? new URL(url, "http://127.0.0.1/") : url;
+				const route = routes(method as Method, urlObj.pathname);
+
+				const interceptors: Interceptor[] = route.allRoute.flatMap((info) =>
+					getInterceptors(info.obj),
+				);
+
+				interceptors.unshift(serverRender);
+
+				let body: any = null;
+				let call: (
+					prop: CallProp,
+				) => ResponseWithMeta | Promise<ResponseWithMeta> = () =>
+					new ResponseWithMeta(null, { code: 404 });
+
+				if (route.finalRoute) {
+					const { obj, propertyKey } = route.finalRoute;
+
+					interceptors.push(...getInterceptors(obj, propertyKey));
+
+					if (typeof (obj as any)[propertyKey] === "function") {
+						const paramType = paramMeta.getParamMetadata(obj, propertyKey);
+						if (paramType.types.body) {
+							for (const h of handles) {
+								const handle = h(reqHeader, paramType.types.body.type);
+								if (handle) {
+									body = await handle(rawBody);
+									break;
+								}
+							}
+						}
+
+						call = async (req: CallProp) => {
+							const rawData = await paramMeta.call(obj, propertyKey, req);
+							return ResponseWithMeta.isResponseWithMeta(rawData)
+								? rawData
+								: new ResponseWithMeta(rawData);
+						};
+					} else {
+						call = () => new ResponseWithMeta((obj as any)[propertyKey]);
+					}
+				}
+
+				const handle = interceptors.reduceRight<
+					(prop: CallProp) => ResponseWithMeta | Promise<ResponseWithMeta>
+				>((next, handle) => (req) => handle(req, next), call);
+				const {
+					data,
+					code = 200,
+					header = {},
+				} = await handle({
+					body,
+					header: reqHeader,
+					query: parse(urlObj.search),
+					url: urlObj,
+					method: method as Method,
+					route,
+				});
+				let res: ReadableStream | Readable | null;
+				if (data instanceof ReadableStream) {
+					res = data;
+				} else if (data instanceof TransformStream) {
+					res = data.readable;
+				} else if (data instanceof Readable) {
+					res = data;
+				} else if (data instanceof PassThrough) {
+					res = new PassThroughReadable(data);
+				} else if (data === null || typeof data === "undefined") {
+					res = null;
+				} else if (header["content-type"]?.includes?.("text")) {
+					res = Readable.from(data?.toString() || "");
+				} else {
+					if (!header["content-type"]) {
+						header["content-type"] = "application/json";
+					}
+					res = Readable.from(JSON.stringify(data));
+				}
+				return {
+					code,
+					header,
+					res,
+				};
+			},
+			// @ts-ignore
+			_rawObject: object,
+		};
+		return ins;
+	};
+}

package/src/server/types.ts

@@ -0,0 +1,11 @@
+import { paramMeta } from "../params/index.js";
+import { RouteType } from "../route/index.js";
+import { Method } from "../route/types.js";
+
+export type CallProp<M extends Method = Method> = Parameters<
+	typeof paramMeta.call
+>[2] & {
+	url: URL;
+	method: M;
+	route: RouteType<M>;
+};

package/src/server/utils/pass-through-readable.ts

@@ -0,0 +1,10 @@
+import { PassThrough, Readable } from "stream";
+
+export class PassThroughReadable extends Readable {
+	constructor(private readonly p: PassThrough) {
+		super();
+	}
+	_read(size: number): void {
+		return this.p.read(size);
+	}
+}

package/src/view/const.ts

@@ -0,0 +1 @@
+export const routeTagName = "sf-route";

package/src/view/data-context/conetext.ts

@@ -0,0 +1,59 @@
+export class SFDataContext<T> {
+	private constructor(private _root: SFRawDataContext<T>) {}
+	get value() {
+		return this._root.value;
+	}
+	private callbacks = new Set<(newValue: T) => void>();
+	private children = new Set<SFDataContext<T>>();
+	fock() {
+		return this._root.createChild();
+	}
+	watch(callback: (newValue: T) => void, updateNow = false) {
+		if (this.callbacks.size === 0)
+			// @ts-ignore 2341
+			this._root.children.add(this);
+		this.callbacks.add(callback);
+		if (updateNow) callback(this.value);
+	}
+	distory() {
+		this._root.distoryChild(this);
+	}
+}
+export class SFRawDataContext<T> {
+	constructor(private _value: T) {}
+	get value() {
+		return this._value;
+	}
+	update(newValue: T) {
+		this._value = newValue;
+		const called = new Set();
+		this.children.forEach((i) => {
+			(i as any).callbacks.forEach((c: any) => {
+				if (!called.has(c)) {
+					called.add(c);
+					c(newValue);
+				}
+			});
+		});
+	}
+	private children = new Set<SFDataContext<T>>();
+	createChild() {
+		const child: SFDataContext<T> =
+			// @ts-ignore
+			new SFDataContext(this);
+		return child;
+	}
+	distoryChild(child: SFDataContext<T>) {
+		this.children.delete(child);
+	}
+}
+export function forkDataContextRecord<T extends Record<keyof T, any>>(
+	data: T,
+): T {
+	return Object.fromEntries(
+		Object.entries(data).map(([k, context]) => [
+			k,
+			context instanceof SFDataContext ? context.fock() : context,
+		]),
+	) as T;
+}

package/src/view/data-context/index.ts

@@ -0,0 +1,18 @@
+import { SFWebRequest } from "../../request/index.js";
+import { RouteType } from "../../route/index.js";
+import { SFDataContext } from "./conetext.js";
+export * from "./conetext.js";
+export interface SystemRenderDataContext {
+	route: SFDataContext<RouteType<"GET">>;
+	request: SFWebRequest;
+	baseUrl: string;
+}
+export interface UserRenderDataContext extends Record<
+	string,
+	SFDataContext<any>
+> {}
+
+export interface RenderDataContext {
+	system: SystemRenderDataContext;
+	user: UserRenderDataContext;
+}

package/src/view/html/create-element.ts

@@ -0,0 +1,20 @@
+import { HTMLVElement, HTMLVNode, VNodeType } from "./types.js";
+
+export function createElement(
+	type: string,
+	prop: any,
+	...children: (HTMLVNode | HTMLVNode[])[]
+): HTMLVElement {
+	return {
+		type: VNodeType.Element,
+		tagName: type,
+		attributes: prop,
+		children: children.flat(),
+	};
+}
+export function createDoctypeElement(): HTMLVNode {
+	return {
+		type: VNodeType.Outher,
+		text: "<!DOCTYPE html>",
+	};
+}

package/src/view/html/index.ts

@@ -0,0 +1,3 @@
+export { renderVDomToString } from "./render-v-dom-to-string.js";
+export { parseHtmlToVDom } from "./parse-html-to-v-dom.js";
+export * from "./create-element.js";