@ez4/gateway 0.34.0 → 0.35.1

package/dist/main.cjs

@@ -1,18 +1,19 @@
-"use strict";var c=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var p=(s,e)=>c(s,"name",{value:e,configurable:!0});var S=(s,e)=>{for(var t in e)c(s,t,{get:e[t],enumerable:!0})},f=(s,e,t,n)=>{if(e&&
-typeof e=="object"||typeof e=="function")for(let o of h(e))!g.call(s,o)&&o!==t&&
-c(s,o,{get:()=>e[o],enumerable:!(n=R(e,o))||n.enumerable});return s};var v=s=>f(c({},"__esModule",{value:!0}),s);var q={};S(q,{Http:()=>H,HttpBadRequestError:()=>u,HttpError:()=>r,HttpForbiddenError:()=>a,
-HttpInternalServerError:()=>d,HttpNotFoundError:()=>m,HttpUnauthorizedError:()=>i,
-HttpUnprocessableEntityError:()=>y,HttpUnsupportedMediaTypeError:()=>x});module.
-exports=v(q);var H;(s=>{})(H||={});var l=require("@ez4/common");var r=class extends l.ServiceError{constructor(t,n,o){super(n,o);this.status=t}static{
-p(this,"HttpError")}},u=class extends r{static{p(this,"HttpBadRequestError")}constructor(e,t){
-super(400,e||"Bad request",t)}},i=class extends r{static{p(this,"HttpUnauthorize\
-dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},a=class extends r{static{
-p(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},m=class extends r{static{
-p(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},x=class extends r{static{
-p(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
-ed media type",t)}},y=class extends r{static{p(this,"HttpUnprocessableEntityErro\
-r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},d=class extends r{static{
-p(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
- error",t)}};0&&(module.exports={Http,HttpBadRequestError,HttpError,HttpForbiddenError,HttpInternalServerError,
-HttpNotFoundError,HttpUnauthorizedError,HttpUnprocessableEntityError,HttpUnsupportedMediaTypeError});
+"use strict";var a=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var o=(r,e)=>a(r,"name",{value:e,configurable:!0});var A=(r,e)=>{for(var t in e)a(r,t,{get:e[t],enumerable:!0})},S=(r,e,t,n)=>{if(e&&
+typeof e=="object"||typeof e=="function")for(let p of f(e))!T.call(r,p)&&p!==t&&
+a(r,p,{get:()=>e[p],enumerable:!(n=h(e,p))||n.enumerable});return r};var g=r=>S(a({},"__esModule",{value:!0}),r);var v={};A(v,{AuthorizationType:()=>c,Http:()=>H,HttpBadRequestError:()=>i,HttpError:()=>s,
+HttpForbiddenError:()=>y,HttpInternalServerError:()=>l,HttpNotFoundError:()=>d,HttpUnauthorizedError:()=>u,
+HttpUnprocessableEntityError:()=>m,HttpUnsupportedMediaTypeError:()=>x});module.
+exports=g(v);var c=(e=>(e.Bearer="bearer",e))(c||{});var H;(r=>{})(H||={});var R=require("@ez4/common");var s=class extends R.ServiceError{constructor(t,n,p){super(n,p);this.status=t}static{
+o(this,"HttpError")}},i=class extends s{static{o(this,"HttpBadRequestError")}constructor(e,t){
+super(400,e||"Bad request",t)}},u=class extends s{static{o(this,"HttpUnauthorize\
+dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},y=class extends s{static{
+o(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},d=class extends s{static{
+o(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},x=class extends s{static{
+o(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
+ed media type",t)}},m=class extends s{static{o(this,"HttpUnprocessableEntityErro\
+r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},l=class extends s{static{
+o(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
+ error",t)}};0&&(module.exports={AuthorizationType,Http,HttpBadRequestError,HttpError,HttpForbiddenError,
+HttpInternalServerError,HttpNotFoundError,HttpUnauthorizedError,HttpUnprocessableEntityError,
+HttpUnsupportedMediaTypeError});
 //# sourceMappingURL=main.cjs.map

package/dist/main.d.ts

@@ -1,3 +1,4 @@
+export { Client, ClientRequest, ClientResponse } from './services/client';
+export { AuthorizationType } from './services/authorization';
 export * from './services/contract';
 export * from './services/errors';
-export { Client, ClientRequest, ClientResponse } from './services/client';

package/dist/main.mjs

@@ -1,14 +1,14 @@
-var d=Object.defineProperty;var r=(s,e)=>d(s,"name",{value:e,configurable:!0});var H;(s=>{})(H||={});import{ServiceError as l}from"@ez4/common";var p=class extends l{constructor(t,x,y){super(x,y);this.status=t}static{r(this,
-"HttpError")}},o=class extends p{static{r(this,"HttpBadRequestError")}constructor(e,t){
-super(400,e||"Bad request",t)}},n=class extends p{static{r(this,"HttpUnauthorize\
-dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},c=class extends p{static{
-r(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},u=class extends p{static{
-r(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},i=class extends p{static{
-r(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
-ed media type",t)}},a=class extends p{static{r(this,"HttpUnprocessableEntityErro\
-r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},m=class extends p{static{
-r(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
- error",t)}};export{H as Http,o as HttpBadRequestError,p as HttpError,c as HttpForbiddenError,
-m as HttpInternalServerError,u as HttpNotFoundError,n as HttpUnauthorizedError,a as HttpUnprocessableEntityError,
-i as HttpUnsupportedMediaTypeError};
+var l=Object.defineProperty;var s=(r,e)=>l(r,"name",{value:e,configurable:!0});var p=(e=>(e.Bearer="bearer",e))(p||{});var H;(r=>{})(H||={});import{ServiceError as R}from"@ez4/common";var o=class extends R{constructor(t,x,m){super(x,m);this.status=t}static{s(this,
+"HttpError")}},n=class extends o{static{s(this,"HttpBadRequestError")}constructor(e,t){
+super(400,e||"Bad request",t)}},a=class extends o{static{s(this,"HttpUnauthorize\
+dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},c=class extends o{static{
+s(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},i=class extends o{static{
+s(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},u=class extends o{static{
+s(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
+ed media type",t)}},y=class extends o{static{s(this,"HttpUnprocessableEntityErro\
+r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},d=class extends o{static{
+s(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
+ error",t)}};export{p as AuthorizationType,H as Http,n as HttpBadRequestError,o as HttpError,
+c as HttpForbiddenError,d as HttpInternalServerError,i as HttpNotFoundError,a as HttpUnauthorizedError,
+y as HttpUnprocessableEntityError,u as HttpUnsupportedMediaTypeError};
 //# sourceMappingURL=main.mjs.map

package/dist/metadata/authorization.d.ts

@@ -0,0 +1,3 @@
+import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { HttpAuthorization } from '../types/common';
+export declare const getHttpAuthorization: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpAuthorization | undefined;

package/dist/metadata/schema.d.ts

@@ -1,2 +1,3 @@
 import type { SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
-export declare const getSchemaFromType: (type: TypeObject | TypeModel | TypeIntersection, reflection: SourceMap) => import("@ez4/schema").ObjectSchema | undefined;
+export declare const getSchemaFromIntersection: (type: TypeObject | TypeModel | TypeIntersection, reflection: SourceMap) => import("@ez4/schema").ObjectSchema | undefined;
+export declare const getSchemaFromObject: (type: TypeObject | TypeModel | TypeIntersection, reflection: SourceMap) => import("@ez4/schema").ObjectSchema | undefined;

package/dist/metadata/utils.d.ts

@@ -10,6 +10,7 @@ export declare const isHttpHandlerRequest: (type: TypeModel) => boolean;
 export declare const isHttpAuthorizerResponse: (type: TypeModel) => boolean;
 export declare const isHttpHandlerResponse: (type: TypeModel) => boolean;
 export declare const isHttpDefaults: (type: TypeModel) => boolean;
+export declare const isHttpAuthorization: (type: TypeModel) => boolean;
 export declare const isHttpPreferences: (type: TypeModel) => boolean;
 export declare const isHttpHeaders: (type: TypeModel) => boolean;
 export declare const isHttpIdentity: (type: TypeModel) => boolean;

package/dist/services/access.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP access configuration.
+ */
+export interface HttpAccess {
+    /**
+     * Log retention (in days) for the access log.
+     */
+    readonly logRetention: number;
+}

package/dist/services/authorization.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HTTP authorization types.
+ */
+export declare const enum AuthorizationType {
+    Bearer = "bearer"
+}
+/**
+ * HTTP authorization configuration.
+ */
+export interface HttpAuthorization {
+    /**
+     * Determines the HTTP authorization type.
+     * Default is: `AuthorizationType.Bearer`
+     */
+    readonly type?: AuthorizationType;
+    /**
+     * Determines the authorization header name.
+     * Default is: `authorization`
+     */
+    readonly header?: string;
+    /**
+     * Determines the HTTP authorization value.
+     */
+    readonly value: string;
+}

package/dist/services/cache.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP cache configuration.
+ */
+export interface HttpCache {
+    /**
+     * Default TTL (in seconds) for cached authorizations.
+     */
+    readonly authorizerTTL: number;
+}

package/dist/services/client.d.ts

@@ -1,15 +1,15 @@
-import type { AnyObject, Prettify } from '@ez4/utils';
+import type { AnyObject, IsObjectEmpty, OptionalProperties, Prettify } from '@ez4/utils';
 import type { Http } from './contract';
 /**
  * HTTP client.
  */
-export type Client<T extends Http.Service> = {
+export type Client<T extends Http.Service | Http.Import<any>> = {
     [P in ClientRoutes<T> as P extends {
         name: infer N;
     } ? (N extends string ? N : never) : never]: P extends {
         handler: infer H;
         authorizer: infer A;
-    } ? AuthorizedClientOperation<H, A> : P extends {
+    } ? AuthorizedClientOperation<H, A, AuthorizationHeaderName<T>> : P extends {
         handler: infer H;
     } ? ClientOperation<H> : never;
 };
@@ -17,51 +17,95 @@ export type Client<T extends Http.Service> = {
  * Default HTTP client request.
  */
 export type ClientRequest = RequestOptions & {
-    headers?: Record<string, string>;
-    parameters?: Record<string, string>;
-    query?: Record<string, unknown>;
-    body?: string | AnyObject;
+    readonly headers?: Record<string, string>;
+    readonly parameters?: Record<string, string>;
+    readonly query?: Record<string, unknown>;
+    readonly body?: string | AnyObject;
 };
 /**
  * Default HTTP response.
  */
 export type ClientResponse = {
-    status: number;
-    headers?: Record<string, string | undefined>;
-    body?: unknown;
+    readonly status: number;
+    readonly headers?: Record<string, string | undefined>;
+    readonly body?: unknown;
 };
 /**
- * Given a HTTP service `T`, it produces a union type containing all gateway routes.
+ * Given a HTTP service `H`, it produces a union type containing all gateway routes.
  */
-type ClientRoutes<T extends Http.Service> = T extends {
+type ClientRoutes<H extends Http.Service> = H extends {
     routes: (infer R)[];
 } ? R : never;
 /**
- * Given a handler type `T`, it produces a callback to invoke the operation.
+ * Given a handler type `H`, it produces a callback to invoke the operation.
  */
-type ClientOperation<T> = T extends (...args: any) => any ? (request: OperationRequest<T>) => OperationResponse<T> : never;
+type ClientOperation<H> = H extends (...args: any) => any ? (request: OperationRequest<H>) => OperationResponse<H> : never;
 /**
- * Given a handler type `T`, it produces a request type.
+ * Given a handler type `H`, it produces a request type.
  */
-type OperationRequest<T extends (...args: any) => any> = Prettify<RequestSchema<Parameters<T>[0]> & RequestOptions>;
+type OperationRequest<H extends (...args: any) => any> = Prettify<RequestSchema<Parameters<H>[0], never> & RequestOptions>;
 /**
- * Given a handler type `T`, it produces a callback to invoke the operation.
+ * Given a service type `T`, it returns the authorization header name.
  */
-type AuthorizedClientOperation<T, U> = T extends (...args: any) => any ? U extends (...args: any) => any ? (request: AuthorizedOperationRequest<T, U>) => OperationResponse<T> : never : never;
+type AuthorizationHeaderName<T extends Http.Service | Http.Import<any>> = T extends {
+    authorization: infer A;
+} ? A extends {
+    header: infer H;
+} ? H : 'authorization' : never;
 /**
- * Given a handler type `T`, it produces a request type.
+ * Given a handler type `H` and an authorizer type `A`, it produces a callback to invoke the authorized operation.
  */
-type AuthorizedOperationRequest<T extends (...args: any) => any, U extends (...args: any) => any> = Prettify<RequestSchema<Parameters<T>[0]> & RequestSchema<Parameters<U>[0]> & RequestOptions>;
+type AuthorizedClientOperation<H, A, N extends string> = H extends (...args: any) => any ? A extends (...args: any) => any ? (request: AuthorizedOperationRequest<H, A, N>) => OperationResponse<H> : never : never;
 /**
- * Given a handler type `T`, it produces a response type.
+ * Given a handler type `H` and an authorized type `A`, it produces a request type for the authorized request.
  */
-type OperationResponse<T extends (...args: any) => any> = Promise<Awaited<ReturnType<T>>>;
+type AuthorizedOperationRequest<H extends (...args: any) => any, A extends (...args: any) => any, N extends string> = Prettify<RequestSchema<Parameters<H>[0], never> & RequestSchema<Parameters<A>[0], N> & RequestOptions>;
 /**
- * Given a request type `T`, it produces a request schema containing only valid parameters.
+ * Given a handler type `H`, it produces a response type.
  */
-type RequestSchema<T> = T extends AnyObject ? {
-    [P in keyof T as P extends 'parameters' | 'headers' | 'query' | 'body' ? P : never]: T[P];
-} : never;
+type OperationResponse<H extends (...args: any) => any> = Promise<Awaited<ReturnType<H>>>;
+/**
+ * Given a request type `R`, it produces a request schema containing only valid parameters.
+ */
+type RequestSchema<R, H extends string> = R extends AnyObject ? RequestHeaders<R, H> & RequestParameters<R> & RequestQuery<R> & RequestBody<R> : never;
+/**
+ * Given a request type `R`, it produces a request headers type.
+ */
+type RequestHeaders<R, H extends string> = R extends {
+    headers: infer T;
+} ? IsObjectEmpty<Omit<T, H>> extends false ? {
+    readonly headers: Prettify<Omit<T, H>>;
+} : {} : {};
+/**
+ * Given a request type `R`, it produces a request parameters type.
+ */
+type RequestParameters<R> = R extends {
+    parameters: infer T;
+} ? IsObjectEmpty<Omit<T, OptionalProperties<NonNullable<T>>>> extends true ? {
+    readonly parameters?: T;
+} : {
+    readonly parameters: T;
+} : {};
+/**
+ * Given a request type `R`, it produces a request query type.
+ */
+type RequestQuery<R> = R extends {
+    query: infer T;
+} ? IsObjectEmpty<Omit<T, OptionalProperties<NonNullable<T>>>> extends true ? {
+    readonly query?: T;
+} : {
+    readonly query: T;
+} : {};
+/**
+ * Given a request type `R`, it produces a request body type.
+ */
+type RequestBody<R> = R extends {
+    body: infer T;
+} ? IsObjectEmpty<Omit<T, OptionalProperties<NonNullable<T>>>> extends true ? {
+    readonly body?: T;
+} : {
+    readonly body: T;
+} : {};
 /**
  * All request options.
  */
@@ -69,6 +113,6 @@ type RequestOptions = {
     /**
      * Maximum wait time for a response.
      */
-    timeout?: number;
+    readonly timeout?: number;
 };
 export {};

package/dist/services/common.d.ts

@@ -1,63 +1,6 @@
-import type { LinkedVariables } from '@ez4/project/library';
-import type { NamingStyle } from '@ez4/schema';
 import type { Service } from '@ez4/common';
+import type { HttpProvider } from './provider';
 import type { Http } from './contract';
-/**
- * Contract for HTTP preferences.
- */
-export interface HttpPreferences {
-    /**
-     * Determines the naming style for the query strings and body payloads.
-     */
-    namingStyle?: NamingStyle;
-}
-/**
- * HTTP CORS configuration.
- */
-export interface HttpCors {
-    /**
-     * List of allowed origins.
-     */
-    allowOrigins: string[];
-    /**
-     * List of allowed methods.
-     */
-    allowMethods?: string[];
-    /**
-     * Determines whether or not requests can be made with credentials.
-     */
-    allowCredentials?: boolean;
-    /**
-     * List of allowed headers.
-     */
-    allowHeaders?: string[];
-    /**
-     * List of exposed headers.
-     */
-    exposeHeaders?: string[];
-    /**
-     * Determines how long the preflight result can be cached.
-     */
-    maxAge?: number;
-}
-/**
- * HTTP cache configuration.
- */
-export interface HttpCache {
-    /**
-     * Default TTL (in seconds) for cached authorizations.
-     */
-    authorizerTTL: number;
-}
-/**
- * HTTP access configuration.
- */
-export interface HttpAccess {
-    /**
-     * Log retention (in days) for the access log.
-     */
-    logRetention: number;
-}
 /**
  * Request headers.
  */
@@ -91,22 +34,18 @@ export type HttpRawBody = string;
  * Authorizer request.
  */
 export interface HttpAuthRequest {
-    /**
-     * Auth request preferences.
-     */
-    preferences?: HttpPreferences;
     /**
      * Expected HTTP headers.
      */
-    headers?: HttpHeaders;
+    readonly headers?: HttpHeaders;
     /**
      * Expected HTTP path parameters.
      */
-    parameters?: HttpPathParameters;
+    readonly parameters?: HttpPathParameters;
     /**
      * Expected HTTP query strings.
      */
-    query?: HttpQueryStrings;
+    readonly query?: HttpQueryStrings;
 }
 /**
  * Authorizer response.
@@ -115,67 +54,49 @@ export interface HttpAuthResponse {
     /**
      * Authorization identity.
      */
-    identity?: HttpIdentity;
+    readonly identity?: HttpIdentity;
 }
 /**
  * HTTP request.
  */
 export interface HttpRequest {
-    /**
-     * Request preferences.
-     */
-    preferences?: HttpPreferences;
     /**
      * Expected identity.
      */
-    identity?: HttpIdentity;
+    readonly identity?: HttpIdentity;
     /**
      * Expected HTTP headers.
      */
-    headers?: HttpHeaders;
+    readonly headers?: HttpHeaders;
     /**
      * Expected HTTP path parameters.
      */
-    parameters?: HttpPathParameters;
+    readonly parameters?: HttpPathParameters;
     /**
      * Expected HTTP query strings.
      */
-    query?: HttpQueryStrings;
+    readonly query?: HttpQueryStrings;
     /**
      * Expected HTTP body payload.
      */
-    body?: HttpJsonBody | HttpRawBody;
+    readonly body?: HttpJsonBody | HttpRawBody;
 }
 /**
  * HTTP response.
  */
 export interface HttpResponse {
-    /**
-     * Response preferences.
-     */
-    preferences?: HttpPreferences;
     /**
      * HTTP status code.
      */
-    status: number;
+    readonly status: number;
     /**
      * HTTP headers.
      */
-    headers?: HttpHeaders;
+    readonly headers?: HttpHeaders;
     /**
      * HTTP body payload.
      */
-    body?: HttpJsonBody | HttpRawBody;
-}
-export interface HttpProvider {
-    /**
-     * Variables associated to the provider.
-     */
-    variables?: LinkedVariables;
-    /**
-     * All services associated to the provider.
-     */
-    services: Record<string, unknown>;
+    readonly body?: HttpJsonBody | HttpRawBody;
 }
 /**
  * Incoming request.
@@ -184,23 +105,27 @@ export type HttpIncoming<T extends HttpRequest | HttpAuthRequest> = T & {
     /**
      * Request tracking Id.
      */
-    requestId: string;
+    readonly requestId: string;
     /**
      * Determines whether request is base64 encoded or not.
      */
-    encoded?: boolean;
+    readonly encoded?: boolean;
     /**
      * Request timestamp.
      */
-    timestamp: Date;
+    readonly timestamp: Date;
     /**
      * Request method.
      */
-    method: string;
+    readonly method: string;
     /**
      * Request path.
      */
-    path: string;
+    readonly path: string;
+    /**
+     * Raw body data (when provided in the request).
+     */
+    readonly data?: string;
 };
 /**
  * Request listener.
@@ -218,5 +143,5 @@ export type HttpHandler<T extends HttpRequest> = (request: HttpIncoming<T> | T,
  * HTTP errors.
  */
 export type HttpErrors = {
-    [code: number]: Error[];
+    [code: number]: readonly Error[];
 };