@ez4/gateway 0.35.0 → 0.36.0

package/dist/main.cjs

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

package/dist/main.d.ts

@@ -1,4 +1,6 @@
-export { Client, ClientRequest, ClientResponse } from './services/client';
-export { AuthorizationType } from './services/authorization';
-export * from './services/contract';
+export { AuthorizationType } from './services/http/authorization';
+export { HttpClient, HttpClientRequest, HttpClientResponse } from './services/http/client';
+export { WsClient } from './services/ws/client';
+export * from './services/ws/contract';
+export * from './services/http/contract';
 export * from './services/errors';

package/dist/main.mjs

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

package/dist/metadata/auth/handler.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
+import type { AuthHandler } from './types';
+export declare const isAuthHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
+export declare const getAuthHandlerMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthHandler | undefined;

package/dist/metadata/auth/identity.d.ts

@@ -0,0 +1,6 @@
+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 isAuthIdentityDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getAuthIdentityMetadata: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[], namespace: string) => ObjectSchema | UnionSchema | undefined;
+export {};

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

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AuthRequest } from '../auth/types';
+export declare const isAuthRequestDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getAuthRequestMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthRequest | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AuthResponse } from '../auth/types';
+export declare const isAuthResponseDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getAuthResponseMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthResponse | undefined;

package/dist/metadata/auth/types.d.ts

@@ -0,0 +1,17 @@
+import type { ObjectSchema, UnionSchema } from '@ez4/schema';
+export type AuthHandler = {
+    name: string;
+    module?: string;
+    file: string;
+    description?: string;
+    response?: AuthResponse;
+    request?: AuthRequest;
+};
+export type AuthResponse = {
+    identity?: ObjectSchema | UnionSchema;
+};
+export type AuthRequest = {
+    headers?: ObjectSchema;
+    parameters?: ObjectSchema;
+    query?: ObjectSchema;
+};

package/dist/metadata/http/access.d.ts

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

package/dist/metadata/http/authorization.d.ts

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

package/dist/metadata/http/cache.d.ts

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

package/dist/metadata/http/cors.d.ts

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

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

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

package/dist/metadata/{errors.d.ts → http/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 | undefined;
+import type { HttpErrors } from './types';
+export declare const getHttpErrorsMetadata: (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/http/handler.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
+import type { HttpHandler } from './types';
+export declare const isHttpHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
+export declare const getHttpHandlerMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], external: boolean) => HttpHandler | undefined;

package/dist/metadata/http/import.d.ts

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

package/dist/metadata/http/provider.d.ts

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

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

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

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

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

package/dist/metadata/{route.d.ts → http/routes.d.ts}

@@ -1,4 +1,5 @@
-import type { ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
-import type { HttpRoute } from '../types/common';
+import type { AllType, ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
+import type { HttpRoute } from './types';
+export declare const isHttpRouteDeclaration: (type: AllType) => type is TypeModel;
 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/http/service.d.ts

@@ -0,0 +1,7 @@
+import type { AllType, SourceMap, TypeClass } from '@ez4/reflection';
+import type { HttpService } from './types';
+export declare const isHttpServiceDeclaration: (type: AllType) => type is TypeClass;
+export declare const getHttpServicesMetadata: (reflection: SourceMap) => {
+    services: Record<string, HttpService>;
+    errors: Error[];
+};

package/dist/{types/common.d.ts → metadata/http/types.d.ts}

@@ -1,9 +1,36 @@
 import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
 import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
+import type { ServiceMetadata } from '@ez4/project/library';
 import type { ServiceListener } from '@ez4/common/library';
-import type { AuthorizationType } from '../services/authorization';
-export type HttpVerb = 'ANY' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
-export type HttpPath = `${HttpVerb} /${string}`;
+import type { AuthorizationType } from '../../services/http/authorization';
+import type { AuthHandler } from '../auth/types';
+import type { HttpPath } from '../../services/http/path';
+export declare const HttpServiceType = "@ez4/http";
+export declare const HttpImportType = "@ez4/import:http";
+export declare const HttpNamespaceType = "Http";
+export declare const isHttpService: (service: ServiceMetadata) => service is HttpService;
+export declare const isHttpImport: (service: ServiceMetadata) => service is HttpImport;
+export type HttpDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+export type HttpService = ServiceMetadata & {
+    type: typeof HttpServiceType;
+    displayName?: string;
+    description?: string;
+    defaults?: HttpDefaults;
+    routes: HttpRoute[];
+    cache?: HttpCache;
+    access?: HttpAccess;
+    cors?: HttpCors;
+};
+export type HttpImport = ServiceMetadata & {
+    type: typeof HttpImportType;
+    reference: string;
+    project: string;
+    displayName?: string;
+    description?: string;
+    defaults?: HttpDefaults;
+    authorization?: HttpAuthorization;
+    routes: HttpRoute[];
+};
 export type HttpPreferences = {
     namingStyle?: NamingStyle;
 };
@@ -12,25 +39,17 @@ export type HttpAuthorization = {
     header: string;
     value: string;
 };
-export type HttpAuthRequest = {
-    headers?: ObjectSchema;
-    parameters?: ObjectSchema;
-    query?: ObjectSchema;
-};
-export type HttpAuthResponse = {
-    identity?: ObjectSchema | UnionSchema;
-};
 export type HttpRequest = {
     identity?: ObjectSchema | UnionSchema;
     headers?: ObjectSchema;
     parameters?: ObjectSchema;
     query?: ObjectSchema;
-    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+    body?: HttpDataSchema;
 };
 export type HttpResponse = {
     status: number | number[];
     headers?: ObjectSchema;
-    body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+    body?: HttpDataSchema;
 };
 export type HttpHandler = {
     name: string;
@@ -41,14 +60,6 @@ export type HttpHandler = {
     request?: HttpRequest;
     provider?: HttpProvider;
 };
-export type HttpAuthorizer = {
-    name: string;
-    module?: string;
-    file: string;
-    description?: string;
-    response?: HttpAuthResponse;
-    request?: HttpAuthRequest;
-};
 export type HttpErrors = {
     [name: string]: number;
 };
@@ -57,7 +68,7 @@ export type HttpRoute = {
     path: HttpPath;
     handler: HttpHandler;
     listener?: ServiceListener;
-    authorizer?: HttpAuthorizer;
+    authorizer?: AuthHandler;
     variables?: LinkedVariables;
     httpErrors?: HttpErrors;
     preferences?: HttpPreferences;

package/dist/metadata/utils/path.d.ts

@@ -0,0 +1,2 @@
+import type { HttpPath } from '../../services/http/path';
+export declare const isHttpPath: (path: string) => path is HttpPath;

package/dist/metadata/utils/type.d.ts

@@ -0,0 +1 @@
+export declare const getFullTypeName: (namespace: string, type: string) => string;

package/dist/metadata/web/body.d.ts

@@ -0,0 +1,6 @@
+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 isWebBodyDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebBodyMetadata: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[], namespace: string) => import("@ez4/schema").BooleanSchema | import("@ez4/schema").NumberSchema | import("@ez4/schema").StringSchema | ObjectSchema | UnionSchema | ArraySchema | undefined;
+export {};

package/dist/metadata/web/headers.d.ts

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

package/dist/metadata/web/parameters.d.ts

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

package/dist/metadata/web/preferences.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { WebPreferences } from './types';
+export declare const isWebPreferencesDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebPreferencesMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => WebPreferences | undefined;

package/dist/metadata/web/query.d.ts

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

package/dist/metadata/web/types.d.ts

@@ -0,0 +1,4 @@
+import type { NamingStyle } from '@ez4/schema';
+export type WebPreferences = {
+    namingStyle?: NamingStyle;
+};

package/dist/metadata/ws/connection.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeClass, TypeModel } from '@ez4/reflection';
+import type { WsConnection } from './types';
+export declare const isWsConnectionDeclaration: (type: AllType) => type is TypeClass;
+export declare const getWsConnectionMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsConnection | undefined;

package/dist/metadata/ws/defaults.d.ts

@@ -0,0 +1,5 @@
+import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { WsDefaults } from './types';
+export declare const FULL_BASE_TYPE: string;
+export declare const isWsDefaultsDeclaration: (type: TypeModel) => boolean;
+export declare const getWsDefaultsMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsDefaults | undefined;

package/dist/metadata/ws/event.d.ts

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

package/dist/metadata/ws/handlers.d.ts

@@ -0,0 +1,5 @@
+import type { AllType, TypeCallback, TypeFunction, TypeModel, SourceMap } from '@ez4/reflection';
+import type { WsHandler } from './types';
+export declare const isWsHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
+export declare const getWsConnectionHandler: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsHandler | undefined;
+export declare const getWsMessageHandler: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsHandler | undefined;

package/dist/metadata/ws/message.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, SourceMap, TypeClass, TypeModel } from '@ez4/reflection';
+import type { WsMessage } from './types';
+export declare const isWsMessageDeclaration: (type: AllType) => type is TypeClass;
+export declare const getWsMessageMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsMessage | undefined;

package/dist/metadata/ws/request.d.ts

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

package/dist/metadata/ws/response.d.ts

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

package/dist/metadata/ws/service.d.ts

@@ -0,0 +1,7 @@
+import type { AllType, SourceMap, TypeClass } from '@ez4/reflection';
+import type { WsService } from './types';
+export declare const isWsServiceDeclaration: (type: AllType) => type is TypeClass;
+export declare const getWsServicesMetadata: (reflection: SourceMap) => {
+    services: Record<string, WsService>;
+    errors: Error[];
+};

package/dist/metadata/ws/types.d.ts

@@ -0,0 +1,72 @@
+import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
+import type { LinkedVariables, ServiceMetadata } from '@ez4/project/library';
+import type { ServiceListener } from '@ez4/common/library';
+import type { AuthHandler } from '../auth/types';
+export declare const WsServiceType = "@ez4/ws";
+export declare const WsNamespaceType = "Ws";
+export declare const isWsService: (service: ServiceMetadata) => service is WsService;
+export type WsDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+export type WsService = ServiceMetadata & {
+    type: typeof WsServiceType;
+    displayName?: string;
+    stageName?: string;
+    description?: string;
+    defaults?: WsDefaults;
+    schema: WsDataSchema;
+    connect: WsConnection;
+    disconnect: WsConnection;
+    message: WsMessage;
+};
+export type WsConnection = {
+    handler: WsHandler;
+    listener?: ServiceListener;
+    authorizer?: AuthHandler;
+    variables?: LinkedVariables;
+    preferences?: WsPreferences;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+};
+export type WsMessage = {
+    handler: WsHandler;
+    listener?: ServiceListener;
+    variables?: LinkedVariables;
+    preferences?: WsPreferences;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+};
+export type WsHandler = {
+    name: string;
+    file: string;
+    module?: string;
+    description?: string;
+    request?: WsRequest | WsEvent;
+    response?: WsResponse;
+};
+export type WsEvent = {
+    identity?: ObjectSchema | UnionSchema;
+    headers?: ObjectSchema;
+    query?: ObjectSchema;
+    body?: WsDataSchema;
+};
+export type WsRequest = {
+    identity?: ObjectSchema | UnionSchema;
+    body?: WsDataSchema;
+};
+export type WsResponse = {
+    body?: WsDataSchema;
+};
+export type WsPreferences = {
+    namingStyle?: NamingStyle;
+};
+export type WsDefaults = {
+    listener?: ServiceListener;
+    preferences?: WsPreferences;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+};
+export type WsCache = {
+    authorizerTTL?: number;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Authorization cache.
+ */
+export interface AuthCache {
+    /**
+     * Default TTL (in seconds) for the authorization cache.
+     */
+    readonly authorizerTTL: number;
+}

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

@@ -0,0 +1,9 @@
+import type { Service } from '@ez4/common';
+import type { AuthIncoming } from './incoming';
+import type { AuthResponse } from './response';
+import type { AuthRequest } from './request';
+import type { AuthProvider } from './provider';
+/**
+ * Authorization handler.
+ */
+export type AuthHandler<T extends AuthRequest> = (request: AuthIncoming<T> | T, context: Service.Context<AuthProvider>) => Promise<AuthResponse> | AuthResponse;

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

@@ -0,0 +1,5 @@
+/**
+ * Authorization identity payload.
+ */
+export interface AuthIdentity {
+}

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

@@ -0,0 +1,22 @@
+import type { AuthRequest } from './request';
+/**
+ * Incoming authorization.
+ */
+export type AuthIncoming<T extends AuthRequest> = T & {
+    /**
+     * Request tracking Id.
+     */
+    readonly requestId: string;
+    /**
+     * Request timestamp.
+     */
+    readonly timestamp: Date;
+    /**
+     * Request method.
+     */
+    readonly method?: string;
+    /**
+     * Request path.
+     */
+    readonly path?: string;
+};

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

@@ -0,0 +1,11 @@
+import type { LinkedVariables } from '@ez4/project/library';
+export interface AuthProvider {
+    /**
+     * Variables associated to the provider.
+     */
+    readonly variables?: LinkedVariables;
+    /**
+     * All services associated to the provider.
+     */
+    readonly services: Record<string, unknown>;
+}

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

@@ -0,0 +1,20 @@
+import type { WebPathParameters } from '../web/parameters';
+import type { WebQueryStrings } from '../web/query';
+import type { WebHeaders } from '../web/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/{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;