@thestarweb/star-framework-app-web 0.1.0

package/src/cli/dev-server.ts

@@ -0,0 +1,66 @@
+import {
+	getEnvironmentName,
+	type SFDevHook,
+} from "@thestarweb/star-framework-cli";
+import { addInterceptor, Interceptor } from "../interceptor/index.js";
+import { middlewareToInterceptor } from "../interceptor/index.js";
+
+import type { ViteDevServer } from "vite";
+import {
+	createHttpServer,
+	ParsedPackage,
+} from "@thestarweb/star-framework-web-runtime-node";
+import { dumpRouteType } from "../server/dump-api-type.js";
+import { join } from "path";
+
+export function devServer(html: string): SFDevHook {
+	let server: Awaited<ReturnType<typeof createHttpServer>>;
+	let viteInterceptor: Interceptor;
+	let _vite: ViteDevServer;
+	const context = {
+		root: process.cwd(),
+		static: "",
+		indexHtml: html,
+	};
+	const ins: ParsedPackage = {
+		...context,
+		instances: undefined as any,
+	};
+	const devInterceptor: Interceptor = (req, next) => {
+		return viteInterceptor(req, next);
+	};
+	function handleIns(obj: any) {
+		addInterceptor(devInterceptor, obj._rawObject);
+		const file = join(process.cwd(), "./route-type.ts");
+		_vite?.watcher.unwatch(file);
+		dumpRouteType(file, obj._rawObject);
+		return obj;
+	}
+	return {
+		async onViteServerInited(vite) {
+			viteInterceptor = middlewareToInterceptor(vite.middlewares);
+			// TODO 暂时像用这种“硬核”方式让middlewares使用特定环境
+			vite.environments.client =
+				vite.environments[getEnvironmentName("sf-web", "browser")];
+			_vite = vite;
+			context.indexHtml = await vite.transformIndexHtml("index.html", html);
+		},
+		async start(main) {
+			ins.instances = handleIns(main(context));
+			server = await createHttpServer({
+				instances: [
+					{
+						package: ins,
+					},
+				],
+				port: 3000,
+			});
+		},
+		async hotReload(main) {
+			if (server) {
+				ins.instances = handleIns(main(context));
+				console.log("hot updated");
+			}
+		},
+	};
+}

package/src/cli/index.ts

@@ -0,0 +1,122 @@
+import { type SFPluging } from "@thestarweb/star-framework-cli";
+import { devServer } from "./dev-server.js";
+import { dirname, join, relative } from "path";
+import { writeFile } from "fs/promises";
+import { readFileSync } from "fs";
+import { PackageInfo } from "@thestarweb/star-framework-web-runtime-node";
+import { fileURLToPath } from "url";
+
+export * from "./types.js";
+const __file = fileURLToPath(import.meta.url);
+const __dir = dirname(__file);
+
+export function SFWebPluging({
+	distPath = "./dist/web/",
+	htmlPath = join(__dir, "../../resource/default-index.html"),
+} = {}): SFPluging {
+	const fullDistPath = join(process.cwd(), distPath);
+	const fullUnpackDistPath = join(fullDistPath, ".unpack");
+
+	let html = "";
+	try {
+		html = readFileSync(htmlPath, "utf-8");
+	} catch {
+		throw new Error("未能找到html文件");
+	}
+
+	return {
+		name: "sf-web",
+		mode: {
+			server: {
+				side: ["server"],
+				dev: devServer(html),
+				environments: {
+					build: { outDir: join(fullUnpackDistPath, "server") },
+				},
+				createApp: {
+					import: "@thestarweb/star-framework-app-web",
+					fnName: "createServerFactory",
+				},
+			},
+			browser: {
+				side: ["browser", "client"],
+				environments: {
+					input: "index.html",
+					consumer: "client",
+					build: { outDir: join(fullUnpackDistPath, "browser") },
+					plugins: [{ name: "test" }],
+				},
+				createApp: {
+					import: "@thestarweb/star-framework-app-web",
+					fnName: "createBrowsweInstance",
+				},
+			},
+		},
+		sideOnlyConfig: [
+			{
+				import: "@thestarweb/star-framework-app-web",
+				name: ["Get", "Post", "Put", "Delete"],
+				side: "server",
+				type: "include",
+				whenMethodDeclaration: {
+					enable: true,
+				},
+			},
+			{
+				import: "@thestarweb/star-framework-app-web",
+				name: ["View"],
+				side: "server",
+				type: "include",
+				whenMethodDeclaration: {
+					enable: true,
+					removeMode: { prop: true, body: "throw" },
+				},
+			},
+		],
+		vitePlugin: {
+			name: "sf-web-html",
+			resolveId: {
+				filter: { id: /^index\.html$/ },
+				async handler(id) {
+					return "index.html";
+				},
+			},
+			load: {
+				filter: { id: /^index\.html$/ },
+				handler(id) {
+					return html;
+				},
+			},
+		},
+		async onAllModeBuildEnd(modes, res) {
+			const configFile = join(fullUnpackDistPath, "package-info.json");
+			console.log("正在写入包信息");
+			let packageName = "sf-web",
+				packageVersion = "1.0.0";
+			try {
+				const pJson = JSON.parse(readFileSync("package.json", "utf-8"));
+				pJson.name ?? (packageName = pJson.name);
+				pJson.version ?? (packageVersion = pJson.version);
+			} catch {}
+			await writeFile(
+				configFile,
+				JSON.stringify({
+					"sf-fomate": "1",
+					name: packageName,
+					version: packageVersion,
+					server: {
+						dir: relative(fullUnpackDistPath, res.server.distPath),
+						main: res.server.main[0],
+					},
+					browser: {
+						dir: relative(fullUnpackDistPath, res.browser.distPath),
+						main: res.browser.main[0],
+						style: res.browser.assets.filter((i) => i.endsWith(".css")),
+					},
+				} as PackageInfo),
+			);
+			console.log("正在打包文件");
+			// TODO 打包
+		},
+	};
+}

package/src/cli/types.ts

@@ -0,0 +1,7 @@
+declare global {
+	interface StarFrameworkSideConfig {
+		server: {};
+		browser: {};
+		client: {};
+	}
+}

package/src/cli-helper.ts

@@ -0,0 +1,5 @@
+declare global {
+	interface StarFrameworkSideConfig {
+		server: {};
+	}
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+export { Get, Post, Put, Delete, SubRoute } from "./route/index.js";
+export { Body, Query, Header } from "./params/index.js";
+// @side-only server
+export { SFWebPluging } from "./cli/index.js";
+export { ResponseWithMeta } from "./return-types/index.js";
+export { AddInterceptor, type Interceptor } from "./interceptor/index.js";
+export {
+	View,
+	Layout,
+	HTMLRender,
+	type IRender,
+	RenderContext,
+	type RenderInstance,
+	type WarpRenderInstance,
+	type RenderDataContext,
+	SFDataContext,
+	SFRawDataContext,
+} from "./view/index.js";
+// @side-only server
+export { createServerFactory } from "./server/index.js";
+export { createBrowsweInstance } from "./browser/index.js";
+// @side-only server
+export * from "./cli-helper.js";
+export { SFWebRequest } from "./request/index.js";

package/src/interceptor/index.ts

@@ -0,0 +1,26 @@
+import { getMetadataAll, initMetadata } from "@thestarweb/star-framework-utils";
+import { Interceptor } from "./types.js";
+export * from "./types.js";
+export { middlewareToInterceptor } from "./middleware-to-interceptor/index.js";
+const metaKey = "$sf:app:interceptor";
+export function AddInterceptor(
+	interceptor: Interceptor | Interceptor[],
+): MethodDecorator & ClassDecorator {
+	return function (target?: any, propertyKey?: PropertyKey) {
+		initMetadata(target, metaKey, propertyKey, [] as Interceptor[]).push(
+			...[interceptor].flat(2),
+		);
+	};
+}
+export function addInterceptor(
+	interceptor: Interceptor | Interceptor[],
+	target: any,
+	propertyKey?: PropertyKey,
+) {
+	initMetadata(target, metaKey, propertyKey, [] as Interceptor[]).push(
+		...[interceptor].flat(2),
+	);
+}
+export function getInterceptors(target: object, propertyKey?: PropertyKey) {
+	return getMetadataAll<Interceptor[]>(target, metaKey, propertyKey).flat();
+}

package/src/interceptor/middleware-to-interceptor/index.ts

@@ -0,0 +1,29 @@
+import { ViteDevServer } from "vite";
+import { Interceptor } from "../types.js";
+// @side-only server
+import { IncomingMessage } from "node:http";
+// @side-only server
+import { MookReq } from "./mook-req.js";
+// @side-only server
+import { MookRes } from "./mock-res.js";
+
+export function middlewareToInterceptor(
+	middleware: ViteDevServer["middlewares"],
+): Interceptor {
+	return (req, next) => {
+		return new Promise((resolve, reject) => {
+			try {
+				const _req = new MookReq(req);
+				middleware(_req as any, new MookRes(_req, resolve) as any, async () => {
+					try {
+						resolve(await next(req));
+					} catch (e) {
+						reject(e);
+					}
+				});
+			} catch (e) {
+				reject(e);
+			}
+		});
+	};
+}

package/src/interceptor/middleware-to-interceptor/mock-res.ts

@@ -0,0 +1,255 @@
+import { type OutgoingHttpHeaders } from "node:http";
+import { ResponseWithMeta } from "../../return-types/response-with-meta.js";
+import { type PipeOptions } from "node:stream";
+
+export class MookRes {
+	_transformStream = new TransformStream();
+	_readable: ReadableStream;
+	_writeable: WritableStreamDefaultWriter;
+
+	statusCode = 404;
+	statusMessage = "";
+	strictContentLength = false;
+	headers: Record<string, any> = {};
+	assignSocket(socket: any): void {
+		throw new Error("Method not implemented.");
+	}
+	detachSocket(socket: any): void {
+		throw new Error("Method not implemented.");
+	}
+	writeContinue(callback?: () => void): void {
+		throw new Error("Method not implemented.");
+	}
+	writeEarlyHints(
+		hints: Record<string, string | string[]>,
+		callback?: () => void,
+	): void {
+		throw new Error("Method not implemented.");
+	}
+	writeHead(statusCode: any, statusMessage?: unknown, headers?: any): this {
+		this.statusCode = statusCode;
+		if (headers) this.setHeaders(headers);
+		return this;
+	}
+	writeProcessing(callback?: () => void): void {
+		throw new Error("Method not implemented.");
+	}
+
+	private readonly __sf_send: () => void;
+	constructor(
+		public req: any,
+		callback: (res: ResponseWithMeta) => any,
+	) {
+		this._readable = this._transformStream.readable;
+		this._writeable = this._transformStream.writable.getWriter();
+		this.__sf_send = () => {
+			if (!this.sendDate) {
+				this.sendDate = true;
+				callback(
+					new ResponseWithMeta(this._transformStream.readable, {
+						code: this.statusCode,
+						header: this.getHeaders() as any,
+					}),
+				);
+			}
+		};
+	}
+	chunkedEncoding = false;
+	shouldKeepAlive = true;
+	useChunkedEncodingByDefault = false;
+	sendDate = false;
+	finishe = false;
+	headersSent = false;
+	connection = null;
+	socket = null;
+	setTimeout(msecs: number, callback?: () => void): this {
+		throw new Error("Method not implemented.");
+	}
+	setHeader(name: string, value: number | string | readonly string[]) {
+		this.headers[name] = value;
+		return this;
+	}
+	setHeaders(
+		headers: Headers | Map<string, number | string | readonly string[]>,
+	): this {
+		if (headers instanceof Map) {
+			headers.forEach((value, key) => {
+				this.setHeader(key, value);
+			});
+		} else {
+			this.headers = {
+				...this.headers,
+				...headers,
+			};
+		}
+		return this;
+	}
+	appendHeader(name: string, value: string | readonly string[]): this {
+		if (!this.headers[name]) {
+			this.headers[name] = value;
+		} else {
+			if (!Array.isArray(this.headers[name])) {
+				this.headers[name] = [this.headers[name]];
+			}
+			this.headers[name].push(...(Array.isArray(value) ? value : [value]));
+		}
+		return this;
+	}
+	getHeader(name: string) {
+		return this.headers[name];
+	}
+	getHeaders() {
+		return this.headers;
+	}
+	getHeaderNames() {
+		return Object.keys(this.headers);
+	}
+	hasHeader(name: string) {
+		return name in this.headers;
+	}
+	removeHeader(name: string): void {
+		delete this.headers[name];
+	}
+	addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>) {
+		throw new Error("Method not implemented.");
+	}
+	flushHeaders(): void {
+		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): any {
+		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): any {
+		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.");
+	}
+	writable = true;
+	writableAborted = false;
+	writableEnded = false;
+	writableFinished = false;
+	writableHighWaterMark = 16 * 1024;
+	writableLength = 0;
+	writableObjectMode = false;
+	writableCorked = 0;
+	destroyed = false;
+	closed = false;
+	errored = null;
+	writableNeedDrain = false;
+	_write(
+		chunk: any,
+		encoding: BufferEncoding,
+		callback?: (error?: Error | null) => void,
+	) {
+		this.__sf_send();
+		const p = this._writeable.write(
+			typeof chunk === "string" ? Buffer.from(chunk, encoding) : chunk,
+		);
+		if (callback) {
+			p.then(() => callback());
+			p.catch((e) => callback(e));
+		}
+	}
+	_writev?(
+		chunks: { chunk: any; encoding: BufferEncoding }[],
+		callback: (error?: Error | null) => void,
+	): void {
+		const p = chunks.reduce((p, { chunk, encoding }) => {
+			return p.then(() => this._write(chunk, encoding));
+		}, Promise.resolve());
+		if (callback) {
+			p.then(() => callback());
+			p.catch((e) => callback(e));
+		}
+	}
+	_construct?(callback: (error?: Error | null) => void): void {
+		throw new Error("Method not implemented.");
+	}
+	_destroy(
+		error: Error | null,
+		callback: (error?: Error | null) => void,
+	): void {
+		throw new Error("Method not implemented.");
+	}
+	_final(callback: (error?: Error | null) => void): void {
+		throw new Error("Method not implemented.");
+	}
+	_defaultEncoding: BufferEncoding = "utf-8";
+	write(chunk: unknown, encoding?: any, callback?: any): boolean {
+		if (typeof encoding === "function") {
+			callback = encoding;
+			encoding = undefined;
+		}
+		this._write(chunk, encoding || this._defaultEncoding, callback);
+		return true;
+	}
+	setDefaultEncoding(encoding: BufferEncoding) {
+		this._defaultEncoding = encoding;
+		return this;
+	}
+	end(chunk?: unknown, encoding?: unknown, cb?: unknown) {
+		this.writableEnded = true;
+		this.writableFinished = true;
+		if (typeof chunk !== "function") {
+			this.write(chunk, encoding, cb);
+		} else {
+			this.__sf_send();
+			chunk?.();
+		}
+		this._writeable.close();
+		return this;
+	}
+	cork(): void {
+		this.writableCorked++;
+	}
+	uncork(): void {
+		this.writableCorked--;
+	}
+	destroy(error?: Error): this {
+		return this;
+	}
+	async [Symbol.asyncDispose](): Promise<void> {}
+	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.");
+	}
+}