@ez4/gateway 0.35.1 → 0.37.0

package/dist/services/auth/request.d.ts

@@ -0,0 +1,20 @@
+import type { WebPathParameters } from '../parameters';
+import type { WebQueryStrings } from '../query';
+import type { WebHeaders } from '../headers';
+/**
+ * Authorization request.
+ */
+export interface AuthRequest {
+    /**
+     * Expected HTTP headers.
+     */
+    readonly headers?: WebHeaders;
+    /**
+     * Expected HTTP path parameters.
+     */
+    readonly parameters?: WebPathParameters;
+    /**
+     * Expected HTTP query strings.
+     */
+    readonly query?: WebQueryStrings;
+}

package/dist/services/auth/response.d.ts

@@ -0,0 +1,10 @@
+import type { AuthIdentity } from './identity';
+/**
+ * Authorization response.
+ */
+export interface AuthResponse {
+    /**
+     * Authorization identity.
+     */
+    readonly identity?: AuthIdentity;
+}

package/dist/services/body.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Json body payload.
+ */
+export interface WebJsonBody {
+}
+/**
+ * Raw body payload.
+ */
+export type WebRawBody = string;
+/**
+ * Body payload.
+ */
+export type WebBody = WebJsonBody | WebRawBody;

package/dist/services/defaults.d.ts

@@ -1,31 +1,22 @@
-import type { HttpAuthRequest, HttpErrors, HttpListener, HttpRequest } from './common';
-import type { HttpPreferences } from './preferences';
+import type { WebPreferences } from './preferences';
 /**
- * Default HTTP service parameters.
+ * Default service parameters.
  */
-export interface HttpDefaults<T extends HttpRequest | HttpAuthRequest> {
+export interface WebDefaults {
     /**
-     * Default route listener.
+     * Default preferences for all handlers.
      */
-    readonly listener?: HttpListener<T>;
-    /**
-     * Status codes for all known exceptions.
-     */
-    readonly httpErrors?: HttpErrors;
-    /**
-     * Default preferences for all handlers and routes.
-     */
-    readonly preferences?: HttpPreferences;
+    readonly preferences?: WebPreferences;
     /**
      * Default log retention (in days) for the handlers.
      */
     readonly logRetention?: number;
     /**
-     * Default execution time (in seconds) for handlers and routes.
+     * Default execution time (in seconds) for handlers.
      */
     readonly timeout?: number;
     /**
-     * Default amount of memory available for handlers.
+     * Default amount of memory available (in megabytes) for handlers.
      */
     readonly memory?: number;
 }

package/dist/services/errors.d.ts

@@ -30,6 +30,12 @@ export declare class HttpForbiddenError extends HttpError {
 export declare class HttpNotFoundError extends HttpError {
     constructor(message?: string, details?: string[]);
 }
+/**
+ * HTTP Conflict error.
+ */
+export declare class HttpConflictError extends HttpError {
+    constructor(message?: string, details?: string[]);
+}
 /**
  * HTTP Unsupported Media Type error.
  */

package/dist/services/headers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Request headers.
+ */
+export interface WebHeaders {
+}
+/**
+ * Request path parameters.
+ */
+export interface WebPathParameters {
+}

package/dist/services/{client.d.ts → http/client.d.ts}

@@ -3,7 +3,7 @@ import type { Http } from './contract';
 /**
  * HTTP client.
  */
-export type Client<T extends Http.Service | Http.Import<any>> = {
+export type HttpClient<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 {
@@ -16,7 +16,7 @@ export type Client<T extends Http.Service | Http.Import<any>> = {
 /**
  * Default HTTP client request.
  */
-export type ClientRequest = RequestOptions & {
+export type HttpClientRequest = RequestOptions & {
     readonly headers?: Record<string, string>;
     readonly parameters?: Record<string, string>;
     readonly query?: Record<string, unknown>;
@@ -25,7 +25,7 @@ export type ClientRequest = RequestOptions & {
 /**
  * Default HTTP response.
  */
-export type ClientResponse = {
+export type HttpClientResponse = {
     readonly status: number;
     readonly headers?: Record<string, string | undefined>;
     readonly body?: unknown;

package/dist/services/{contract.d.ts → http/contract.d.ts}

@@ -1,52 +1,66 @@
 import type { Service as CommonService } from '@ez4/common';
 import type { LinkedVariables } from '@ez4/project/library';
-import type { HttpSuccessStatuses, HttpSuccessEmptyResponse, HttpSuccessResponse } from './utils';
+import type { AuthProvider as HttpAuthProvider } from '../auth/provider';
+import type { AuthResponse as HttpAuthResponse } from '../auth/response';
+import type { AuthRequest as HttpAuthRequest } from '../auth/request';
+import type { AuthIdentity } from '../auth/identity';
+import type { AuthCache } from '../auth/cache';
+import type { WebHeaders } from '../headers';
+import type { WebQueryStrings } from '../query';
+import type { WebPreferences } from '../preferences';
+import type { WebPathParameters } from '../parameters';
+import type { WebJsonBody, WebRawBody } from '../body';
+import type { HttpSuccessStatuses, HttpSuccessEmptyResponse, HttpSuccessResponse, HttpEmptyRequest } from './utils';
 import type { HttpAuthorization } from './authorization';
-import type { HttpPreferences } from './preferences';
 import type { HttpDefaults } from './defaults';
 import type { HttpProvider } from './provider';
+import type { HttpListener } from './listener';
+import type { HttpIncoming } from './incoming';
+import type { HttpResponse } from './response';
+import type { HttpRequest } from './request';
+import type { HttpHandler } from './handler';
+import type { HttpClient } from './client';
 import type { HttpAccess } from './access';
+import type { HttpErrors } from './errors';
 import type { HttpRoute } from './route';
-import type { HttpCache } from './cache';
 import type { HttpCors } from './cors';
-import type { Client } from './client';
-import type { HttpHeaders, HttpIdentity, HttpPathParameters, HttpQueryStrings, HttpJsonBody, HttpRawBody, HttpAuthRequest, HttpAuthResponse, HttpRequest, HttpResponse, HttpErrors, HttpIncoming, HttpListener, HttpAuthorizer, HttpHandler } from './common';
 /**
  * Provide all contracts for a self-managed HTTP service.
  */
 export declare namespace Http {
-    type Headers = HttpHeaders;
-    type Identity = HttpIdentity;
-    type PathParameters = HttpPathParameters;
-    type QueryStrings = HttpQueryStrings;
-    type JsonBody = HttpJsonBody;
-    type RawBody = HttpRawBody;
+    type Headers = WebHeaders;
+    type Identity = AuthIdentity;
+    type PathParameters = WebPathParameters;
+    type QueryStrings = WebQueryStrings;
+    type JsonBody = WebJsonBody;
+    type RawBody = WebRawBody;
     type Authorization = HttpAuthorization;
-    type Preferences = HttpPreferences;
-    type AuthRequest = HttpAuthRequest;
+    type Access = HttpAccess;
+    type Preferences = WebPreferences;
+    type Cache = AuthCache;
     type Request = HttpRequest;
-    type AuthResponse = HttpAuthResponse;
     type Response = HttpResponse;
-    type Errors = HttpErrors;
     type Provider = HttpProvider;
-    type Cache = HttpCache;
-    type Access = HttpAccess;
+    type AuthRequest = HttpAuthRequest;
+    type AuthResponse = HttpAuthResponse;
+    type AuthProvider = HttpAuthProvider;
+    type Errors = HttpErrors;
     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 Incoming<T extends Request> = HttpIncoming<T>;
+    type Listener<T extends Request> = HttpListener<T>;
     type Handler<T extends Request> = HttpHandler<T>;
     type Route<T extends Request = Request, U extends AuthRequest = AuthRequest> = HttpRoute<T, U>;
-    type Defaults<T extends HttpRequest | HttpAuthRequest = any> = HttpDefaults<T>;
-    type ServiceEvent<T extends Request | AuthRequest = Request> = CommonService.AnyEvent<Incoming<T>>;
+    type Defaults<T extends Request = Request> = HttpDefaults<T>;
+    type ServiceEvent<T extends Request = Request> = CommonService.AnyEvent<Incoming<T>>;
     type SuccessEmptyResponse<S extends HttpSuccessStatuses = 204> = HttpSuccessEmptyResponse<S>;
-    type SuccessResponse<S extends HttpSuccessStatuses, T extends HttpRawBody | HttpJsonBody> = HttpSuccessResponse<S, T>;
+    type SuccessResponse<S extends HttpSuccessStatuses, T extends JsonBody | RawBody> = HttpSuccessResponse<S, T>;
+    type EmptyRequest = HttpEmptyRequest;
     /**
      * HTTP Route definition.
      */
     type UseRoute<T extends Route<any, any>> = T;
     /**
-     * HTTP Service definition.
+     * HTTP Defaults definition.
      */
     type UseDefaults<T extends Defaults<any>> = T;
     /**
@@ -74,7 +88,7 @@ export declare namespace Http {
      */
     abstract class Service implements CommonService.Provider {
         /**
-         * All expected routes.
+         * All routes associated to the gateway.
          */
         abstract readonly routes: Route<any, any>[];
         /**
@@ -82,19 +96,19 @@ export declare namespace Http {
          */
         readonly name?: string;
         /**
-         * Default parameters.
+         * Default gateway parameters.
          */
         readonly defaults?: Defaults<any>;
         /**
-         * CORS configuration.
+         * CORS configuration for all routes.
          */
         readonly cors?: Cors;
         /**
-         * Cache configuration.
+         * Cache configuration for authorizers.
          */
         readonly cache?: Cache;
         /**
-         * Access configuration.
+         * Access configuration for logs.
          */
         readonly access?: Access;
         /**
@@ -104,7 +118,7 @@ export declare namespace Http {
         /**
          * Service client.
          */
-        readonly client: Client<Service>;
+        readonly client: HttpClient<Service>;
     }
     /**
      * Imported HTTP service.
@@ -137,7 +151,7 @@ export declare namespace Http {
         /**
          * Imported service client (do not replace).
          */
-        readonly client: Client<T>;
+        readonly client: HttpClient<T>;
         /**
          * Variables are not allowed.
          */

package/dist/services/http/defaults.d.ts

@@ -0,0 +1,17 @@
+import type { WebDefaults } from '../defaults';
+import type { HttpListener } from './listener';
+import type { HttpRequest } from './request';
+import type { HttpErrors } from './errors';
+/**
+ * Default HTTP service parameters.
+ */
+export interface HttpDefaults<T extends HttpRequest> extends WebDefaults {
+    /**
+     * Default listener.
+     */
+    readonly listener?: HttpListener<T>;
+    /**
+     * Status codes for all known exceptions.
+     */
+    readonly httpErrors?: HttpErrors;
+}

package/dist/services/http/errors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * HTTP errors.
+ */
+export type HttpErrors = {
+    [code: number]: readonly Error[];
+};

package/dist/services/http/handler.d.ts

@@ -0,0 +1,10 @@
+import type { Service } from '@ez4/common';
+import type { HttpProvider } from './provider';
+import type { HttpIncoming } from './incoming';
+import type { HttpResponse } from './response';
+import type { HttpRequest } from './request';
+import type { Http } from './contract';
+/**
+ * HTTP request handler.
+ */
+export type HttpHandler<T extends HttpRequest> = (request: HttpIncoming<T> | T, context: Service.Context<Http.Service | HttpProvider>) => Promise<HttpResponse> | HttpResponse;

package/dist/services/http/incoming.d.ts

@@ -0,0 +1,30 @@
+import type { HttpRequest } from './request';
+/**
+ * Incoming request.
+ */
+export type HttpIncoming<T extends HttpRequest> = T & {
+    /**
+     * Request tracking Id.
+     */
+    readonly requestId: string;
+    /**
+     * Determines whether request is base64 encoded or not.
+     */
+    readonly encoded?: boolean;
+    /**
+     * Request timestamp.
+     */
+    readonly timestamp: Date;
+    /**
+     * Request method.
+     */
+    readonly method: string;
+    /**
+     * Request path.
+     */
+    readonly path: string;
+    /**
+     * Raw body data (when provided in the request).
+     */
+    readonly data?: string;
+};

package/dist/services/http/listener.d.ts

@@ -0,0 +1,9 @@
+import type { Service } from '@ez4/common';
+import type { HttpProvider } from './provider';
+import type { HttpIncoming } from './incoming';
+import type { HttpRequest } from './request';
+import type { Http } from './contract';
+/**
+ * HTTP request listener.
+ */
+export type HttpListener<T extends HttpRequest> = (event: Service.AnyEvent<HttpIncoming<T>>, context: Service.Context<Http.Service | HttpProvider>) => Promise<void> | void;

package/dist/services/http/path.d.ts

@@ -0,0 +1,2 @@
+export type HttpVerb = 'ANY' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+export type HttpPath = `${HttpVerb} /${string}`;

package/dist/services/http/request.d.ts

@@ -0,0 +1,30 @@
+import type { AuthIdentity } from '../auth/identity';
+import type { WebPathParameters } from '../parameters';
+import type { WebQueryStrings } from '../query';
+import type { WebHeaders } from '../headers';
+import type { WebBody } from '../body';
+/**
+ * HTTP request.
+ */
+export interface HttpRequest {
+    /**
+     * Expected identity.
+     */
+    readonly identity?: AuthIdentity;
+    /**
+     * Expected HTTP headers.
+     */
+    readonly headers?: WebHeaders;
+    /**
+     * Expected HTTP path parameters.
+     */
+    readonly parameters?: WebPathParameters;
+    /**
+     * Expected HTTP query strings.
+     */
+    readonly query?: WebQueryStrings;
+    /**
+     * Expected HTTP body payload.
+     */
+    readonly body?: WebBody;
+}

package/dist/services/http/response.d.ts

@@ -0,0 +1,19 @@
+import type { WebHeaders } from '../headers';
+import type { WebBody } from '../body';
+/**
+ * HTTP response.
+ */
+export interface HttpResponse {
+    /**
+     * HTTP status code.
+     */
+    readonly status: number;
+    /**
+     * HTTP headers.
+     */
+    readonly headers?: WebHeaders;
+    /**
+     * HTTP body payload.
+     */
+    readonly body?: WebBody;
+}

package/dist/services/http/route.d.ts

@@ -0,0 +1,45 @@
+import type { AuthHandler } from '../auth/handler';
+import type { AuthRequest } from '../auth/request';
+import type { WebTarget } from '../target';
+import type { HttpListener } from './listener';
+import type { HttpRequest } from './request';
+import type { HttpHandler } from './handler';
+import type { HttpErrors } from './errors';
+import type { HttpPath } from './path';
+/**
+ * HTTP route.
+ */
+export interface HttpRoute<T extends HttpRequest, U extends AuthRequest> extends WebTarget {
+    /**
+     * Route operation name.
+     */
+    readonly name?: string;
+    /**
+     * Route path including the HTTP verb.
+     */
+    readonly path: HttpPath;
+    /**
+     * Life-cycle listener function for the route.
+     */
+    readonly listener?: HttpListener<T>;
+    /**
+     * Entry-point authorizer handler function for the route.
+     */
+    readonly authorizer?: AuthHandler<U>;
+    /**
+     * Entry-point handler function for the route.
+     */
+    readonly handler: HttpHandler<T>;
+    /**
+     * Map status codes and errors for all known exceptions.
+     */
+    readonly httpErrors?: HttpErrors;
+    /**
+     * Determines whether or not the route is disabled.
+     */
+    readonly disabled?: boolean;
+    /**
+     * Determines whether or not CORS is enabled for the route.
+     */
+    readonly cors?: boolean;
+}

package/dist/services/{utils.d.ts → http/utils.d.ts}

@@ -1,18 +1,26 @@
-import type { HttpResponse, HttpJsonBody, HttpRawBody } from './common';
+import type { Http } from './contract';
+/**
+ * HTTP success status codes.
+ */
 export type HttpSuccessStatuses = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208;
 /**
- * Common HTTP success response without a response body.
+ * HTTP empty request.
+ */
+export declare class HttpEmptyRequest implements Http.Request {
+}
+/**
+ * HTTP success response without a response body.
  */
-export declare class HttpSuccessEmptyResponse<S extends HttpSuccessStatuses> implements HttpResponse {
+export declare class HttpSuccessEmptyResponse<S extends HttpSuccessStatuses> implements Http.Response {
     /**
      * HTTP status code.
      */
     readonly status: S;
 }
 /**
- * Common HTTP success response.
+ * HTTP success response.
  */
-export declare class HttpSuccessResponse<S extends HttpSuccessStatuses, T extends HttpJsonBody | HttpRawBody> implements HttpResponse {
+export declare class HttpSuccessResponse<S extends HttpSuccessStatuses, T extends Http.JsonBody | Http.RawBody> implements Http.Response {
     /**
      * HTTP status code.
      */

package/dist/services/parameters.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Request path parameters.
+ */
+export interface WebPathParameters {
+}

package/dist/services/preferences.d.ts

@@ -1,8 +1,8 @@
 import type { NamingStyle } from '@ez4/schema';
 /**
- * HTTP preferences configuration.
+ * Preferences configuration.
  */
-export interface HttpPreferences {
+export interface WebPreferences {
     /**
      * Determines the naming style for the query strings and body payloads.
      */

package/dist/services/query.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Request query strings.
+ */
+export interface WebQueryStrings {
+}

package/dist/services/target.d.ts

@@ -0,0 +1,27 @@
+import type { LinkedVariables } from '@ez4/project/library';
+import type { WebPreferences } from './preferences';
+/**
+ * Target configuration.
+ */
+export interface WebTarget {
+    /**
+     * Target preference options.
+     */
+    readonly preferences?: WebPreferences;
+    /**
+     * Default log retention (in days) for the handlers.
+     */
+    readonly logRetention?: number;
+    /**
+     * Variables associated to the event.
+     */
+    readonly variables?: LinkedVariables;
+    /**
+     * Max execution time (in seconds) for the event.
+     */
+    readonly timeout?: number;
+    /**
+     * Amount of memory available (in megabytes) for the handler.
+     */
+    readonly memory?: number;
+}

package/dist/services/ws/client.d.ts

@@ -0,0 +1,19 @@
+import type { Ws } from './contract';
+/**
+ * WS client.
+ */
+export interface WsClient<T extends Ws.JsonBody> {
+    /**
+     * Send a new JSON message to the connection.
+     *
+     * @param connectionId Connection identifier.
+     * @param message Message object.
+     */
+    sendMessage(connectionId: string, message: T): Promise<void>;
+    /**
+     * Terminate an active connection.
+     *
+     * @param connectionId Connection identifier.
+     */
+    disconnect(connectionId: string): Promise<void>;
+}

package/dist/services/ws/connect.d.ts

@@ -0,0 +1,23 @@
+import type { AuthHandler } from '../auth/handler';
+import type { AuthRequest } from '../auth/request';
+import type { WebTarget } from '../target';
+import type { WsListener } from './listener';
+import type { WsHandler } from './handler';
+import type { WsEvent } from './event';
+/**
+ * WS connect event.
+ */
+export interface WsConnect<T extends WsEvent, U extends AuthRequest> extends WebTarget {
+    /**
+     * Life-cycle listener function for the event.
+     */
+    readonly listener?: WsListener<T>;
+    /**
+     * Entry-point authorizer handler function for the event.
+     */
+    readonly authorizer?: AuthHandler<U>;
+    /**
+     * Entry-point handler function for the event.
+     */
+    readonly handler: WsHandler<T>;
+}