@fragno-dev/core 0.0.1

package/src/api/request-input-context.test.ts

@@ -0,0 +1,437 @@
+import { test, expect, describe } from "vitest";
+import { RequestInputContext } from "./request-input-context";
+import { FragnoApiValidationError } from "./api";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+// Mock schema implementations for testing
+const createMockSchema = (shouldPass: boolean, returnValue?: unknown): StandardSchemaV1 => ({
+  "~standard": {
+    version: 1,
+    vendor: "test",
+    validate: async (value: unknown) => {
+      if (shouldPass) {
+        return { value: returnValue ?? value };
+      } else {
+        return {
+          issues: [
+            {
+              kind: "validation",
+              type: "string",
+              input: value,
+              expected: "string",
+              received: typeof value,
+              message: "Expected string",
+              path: [],
+            },
+          ],
+        };
+      }
+    },
+  },
+});
+
+const validStringSchema = createMockSchema(true, "validated-string");
+const invalidSchema = createMockSchema(false);
+
+describe("RequestContext", () => {
+  test("Should be able to destructure RequestContext class instance", () => {
+    const ctx = new RequestInputContext({
+      method: "GET",
+      path: "/",
+      pathParams: {},
+      searchParams: new URLSearchParams(),
+      body: undefined,
+    });
+
+    const { path, pathParams, query: searchParams, input, rawBody: body } = ctx;
+
+    expect(path).toBe("/");
+    expect(pathParams).toEqual({});
+    expect(searchParams).toBeInstanceOf(URLSearchParams);
+    expect(input).toBeUndefined();
+    expect(body).toBeUndefined();
+  });
+
+  test("Should support body in constructor", () => {
+    const jsonBody = { test: "data" };
+    const ctx = new RequestInputContext({
+      method: "POST",
+      path: "/api/test",
+      pathParams: {},
+      searchParams: new URLSearchParams(),
+      body: jsonBody,
+    });
+
+    expect(ctx.rawBody).toEqual(jsonBody);
+  });
+
+  test("Should support FormData body", () => {
+    const formData = new FormData();
+    formData.append("key", "value");
+
+    const ctx = new RequestInputContext({
+      path: "/api/form",
+      pathParams: {},
+      searchParams: new URLSearchParams(),
+      body: formData,
+      method: "POST",
+    });
+
+    expect(ctx.rawBody).toBe(formData);
+  });
+
+  test("Should support Blob body", () => {
+    const blob = new Blob(["test content"], { type: "text/plain" });
+
+    const ctx = new RequestInputContext({
+      path: "/api/upload",
+      pathParams: {},
+      searchParams: new URLSearchParams(),
+      body: blob,
+      method: "POST",
+    });
+
+    expect(ctx.rawBody).toBe(blob);
+  });
+
+  test("Should create RequestContext with fromRequest static method", async () => {
+    const request = new Request("https://example.com/api/test", {
+      method: "POST",
+      body: JSON.stringify({ test: "data" }),
+    });
+
+    const bodyData = { test: "data" };
+    const ctx = await RequestInputContext.fromRequest({
+      request,
+      method: "POST",
+      path: "/api/test",
+      pathParams: {},
+    });
+
+    expect(ctx.path).toBe("/api/test");
+    expect(ctx.rawBody).toEqual(bodyData);
+  });
+
+  test("Should create RequestContext with fromSSRContext static method", () => {
+    const bodyData = { ssr: "data" };
+    const ctx = RequestInputContext.fromSSRContext({
+      method: "POST",
+      path: "/api/ssr",
+      pathParams: {},
+      body: bodyData,
+    });
+
+    expect(ctx.path).toBe("/api/ssr");
+    expect(ctx.rawBody).toEqual(bodyData);
+  });
+
+  describe("Input handling", () => {
+    test("Should return undefined input when no input schema is provided", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: { test: "data" },
+        method: "POST",
+      });
+
+      expect(ctx.input).toBeUndefined();
+    });
+
+    test("Should return input object when input schema is provided", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: { test: "data" },
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      expect(ctx.input).toBeDefined();
+      expect(ctx.input?.schema).toBe(validStringSchema);
+      expect(typeof ctx.input.valid).toBe("function");
+    });
+
+    test("Should validate input successfully with valid data", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: "test string",
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      const result = await ctx.input?.valid();
+      expect(result).toBe("validated-string");
+    });
+
+    test("Should throw validation error with invalid data", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: 123, // Invalid for string schema
+        inputSchema: invalidSchema,
+        method: "POST",
+      });
+
+      await expect(ctx.input.valid()).rejects.toThrow(FragnoApiValidationError);
+    });
+
+    test("Should throw validation error with detailed issues", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: 123,
+        inputSchema: invalidSchema,
+        method: "POST",
+      });
+
+      try {
+        await ctx.input?.valid();
+        expect.fail("Should have thrown validation error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(FragnoApiValidationError);
+        const validationError = error as FragnoApiValidationError;
+        expect(validationError.issues).toHaveLength(1);
+        expect(validationError.issues[0]).toMatchObject({
+          kind: "validation",
+          type: "string",
+          input: 123,
+          expected: "string",
+          received: "number",
+          message: "Expected string",
+        });
+      }
+    });
+
+    test("Should skip validation when shouldValidateInput is false", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: 123,
+        inputSchema: invalidSchema,
+        shouldValidateInput: false,
+        method: "POST",
+      });
+
+      // Should return the raw body without validation when validation is disabled
+      const result = await ctx.input?.valid();
+      expect(result).toBe(123);
+    });
+
+    test("Should throw error when trying to validate FormData", async () => {
+      const formData = new FormData();
+      formData.append("key", "value");
+
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: formData,
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      await expect(ctx.input.valid()).rejects.toThrow(
+        "Schema validation is only supported for JSON data, not FormData or Blob",
+      );
+    });
+
+    test("Should throw error when trying to validate Blob", async () => {
+      const blob = new Blob(["test content"], { type: "text/plain" });
+
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: blob,
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      await expect(ctx.input.valid()).rejects.toThrow(
+        "Schema validation is only supported for JSON data, not FormData or Blob",
+      );
+    });
+
+    test("Should handle null body", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: null,
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      const result = await ctx.input.valid();
+      expect(result).toBe("validated-string");
+    });
+
+    test("Should handle undefined body", async () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        body: undefined,
+        inputSchema: validStringSchema,
+        method: "POST",
+      });
+
+      const result = await ctx.input.valid();
+      expect(result).toBe("validated-string");
+    });
+  });
+
+  describe("Validation configuration", () => {
+    test("Should default shouldValidateInput to true", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        inputSchema: validStringSchema,
+        method: "POST",
+        body: undefined,
+      });
+
+      // We can't directly access the private field, but we can test the behavior
+      expect(ctx.input).toBeDefined();
+    });
+
+    test("Should respect explicit shouldValidateInput true", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        inputSchema: validStringSchema,
+        shouldValidateInput: true,
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.input).toBeDefined();
+    });
+
+    test("Should respect shouldValidateInput false", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        inputSchema: validStringSchema,
+        shouldValidateInput: false,
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.input).toBeDefined();
+    });
+
+    test("Should disable validation in SSR context by default", () => {
+      const ctx = RequestInputContext.fromSSRContext({
+        path: "/test",
+        pathParams: {},
+        // inputSchema is not available in SSR context, but validation is disabled
+        method: "POST",
+        body: undefined,
+      });
+
+      // This tests that shouldValidateInput is set to false in SSR context
+      expect(ctx.input).toBeUndefined();
+    });
+
+    test("Should pass through shouldValidateInput from fromRequest", async () => {
+      const request = new Request("https://example.com/api/test");
+      const ctx = await RequestInputContext.fromRequest({
+        request,
+        path: "/test",
+        pathParams: {},
+        inputSchema: validStringSchema,
+        shouldValidateInput: false,
+        method: "POST",
+      });
+
+      expect(ctx.input).toBeDefined();
+    });
+  });
+
+  describe("Edge cases and error conditions", () => {
+    test("Should handle empty path params", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.pathParams).toEqual({});
+    });
+
+    test("Should handle empty search params", () => {
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams: new URLSearchParams(),
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.query.toString()).toBe("");
+    });
+
+    test("Should handle search params with values", () => {
+      const searchParams = new URLSearchParams("?key=value&another=test");
+      const ctx = new RequestInputContext({
+        path: "/test",
+        pathParams: {},
+        searchParams,
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.query.get("key")).toBe("value");
+      expect(ctx.query.get("another")).toBe("test");
+    });
+
+    test("Should extract search params from request URL in fromRequest", async () => {
+      const request = new Request("https://example.com/api/test?param=value");
+      const ctx = await RequestInputContext.fromRequest({
+        request,
+        path: "/test",
+        pathParams: {},
+        method: "POST",
+      });
+
+      expect(ctx.query.get("param")).toBe("value");
+    });
+
+    test("Should use default empty search params in fromSSRContext when not provided", () => {
+      const ctx = RequestInputContext.fromSSRContext({
+        path: "/test",
+        pathParams: {},
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.query.toString()).toBe("");
+    });
+
+    test("Should use provided search params in fromSSRContext", () => {
+      const searchParams = new URLSearchParams("?ssr=true");
+      const ctx = RequestInputContext.fromSSRContext({
+        path: "/test",
+        pathParams: {},
+        searchParams,
+        method: "POST",
+        body: undefined,
+      });
+
+      expect(ctx.query.get("ssr")).toBe("true");
+    });
+  });
+});

package/src/api/request-input-context.ts

@@ -0,0 +1,201 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { ExtractPathParams } from "./internal/path";
+import { FragnoApiValidationError, type HTTPMethod } from "./api";
+
+export type RequestBodyType =
+  | unknown // JSON
+  | FormData
+  | Blob
+  | null
+  | undefined;
+
+export class RequestInputContext<
+  TPath extends string = string,
+  TInputSchema extends StandardSchemaV1 | undefined = undefined,
+> {
+  readonly #path: TPath;
+  readonly #method: string;
+  readonly #pathParams: ExtractPathParams<TPath>;
+  readonly #searchParams: URLSearchParams;
+  readonly #body: RequestBodyType;
+  readonly #inputSchema: TInputSchema | undefined;
+  readonly #shouldValidateInput: boolean;
+
+  constructor(config: {
+    path: TPath;
+    method: string;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams: URLSearchParams;
+    body: RequestBodyType;
+
+    request?: Request;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+  }) {
+    this.#path = config.path;
+    this.#method = config.method;
+    this.#pathParams = config.pathParams;
+    this.#searchParams = config.searchParams;
+    this.#body = config.body;
+    this.#inputSchema = config.inputSchema;
+    this.#shouldValidateInput = config.shouldValidateInput ?? true;
+  }
+
+  /**
+   * Create a RequestContext from a Request object for server-side handling
+   */
+  static async fromRequest<
+    TPath extends string,
+    TInputSchema extends StandardSchemaV1 | undefined = undefined,
+  >(config: {
+    request: Request;
+    method: string;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+  }): Promise<RequestInputContext<TPath, TInputSchema>> {
+    const url = new URL(config.request.url);
+
+    // Clone the request to avoid consuming the body stream
+    // TODO: Probably we should just cache the result instead
+    const request = config.request.clone();
+
+    // TODO: Support other body types other than json
+    const json = request.body instanceof ReadableStream ? await request.json() : undefined;
+
+    return new RequestInputContext({
+      method: config.method,
+      path: config.path,
+      pathParams: config.pathParams,
+      searchParams: url.searchParams,
+      body: json,
+      inputSchema: config.inputSchema,
+      shouldValidateInput: config.shouldValidateInput,
+    });
+  }
+
+  /**
+   * Create a RequestContext for server-side rendering contexts (no Request object)
+   */
+  static fromSSRContext<
+    TPath extends string,
+    TInputSchema extends StandardSchemaV1 | undefined = undefined,
+  >(
+    config:
+      | {
+          method: "GET";
+          path: TPath;
+          pathParams: ExtractPathParams<TPath>;
+          searchParams?: URLSearchParams;
+        }
+      | {
+          method: Exclude<HTTPMethod, "GET">;
+          path: TPath;
+          pathParams: ExtractPathParams<TPath>;
+          searchParams?: URLSearchParams;
+          body: RequestBodyType;
+          inputSchema?: TInputSchema;
+        },
+  ): RequestInputContext<TPath, TInputSchema> {
+    return new RequestInputContext({
+      method: config.method,
+      path: config.path,
+      pathParams: config.pathParams,
+      searchParams: config.searchParams ?? new URLSearchParams(),
+      body: "body" in config ? config.body : undefined,
+      inputSchema: "inputSchema" in config ? config.inputSchema : undefined,
+      shouldValidateInput: false, // No input validation in SSR context
+    });
+  }
+
+  // TODO(Wilco): We should support reading/modifying headers here.
+  /**
+   * The HTTP method as string (e.g., `GET`, `POST`)
+   */
+  get method(): string {
+    return this.#method;
+  }
+  /**
+   * The matched route path (e.g., `/users/:id`)
+   * @remarks `string`
+   */
+  get path(): TPath {
+    return this.#path;
+  }
+  /**
+   * Extracted path parameters as object (e.g., `{ id: '123' }`)
+   * @remarks `Record<string, string>`
+   */
+  get pathParams(): ExtractPathParams<TPath> {
+    return this.#pathParams;
+  }
+  /**
+   * [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+   * @remarks `URLSearchParams`
+   */
+  get query(): URLSearchParams {
+    return this.#searchParams;
+  }
+  // TODO: Should probably remove this
+  /**
+   * @internal
+   */
+  get rawBody(): RequestBodyType {
+    return this.#body;
+  }
+  /**
+   * Input validation context (only if inputSchema is defined)
+   * @remarks `InputContext`
+   */
+  get input(): TInputSchema extends undefined
+    ? undefined
+    : {
+        schema: TInputSchema;
+        valid: () => Promise<
+          TInputSchema extends StandardSchemaV1
+            ? StandardSchemaV1.InferOutput<TInputSchema>
+            : unknown
+        >;
+      } {
+    if (!this.#inputSchema) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return undefined as any;
+    }
+
+    return {
+      schema: this.#inputSchema,
+      valid: async () => {
+        if (!this.#shouldValidateInput) {
+          // In SSR context, return the body directly without validation
+          return this.#body;
+        }
+
+        return this.#validateInput();
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+  }
+
+  async #validateInput(): Promise<
+    TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : never
+  > {
+    if (!this.#inputSchema) {
+      throw new Error("No input schema defined for this route");
+    }
+
+    if (this.#body instanceof FormData || this.#body instanceof Blob) {
+      throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
+    }
+
+    const result = await this.#inputSchema["~standard"].validate(this.#body);
+
+    if (result.issues) {
+      throw new FragnoApiValidationError("Validation failed", result.issues);
+    }
+
+    return result.value as TInputSchema extends StandardSchemaV1
+      ? StandardSchemaV1.InferOutput<TInputSchema>
+      : never;
+  }
+}