@ez4/gateway 0.29.0 → 0.31.0

package/dist/main.cjs

@@ -1,17 +1,17 @@
-"use strict";var u=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var p=(s,e)=>u(s,"name",{value:e,configurable:!0});var S=(s,e)=>{for(var t in e)u(s,t,{get:e[t],enumerable:!0})},q=(s,e,t,n)=>{if(e&&
+"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&&
-u(s,o,{get:()=>e[o],enumerable:!(n=l(e,o))||n.enumerable});return s};var f=s=>q(u({},"__esModule",{value:!0}),s);var A={};S(A,{Http:()=>d,HttpBadRequestError:()=>c,HttpError:()=>r,HttpForbiddenError:()=>a,
-HttpInternalServerError:()=>H,HttpNotFoundError:()=>x,HttpUnauthorizedError:()=>i,
-HttpUnprocessableEntityError:()=>y,HttpUnsupportedMediaTypeError:()=>m});module.
-exports=f(A);var d;(s=>{})(d||={});var R=require("@ez4/common");var r=class extends R.ServiceError{constructor(t,n,o){super(n,o);this.status=t}static{
-p(this,"HttpError")}},c=class extends r{static{p(this,"HttpBadRequestError")}constructor(e,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)}},x=class extends r{static{
-p(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},m=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)}},H=class extends r{static{
+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});

package/dist/main.d.ts

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

package/dist/main.mjs

@@ -1,14 +1,14 @@
-var H=Object.defineProperty;var r=(s,e)=>H(s,"name",{value:e,configurable:!0});var d;(s=>{})(d||={});import{ServiceError as R}from"@ez4/common";var p=class extends R{constructor(t,m,y){super(m,y);this.status=t}static{r(this,
+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)}},u=class extends p{static{
-r(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},c=class extends p{static{
+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)}},x=class extends p{static{
+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{d as Http,o as HttpBadRequestError,p as HttpError,u as HttpForbiddenError,
-x as HttpInternalServerError,c as HttpNotFoundError,n as HttpUnauthorizedError,a as HttpUnprocessableEntityError,
+ 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};
 //# sourceMappingURL=main.mjs.map

package/dist/metadata/access.d.ts

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

package/dist/metadata/authorizer.d.ts

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

package/dist/metadata/body.d.ts

@@ -1,5 +1,5 @@
 import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
 import type { ArraySchema, ObjectSchema, UnionSchema } from '@ez4/schema/library';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
-export declare const getHttpBody: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").BooleanSchema | import("@ez4/schema").NumberSchema | import("@ez4/schema").StringSchema | ObjectSchema | UnionSchema | ArraySchema | null;
+export declare const getHttpBody: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => ObjectSchema | UnionSchema | ArraySchema | import("@ez4/schema").BooleanSchema | import("@ez4/schema").NumberSchema | import("@ez4/schema").StringSchema | undefined;
 export {};

package/dist/metadata/cache.d.ts

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

package/dist/metadata/context.d.ts

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

package/dist/metadata/cors.d.ts

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

package/dist/metadata/defaults.d.ts

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

package/dist/metadata/errors.d.ts

@@ -1,4 +1,4 @@
 import type { AllType, ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
 import type { HttpErrors } from '../types/common';
-export declare const getHttpErrors: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpErrors | null;
+export declare const getHttpErrors: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpErrors | undefined;
 export declare const getErrorClasses: (member: ModelProperty, errorCode: number, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpErrors;

package/dist/metadata/handler.d.ts

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

package/dist/metadata/headers.d.ts

@@ -1,4 +1,4 @@
 import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
-export declare const getHttpHeaders: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | null;
+export declare const getHttpHeaders: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | undefined;
 export {};

package/dist/metadata/identity.d.ts

@@ -1,5 +1,5 @@
 import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
 import type { ObjectSchema, UnionSchema } from '@ez4/schema/library';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
-export declare const getHttpIdentity: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => ObjectSchema | UnionSchema | null;
+export declare const getHttpIdentity: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => ObjectSchema | UnionSchema | undefined;
 export {};

package/dist/metadata/import.d.ts

@@ -0,0 +1,6 @@
+import type { SourceMap } from '@ez4/reflection';
+import type { HttpImport } from '../types/import';
+export declare const getHttpImports: (reflection: SourceMap) => {
+    services: Record<string, HttpImport>;
+    errors: Error[];
+};

package/dist/metadata/parameters.d.ts

@@ -1,4 +1,4 @@
 import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
-export declare const getHttpParameters: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | null;
+export declare const getHttpParameters: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | undefined;
 export {};

package/dist/metadata/provider.d.ts

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

package/dist/metadata/query.d.ts

@@ -1,4 +1,4 @@
 import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
-export declare const getHttpQuery: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | null;
+export declare const getHttpQuery: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[]) => import("@ez4/schema").ObjectSchema | undefined;
 export {};

package/dist/metadata/request.d.ts

@@ -1,4 +1,4 @@
 import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
 import type { HttpAuthRequest, HttpRequest } from '../types/common';
-export declare const getHttpAuthRequest: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => (HttpAuthRequest & HttpRequest) | null;
-export declare const getHttpHandlerRequest: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => (HttpAuthRequest & HttpRequest) | null;
+export declare const getHttpAuthRequest: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => (HttpAuthRequest & HttpRequest) | undefined;
+export declare const getHttpHandlerRequest: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => (HttpAuthRequest & HttpRequest) | undefined;

package/dist/metadata/response.d.ts

@@ -1,5 +1,4 @@
 import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
-import type { Incomplete } from '@ez4/utils';
 import type { HttpAuthResponse, HttpResponse } from '../types/common';
-export declare const getHttpAuthResponse: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => Incomplete<HttpAuthResponse & HttpResponse> | null;
-export declare const getHttpHandlerResponse: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpResponse | null;
+export declare const getHttpAuthResponse: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpAuthResponse | undefined;
+export declare const getHttpHandlerResponse: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpResponse | undefined;

package/dist/metadata/route.d.ts

@@ -1,3 +1,4 @@
 import type { ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
 import type { HttpRoute } from '../types/common';
-export declare const getHttpRoutes: (parent: TypeModel, member: ModelProperty, reflection: SourceMap, errorList: Error[]) => HttpRoute[];
+export declare const getHttpLocalRoutes: (parent: TypeModel, member: ModelProperty, reflection: SourceMap, errorList: Error[]) => HttpRoute[] | undefined;
+export declare const getHttpRemoteRoutes: (parent: TypeModel, member: ModelProperty, reflection: SourceMap, errorList: Error[]) => HttpRoute[] | undefined;

package/dist/metadata/schema.d.ts

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

package/dist/metadata/utils.d.ts

@@ -2,6 +2,8 @@ import type { AllType, TypeCallback, TypeClass, TypeFunction, TypeModel } from '
 import type { HttpPath } from '../types/common';
 export declare const isHttpPath: (path: string) => path is HttpPath;
 export declare const isHttpService: (type: AllType) => type is TypeClass;
+export declare const isHttpImport: (type: AllType) => type is TypeClass;
+export declare const isHttpProvider: (type: AllType) => type is TypeModel;
 export declare const isHttpRoute: (type: AllType) => type is TypeModel;
 export declare const isHttpAuthorizerRequest: (type: TypeModel) => boolean;
 export declare const isHttpHandlerRequest: (type: TypeModel) => boolean;
@@ -14,7 +16,8 @@ export declare const isHttpIdentity: (type: TypeModel) => boolean;
 export declare const isHttpQuery: (type: TypeModel) => boolean;
 export declare const isHttpParameters: (type: TypeModel) => boolean;
 export declare const isJsonBody: (type: TypeModel) => boolean;
-export declare const isHttpCors: (type: TypeModel) => boolean;
 export declare const isHttpCache: (type: TypeModel) => boolean;
+export declare const isHttpAccess: (type: TypeModel) => boolean;
+export declare const isHttpCors: (type: TypeModel) => boolean;
 export declare const isHttpAuthorizer: (type: AllType) => type is TypeCallback | TypeFunction;
 export declare const isHttpHandler: (type: AllType) => type is TypeCallback | TypeFunction;

package/dist/services/client.d.ts

@@ -0,0 +1,73 @@
+import type { AnyObject, Prettify } from '@ez4/utils';
+import type { Http } from './contract';
+/**
+ * HTTP client.
+ */
+export type Client<T extends Http.Service> = {
+    [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 {
+        handler: infer H;
+    } ? ClientOperation<H> : never;
+};
+/**
+ * Default HTTP client request.
+ */
+export type ClientRequest = RequestOptions & {
+    headers?: Record<string, string>;
+    parameters?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: string | AnyObject;
+};
+/**
+ * Default HTTP response.
+ */
+export type ClientResponse = {
+    status: number;
+    body?: unknown;
+};
+/**
+ * Given a HTTP service `T`, it produces a union type containing all gateway routes.
+ */
+type ClientRoutes<T extends Http.Service> = T extends {
+    routes: (infer R)[];
+} ? R : never;
+/**
+ * Given a handler type `T`, it produces a callback to invoke the operation.
+ */
+type ClientOperation<T> = T extends (...args: any) => any ? (request: OperationRequest<T>) => OperationResponse<T> : never;
+/**
+ * Given a handler type `T`, it produces a request type.
+ */
+type OperationRequest<T extends (...args: any) => any> = Prettify<RequestSchema<Parameters<T>[0]> & RequestOptions>;
+/**
+ * Given a handler type `T`, it produces a callback to invoke the operation.
+ */
+type AuthorizedClientOperation<T, U> = T extends (...args: any) => any ? U extends (...args: any) => any ? (request: AuthorizedOperationRequest<T, U>) => OperationResponse<T> : never : never;
+/**
+ * Given a handler type `T`, it produces a request type.
+ */
+type AuthorizedOperationRequest<T extends (...args: any) => any, U extends (...args: any) => any> = Prettify<RequestSchema<Parameters<T>[0]> & RequestSchema<Parameters<U>[0]> & RequestOptions>;
+/**
+ * Given a handler type `T`, it produces a response type.
+ */
+type OperationResponse<T extends (...args: any) => any> = Promise<Awaited<ReturnType<T>>>;
+/**
+ * Given a request type `T`, it produces a request schema containing only valid parameters.
+ */
+type RequestSchema<T> = T extends AnyObject ? {
+    [P in keyof T as P extends 'parameters' | 'headers' | 'query' | 'body' ? P : never]: T[P];
+} : never;
+/**
+ * All request options.
+ */
+type RequestOptions = {
+    /**
+     * Maximum wait time for a response.
+     */
+    timeout?: number;
+};
+export {};

package/dist/services/common.d.ts

@@ -1,5 +1,6 @@
-import type { Service } from '@ez4/common';
+import type { LinkedVariables } from '@ez4/project/library';
 import type { NamingStyle } from '@ez4/schema';
+import type { Service } from '@ez4/common';
 import type { Http } from './contract';
 /**
  * Contract for HTTP preferences.
@@ -40,7 +41,7 @@ export interface HttpCors {
     maxAge?: number;
 }
 /**
- * HTTP cache.
+ * HTTP cache configuration.
  */
 export interface HttpCache {
     /**
@@ -48,6 +49,15 @@ export interface HttpCache {
      */
     authorizerTTL: number;
 }
+/**
+ * HTTP access configuration.
+ */
+export interface HttpAccess {
+    /**
+     * Log retention (in days) for the access log.
+     */
+    logRetention: number;
+}
 /**
  * Request headers.
  */
@@ -158,6 +168,10 @@ export interface HttpResponse {
     body?: HttpJsonBody | HttpRawBody;
 }
 export interface HttpProvider {
+    /**
+     * Variables associated to the provider.
+     */
+    variables?: LinkedVariables;
     /**
      * All services associated to the provider.
      */

package/dist/services/contract.d.ts

@@ -1,8 +1,9 @@
 import type { Service as CommonService } from '@ez4/common';
 import type { LinkedVariables } from '@ez4/project/library';
 import type { HttpPath } from '../types/common';
-import type { HttpSuccessStatuses, HttpEmptySuccessResponse, HttpSuccessResponse } from './utils';
-import type { HttpHeaders, HttpIdentity, HttpPathParameters, HttpQueryStrings, HttpJsonBody, HttpRawBody, HttpPreferences, HttpAuthRequest, HttpAuthResponse, HttpRequest, HttpResponse, HttpErrors, HttpProvider, HttpIncoming, HttpListener, HttpAuthorizer, HttpHandler, HttpCache, HttpCors } from './common';
+import type { HttpSuccessStatuses, HttpSuccessEmptyResponse, HttpSuccessResponse } from './utils';
+import type { Client } from './client';
+import type { HttpHeaders, HttpIdentity, HttpPathParameters, HttpQueryStrings, HttpJsonBody, HttpRawBody, HttpPreferences, HttpAuthRequest, HttpAuthResponse, HttpRequest, HttpResponse, HttpErrors, HttpProvider, HttpIncoming, HttpListener, HttpAuthorizer, HttpHandler, HttpCache, HttpAccess, HttpCors } from './common';
 /**
  * Provide all contracts for a self-managed HTTP service.
  */
@@ -21,18 +22,23 @@ export declare namespace Http {
     type Errors = HttpErrors;
     type Provider = HttpProvider;
     type Cache = HttpCache;
+    type Access = HttpAccess;
     type Cors = HttpCors;
     type Incoming<T extends Request | AuthRequest> = HttpIncoming<T>;
     type Listener<T extends Request | AuthRequest> = HttpListener<T>;
     type Authorizer<T extends AuthRequest> = HttpAuthorizer<T>;
     type Handler<T extends Request> = HttpHandler<T>;
     type ServiceEvent<T extends Request | AuthRequest = Request> = CommonService.AnyEvent<Incoming<T>>;
-    type EmptySuccessResponse<S extends HttpSuccessStatuses = 204> = HttpEmptySuccessResponse<S>;
+    type SuccessEmptyResponse<S extends HttpSuccessStatuses = 204> = HttpSuccessEmptyResponse<S>;
     type SuccessResponse<S extends HttpSuccessStatuses, T extends HttpRawBody | HttpJsonBody> = HttpSuccessResponse<S, T>;
     /**
      * HTTP route.
      */
     interface Route<T extends Request = Request, U extends AuthRequest = AuthRequest> {
+        /**
+         * Route name.
+         */
+        name?: string;
         /**
          * Route path.
          */
@@ -127,6 +133,10 @@ export declare namespace Http {
          * Cache configuration.
          */
         cache?: Cache;
+        /**
+         * Access configuration.
+         */
+        access?: Access;
         /**
          * Variables associated to all routes.
          */
@@ -134,6 +144,43 @@ export declare namespace Http {
         /**
          * Service client.
          */
-        client: never;
+        client: Client<Service>;
+    }
+    /**
+     * Imported HTTP service.
+     */
+    abstract class Import<T extends Service> implements CommonService.Provider {
+        /**
+         * Name of the imported project defined in the project options file.
+         */
+        abstract project: string;
+        /**
+         * Imported service reference.
+         */
+        reference: T;
+        /**
+         * All routes attached to the imported service (do not replace).
+         */
+        routes: T['routes'];
+        /**
+         * Display name for the service imported service (do not replace).
+         */
+        name: T['name'];
+        /**
+         * All default configurations attached to the imported service (do not replace).
+         */
+        defaults: T['defaults'];
+        /**
+         * Imported service client (do not replace).
+         */
+        client: Client<T>;
+        /**
+         * Variables are not allowed.
+         */
+        variables: never;
+        /**
+         * Services are not allowed.
+         */
+        service: never;
     }
 }

package/dist/services/utils.d.ts

@@ -3,7 +3,7 @@ export type HttpSuccessStatuses = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207
 /**
  * Common HTTP success response without a response body.
  */
-export declare class HttpEmptySuccessResponse<S extends HttpSuccessStatuses> implements HttpResponse {
+export declare class HttpSuccessEmptyResponse<S extends HttpSuccessStatuses> implements HttpResponse {
     /**
      * HTTP status code.
      */

package/dist/triggers/service.d.ts

@@ -0,0 +1,3 @@
+import type { TypeClass } from '@ez4/reflection';
+export declare const getLinkedService: (declaration: TypeClass) => string | null;
+export declare const getLinkedImport: (declaration: TypeClass) => string | null;

package/dist/types/common.d.ts

@@ -1,5 +1,5 @@
 import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
-import type { LinkedVariables } from '@ez4/project/library';
+import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
 import type { ServiceListener } from '@ez4/common/library';
 export type HttpVerb = 'ANY' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
 export type HttpPath = `${HttpVerb} /${string}`;
@@ -7,32 +7,33 @@ export type HttpPreferences = {
     namingStyle?: NamingStyle;
 };
 export type HttpAuthRequest = {
-    headers?: ObjectSchema | null;
-    parameters?: ObjectSchema | null;
-    query?: ObjectSchema | null;
+    headers?: ObjectSchema;
+    parameters?: ObjectSchema;
+    query?: ObjectSchema;
 };
 export type HttpAuthResponse = {
-    identity?: ObjectSchema | UnionSchema | null;
+    identity?: ObjectSchema | UnionSchema;
 };
 export type HttpRequest = {
-    identity?: ObjectSchema | UnionSchema | null;
-    headers?: ObjectSchema | null;
-    parameters?: ObjectSchema | null;
-    query?: ObjectSchema | null;
-    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema | null;
+    identity?: ObjectSchema | UnionSchema;
+    headers?: ObjectSchema;
+    parameters?: ObjectSchema;
+    query?: ObjectSchema;
+    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
 };
 export type HttpResponse = {
-    status: number;
-    headers?: ObjectSchema | null;
-    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema | null;
+    status: number | number[];
+    headers?: ObjectSchema;
+    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
 };
 export type HttpHandler = {
     name: string;
+    file: string;
+    module?: string;
     description?: string;
     response: HttpResponse;
     request?: HttpRequest;
-    file: string;
-    module?: string;
+    provider?: HttpProvider;
 };
 export type HttpAuthorizer = {
     name: string;
@@ -46,29 +47,33 @@ export type HttpErrors = {
     [name: string]: number;
 };
 export type HttpRoute = {
+    name?: string;
     path: HttpPath;
     handler: HttpHandler;
-    listener?: ServiceListener | null;
-    authorizer?: HttpAuthorizer | null;
-    variables?: LinkedVariables | null;
-    httpErrors?: HttpErrors | null;
+    listener?: ServiceListener;
+    authorizer?: HttpAuthorizer;
+    variables?: LinkedVariables;
+    httpErrors?: HttpErrors;
     preferences?: HttpPreferences;
-    logRetention?: number | null;
-    timeout?: number | null;
-    memory?: number | null;
-    cors?: boolean | null;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+    cors?: boolean;
 };
 export type HttpDefaults = {
-    listener?: ServiceListener | null;
-    httpErrors?: HttpErrors | null;
+    listener?: ServiceListener;
+    httpErrors?: HttpErrors;
     preferences?: HttpPreferences;
-    logRetention?: number | null;
-    timeout?: number | null;
-    memory?: number | null;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
 };
 export type HttpCache = {
     authorizerTTL?: number;
 };
+export type HttpAccess = {
+    logRetention: number;
+};
 export type HttpCors = {
     allowOrigins: string[];
     allowMethods?: string[];
@@ -77,3 +82,7 @@ export type HttpCors = {
     allowHeaders?: string[];
     maxAge?: number;
 };
+export type HttpProvider = {
+    variables?: LinkedVariables;
+    services?: LinkedServices;
+};

package/dist/types/import.d.ts

@@ -0,0 +1,13 @@
+import type { ServiceMetadata } from '@ez4/project/library';
+import type { HttpRoute, HttpDefaults } from './common';
+export declare const ImportType = "@ez4/import:http";
+export type HttpImport = ServiceMetadata & {
+    type: typeof ImportType;
+    reference: string;
+    project: string;
+    displayName?: string;
+    description?: string;
+    defaults?: HttpDefaults;
+    routes: HttpRoute[];
+};
+export declare const isHttpImport: (service: ServiceMetadata) => service is HttpImport;

package/dist/types/service.d.ts

@@ -1,5 +1,5 @@
 import type { ServiceMetadata } from '@ez4/project/library';
-import type { HttpRoute, HttpCors, HttpDefaults, HttpCache } from './common';
+import type { HttpRoute, HttpCors, HttpDefaults, HttpCache, HttpAccess } from './common';
 export declare const ServiceType = "@ez4/http";
 export type HttpService = ServiceMetadata & {
     type: typeof ServiceType;
@@ -7,7 +7,8 @@ export type HttpService = ServiceMetadata & {
     description?: string;
     defaults?: HttpDefaults;
     routes: HttpRoute[];
-    cors?: HttpCors;
     cache?: HttpCache;
+    access?: HttpAccess;
+    cors?: HttpCors;
 };
 export declare const isHttpService: (service: ServiceMetadata) => service is HttpService;

package/dist/utils/body.d.ts

@@ -2,3 +2,7 @@ import type { AnySchema } from '@ez4/schema';
 import type { Http } from '../services/contract';
 export declare const getRequestBody: <T extends Http.JsonBody | Http.RawBody>(input: T | undefined, schema: AnySchema, preferences?: Http.Preferences | null) => Promise<T>;
 export declare const getResponseBody: (body: unknown, schema: AnySchema, preferences?: Http.Preferences) => unknown;
+export declare const prepareBodyRequest: (body: unknown) => {
+    body: string;
+    json: boolean;
+};

package/dist/utils/client.d.ts

@@ -0,0 +1,8 @@
+import { type AnySchema, type NamingStyle } from '@ez4/schema';
+import type { ClientRequest, ClientResponse } from '../services/client';
+export declare const getClientRequestUrl: (host: string, path: string, request: ClientRequest) => string;
+export type SendClientRequest = ClientRequest & {
+    responseSchema?: AnySchema;
+    namingStyle?: NamingStyle;
+};
+export declare const sendClientRequest: (url: string, method: string, request: SendClientRequest) => Promise<ClientResponse>;

package/dist/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import type { HttpError } from '@ez4/gateway';
+import { HttpError } from '@ez4/gateway';
 /**
  * Get a JSON error response for the given HTTP error.
  *
@@ -11,3 +11,12 @@ export declare const getJsonError: ({ status, message, details }: HttpError) =>
         details: string[] | undefined;
     };
 };
+/**
+ * Get a exception based on the given HTTP status code.
+ *
+ * @param status HTTP status code.
+ * @param message Exception message.
+ * @param details Exception details.
+ * @returns Returns the corresponding exception.
+ */
+export declare const getHttpException: (status: number, message: string, details?: string[]) => HttpError;

package/dist/utils/headers.d.ts

@@ -1,3 +1,3 @@
 import type { ObjectSchema } from '@ez4/schema';
-import type { Http } from '@ez4/gateway';
+import type { Http } from '../services/contract';
 export declare const getHeaders: <T extends Http.Headers>(input: T, schema: ObjectSchema) => Promise<T>;

package/dist/utils/identity.d.ts

@@ -1,3 +1,3 @@
 import type { ObjectSchema, UnionSchema } from '@ez4/schema';
-import type { Http } from '@ez4/gateway';
+import type { Http } from '../services/contract';
 export declare const getIdentity: <T extends Http.Identity>(input: T, schema: ObjectSchema | UnionSchema) => Promise<T>;