@grest-ts/http 0.0.63 → 0.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grest-ts/http",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "type": "module",
   "license": "MIT",
   "description": "HTTP server and client library for Node.js and browser",
@@ -61,16 +61,16 @@
     "find-my-way": "^9.4.0"
   },
   "peerDependencies": {
-    "@grest-ts/common": "0.0.63",
-    "@grest-ts/context": "0.0.63",
-    "@grest-ts/discovery": "0.0.63",
-    "@grest-ts/locator": "0.0.63",
-    "@grest-ts/logger": "0.0.63",
-    "@grest-ts/metrics": "0.0.63",
-    "@grest-ts/schema": "0.0.63",
-    "@grest-ts/trace": "0.0.63"
+    "@grest-ts/common": "0.0.65",
+    "@grest-ts/context": "0.0.65",
+    "@grest-ts/discovery": "0.0.65",
+    "@grest-ts/locator": "0.0.65",
+    "@grest-ts/logger": "0.0.65",
+    "@grest-ts/metrics": "0.0.65",
+    "@grest-ts/schema": "0.0.65",
+    "@grest-ts/trace": "0.0.65"
   },
   "devDependencies": {
-    "@grest-ts/testkit": "0.0.63"
+    "@grest-ts/testkit": "0.0.65"
   }
 }

package/src/_dedupCheck.ts

@@ -12,7 +12,7 @@
 const __KEY = Symbol.for("grest-ts:dedup:@grest-ts/http");
 const __slot = globalThis as Record<symbol, unknown>;
 const __existing = __slot[__KEY] as { path: string; version: string } | undefined;
-const __here = { path: import.meta.url, version: "0.0.63" };
+const __here = { path: import.meta.url, version: "0.0.65" };
 // Same path + same version means the same physical package is being
 // re-evaluated by a different ESM runner (e.g. vitest projects share one
 // process but each project has its own module cache). That isn't a true

package/src/client/GGHttpSchema.createClient.test.ts

@@ -1,6 +1,6 @@
 import {describe, it, expect, vi, afterEach} from 'vitest'
 import {GGContractClass, IsObject, IsString, SERVER_ERROR} from '@grest-ts/schema'
-import {httpSchema} from '../schema/httpSchema'
+import {GGHttpSchema} from '../schema/GGHttpSchema'
 import {GGRpc} from '../rpc/GGHttpRouteRPC'
 import {createClient, _registerDiscoveryUrlResolver} from './GGHttpSchema.createClient'
 import {discoveryUrlResolver} from './GGHttpSchema.createClient.node'
@@ -13,9 +13,11 @@ const PingContract = new GGContractClass("CreateClientTestApi", {
     },
 })
 
-const PingApi = httpSchema(PingContract)
-    .pathPrefix("api/ping")
-    .routes({ping: GGRpc.POST("ping")})
+const PingApi = new GGHttpSchema({
+    contract: PingContract,
+    pathPrefix: "api/ping",
+    routes: {ping: GGRpc.POST("ping")},
+})
 
 function okResponse(): Response {
     return new Response(JSON.stringify({success: true, type: "OK", data: {msg: "pong"}}), {
@@ -67,4 +69,20 @@ describe('createClient discovery url resolution', () => {
         expect(res.msg).toBe("pong")
         expect(resolve).not.toHaveBeenCalled()
     })
+
+    it('a non-JSON response names the status and body in displayMessage (survives reconstruction)', async () => {
+        vi.stubGlobal("fetch", vi.fn(async () => new Response("<html>502 Bad Gateway</html>", {
+            status: 502, headers: {"content-type": "text/html"},
+        })))
+        const client = createClient(PingApi, {url: "http://explicit:1"})
+        const res = await client.ping({msg: "hi"}).asResult()
+        expect(res.success).toBe(false)
+        expect(res).toBeInstanceOf(SERVER_ERROR)
+        if (res instanceof SERVER_ERROR) {
+            // displayMessage survives createErrorObj reconstruction, so the consumer
+            // sees the status + body, not a bare "Failed to parse JSON".
+            expect(res.context?.displayMessage).toContain("HTTP 502")
+            expect(res.context?.displayMessage).toContain("502 Bad Gateway")
+        }
+    })
 })

package/src/client/GGHttpSchema.createClient.ts

@@ -4,7 +4,7 @@ import {isBrowser} from "@grest-ts/common";
 
 
 declare module "../schema/GGHttpSchema" {
-    interface GGHttpSchema<TContract extends GGContractApiDefinition, TContext = {}> {
+    interface GGHttpSchema<TContract extends GGContractApiDefinition> {
         createClient(config?: GGHttpClientConfig): GGContractClient<TContract>
     }
 }
@@ -65,15 +65,15 @@ export function _registerDiscoveryUrlResolver(resolver: (apiName: string) => Pro
     discoveryUrlResolver = resolver
 }
 
-GGHttpSchema.prototype.createClient = function <TContract extends GGContractApiDefinition, TContext>(
-    this: GGHttpSchema<TContract, TContext>,
+GGHttpSchema.prototype.createClient = function <TContract extends GGContractApiDefinition>(
+    this: GGHttpSchema<TContract>,
     config?: GGHttpClientConfig
 ): GGContractClient<TContract> {
     return createClient(this, config);
 }
 
-export function createClient<TContract extends GGContractApiDefinition, TContext>(
-    httpSchema: GGHttpSchema<TContract, TContext>,
+export function createClient<TContract extends GGContractApiDefinition>(
+    httpSchema: GGHttpSchema<TContract>,
     config?: GGHttpClientConfig
 ): GGContractClient<TContract> {
     config ??= {};

package/src/index-browser.ts

@@ -1,7 +1,6 @@
 import "./_dedupCheck";
 // API Schema
 export * from "./schema/GGHttpSchema";
-export * from "./schema/httpSchema";
 export * from "./schema/GGCookie";
 export * from "./schema/GGWireContextKey";
 export * from "./schema/GGHeader";

package/src/index-node.ts

@@ -21,7 +21,6 @@ export * from "./server/GG_HTTP_REQUEST";
 
 // API Schema
 export * from "./schema/GGHttpSchema";
-export * from "./schema/httpSchema";
 export * from "./schema/GGCookie";
 export * from "./schema/GGWireContextKey";
 export * from "./schema/GGWireContextKey.node";
@@ -52,5 +51,4 @@ export * from "./server/GGHttpSchema.startServer";
 // Extensions
 import "./client/GGHttpSchema.createClient";
 import "./client/GGHttpSchema.createClient.node";
-import "./server/GGHttpSchema.startServer";
 import "./schema/GGWireContextKey.node";

package/src/rpc/RpcResponse/GGRpcResponseParser.ts

@@ -1,6 +1,14 @@
 import {ERROR_JSON, OK, SERVER_ERROR} from "@grest-ts/schema";
 import {ClientHttpRouteToRpcTransformClientConfig} from "../../schema/GGHttpSchema";
 
+/** Collapse whitespace and clip a response body to a short, log-safe snippet so a
+ *  non-JSON / wrong-shape response can say what it actually was. */
+function bodySnippet(body: string, max = 300): string {
+    const clean = body.replace(/\s+/g, " ").trim();
+    if (!clean) return "(empty body)";
+    return clean.length > max ? clean.slice(0, max) + "…" : clean;
+}
+
 export class GGRpcResponseParser {
 
     constructor(config: ClientHttpRouteToRpcTransformClientConfig) {
@@ -14,10 +22,13 @@ export class GGRpcResponseParser {
             if (typeof json === "object" && "success" in json && "type" in json) {
                 return json
             } else {
-                return new SERVER_ERROR({displayMessage: "Invalid response format!", debugData: {json: json}});
+                // The status + body snippet ride displayMessage, the one context field
+                // that survives the wire and createErrorObj reconstruction, so the caller
+                // sees what came back instead of a bare "Invalid response format".
+                return new SERVER_ERROR({displayMessage: `Unexpected response shape (HTTP ${response.status}) — not a grest OK/error envelope: ${bodySnippet(txt)}`, debugData: {json: json}});
             }
         } catch (err) {
-            return new SERVER_ERROR({displayMessage: "Failed to parse JSON", originalError: err, debugData: {text: txt}});
+            return new SERVER_ERROR({displayMessage: `Failed to parse response as JSON (HTTP ${response.status}): ${bodySnippet(txt)}`, originalError: err, debugData: {text: txt}});
         }
     }
 }

package/src/schema/GGHttpSchema.ts

@@ -4,7 +4,14 @@ import type http from "http";
 import type {GGContextKey, GGTransportMiddleware} from "@grest-ts/context";
 import type {OpenAPIV3_1} from "openapi-types";
 
-export class GGHttpSchema<TContract extends GGContractApiDefinition, TContext> {
+export interface GGHttpSchemaConfig<TContract extends GGContractApiDefinition> {
+    contract: GGContractClass<TContract>
+    pathPrefix: string
+    use?: readonly GGTransportMiddleware[]
+    routes: Record<keyof TContract, GGHttpCodec>
+}
+
+export class GGHttpSchema<TContract extends GGContractApiDefinition> {
 
     public readonly name: string
     public readonly pathPrefix: string
@@ -12,17 +19,12 @@ export class GGHttpSchema<TContract extends GGContractApiDefinition, TContext> {
     public readonly codec: Record<keyof TContract, GGHttpCodec>
     public readonly contract: GGContractClass<TContract>
 
-    constructor(
-        pathPrefix: string,
-        contract: GGContractClass<TContract>,
-        wireCodec: Record<keyof TContract, GGHttpCodec>,
-        middlewares: readonly GGTransportMiddleware[] = []
-    ) {
-        this.name = contract.name
-        this.pathPrefix = pathPrefix
-        this.apiMiddlewares = middlewares
-        this.codec = wireCodec
-        this.contract = contract
+    constructor(config: GGHttpSchemaConfig<TContract>) {
+        this.name = config.contract.name
+        this.pathPrefix = config.pathPrefix
+        this.apiMiddlewares = config.use ?? []
+        this.codec = config.routes
+        this.contract = config.contract
         Object.freeze(this.apiMiddlewares)
         Object.freeze(this.codec)
         Object.freeze(this)

package/src/server/GGHttp.ts

@@ -2,34 +2,35 @@ import {GGHttpSchema} from "../schema/GGHttpSchema";
 import {GGContractApiDefinition, GGContractImplementation} from "@grest-ts/schema";
 import type {GGTransportMiddleware} from "@grest-ts/context";
 import {GGHttpServer} from "./GGHttpServer";
+import {registerHttpSchema} from "./GGHttpSchema.startServer";
 
-export class GGHttp<TContext = undefined> {
+export class GGHttp {
 
     /**
-     * Protected (not private) so that plugin modules can access the underlying server
-     * via module augmentation (e.g. @grest-ts/openapi adds .openApi() to the builder).
+     * Protected (not private) so plugin packages can reach them from `declare module`
+     * augmentations (@grest-ts/openapi's .openApi(), @grest-ts/websocket's .ws()/.wsRaw()).
      * Do not tighten back to private.
      */
     protected readonly httpServer: GGHttpServer
-    private readonly middlewares: GGTransportMiddleware[] = [];
+    protected readonly middlewares: GGTransportMiddleware[] = [];
 
     constructor(httpServer: GGHttpServer) {
         this.httpServer = httpServer;
     }
 
-    public use<M extends GGTransportMiddleware>(middleware: M): GGHttp<TContext | M> {
+    public use(middleware: GGTransportMiddleware): this {
         this.middlewares.push(middleware);
-        return this as any;
+        return this;
     }
 
-    public http<TContract extends GGContractApiDefinition, TSchemaContext>(
-        schema: GGHttpSchema<TContract, TSchemaContext>,
+    public http<TContract extends GGContractApiDefinition>(
+        schema: GGHttpSchema<TContract>,
         implementation: GGContractImplementation<TContract>
     ): this {
-        schema.register(implementation, {
+        registerHttpSchema(schema, implementation, {
             http: this.httpServer,
             middlewares: this.middlewares,
         });
-        return this as any;
+        return this;
     }
 }

package/src/server/GGHttpSchema.startServer.ts

@@ -1,6 +1,5 @@
 /**
- * Server extension for HttpApiSchema - adds register method.
- * This file should only be imported in server (Node.js) context.
+ * Server-side registerHttpSchema for GGHttpSchema. Node.js only.
  */
 
 import http from "http";
@@ -15,55 +14,32 @@ import {GG_HTTP_REQUEST} from "./GG_HTTP_REQUEST";
 import {GG_COOKIE_WRITES} from "../schema/GGCookie";
 import {GG_METRICS} from "@grest-ts/metrics";
 import {GGHttpMetrics} from "./GGHttpMetrics";
-import {GG_HTTP_SERVER} from "./GG_HTTP_SERVER";
 import {GGHttpServer} from "./GGHttpServer";
 import {GGLog} from "@grest-ts/logger";
 import {GGHttpPermissionsChecker} from "../schema/GGHttpPermissionsChecker";
 
-export interface GGHttpSchemaConfig {
-    /**
-     * The HTTP request handler to register with.
-     */
-    http?: GGHttpServer;
-    /**
-     * Additional middlewares to apply to all routes.
-     */
+export interface GGHttpRegisterConfig {
+    http: GGHttpServer;
     middlewares?: GGTransportMiddleware[];
 }
 
-declare module "../schema/GGHttpSchema" {
-    interface GGHttpSchema<TContract extends GGContractApiDefinition> {
-        /**
-         * Start server with direct implementation.
-         * Uses parseRequest from use classes without transform.
-         * For custom transforms, use createServer() instead.
-         */
-        register(implementation: GGContractImplementation<TContract>, config?: GGHttpSchemaConfig): void
-    }
-}
-
-GGHttpSchema.prototype.register = function <TContract extends GGContractApiDefinition>(
-    this: GGHttpSchema<TContract>,
+export function registerHttpSchema<TContract extends GGContractApiDefinition>(
+    schema: GGHttpSchema<TContract>,
     implementation: GGContractImplementation<TContract>,
-    config?: GGHttpSchemaConfig
-) {
-    return setupRoutes(this, implementation, config)
+    config: GGHttpRegisterConfig
+): void {
+    setupRoutes(schema, implementation, config)
 }
 
 function setupRoutes<TContract extends GGContractApiDefinition>(
     httpSchema: GGHttpSchema<TContract>,
     implementation: GGContractImplementation<TContract>,
-    config?: GGHttpSchemaConfig
+    config: GGHttpRegisterConfig
 ) {
-    config ??= {};
-    config.middlewares ??= [];
-
     if (!httpSchema.contract) throw new Error(`HttpApiSchema "${httpSchema.name}" has no contract.`);
 
-    const server = config.http ?? GGLocator.getScope().get(GG_HTTP_SERVER);
-    if (!server) throw new Error(`No HTTP server found. Make sure to register GGHttpServerAdapter in the scope or pass handler via config`)
-
-    server._registerSchema(httpSchema as GGHttpSchema<any, any>);
+    const server = config.http;
+    server._registerSchema(httpSchema as GGHttpSchema<any>);
 
     const pathPrefix = "/" + httpSchema.pathPrefix + "/"
     const apiMiddlewares = httpSchema.apiMiddlewares;

package/src/server/GGHttpServer.ts

@@ -10,19 +10,20 @@ import {checkWiresImplemented} from "./checkers/checkWiresImplemented";
 import {checkPermissionsAtStart} from "./checkers/checkPermissionsAtStart";
 import {checkWireConflicts} from "./checkers/checkWireConflicts";
 import "../schema/GGWireContextKey.node";
-import {GGContractMethod, GGPermission} from "@grest-ts/schema";
+import {GGContractMethod} from "@grest-ts/schema";
 import type {GGTransportMiddleware} from "@grest-ts/context";
 // Forward declaration — actual type lives in @grest-ts/websocket to avoid circular dep.
-// GGHttpServer only stores the array; callers cast as needed.
+// GGHttpServer only stores the array; callers cast as needed. `contract` is absent for
+// byte-stream schemas (they carry no per-message methods).
 type AnyWebSocketSchema = {
     name: string;
     path: string;
     contract: {
-        clientToServer: {methods: Record<string, GGContractMethod>};
-        serverToClient: {methods: Record<string, GGContractMethod>};
+        connect: {method: GGContractMethod};
+        clientToServer?: {methods: Record<string, GGContractMethod>};
+        serverToClient?: {methods: Record<string, GGContractMethod>};
     };
     middlewares: readonly GGTransportMiddleware[];
-    connectPermission?: GGPermission;
 };
 
 export interface GGCorsConfig {
@@ -80,7 +81,7 @@ export class GGHttpServer {
      * Mutable during compose(); frozen and exposed as ReadonlyArray once the server starts.
      * Framework-internal — only setupRoutes() (in GGHttpSchema.startServer.ts) should push here.
      */
-    private readonly _registeredSchemas: GGHttpSchema<any, any>[] = [];
+    private readonly _registeredSchemas: GGHttpSchema<any>[] = [];
     private readonly _registeredWebSocketSchemas: AnyWebSocketSchema[] = [];
 
     public readonly httpServer: http.Server;
@@ -97,12 +98,12 @@ export class GGHttpServer {
 
     constructor(config?: GGHttpServerAdapterConfig) {
 
-        this.runtimeName = GGLocator.getScope().serviceName;
         this.scope = GGLocator.getScope();
+        this.runtimeName = this.scope.serviceName;
         this.configuredPort = config?.port ?? (process.env.PORT ? Number(process.env.PORT) : 0);
         this.cors = config?.cors;
 
-        GGLocator.getScope().setWithLifecycle(config?.key ?? GG_HTTP_SERVER, this, {
+        this.scope.setWithLifecycle(config?.key ?? GG_HTTP_SERVER, this, {
             type: GGLocatorServiceType.HTTP,
             start: this.start.bind(this),
             teardown: this.teardown.bind(this)
@@ -191,7 +192,7 @@ export class GGHttpServer {
     // =========================================================================
 
     /** @internal Called by setupRoutes() during compose(). Do not call directly. */
-    public _registerSchema(schema: GGHttpSchema<any, any>): void {
+    public _registerSchema(schema: GGHttpSchema<any>): void {
         this._registeredSchemas.push(schema);
     }
 
@@ -199,18 +200,18 @@ export class GGHttpServer {
      * All GGHttpSchema instances registered on this server, in registration order.
      * Available from the moment compose() begins; frozen (no further push allowed) once start() is called.
      */
-    get registeredSchemas(): ReadonlyArray<GGHttpSchema<any, any>> {
+    get registeredSchemas(): ReadonlyArray<GGHttpSchema<any>> {
         return this._registeredSchemas;
     }
 
-    /** @internal Called by GGWebSocketSchema.startServer(). Do not call directly. */
+    /** @internal Called by GGHttp.ws()/.wsRaw(). Do not call directly. */
     public _registerWebSocketSchema(schema: AnyWebSocketSchema): void {
         this._registeredWebSocketSchemas.push(schema);
     }
 
     /**
      * All GGWebSocketSchema instances registered on this server, in registration order.
-     * Populated automatically by GGWebSocketSchema.startServer() / .register().
+     * Populated when a socket schema is registered via GGHttp.ws()/.wsRaw().
      */
     get registeredWebSocketSchemas(): ReadonlyArray<AnyWebSocketSchema> {
         return this._registeredWebSocketSchemas;

package/src/server/checkers/checkPermissionsAtStart.ts

@@ -26,10 +26,11 @@ interface WebSocketSchemaLike {
     name: string
     middlewares: readonly GGTransportMiddleware[]
     contract: {
-        clientToServer: {methods: Record<string, GGContractMethod>}
-        serverToClient: {methods: Record<string, GGContractMethod>}
+        connect: {method: GGContractMethod}
+        // Absent on byte-stream (raw) schemas — they carry only `connect`.
+        clientToServer?: {methods: Record<string, GGContractMethod>}
+        serverToClient?: {methods: Record<string, GGContractMethod>}
     }
-    connectPermission?: GGPermission
 }
 
 function isNonPublic(permission: GGPermission | undefined): boolean {
@@ -57,16 +58,21 @@ export function checkPermissionsAtStart(
     }
     for (const ws of webSocketSchemas) {
         const hasWire = hasPermissionWire(ws.middlewares)
-        const methods = ws.contract.clientToServer.methods
-        for (const name of Object.keys(methods)) {
-            surfaces.push({label: `${ws.name}.${name}`, permission: methods[name].permission, hasWire})
+        const connectPermission = ws.contract.connect.method.permission
+        if (connectPermission !== undefined) {
+            surfaces.push({label: `${ws.name} (connect)`, permission: connectPermission, hasWire})
         }
-        if (ws.connectPermission !== undefined) {
-            surfaces.push({label: `${ws.name} (connectPermission)`, permission: ws.connectPermission, hasWire})
+        const clientToServer = ws.contract.clientToServer?.methods
+        if (clientToServer) {
+            for (const name of Object.keys(clientToServer)) {
+                surfaces.push({label: `${ws.name}.${name}`, permission: clientToServer[name].permission, hasWire})
+            }
         }
-        const pushed = ws.contract.serverToClient.methods
-        for (const name of Object.keys(pushed)) {
-            if (isNonPublic(pushed[name].permission)) deadServerToClient.push(`  ${ws.name}.${name}`)
+        const serverToClient = ws.contract.serverToClient?.methods
+        if (serverToClient) {
+            for (const name of Object.keys(serverToClient)) {
+                if (isNonPublic(serverToClient[name].permission)) deadServerToClient.push(`  ${ws.name}.${name}`)
+            }
         }
     }
 

package/dist/src/schema/httpSchema.d.ts

@@ -1,41 +0,0 @@
-import { GGHttpCodec, GGHttpSchema } from "./GGHttpSchema";
-import { GGContractApiDefinition, GGContractClass } from "@grest-ts/schema";
-import type { GGTransportMiddleware } from "@grest-ts/context";
-/**
- * Create an HTTP API schema builder from a contract.
- *
- * @example
- * export const MyApiContract = defineApi("MyApi", () => ({
- *     list: {
- *         success: IsArray(IsItem),
- *         errors: [NOT_AUTHORIZED, SERVER_ERROR]
- *     },
- *     create: {
- *         input: IsCreateRequest,
- *         success: IsItem,
- *         errors: [NOT_AUTHORIZED, VALIDATION_ERROR, SERVER_ERROR]
- *     }
- * }))
- *
- * export const MyApi = httpApi(MyApiContract)
- *     .pathPrefix("api/items")
- *     .use(AuthMiddleware)
- *     .routes({
- *         list: GGRpc.GET("list"),
- *         create: GGRpc.POST("create")
- *     })
- */
-export declare function httpSchema<TContract extends GGContractApiDefinition>(contract: GGContractClass<TContract>): GGHttpSchemaBuilder<TContract>;
-declare class GGHttpSchemaBuilder<TContract extends GGContractApiDefinition, TContext = undefined> {
-    private readonly _contract;
-    private _pathPrefix;
-    private _middlewares;
-    constructor(contract: GGContractClass<TContract>);
-    pathPrefix(prefix: string): this;
-    use<M extends GGTransportMiddleware>(middleware: M): GGHttpSchemaBuilder<TContract, TContext | M>;
-    routes(mapping: {
-        [K in keyof TContract]: GGHttpCodec;
-    }): GGHttpSchema<TContract, TContext>;
-}
-export {};
-//# sourceMappingURL=httpSchema.d.ts.map

package/dist/src/schema/httpSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpSchema.d.ts","sourceRoot":"","sources":["../../../src/schema/httpSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,YAAY,EAAC,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAC,uBAAuB,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,SAAS,SAAS,uBAAuB,EAChE,QAAQ,EAAE,eAAe,CAAC,SAAS,CAAC,GACrC,mBAAmB,CAAC,SAAS,CAAC,CAEhC;AAED,cAAM,mBAAmB,CAAC,SAAS,SAAS,uBAAuB,EAAE,QAAQ,GAAG,SAAS;IAErF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4B;IACtD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,YAAY,CAA8B;gBAEtC,QAAQ,EAAE,eAAe,CAAC,SAAS,CAAC;IAIhD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKhC,GAAG,CAAC,CAAC,SAAS,qBAAqB,EAAE,UAAU,EAAE,CAAC,GAAG,mBAAmB,CAAC,SAAS,EAAE,QAAQ,GAAG,CAAC,CAAC;IAKjG,MAAM,CAAC,OAAO,EAAE;SAAG,CAAC,IAAI,MAAM,SAAS,GAAG,WAAW;KAAE,GAAG,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC;CAG9F"}

package/dist/src/schema/httpSchema.js

@@ -1,48 +0,0 @@
-import { GGHttpSchema } from "./GGHttpSchema.js";
-/**
- * Create an HTTP API schema builder from a contract.
- *
- * @example
- * export const MyApiContract = defineApi("MyApi", () => ({
- *     list: {
- *         success: IsArray(IsItem),
- *         errors: [NOT_AUTHORIZED, SERVER_ERROR]
- *     },
- *     create: {
- *         input: IsCreateRequest,
- *         success: IsItem,
- *         errors: [NOT_AUTHORIZED, VALIDATION_ERROR, SERVER_ERROR]
- *     }
- * }))
- *
- * export const MyApi = httpApi(MyApiContract)
- *     .pathPrefix("api/items")
- *     .use(AuthMiddleware)
- *     .routes({
- *         list: GGRpc.GET("list"),
- *         create: GGRpc.POST("create")
- *     })
- */
-export function httpSchema(contract) {
-    return new GGHttpSchemaBuilder(contract);
-}
-class GGHttpSchemaBuilder {
-    _contract;
-    _pathPrefix = "";
-    _middlewares = [];
-    constructor(contract) {
-        this._contract = contract;
-    }
-    pathPrefix(prefix) {
-        this._pathPrefix = prefix;
-        return this;
-    }
-    use(middleware) {
-        this._middlewares.push(middleware);
-        return this;
-    }
-    routes(mapping) {
-        return new GGHttpSchema(this._pathPrefix, this._contract, mapping, this._middlewares);
-    }
-}
-//# sourceMappingURL=httpSchema.js.map

package/dist/src/schema/httpSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpSchema.js","sourceRoot":"","sources":["../../../src/schema/httpSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,UAAU,CACtB,QAAoC;IAEpC,OAAO,IAAI,mBAAmB,CAAC,QAAQ,CAAC,CAAA;AAC5C,CAAC;AAED,MAAM,mBAAmB;IAEJ,SAAS,CAA4B;IAC9C,WAAW,GAAW,EAAE,CAAA;IACxB,YAAY,GAA4B,EAAE,CAAA;IAElD,YAAY,QAAoC;QAC5C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC9B,CAAC;IAED,UAAU,CAAC,MAAc;QACrB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAA;QACzB,OAAO,IAAI,CAAA;IACf,CAAC;IAED,GAAG,CAAkC,UAAa;QAC9C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAClC,OAAO,IAA+D,CAAA;IAC1E,CAAC;IAED,MAAM,CAAC,OAAgD;QACnD,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IACzF,CAAC;CACJ"}

package/src/schema/httpSchema.ts

@@ -1,58 +0,0 @@
-import {GGHttpCodec, GGHttpSchema} from "./GGHttpSchema";
-import {GGContractApiDefinition, GGContractClass} from "@grest-ts/schema";
-import type {GGTransportMiddleware} from "@grest-ts/context";
-
-/**
- * Create an HTTP API schema builder from a contract.
- *
- * @example
- * export const MyApiContract = defineApi("MyApi", () => ({
- *     list: {
- *         success: IsArray(IsItem),
- *         errors: [NOT_AUTHORIZED, SERVER_ERROR]
- *     },
- *     create: {
- *         input: IsCreateRequest,
- *         success: IsItem,
- *         errors: [NOT_AUTHORIZED, VALIDATION_ERROR, SERVER_ERROR]
- *     }
- * }))
- *
- * export const MyApi = httpApi(MyApiContract)
- *     .pathPrefix("api/items")
- *     .use(AuthMiddleware)
- *     .routes({
- *         list: GGRpc.GET("list"),
- *         create: GGRpc.POST("create")
- *     })
- */
-export function httpSchema<TContract extends GGContractApiDefinition>(
-    contract: GGContractClass<TContract>
-): GGHttpSchemaBuilder<TContract> {
-    return new GGHttpSchemaBuilder(contract)
-}
-
-class GGHttpSchemaBuilder<TContract extends GGContractApiDefinition, TContext = undefined> {
-
-    private readonly _contract: GGContractClass<TContract>
-    private _pathPrefix: string = ""
-    private _middlewares: GGTransportMiddleware[] = []
-
-    constructor(contract: GGContractClass<TContract>) {
-        this._contract = contract;
-    }
-
-    pathPrefix(prefix: string): this {
-        this._pathPrefix = prefix
-        return this
-    }
-
-    use<M extends GGTransportMiddleware>(middleware: M): GGHttpSchemaBuilder<TContract, TContext | M> {
-        this._middlewares.push(middleware)
-        return this as unknown as GGHttpSchemaBuilder<TContract, TContext | M>
-    }
-
-    routes(mapping: { [K in keyof TContract]: GGHttpCodec }): GGHttpSchema<TContract, TContext> {
-        return new GGHttpSchema(this._pathPrefix, this._contract, mapping, this._middlewares)
-    }
-}