@grest-ts/http 0.0.5 → 0.0.7

package/src/client/GGHttpSchema.createClient.ts

@@ -1,107 +1,107 @@
-import {ANY_ERROR, ERROR, GGContractApiDefinition, GGContractClient, GGContractExecutor, GGContractImplementation, GGPromise, OK, SERVER_ERROR} from "@grest-ts/schema"
-import {ClientHttpRouteToRpcTransformClientCodec, GGHttpCodec, GGHttpSchema} from "../schema/GGHttpSchema";
-import {isBrowser} from "@grest-ts/common";
-
-
-declare module "../schema/GGHttpSchema" {
-    interface GGHttpSchema<TContract extends GGContractApiDefinition, TContext = {}> {
-        createClient(config?: GGHttpClientConfig): GGContractClient<TContract>
-    }
-}
-
-export interface GGHttpClientConfig {
-    url?: string;
-    timeout?: number;
-    noValidation?: boolean
-}
-
-GGHttpSchema.prototype.createClient = function <TContract extends GGContractApiDefinition, TContext>(
-    this: GGHttpSchema<TContract, TContext>,
-    config?: GGHttpClientConfig
-): GGContractClient<TContract> {
-    return createClient(this, config);
-}
-
-export function createClient<TContract extends GGContractApiDefinition, TContext>(
-    httpSchema: GGHttpSchema<TContract, TContext>,
-    config?: GGHttpClientConfig
-): GGContractClient<TContract> {
-    config ??= {};
-    config.timeout ??= 15000;
-
-    if (config.url === undefined && isBrowser()) {
-        throw new Error("Must define URL for GGHttpClient when running in browser! Use empty string for same-origin requests.");
-    }
-
-    const pathPrefix = "/" + httpSchema.pathPrefix + "/";
-
-    const transportImplementation: any = {}
-    for (const methodName of Object.keys(httpSchema.codec)) {
-
-        const contractFunction = httpSchema.contract.methods[methodName];
-        const noValidation = config?.noValidation === true;
-
-        const codec: GGHttpCodec = httpSchema.codec[methodName];
-        const wireFormat: ClientHttpRouteToRpcTransformClientCodec = codec.createForClient({
-            pathPrefix: pathPrefix,
-            contract: contractFunction,
-            middlewares: httpSchema.apiMiddlewares
-        })
-
-        const implementation = async (data?: unknown): Promise<OK<unknown> | ANY_ERROR> => {
-            try {
-                let baseUrl: string = config.url;
-                if (baseUrl === undefined) {
-                    try {
-                        const {GG_DISCOVERY} = await import(/* @vite-ignore */ '@grest-ts/discovery');
-                        baseUrl = await GG_DISCOVERY.get().discoverApi(httpSchema.name);
-                    } catch (err) {
-                        throw new SERVER_ERROR({displayMessage: "Service discovery failed", originalError: err});
-                    }
-                }
-
-                // ---------------------------------------------
-                // Input validation
-                const validatedInput = noValidation ? data : GGContractExecutor.parseInput(contractFunction.input, data)
-
-                // ---------------------------------------------
-                // Execution
-                const fetchRequest = await wireFormat.createRequest(validatedInput);
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), config.timeout);
-                const wireResponse = await fetch(baseUrl + fetchRequest.url, {
-                    method: fetchRequest.method,
-                    signal: controller.signal,
-                    headers: fetchRequest.headers,
-                    body: fetchRequest.body
-                }).finally(() => clearTimeout(timeoutId));
-                const resData = await wireFormat.parseResponse(wireResponse);
-
-                // ---------------------------------------------
-                // Response handling
-                const schema = GGContractExecutor.getResponseSchema(contractFunction, resData);
-                if (schema) {
-                    resData.data = noValidation ? resData.data : GGContractExecutor.parseOutputData(schema, resData.data);
-                } else if (resData.data !== undefined) {
-                    resData.data = undefined
-                }
-                if (resData.success === true) {
-                    return resData as OK<unknown>;
-                } else {
-                    return GGContractExecutor.createErrorObj(resData, contractFunction.errors);
-                }
-                // ---------------------------------------------
-            } catch (error) {
-                return ERROR.fromUnknown(error);
-            }
-        };
-
-        transportImplementation[methodName] = (data?: unknown) => {
-            return new GGPromise(implementation(data))
-        }
-
-    }
-    // @TODO Next line is just so test would register it correctly.
-    httpSchema.contract.implement(transportImplementation as GGContractImplementation<TContract>)
-    return transportImplementation;
+import {ANY_ERROR, ERROR, GGContractApiDefinition, GGContractClient, GGContractExecutor, GGContractImplementation, GGPromise, OK, SERVER_ERROR} from "@grest-ts/schema"
+import {ClientHttpRouteToRpcTransformClientCodec, GGHttpCodec, GGHttpSchema} from "../schema/GGHttpSchema";
+import {isBrowser} from "@grest-ts/common";
+
+
+declare module "../schema/GGHttpSchema" {
+    interface GGHttpSchema<TContract extends GGContractApiDefinition, TContext = {}> {
+        createClient(config?: GGHttpClientConfig): GGContractClient<TContract>
+    }
+}
+
+export interface GGHttpClientConfig {
+    url?: string;
+    timeout?: number;
+    noValidation?: boolean
+}
+
+GGHttpSchema.prototype.createClient = function <TContract extends GGContractApiDefinition, TContext>(
+    this: GGHttpSchema<TContract, TContext>,
+    config?: GGHttpClientConfig
+): GGContractClient<TContract> {
+    return createClient(this, config);
+}
+
+export function createClient<TContract extends GGContractApiDefinition, TContext>(
+    httpSchema: GGHttpSchema<TContract, TContext>,
+    config?: GGHttpClientConfig
+): GGContractClient<TContract> {
+    config ??= {};
+    config.timeout ??= 15000;
+
+    if (config.url === undefined && isBrowser()) {
+        throw new Error("Must define URL for GGHttpClient when running in browser! Use empty string for same-origin requests.");
+    }
+
+    const pathPrefix = "/" + httpSchema.pathPrefix + "/";
+
+    const transportImplementation: any = {}
+    for (const methodName of Object.keys(httpSchema.codec)) {
+
+        const contractFunction = httpSchema.contract.methods[methodName];
+        const noValidation = config?.noValidation === true;
+
+        const codec: GGHttpCodec = httpSchema.codec[methodName];
+        const wireFormat: ClientHttpRouteToRpcTransformClientCodec = codec.createForClient({
+            pathPrefix: pathPrefix,
+            contract: contractFunction,
+            middlewares: httpSchema.apiMiddlewares
+        })
+
+        const implementation = async (data?: unknown): Promise<OK<unknown> | ANY_ERROR> => {
+            try {
+                let baseUrl: string = config.url;
+                if (baseUrl === undefined) {
+                    try {
+                        const {GG_DISCOVERY} = await import(/* @vite-ignore */ '@grest-ts/discovery');
+                        baseUrl = await GG_DISCOVERY.get().discoverApi(httpSchema.name);
+                    } catch (err) {
+                        throw new SERVER_ERROR({displayMessage: "Service discovery failed", originalError: err});
+                    }
+                }
+
+                // ---------------------------------------------
+                // Input validation
+                const validatedInput = noValidation ? data : GGContractExecutor.parseInput(contractFunction.input, data)
+
+                // ---------------------------------------------
+                // Execution
+                const fetchRequest = await wireFormat.createRequest(validatedInput);
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+                const wireResponse = await fetch(baseUrl + fetchRequest.url, {
+                    method: fetchRequest.method,
+                    signal: controller.signal,
+                    headers: fetchRequest.headers,
+                    body: fetchRequest.body
+                }).finally(() => clearTimeout(timeoutId));
+                const resData = await wireFormat.parseResponse(wireResponse);
+
+                // ---------------------------------------------
+                // Response handling
+                const schema = GGContractExecutor.getResponseSchema(contractFunction, resData);
+                if (schema) {
+                    resData.data = noValidation ? resData.data : GGContractExecutor.parseOutputData(schema, resData.data);
+                } else if (resData.data !== undefined) {
+                    resData.data = undefined
+                }
+                if (resData.success === true) {
+                    return resData as OK<unknown>;
+                } else {
+                    return GGContractExecutor.createErrorObj(resData, contractFunction.errors);
+                }
+                // ---------------------------------------------
+            } catch (error) {
+                return ERROR.fromUnknown(error);
+            }
+        };
+
+        transportImplementation[methodName] = (data?: unknown) => {
+            return new GGPromise(implementation(data))
+        }
+
+    }
+    // @TODO Next line is just so test would register it correctly.
+    httpSchema.contract.implement(transportImplementation as GGContractImplementation<TContract>)
+    return transportImplementation;
 }

package/src/index-browser.ts

@@ -1,12 +1,12 @@
-// API Schema
-export * from "./schema/GGHttpSchema";
-export * from "./schema/httpSchema";
-export * from "./rpc/GGHttpRouteRPC";
-export * from "./rpc/RpcRequest/GGRpcRequestBuilder";
-export * from "./rpc/RpcResponse/GGRpcResponseParser";
-
-// Client
-export * from "./client/GGHttpSchema.createClient";
-
-// Extensions
-import "./client/GGHttpSchema.createClient";
+// API Schema
+export * from "./schema/GGHttpSchema";
+export * from "./schema/httpSchema";
+export * from "./rpc/GGHttpRouteRPC";
+export * from "./rpc/RpcRequest/GGRpcRequestBuilder";
+export * from "./rpc/RpcResponse/GGRpcResponseParser";
+
+// Client
+export * from "./client/GGHttpSchema.createClient";
+
+// Extensions
+import "./client/GGHttpSchema.createClient";

package/src/index-node.ts

@@ -1,38 +1,38 @@
-// Register server RPC codec factory (must be before other exports that use it)
-import {_registerRpcServerCodecFactory} from "./rpc/GGHttpRouteRPC";
-import {GGRpcResponseBuilder} from "./rpc/RpcResponse/GGRpcResponseBuilder";
-import {GGRpcRequestParser} from "./rpc/RpcRequest/GGRpcRequestParser";
-_registerRpcServerCodecFactory((method, path, config) => ({
-    parseRequest: new GGRpcRequestParser(method, path, config).parseRequest,
-    sendResponse: new GGRpcResponseBuilder(config).sendResponse
-}));
-
-// Metrics
-export * from "./server/GGHttpMetrics";
-
-// Context
-export * from "./server/GG_HTTP_REQUEST";
-
-// API Schema
-export * from "./schema/GGHttpSchema";
-export * from "./schema/httpSchema";
-export * from "./rpc/GGHttpRouteRPC";
-export * from "./rpc/RpcRequest/GGRpcRequestBuilder";
-export * from "./rpc/RpcRequest/GGRpcRequestParser";
-export * from "./rpc/RpcResponse/GGRpcResponseBuilder";
-export * from "./rpc/RpcResponse/GGRpcResponseParser";
-
-// Server (convenience builder)
-export * from "./server/GGHttp";
-export * from "./server/GGHttp";
-export * from "./server/GGHttpServer";
-export * from "./server/GG_HTTP_SERVER";
-
-// Client
-export * from "./client/GGHttpSchema.createClient";
-export * from "./server/GGHttpSchema.startServer";
-
-
-// Extensions
-import "./client/GGHttpSchema.createClient";
-import "./server/GGHttpSchema.startServer";
+// Register server RPC codec factory (must be before other exports that use it)
+import {_registerRpcServerCodecFactory} from "./rpc/GGHttpRouteRPC";
+import {GGRpcResponseBuilder} from "./rpc/RpcResponse/GGRpcResponseBuilder";
+import {GGRpcRequestParser} from "./rpc/RpcRequest/GGRpcRequestParser";
+_registerRpcServerCodecFactory((method, path, config) => ({
+    parseRequest: new GGRpcRequestParser(method, path, config).parseRequest,
+    sendResponse: new GGRpcResponseBuilder(config).sendResponse
+}));
+
+// Metrics
+export * from "./server/GGHttpMetrics";
+
+// Context
+export * from "./server/GG_HTTP_REQUEST";
+
+// API Schema
+export * from "./schema/GGHttpSchema";
+export * from "./schema/httpSchema";
+export * from "./rpc/GGHttpRouteRPC";
+export * from "./rpc/RpcRequest/GGRpcRequestBuilder";
+export * from "./rpc/RpcRequest/GGRpcRequestParser";
+export * from "./rpc/RpcResponse/GGRpcResponseBuilder";
+export * from "./rpc/RpcResponse/GGRpcResponseParser";
+
+// Server (convenience builder)
+export * from "./server/GGHttp";
+export * from "./server/GGHttp";
+export * from "./server/GGHttpServer";
+export * from "./server/GG_HTTP_SERVER";
+
+// Client
+export * from "./client/GGHttpSchema.createClient";
+export * from "./server/GGHttpSchema.startServer";
+
+
+// Extensions
+import "./client/GGHttpSchema.createClient";
+import "./server/GGHttpSchema.startServer";

package/src/rpc/GGHttpRouteRPC.ts

@@ -1,42 +1,42 @@
-import {HttpMethod} from "@grest-ts/common"
-import {ClientHttpRouteToRpcTransformClientCodec, ClientHttpRouteToRpcTransformClientConfig, ClientHttpRouteToRpcTransformServerCodec, ClientHttpRouteToRpcTransformServerConfig, GGHttpCodec} from "../schema/GGHttpSchema"
-import {GGRpcRequestBuilder} from "./RpcRequest/GGRpcRequestBuilder";
-import {GGRpcResponseParser} from "./RpcResponse/GGRpcResponseParser";
-
-export type GGRpcServerCodecFactory = (method: HttpMethod, path: string, config: ClientHttpRouteToRpcTransformServerConfig) => ClientHttpRouteToRpcTransformServerCodec;
-
-let _serverCodecFactory: GGRpcServerCodecFactory | undefined;
-
-export function _registerRpcServerCodecFactory(factory: GGRpcServerCodecFactory): void {
-    _serverCodecFactory = factory;
-}
-
-export const GGRpc = {
-    GET: (path: string) => new GGHttpRpcCodec("GET", path),
-    DELETE: (path: string) => new GGHttpRpcCodec("DELETE", path),
-    POST: (path: string) => new GGHttpRpcCodec("POST", path),
-    PUT: (path: string) => new GGHttpRpcCodec("PUT", path),
-}
-
-class GGHttpRpcCodec implements GGHttpCodec {
-
-    public readonly method: HttpMethod
-    public readonly path: string
-
-    constructor(method: HttpMethod, path: string) {
-        this.method = method
-        this.path = path
-    }
-
-    public createForClient(config: ClientHttpRouteToRpcTransformClientConfig): ClientHttpRouteToRpcTransformClientCodec {
-        return {
-            createRequest: new GGRpcRequestBuilder(this.method, this.path, config).createRequest,
-            parseResponse: new GGRpcResponseParser(config).parseResponse
-        }
-    }
-
-    public createForServer(config: ClientHttpRouteToRpcTransformServerConfig): ClientHttpRouteToRpcTransformServerCodec {
-        if (!_serverCodecFactory) throw new Error("Server RPC codec not available. Ensure @grest-ts/http server entry is imported.");
-        return _serverCodecFactory(this.method, this.path, config);
-    }
-}
+import {HttpMethod} from "@grest-ts/common"
+import {ClientHttpRouteToRpcTransformClientCodec, ClientHttpRouteToRpcTransformClientConfig, ClientHttpRouteToRpcTransformServerCodec, ClientHttpRouteToRpcTransformServerConfig, GGHttpCodec} from "../schema/GGHttpSchema"
+import {GGRpcRequestBuilder} from "./RpcRequest/GGRpcRequestBuilder";
+import {GGRpcResponseParser} from "./RpcResponse/GGRpcResponseParser";
+
+export type GGRpcServerCodecFactory = (method: HttpMethod, path: string, config: ClientHttpRouteToRpcTransformServerConfig) => ClientHttpRouteToRpcTransformServerCodec;
+
+let _serverCodecFactory: GGRpcServerCodecFactory | undefined;
+
+export function _registerRpcServerCodecFactory(factory: GGRpcServerCodecFactory): void {
+    _serverCodecFactory = factory;
+}
+
+export const GGRpc = {
+    GET: (path: string) => new GGHttpRpcCodec("GET", path),
+    DELETE: (path: string) => new GGHttpRpcCodec("DELETE", path),
+    POST: (path: string) => new GGHttpRpcCodec("POST", path),
+    PUT: (path: string) => new GGHttpRpcCodec("PUT", path),
+}
+
+class GGHttpRpcCodec implements GGHttpCodec {
+
+    public readonly method: HttpMethod
+    public readonly path: string
+
+    constructor(method: HttpMethod, path: string) {
+        this.method = method
+        this.path = path
+    }
+
+    public createForClient(config: ClientHttpRouteToRpcTransformClientConfig): ClientHttpRouteToRpcTransformClientCodec {
+        return {
+            createRequest: new GGRpcRequestBuilder(this.method, this.path, config).createRequest,
+            parseResponse: new GGRpcResponseParser(config).parseResponse
+        }
+    }
+
+    public createForServer(config: ClientHttpRouteToRpcTransformServerConfig): ClientHttpRouteToRpcTransformServerCodec {
+        if (!_serverCodecFactory) throw new Error("Server RPC codec not available. Ensure @grest-ts/http server entry is imported.");
+        return _serverCodecFactory(this.method, this.path, config);
+    }
+}

package/src/rpc/RpcRequest/GGRpcRequestBuilder.ts

@@ -1,91 +1,91 @@
-import type {HttpMethod} from "@grest-ts/common";
-import {GGContractMethod} from "@grest-ts/schema";
-import {ClientHttpRouteToRpcTransformClientConfig, GGHttpFetchRequest, GGHttpTransportMiddleware} from "../../schema/GGHttpSchema";
-
-export class GGRpcRequestBuilder {
-
-    public readonly contract: GGContractMethod
-    public readonly middlewares: readonly GGHttpTransportMiddleware[]
-    public readonly method: HttpMethod;
-    public readonly pathTemplate: string;
-    public readonly pathParams: string[];
-    public readonly pathPrefix: string;
-    public readonly hasBody: boolean;
-
-    constructor(
-        method: HttpMethod,
-        pathTemplate: string,
-        config: ClientHttpRouteToRpcTransformClientConfig
-    ) {
-        this.method = method
-        this.pathTemplate = pathTemplate
-        this.pathPrefix = config.pathPrefix
-        this.contract = config.contract
-        this.middlewares = config.middlewares
-        this.pathParams = (pathTemplate.match(/:(\w+)/g) || []).map(m => m.slice(1))
-        this.hasBody = method === "POST" || method === "PUT" || method === "PATCH"
-    }
-
-    public createRequest = (data: unknown): GGHttpFetchRequest => {
-        let result: GGHttpFetchRequest;
-        if (this.hasBody) {
-            result = {
-                url: this.pathPrefix + this.buildPath(data),
-                method: this.method,
-                headers: {'Content-Type': 'application/json'},
-                body: this.buildBody(data)
-            }
-        } else {
-            result = {
-                url: this.pathPrefix + this.buildPath(data) + this.buildQueryString(data as Record<string, unknown>),
-                method: this.method,
-                headers: {},
-                body: undefined
-            }
-        }
-        this.middlewares?.forEach(mw => mw.updateRequest?.(result))
-        return result
-    }
-
-    private buildPath(data: unknown) {
-        let path: string = this.pathTemplate;
-        if (this.pathParams.length > 0 && typeof data === "object" && data) {
-            for (let i = 0; i < this.pathParams.length; i++) {
-                const p = this.pathParams[i]
-                const val = (data as Record<string, unknown>)[p]
-                path = path.replace(':' + p, encodeURIComponent(val === undefined || val === null ? "" : String(val)))
-            }
-        }
-        return path;
-    }
-
-    private buildBody(data: unknown) {
-        if (data === undefined || data === null) {
-            return undefined;
-        }
-        if (this.contract.input?.def.hasNonJsonData) {
-            throw new Error("Schema contains non-JSON data (e.g. files). Use GGRpc.MULTIPART_POST instead of GGRpc.POST for this route.")
-        } else {
-            return JSON.stringify(data)
-        }
-    }
-
-    private buildQueryString(data: unknown): string {
-        if (data && typeof data === "object") {
-            const params = new URLSearchParams()
-            for (const [key, value] of Object.entries(data)) {
-                if (value !== undefined && value !== null) {
-                    if (this.pathParams.length > 0 && this.pathParams.includes(key)) {
-                        continue;
-                    }
-                    params.append(key, String(value))
-                }
-            }
-            const query = params.toString()
-            if (query) {
-                return "?" + query
-            }
-        }
-        return ""
-    }
-}
+import type {HttpMethod} from "@grest-ts/common";
+import {GGContractMethod} from "@grest-ts/schema";
+import {ClientHttpRouteToRpcTransformClientConfig, GGHttpFetchRequest, GGHttpTransportMiddleware} from "../../schema/GGHttpSchema";
+
+export class GGRpcRequestBuilder {
+
+    public readonly contract: GGContractMethod
+    public readonly middlewares: readonly GGHttpTransportMiddleware[]
+    public readonly method: HttpMethod;
+    public readonly pathTemplate: string;
+    public readonly pathParams: string[];
+    public readonly pathPrefix: string;
+    public readonly hasBody: boolean;
+
+    constructor(
+        method: HttpMethod,
+        pathTemplate: string,
+        config: ClientHttpRouteToRpcTransformClientConfig
+    ) {
+        this.method = method
+        this.pathTemplate = pathTemplate
+        this.pathPrefix = config.pathPrefix
+        this.contract = config.contract
+        this.middlewares = config.middlewares
+        this.pathParams = (pathTemplate.match(/:(\w+)/g) || []).map(m => m.slice(1))
+        this.hasBody = method === "POST" || method === "PUT" || method === "PATCH"
+    }
+
+    public createRequest = (data: unknown): GGHttpFetchRequest => {
+        let result: GGHttpFetchRequest;
+        if (this.hasBody) {
+            result = {
+                url: this.pathPrefix + this.buildPath(data),
+                method: this.method,
+                headers: {'Content-Type': 'application/json'},
+                body: this.buildBody(data)
+            }
+        } else {
+            result = {
+                url: this.pathPrefix + this.buildPath(data) + this.buildQueryString(data as Record<string, unknown>),
+                method: this.method,
+                headers: {},
+                body: undefined
+            }
+        }
+        this.middlewares?.forEach(mw => mw.updateRequest?.(result))
+        return result
+    }
+
+    private buildPath(data: unknown) {
+        let path: string = this.pathTemplate;
+        if (this.pathParams.length > 0 && typeof data === "object" && data) {
+            for (let i = 0; i < this.pathParams.length; i++) {
+                const p = this.pathParams[i]
+                const val = (data as Record<string, unknown>)[p]
+                path = path.replace(':' + p, encodeURIComponent(val === undefined || val === null ? "" : String(val)))
+            }
+        }
+        return path;
+    }
+
+    private buildBody(data: unknown) {
+        if (data === undefined || data === null) {
+            return undefined;
+        }
+        if (this.contract.input?.def.hasNonJsonData) {
+            throw new Error("Schema contains non-JSON data (e.g. files). Use GGRpc.MULTIPART_POST instead of GGRpc.POST for this route.")
+        } else {
+            return JSON.stringify(data)
+        }
+    }
+
+    private buildQueryString(data: unknown): string {
+        if (data && typeof data === "object") {
+            const params = new URLSearchParams()
+            for (const [key, value] of Object.entries(data)) {
+                if (value !== undefined && value !== null) {
+                    if (this.pathParams.length > 0 && this.pathParams.includes(key)) {
+                        continue;
+                    }
+                    params.append(key, String(value))
+                }
+            }
+            const query = params.toString()
+            if (query) {
+                return "?" + query
+            }
+        }
+        return ""
+    }
+}