npm - @smuzi/http-client - Versions diffs - 0.0.1 - Mend

@smuzi/http-client 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/LICENSE +21 -0
package/README.md +18 -0
package/build/base.d.ts +32 -0
package/build/base.js +100 -0
package/build/connection.d.ts +3 -0
package/build/connection.js +1 -0
package/build/index.d.ts +2 -0
package/build/index.js +2 -0
package/package.json +48 -0
package/src/base.ts +186 -0
package/src/connection.ts +4 -0
package/src/index.ts +2 -0
package/tests/.env +3 -0
package/tests/http1/config/config.ts +20 -0
package/tests/http1/config/router.ts +77 -0
package/tests/http1/get.test.ts +105 -0
package/tests/http1/index.ts +23 -0
package/tests/http1/post.test.ts +36 -0
package/tests/index.ts +3 -0

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2025 smuzi-ts
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,18 @@
+# @smuzi/http-client
+TODO
+---
+## Installation
+```bash
+npm install @smuzi/http-client
+```
+---
+> See more examples in the [tests folder](./tests).
+## Example
+```ts
+```

package/build/base.d.ts ADDED Viewed

@@ -0,0 +1,32 @@
+import { Option, Result, HttpMethod, HttpResponse, RequestHttpHeaders, StdError } from "@smuzi/std";
+import { Connector } from "./connection.js";
+export type BaseRequestConfig = {
+    method: HttpMethod;
+    headers: RequestHttpHeaders;
+    query: Record<string, string | number | boolean>;
+    body: Option;
+    rawResponse: boolean;
+};
+export type GetRequestConfig = {
+    headers?: RequestHttpHeaders;
+    query?: Record<string, string | number | boolean>;
+    rawResponse?: boolean;
+};
+export type PostRequestConfig = {
+    headers?: RequestHttpHeaders;
+    query?: Record<string, string | number | boolean>;
+    body?: Option;
+    rawResponse?: boolean;
+};
+export type HttpClientConfig = {
+    baseUrl?: string;
+    baseHeaders?: Record<string, string>;
+    connector?: Option<Connector>;
+};
+export type HttpClient = {
+    get<Body = unknown, E = unknown>(url: any, config?: GetRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>;
+    post<Body = unknown, E = unknown>(url: any, config?: PostRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>;
+    put<Body = unknown, E = unknown>(url: any, config?: PostRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>;
+    delete<Body = unknown, E = unknown>(url: any, config?: GetRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>;
+};
+export declare function buildHttpClient({ baseUrl, baseHeaders, connector }: HttpClientConfig): HttpClient;

package/build/base.js ADDED Viewed

@@ -0,0 +1,100 @@
+import { Err, None, Ok, OptionFromNullable, HttpMethod, HttpResponse, RequestHttpHeaders, ResponseHttpHeaders, isObject, asNull, StdJson, StdFormData } from "@smuzi/std";
+function buildUrl(baseUrl = "", url, query) {
+    const fullUrl = baseUrl + url;
+    let qs = "";
+    for (const [key, value] of Object.entries(query)) {
+        qs += key + "=" + value + "&";
+    }
+    return qs ? `${fullUrl}?${qs.slice(0, -1)}` : fullUrl;
+}
+export function buildHttpClient({ baseUrl = "", baseHeaders = {}, connector = None() }) {
+    async function request(url, config) {
+        await connector.asyncSomeThen(async (connector_fn) => {
+            config = (await connector_fn(config)).unwrap();
+        });
+        const finalUrl = buildUrl(baseUrl, url, config.query);
+        const requestInit = {
+            method: config.method,
+        };
+        if (config.method !== HttpMethod.GET && config.method !== HttpMethod.DELETE) {
+            let bodyParsed;
+            bodyParsed = config.body.mapSome((bodyValue) => {
+                //TODO: Handle bodyValue instanceof FormData
+                if (bodyValue instanceof StdFormData) {
+                    return {
+                        body: bodyValue.toString().unwrap(),
+                        contentType: "application/x-www-form-urlencoded"
+                    };
+                }
+                if (isObject(bodyValue) && !(bodyValue instanceof FormData)) {
+                    return {
+                        body: StdJson.toString(bodyValue).unwrap(),
+                        contentType: "application/json; charset=utf-8"
+                    };
+                }
+                //TODO SAFE: "body as string", need to added any chekers
+                return {
+                    body: asNull(bodyValue) ? "" : bodyValue,
+                    contentType: "text/plain; charset=utf-8"
+                };
+            });
+            if (!bodyParsed.isNone()) {
+                requestInit.body = bodyParsed.unwrapByKey("body");
+                config.headers.set("content-type", bodyParsed.unwrapByKey("contentType"));
+            }
+        }
+        //TODO SAFE: researching problem with types and make this more type safe without "as any"
+        requestInit.headers = config.headers.unsafeSource();
+        try {
+            const response = await fetch(finalUrl, requestInit);
+            const responseContentType = response.headers.get("content-type") ?? "";
+            try {
+                const text = await response.text();
+                const body = OptionFromNullable(text)
+                    .mapSome((rawData) => {
+                    if (config.rawResponse) {
+                        return rawData;
+                    }
+                    if (!responseContentType.includes("application/json")) {
+                        return rawData;
+                    }
+                    return StdJson.fromString(rawData).unwrap();
+                }).flat();
+                if (!response.ok) {
+                    return Err(new HttpResponse({
+                        status: response.status,
+                        statusText: response.statusText,
+                        body: body,
+                        headers: ResponseHttpHeaders.fromHeaders(response.headers)
+                    }));
+                }
+                return Ok(new HttpResponse({
+                    status: response.status,
+                    statusText: response.statusText,
+                    body: body,
+                    headers: ResponseHttpHeaders.fromHeaders(response.headers)
+                }));
+            }
+            catch (e) {
+                return Err(e);
+            }
+        }
+        catch (err) {
+            return Err(err);
+        }
+    }
+    return {
+        get(url, { query = {}, headers = new RequestHttpHeaders, rawResponse = false } = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.GET, body: None() });
+        },
+        post(url, { query = {}, headers = new RequestHttpHeaders, body = None(), rawResponse = false } = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.POST, body });
+        },
+        put(url, { query = {}, headers = new RequestHttpHeaders, body = None(), rawResponse = false } = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.PUT, body });
+        },
+        delete(url, { query = {}, headers = new RequestHttpHeaders, rawResponse = false } = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.GET, body: None() });
+        },
+    };
+}

package/build/connection.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Result, StdError } from "@smuzi/std";
+import { BaseRequestConfig } from "./index.js";
+export type Connector = (request: BaseRequestConfig) => Promise<Result<BaseRequestConfig, StdError>>;

package/build/connection.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/build/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./base.js";
2	+ export * from "./connection.js";

package/build/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./base.js";
2	+ export * from "./connection.js";

package/package.json ADDED Viewed

@@ -0,0 +1,48 @@
+{
+  "name": "@smuzi/http-client",
+  "version": "0.0.1",
+  "description": "HTTP client for JavaScript and TypeScript",
+  "type": "module",
+  "types": "./build/index.d.ts",
+  "keywords": [
+    "http",
+    "api",
+    "rest",
+    "json",
+    "request"
+  ],
+  "author": "Denis Ratushniak <dinisimys2018@gmail.com>",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "./src",
+    "./build",
+    "./tests"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "imports": {
+    "#lib/*": "./src/*"
+  },
+  "dependencies": {
+    "@smuzi/std": "0.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsx": "^4.20.6",
+    "typescript": "^7.0.2",
+    "@smuzi/faker": "0.0.2",
+    "@smuzi/tests": "0.0.1",
+    "@smuzi/schema": "0.0.2",
+    "@smuzi/http-server": "0.0.2"
+  },
+  "scripts": {
+    "test": "tsx --env-file=./tests/.env tests/index.ts",
+    "build": "tsc --project tsconfig.build.json"
+  }
+}

package/src/base.ts ADDED Viewed

@@ -0,0 +1,186 @@
+import {
+    dump,
+    Err,
+    None,
+    Ok,
+    Option,
+    OptionFromNullable,
+    Result,
+    HttpMethod,
+    HttpResponse,
+    RequestHttpHeaders,
+    ResponseHttpHeaders,
+    isObject,
+    isNull,
+    asNull,
+    StdError,
+    isNone,
+    asString,
+    StdJson,
+    querystring,
+    StdFormData
+} from "@smuzi/std";
+import { Connector } from "./connection.js";
+export type BaseRequestConfig = {
+    method: HttpMethod;
+    headers: RequestHttpHeaders;
+    query: Record<string, string | number | boolean>;
+    body: Option;
+    rawResponse: boolean
+};
+export type GetRequestConfig = {
+    headers?: RequestHttpHeaders;
+    query?: Record<string, string | number | boolean>;
+    rawResponse?: boolean
+};
+export type PostRequestConfig = {
+    headers?: RequestHttpHeaders;
+    query?: Record<string, string | number | boolean>;
+    body?: Option,
+    rawResponse?: boolean
+};
+function buildUrl(baseUrl: string = "", url: string, query: Record<string, string | number | boolean>) {
+    const fullUrl = baseUrl + url;
+    let qs = "";
+    for (const [key, value] of Object.entries(query)) {
+        qs += key + "=" + value + "&";
+    }
+    return qs ? `${fullUrl}?${qs.slice(0, -1)}` : fullUrl;
+}
+export type HttpClientConfig = {
+    baseUrl?: string
+    baseHeaders?: Record<string, string>,
+    connector?: Option<Connector>,
+}
+export type HttpClient = {
+    get<Body = unknown, E = unknown>(url, config?: GetRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>,
+    post<Body = unknown, E = unknown>(url, config?: PostRequestConfig):  Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>
+    put<Body = unknown, E = unknown>(url, config?: PostRequestConfig):  Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>
+    delete<Body = unknown, E = unknown>(url, config?: GetRequestConfig): Promise<Result<HttpResponse<Body>, HttpResponse<E> | StdError>>,
+};
+export function buildHttpClient({ baseUrl = "", baseHeaders = {}, connector = None() }: HttpClientConfig): HttpClient {
+    async function request<B = unknown, E = unknown>(
+        url: string, config: BaseRequestConfig
+    ): Promise<Result<HttpResponse<B>, HttpResponse<E> | StdError>> {
+        await connector.asyncSomeThen(async (connector_fn) => {
+            config = (await connector_fn(config)).unwrap();
+        })
+        const finalUrl = buildUrl(baseUrl, url, config.query);
+        const requestInit: RequestInit = {
+            method: config.method,
+        };
+        if (config.method !== HttpMethod.GET && config.method !== HttpMethod.DELETE) {
+            let bodyParsed: Option<{
+                body: string,
+                contentType: string
+            }>;
+            bodyParsed = config.body.mapSome((bodyValue) => {
+                //TODO: Handle bodyValue instanceof FormData
+                if (bodyValue instanceof StdFormData) {
+                    return {
+                        body: bodyValue.toString().unwrap(),
+                        contentType: "application/x-www-form-urlencoded"
+                    }
+                }
+                if (isObject(bodyValue) && !(bodyValue instanceof FormData)) {
+                    return {
+                        body: StdJson.toString(bodyValue).unwrap(),
+                        contentType: "application/json; charset=utf-8"
+                    }
+                }
+                //TODO SAFE: "body as string", need to added any chekers
+                return {
+                        body: asNull(bodyValue) ? "" : bodyValue as string,
+                        contentType: "text/plain; charset=utf-8"
+                }
+            });
+            if (! bodyParsed.isNone()) {
+                requestInit.body = bodyParsed.unwrapByKey("body");
+                config.headers.set("content-type", bodyParsed.unwrapByKey("contentType"));
+            }
+        }
+        //TODO SAFE: researching problem with types and make this more type safe without "as any"
+        requestInit.headers = config.headers.unsafeSource() as any;
+        try {
+            const response = await fetch(finalUrl, requestInit);
+            const responseContentType = response.headers.get("content-type") ?? "";
+            try {
+                const text  = await response.text();
+                const body = OptionFromNullable(text)
+                    .mapSome((rawData) => {
+                        if (config.rawResponse) {
+                            return rawData;
+                        }
+                        if (! responseContentType.includes("application/json")) {
+                            return rawData;
+                        }
+                        return StdJson.fromString(rawData).unwrap();
+                    }).flat();
+                if (!response.ok) {
+                    return Err(new HttpResponse({
+                        status: response.status,
+                        statusText: response.statusText,
+                        body: body as Option<E>,
+                        headers: ResponseHttpHeaders.fromHeaders(response.headers)
+                    }))
+                }
+                return Ok(new HttpResponse({
+                    status: response.status,
+                    statusText: response.statusText,
+                    body: body as Option<B>,
+                    headers: ResponseHttpHeaders.fromHeaders(response.headers)
+                }));
+            } catch (e) {
+                return Err(e);
+            }
+        } catch (err) {
+            return Err(err);
+        }
+    }
+    return {
+        get(url, { query = {}, headers = new RequestHttpHeaders, rawResponse = false }: GetRequestConfig = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.GET, body: None() });
+        },
+        post(url, { query = {}, headers = new RequestHttpHeaders, body = None(), rawResponse = false }: PostRequestConfig = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.POST, body });
+        },
+        put(url, { query = {}, headers = new RequestHttpHeaders, body = None(), rawResponse = false }: PostRequestConfig = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.PUT, body });
+        },
+        delete(url, { query = {}, headers = new RequestHttpHeaders, rawResponse = false }: GetRequestConfig = {}) {
+            return request(url, { query, headers, rawResponse, method: HttpMethod.GET, body: None() });
+        },
+    }
+}

package/src/connection.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { Result, StdError } from "@smuzi/std";
+import { BaseRequestConfig } from "./index.js";
+export type Connector = (request: BaseRequestConfig) => Promise<Result<BaseRequestConfig,StdError>>

package/src/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./base.js"
2	+ export * from "./connection.js"

package/tests/.env ADDED Viewed

@@ -0,0 +1,3 @@
+APP_HOST=localhost
+APP_PORT=8445
+API_KEY=123

package/tests/http1/config/config.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { env, Some, http } from "@smuzi/std";
+import { buildHttp1ServerConfig } from "@smuzi/http-server";
+import { buildHttpClient } from "#lib/index.js";
+import  router from "./router.js";
+export const serverConfig = buildHttp1ServerConfig({
+    host: env("APP_HOST", Some("localhost")),
+    port: parseInt(env("APP_PORT", Some('81'))),
+    router,
+});
+export const apiConfig = {
+    key: env("API_KEY")
+}
+export const httpClient = buildHttpClient({
+    baseUrl: http.buildUrl(serverConfig.protocol, serverConfig.host, Some(serverConfig.port)),
+});

package/tests/http1/config/router.ts ADDED Viewed

@@ -0,0 +1,77 @@
+import { dump, HttpResponse, Option, RequestHttpHeaders } from "@smuzi/std";
+import { CreateHttp1Router } from "@smuzi/http-server";
+import { faker } from "@smuzi/faker";
+import { apiConfig } from "./config.js";
+const router = CreateHttp1Router({ path: '' });
+const usersRouter = CreateHttp1Router({ path: 'users/' });
+usersRouter.get("list", () => {
+    return faker.repeat.asArray(5, () => ({
+        id: faker.integer(),
+        name: faker.string(),
+        email: faker.string(),
+    }))
+})
+usersRouter.get("auth", (context) => {
+    const token = context.request.query().get("token").someOr("");
+    if (token != apiConfig.key) {
+        context.response.writeHead(401, "Unauthorized");
+        context.response.end();
+        return;
+    }
+    context.response.writeHead(200, "Authorized");
+    context.response.end();
+})
+usersRouter.get("authHeader", (context) => {
+    const token = context.request.headers.getOther("x-token").someOr("");
+    if (token != apiConfig.key) {
+        context.response.writeHead(401, "Unauthorized");
+        context.response.end();
+        return;
+    }
+    context.response.writeHead(200, "Authorized");
+    context.response.end();
+})
+router.get("echoQuery", (context) => {
+    const resp = {};
+    for(const [key, val] of context.request.query()) {
+        resp[key] = val.someOr("");
+    }
+    return resp;
+})
+router.get("echoHeaders", (context) => {
+   const resp = new HttpResponse();
+    for(const [key, val] of context.request.headers) {
+        if (key.endsWith("custom")) {
+            resp.headers.setOther(key, val.someOr(""));
+        }
+    }
+    return resp;
+})
+router.post("echoBodyString", async (context) => {
+    const body = (await context.request.json());
+    return body.match({
+        Err(err) {
+            return new HttpResponse({status: 400, statusText: err.message});
+            },
+        Ok(json) {
+            return json.unwrap() as any;
+        }
+    })
+})
+router.group(usersRouter);
+export default router;

package/tests/http1/get.test.ts ADDED Viewed

@@ -0,0 +1,105 @@
+import {assert, it, okMsg} from "@smuzi/tests";
+import {Some, RequestHttpHeaders, StdError, StdList, StdRecord} from "@smuzi/std";
+import {apiConfig, httpClient} from "./config/config.js";
+import {faker} from "@smuzi/faker";
+import {http1TestRunner} from "./index.js";
+http1TestRunner.describe("http-client-http1-GET-", [
+        it("without options", async () => {
+            type User = StdRecord<{ email: string, name: string }>;
+            type UsersList = StdList<User>
+            const response = await httpClient.get<UsersList>('/users/list');
+            const body = response.unwrap().body.unwrap();
+            const user = body.get(0).unwrap();
+            assert.isString(user.get("email").unwrap())
+            assert.isString(user.get("name").unwrap())
+        }),
+        it("not found", async () => {
+            const response = (await httpClient.get('/users/list/notFound'));
+            assert.result.equalErr(response);
+            response.runThenErr((err) => {
+                if (err instanceof StdError) {
+                    assert.fail(err);
+                }
+                assert.equal(err.status, 404);
+                assert.equal(err.statusText, "Not Found");
+            })
+        }),
+        it(okMsg("unauthorized"), async () => {
+            const response = await httpClient.get('/users/auth');
+            assert.result.equalErr(response);
+            response.runThenErr((err) => {
+                if (err instanceof StdError) {
+                    assert.fail(err);
+                }
+                assert.equal(err.status, 401);
+                assert.equal(err.statusText, "Unauthorized");
+            })
+        }),
+        it(okMsg("success authorized"), async () => {
+            const response = await httpClient.get('/users/auth', {query: {token: apiConfig.key}});
+            assert.result.equalOk(response);
+            response.runThenOk((resp) => {
+                assert.equal(resp.status, 200);
+                assert.equal(resp.statusText, "Authorized");
+            })
+        }),
+        it("echo query", async () => {
+            const query = {
+                a: faker.string(),
+                b: faker.string(),
+                c: faker.string(),
+            };
+            type ResponseJson = StdRecord<typeof query>
+            const response = await httpClient.get<ResponseJson>('/echoQuery', {query});
+            assert.result.equalOk(response);
+            response.runThenOk((resp) => {
+                assert.equal(resp.status, 200);
+                assert.equal(resp.statusText, "OK");
+                const body = resp.body.unwrap();
+                assert.equal(body.get("a").unwrap(), query.a);
+                assert.equal(body.get("b").unwrap(), query.b);
+                assert.equal(body.get("c").unwrap(), query.c);
+            })
+        }),
+        it(okMsg("echo custom headers"), async () => {
+            const headers = new RequestHttpHeaders();
+            headers.setOther("x-custom", "xxx");
+            headers.setOther("y-custom", "yyy");
+            headers.setOther("z-custom", "zzz");
+            const response = await httpClient.get('/echoHeaders', {headers});
+            assert.result.equalOk(response);
+            response.runThenOk((resp) => {
+                assert.equal(resp.status, 200);
+                assert.equal(resp.statusText, "OK");
+                assert.deepEqual(resp.headers.getOther("x-custom"), Some("xxx"));
+                assert.deepEqual(resp.headers.getOther("y-custom"), Some("yyy"));
+                assert.deepEqual(resp.headers.getOther("z-custom"), Some("zzz"));
+            })
+        }),
+    ]
+)

package/tests/http1/index.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import {TestRunner} from "@smuzi/tests";
+import { http1ServerRun, StdHttp1Server } from "@smuzi/http-server";
+import {Option, Some} from "@smuzi/std";
+import { serverConfig } from "./config/config.js";
+type GlobalSetup = Option<{
+    server: StdHttp1Server
+}>
+export const http1TestRunner = new TestRunner<GlobalSetup>({
+    folder: './tests/http1',
+    beforeGlobal: Some(async () => {
+        return Some({
+             server: (await http1ServerRun(serverConfig)).unwrap()
+        });
+    }
+    ),
+    afterGlobal: Some(async (globalSetup) => {
+        await globalSetup.unwrap().server.close();
+    }),
+});
+export default async () => http1TestRunner.run();

package/tests/http1/post.test.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import { it, assert } from "@smuzi/tests";
+import { httpClient } from "./config/config.js";
+import {dump, Some, StdRecord} from "@smuzi/std";
+import { faker } from "@smuzi/faker";
+import {schema} from "@smuzi/schema";
+import {http1TestRunner} from "./index.js";
+http1TestRunner.describe("http-client-http1-POST-", [
+    it("echo json", async () => {
+        const userSchema = schema.record({
+            name: schema.string(),
+            age: schema.number(),
+            posts: schema.list(schema.record({
+                id: schema.number(),
+                subject: schema.string(),
+            }))
+        })
+        const createUser = faker.schema.make(userSchema);
+        const response = await httpClient.post<typeof createUser>('/echoBodyString', {
+            body: Some(createUser)
+        });
+        const responseBody = response
+            .unwrap()
+            .body
+            .unwrap();
+        assert.result.equalOk(userSchema.validate(responseBody))
+    }),
+]
+)

package/tests/index.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import http1 from "./http1/index.js"
+await http1();