@rexeus/typeweaver-server 0.5.1

package/dist/index.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+var path = require('node:path');
+var node_url = require('node:url');
+var typeweaverGen = require('@rexeus/typeweaver-gen');
+var typeweaverCore = require('@rexeus/typeweaver-core');
+var Case = require('case');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var Case__default = /*#__PURE__*/_interopDefault(Case);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var RouterGenerator = class {
+  /**
+   * Generates router files for all resources in the given context.
+   *
+   * @param context - The generator context containing resources, templates, and output configuration
+   */
+  static generate(context) {
+    const moduleDir2 = path__default.default.dirname(node_url.fileURLToPath(importMetaUrl));
+    const templateFile = path__default.default.join(moduleDir2, "templates", "Router.ejs");
+    for (const [entityName, entityResource] of Object.entries(
+      context.resources.entityResources
+    )) {
+      this.writeRouter(
+        entityName,
+        templateFile,
+        entityResource.operations,
+        context
+      );
+    }
+  }
+  static writeRouter(entityName, templateFile, operationResources, context) {
+    const pascalCaseEntityName = Case__default.default.pascal(entityName);
+    const outputDir = path__default.default.join(context.outputDir, entityName);
+    const outputPath = path__default.default.join(outputDir, `${pascalCaseEntityName}Router.ts`);
+    const operations = operationResources.filter((resource) => resource.definition.method !== typeweaverCore.HttpMethod.HEAD).map((resource) => this.createOperationData(resource)).sort((a, b) => this.compareRoutes(a, b));
+    const content = context.renderTemplate(templateFile, {
+      coreDir: typeweaverGen.Path.relative(outputDir, context.outputDir),
+      entityName,
+      pascalCaseEntityName,
+      operations
+    });
+    const relativePath = path__default.default.relative(context.outputDir, outputPath);
+    context.writeFile(relativePath, content);
+  }
+  static createOperationData(resource) {
+    const className = Case__default.default.pascal(resource.definition.operationId);
+    return {
+      className,
+      handlerName: `handle${className}Request`,
+      method: resource.definition.method,
+      path: resource.definition.path
+    };
+  }
+  static compareRoutes(a, b) {
+    const aSegments = a.path.split("/").filter((s) => s);
+    const bSegments = b.path.split("/").filter((s) => s);
+    if (aSegments.length !== bSegments.length) {
+      return aSegments.length - bSegments.length;
+    }
+    for (let i = 0; i < aSegments.length; i++) {
+      const aSegment = aSegments[i];
+      const bSegment = bSegments[i];
+      const aIsParam = aSegment.startsWith(":");
+      const bIsParam = bSegment.startsWith(":");
+      if (aIsParam !== bIsParam) {
+        return aIsParam ? 1 : -1;
+      }
+      if (aSegment !== bSegment) {
+        return aSegment.localeCompare(bSegment);
+      }
+    }
+    return this.getMethodPriority(a.method) - this.getMethodPriority(b.method);
+  }
+  static METHOD_PRIORITY = {
+    GET: 1,
+    POST: 2,
+    PUT: 3,
+    PATCH: 4,
+    DELETE: 5,
+    OPTIONS: 6,
+    HEAD: 7
+  };
+  static getMethodPriority(method) {
+    return this.METHOD_PRIORITY[method] ?? 999;
+  }
+};
+
+// src/index.ts
+var moduleDir = path__default.default.dirname(node_url.fileURLToPath(importMetaUrl));
+var ServerPlugin = class extends typeweaverGen.BasePlugin {
+  name = "server";
+  /**
+   * Generates the server runtime and typed routers for all resources.
+   *
+   * @param context - The generator context
+   */
+  generate(context) {
+    const libSourceDir = path__default.default.join(moduleDir, "lib");
+    this.copyLibFiles(context, libSourceDir, this.name);
+    RouterGenerator.generate(context);
+  }
+};
+
+module.exports = ServerPlugin;

package/dist/index.d.cts

@@ -0,0 +1,20 @@
+import { BasePlugin, GeneratorContext } from '@rexeus/typeweaver-gen';
+
+/**
+ * Typeweaver plugin that generates a lightweight, dependency-free server
+ * with built-in routing and middleware support.
+ *
+ * Copies the runtime library files (`TypeweaverApp`, `TypeweaverRouter`, `Router`,
+ * `Middleware`, etc.) and generates typed router classes for each resource.
+ */
+declare class ServerPlugin extends BasePlugin {
+    name: string;
+    /**
+     * Generates the server runtime and typed routers for all resources.
+     *
+     * @param context - The generator context
+     */
+    generate(context: GeneratorContext): void;
+}
+
+export { ServerPlugin as default };

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { BasePlugin, GeneratorContext } from '@rexeus/typeweaver-gen';
+
+/**
+ * Typeweaver plugin that generates a lightweight, dependency-free server
+ * with built-in routing and middleware support.
+ *
+ * Copies the runtime library files (`TypeweaverApp`, `TypeweaverRouter`, `Router`,
+ * `Middleware`, etc.) and generates typed router classes for each resource.
+ */
+declare class ServerPlugin extends BasePlugin {
+    name: string;
+    /**
+     * Generates the server runtime and typed routers for all resources.
+     *
+     * @param context - The generator context
+     */
+    generate(context: GeneratorContext): void;
+}
+
+export { ServerPlugin as default };

package/dist/index.js

@@ -0,0 +1,101 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BasePlugin, Path } from '@rexeus/typeweaver-gen';
+import { HttpMethod } from '@rexeus/typeweaver-core';
+import Case from 'case';
+
+// src/index.ts
+var RouterGenerator = class {
+  /**
+   * Generates router files for all resources in the given context.
+   *
+   * @param context - The generator context containing resources, templates, and output configuration
+   */
+  static generate(context) {
+    const moduleDir2 = path.dirname(fileURLToPath(import.meta.url));
+    const templateFile = path.join(moduleDir2, "templates", "Router.ejs");
+    for (const [entityName, entityResource] of Object.entries(
+      context.resources.entityResources
+    )) {
+      this.writeRouter(
+        entityName,
+        templateFile,
+        entityResource.operations,
+        context
+      );
+    }
+  }
+  static writeRouter(entityName, templateFile, operationResources, context) {
+    const pascalCaseEntityName = Case.pascal(entityName);
+    const outputDir = path.join(context.outputDir, entityName);
+    const outputPath = path.join(outputDir, `${pascalCaseEntityName}Router.ts`);
+    const operations = operationResources.filter((resource) => resource.definition.method !== HttpMethod.HEAD).map((resource) => this.createOperationData(resource)).sort((a, b) => this.compareRoutes(a, b));
+    const content = context.renderTemplate(templateFile, {
+      coreDir: Path.relative(outputDir, context.outputDir),
+      entityName,
+      pascalCaseEntityName,
+      operations
+    });
+    const relativePath = path.relative(context.outputDir, outputPath);
+    context.writeFile(relativePath, content);
+  }
+  static createOperationData(resource) {
+    const className = Case.pascal(resource.definition.operationId);
+    return {
+      className,
+      handlerName: `handle${className}Request`,
+      method: resource.definition.method,
+      path: resource.definition.path
+    };
+  }
+  static compareRoutes(a, b) {
+    const aSegments = a.path.split("/").filter((s) => s);
+    const bSegments = b.path.split("/").filter((s) => s);
+    if (aSegments.length !== bSegments.length) {
+      return aSegments.length - bSegments.length;
+    }
+    for (let i = 0; i < aSegments.length; i++) {
+      const aSegment = aSegments[i];
+      const bSegment = bSegments[i];
+      const aIsParam = aSegment.startsWith(":");
+      const bIsParam = bSegment.startsWith(":");
+      if (aIsParam !== bIsParam) {
+        return aIsParam ? 1 : -1;
+      }
+      if (aSegment !== bSegment) {
+        return aSegment.localeCompare(bSegment);
+      }
+    }
+    return this.getMethodPriority(a.method) - this.getMethodPriority(b.method);
+  }
+  static METHOD_PRIORITY = {
+    GET: 1,
+    POST: 2,
+    PUT: 3,
+    PATCH: 4,
+    DELETE: 5,
+    OPTIONS: 6,
+    HEAD: 7
+  };
+  static getMethodPriority(method) {
+    return this.METHOD_PRIORITY[method] ?? 999;
+  }
+};
+
+// src/index.ts
+var moduleDir = path.dirname(fileURLToPath(import.meta.url));
+var ServerPlugin = class extends BasePlugin {
+  name = "server";
+  /**
+   * Generates the server runtime and typed routers for all resources.
+   *
+   * @param context - The generator context
+   */
+  generate(context) {
+    const libSourceDir = path.join(moduleDir, "lib");
+    this.copyLibFiles(context, libSourceDir, this.name);
+    RouterGenerator.generate(context);
+  }
+};
+
+export { ServerPlugin as default };

package/dist/lib/Errors.ts

@@ -0,0 +1,38 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+/**
+ * Error thrown when the request body cannot be parsed.
+ * Caught by TypeweaverApp to return a 400 Bad Request response.
+ */
+export class BodyParseError extends Error {
+  public override readonly name = "BodyParseError";
+}
+
+/**
+ * Error thrown when the request body exceeds the configured size limit.
+ * Caught by TypeweaverApp to return a 413 Payload Too Large response.
+ */
+export class PayloadTooLargeError extends Error {
+  public override readonly name = "PayloadTooLargeError";
+  public constructor(
+    public readonly contentLength: number,
+    public readonly maxBodySize: number
+  ) {
+    super(
+      `Request body too large: ${contentLength} bytes exceeds limit of ${maxBodySize} bytes`
+    );
+  }
+}
+
+/**
+ * Error thrown when the response body cannot be serialized to JSON.
+ * Typically caused by circular references or non-serializable values.
+ */
+export class ResponseSerializationError extends Error {
+  public override readonly name = "ResponseSerializationError";
+}

package/dist/lib/FetchApiAdapter.ts

@@ -0,0 +1,362 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
+
+import type {
+  HttpMethod,
+  IHttpBody,
+  IHttpHeader,
+  IHttpQuery,
+  IHttpRequest,
+  IHttpResponse,
+} from "@rexeus/typeweaver-core";
+import {
+  BodyParseError,
+  PayloadTooLargeError,
+  ResponseSerializationError,
+} from "./Errors";
+
+export type FetchApiAdapterOptions = {
+  readonly maxBodySize?: number;
+};
+
+/**
+ * Converts between Fetch API `Request`/`Response` and typeweaver's
+ * `IHttpRequest`/`IHttpResponse` at the server boundary.
+ *
+ * This is the **only** place where framework-specific types exist.
+ * Everything inside the middleware pipeline and handlers works
+ * exclusively with typeweaver's native types.
+ *
+ * Works with all runtimes that support the Fetch API:
+ * Bun, Deno, Node.js (>=18), Cloudflare Workers.
+ */
+export class FetchApiAdapter {
+  private static readonly DEFAULT_MAX_BODY_SIZE = 1_048_576; // 1 MB
+
+  private readonly maxBodySize: number;
+
+  public constructor(options?: FetchApiAdapterOptions) {
+    this.maxBodySize =
+      options?.maxBodySize ?? FetchApiAdapter.DEFAULT_MAX_BODY_SIZE;
+  }
+
+  /**
+   * Converts a Fetch API Request to an IHttpRequest.
+   *
+   * Accepts an optional pre-parsed URL to avoid redundant parsing.
+   *
+   * @param request - The Fetch API Request object
+   * @param url - Optional pre-parsed URL object to avoid double parsing
+   * @returns Promise resolving to an IHttpRequest
+   * @throws BodyParseError when the request body is malformed
+   */
+  public async toRequest(request: Request, url?: URL): Promise<IHttpRequest> {
+    const parsedUrl = url ?? new URL(request.url);
+
+    return {
+      method: request.method.toUpperCase() as HttpMethod,
+      path: parsedUrl.pathname,
+      header: FetchApiAdapter.extractHeaders(request.headers),
+      query: FetchApiAdapter.extractQueryParams(parsedUrl),
+      body: await this.parseRequestBody(request),
+    };
+  }
+
+  /**
+   * Converts an IHttpResponse to a Fetch API Response.
+   *
+   * @param response - The IHttpResponse to convert
+   * @returns A Fetch API Response object
+   */
+  public toResponse(response: IHttpResponse): Response {
+    const { statusCode, body, header } = response;
+
+    return new Response(FetchApiAdapter.serializeResponseBody(body), {
+      status: statusCode,
+      headers: FetchApiAdapter.buildResponseHeaders(header, body),
+    });
+  }
+
+  private static extractMediaType(contentType: string | null): string | null {
+    if (!contentType) return null;
+    return contentType.split(";")[0]!.trim().toLowerCase();
+  }
+
+  private static isJsonContentType(contentType: string | null): boolean {
+    const mediaType = FetchApiAdapter.extractMediaType(contentType);
+    if (!mediaType) return false;
+    return mediaType === "application/json" || mediaType.endsWith("+json");
+  }
+
+  private static isTextContentType(contentType: string | null): boolean {
+    const mediaType = FetchApiAdapter.extractMediaType(contentType);
+    if (!mediaType) return false;
+    return mediaType.startsWith("text/");
+  }
+
+  private static isFormUrlencodedContentType(
+    contentType: string | null
+  ): boolean {
+    return (
+      FetchApiAdapter.extractMediaType(contentType) ===
+      "application/x-www-form-urlencoded"
+    );
+  }
+
+  private static isMultipartFormDataContentType(
+    contentType: string | null
+  ): boolean {
+    return (
+      FetchApiAdapter.extractMediaType(contentType) === "multipart/form-data"
+    );
+  }
+
+  private static extractHeaders(headers: Headers): IHttpHeader {
+    const result: Record<string, string | string[]> = Object.create(null);
+    headers.forEach((value, key) => {
+      FetchApiAdapter.addMultiValue(result, key, value);
+    });
+    return Object.keys(result).length > 0 ? result : undefined;
+  }
+
+  private static extractQueryParams(url: URL): IHttpQuery {
+    const result: Record<string, string | string[]> = Object.create(null);
+    url.searchParams.forEach((value, key) => {
+      FetchApiAdapter.addMultiValue(result, key, value);
+    });
+    return Object.keys(result).length > 0 ? result : undefined;
+  }
+
+  private async parseRequestBody(request: Request): Promise<IHttpBody> {
+    if (!request.body) return undefined;
+
+    const checkedRequest = await this.enforceBodySizeLimit(request);
+    const contentType = checkedRequest.headers.get("content-type");
+
+    if (FetchApiAdapter.isJsonContentType(contentType)) {
+      return FetchApiAdapter.parseJsonBody(checkedRequest);
+    }
+    if (FetchApiAdapter.isTextContentType(contentType)) {
+      return FetchApiAdapter.parseTextBody(checkedRequest);
+    }
+    if (FetchApiAdapter.isFormUrlencodedContentType(contentType)) {
+      return FetchApiAdapter.parseFormUrlencodedBody(checkedRequest);
+    }
+    if (FetchApiAdapter.isMultipartFormDataContentType(contentType)) {
+      return FetchApiAdapter.parseMultipartBody(checkedRequest);
+    }
+    return FetchApiAdapter.parseRawBody(checkedRequest);
+  }
+
+  private static async parseJsonBody(request: Request): Promise<IHttpBody> {
+    try {
+      const text = await request.text();
+      return JSON.parse(text, (key, value) => {
+        if (key === "__proto__") return undefined;
+        return value;
+      });
+    } catch (error) {
+      throw new BodyParseError("Invalid JSON in request body", {
+        cause: error,
+      });
+    }
+  }
+
+  private static async parseTextBody(request: Request): Promise<IHttpBody> {
+    try {
+      return await request.text();
+    } catch (error) {
+      throw new BodyParseError("Failed to read text request body", {
+        cause: error,
+      });
+    }
+  }
+
+  private static async parseFormUrlencodedBody(
+    request: Request
+  ): Promise<IHttpBody> {
+    let text: string;
+    try {
+      text = await request.text();
+    } catch (error) {
+      throw new BodyParseError("Failed to read form-urlencoded request body", {
+        cause: error,
+      });
+    }
+
+    const result: Record<string, string | string[]> = Object.create(null);
+    new URLSearchParams(text).forEach((value, key) => {
+      FetchApiAdapter.addMultiValue(result, key, value);
+    });
+    return result;
+  }
+
+  private static async parseMultipartBody(
+    request: Request
+  ): Promise<IHttpBody> {
+    let formData: FormData;
+    try {
+      formData = await request.formData();
+    } catch (error) {
+      throw new BodyParseError("Invalid multipart/form-data in request body", {
+        cause: error,
+      });
+    }
+
+    const result: Record<string, string | File | (string | File)[]> =
+      Object.create(null);
+    formData.forEach((value, key) => {
+      const existing = result[key];
+      if (existing === undefined) {
+        result[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    });
+    return result;
+  }
+
+  private static async parseRawBody(request: Request): Promise<IHttpBody> {
+    try {
+      const text = await request.text();
+      return text || undefined;
+    } catch (error) {
+      throw new BodyParseError("Failed to read request body", {
+        cause: error,
+      });
+    }
+  }
+
+  private async enforceBodySizeLimit(request: Request): Promise<Request> {
+    const contentLengthHeader = request.headers.get("content-length");
+    if (contentLengthHeader === null) {
+      return this.readBodyWithLimit(request);
+    }
+
+    const contentLength = Number(contentLengthHeader);
+    if (!Number.isFinite(contentLength) || contentLength < 0) {
+      return this.readBodyWithLimit(request);
+    }
+
+    if (contentLength > this.maxBodySize) {
+      throw new PayloadTooLargeError(contentLength, this.maxBodySize);
+    }
+
+    return request;
+  }
+
+  private async readBodyWithLimit(request: Request): Promise<Request> {
+    if (!request.body) return request;
+
+    const reader = request.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let totalBytes = 0;
+
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        totalBytes += value.byteLength;
+        if (totalBytes > this.maxBodySize) {
+          await reader.cancel();
+          throw new PayloadTooLargeError(totalBytes, this.maxBodySize);
+        }
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    return new Request(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: FetchApiAdapter.concatChunks(chunks, totalBytes),
+    });
+  }
+
+  private static concatChunks(
+    chunks: Uint8Array[],
+    totalBytes: number
+  ): Uint8Array {
+    const buffer = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      buffer.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return buffer;
+  }
+
+  private static serializeResponseBody(
+    body: any
+  ): string | ArrayBuffer | Blob | null {
+    if (body === undefined || body === null) return null;
+    if (typeof body === "string") return body;
+    if (body instanceof Blob || body instanceof ArrayBuffer) return body;
+
+    try {
+      return JSON.stringify(body);
+    } catch (error) {
+      throw new ResponseSerializationError(
+        "Failed to serialize response body to JSON",
+        { cause: error }
+      );
+    }
+  }
+
+  private static buildResponseHeaders(
+    header?: IHttpHeader,
+    body?: any
+  ): Headers {
+    const headers = new Headers();
+
+    if (header) {
+      for (const [key, value] of Object.entries(header)) {
+        if (value === undefined) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) headers.append(key, v);
+        } else {
+          headers.set(key, String(value));
+        }
+      }
+    }
+
+    if (!headers.has("content-type") && FetchApiAdapter.isJsonBody(body)) {
+      headers.set("content-type", "application/json");
+    }
+
+    return headers;
+  }
+
+  private static isJsonBody(body: any): boolean {
+    return (
+      body !== undefined &&
+      body !== null &&
+      typeof body !== "string" &&
+      !(body instanceof Blob) &&
+      !(body instanceof ArrayBuffer)
+    );
+  }
+
+  private static addMultiValue(
+    record: Record<string, string | string[]>,
+    key: string,
+    value: string
+  ): void {
+    const existing = record[key];
+    if (existing === undefined) {
+      record[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      record[key] = [existing, value];
+    }
+  }
+}