@ez4/gateway 0.35.1 → 0.37.0

package/dist/main.cjs

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

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[], namespace: string) => AuthHandler | undefined;

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

@@ -0,0 +1,6 @@
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+import type { ObjectSchema, UnionSchema } from '@ez4/schema';
+type TypeParent = TypeObject | TypeModel | TypeIntersection;
+export declare const isAuthIdentityDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getAuthIdentityMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => ObjectSchema | UnionSchema | undefined;
+export {};

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[], namespace: string) => AuthRequest | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[], namespace: string) => AuthResponse | undefined;

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

@@ -0,0 +1,20 @@
+import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
+import type { FunctionSignature } from '@ez4/common/library';
+import type { ObjectSchema, UnionSchema } from '@ez4/schema';
+export type AuthHandler = FunctionSignature & {
+    provider?: AuthProvider;
+    response?: AuthResponse;
+    request?: AuthRequest;
+};
+export type AuthResponse = {
+    identity?: ObjectSchema | UnionSchema;
+};
+export type AuthRequest = {
+    headers?: ObjectSchema;
+    parameters?: ObjectSchema;
+    query?: ObjectSchema;
+};
+export type AuthProvider = {
+    variables?: LinkedVariables;
+    services?: LinkedServices;
+};

package/dist/metadata/body.d.ts

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

package/dist/metadata/headers.d.ts

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

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpAccess | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpAuthorization | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpCache | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpCors | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpDefaults | undefined;

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

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

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[], external: boolean) => HttpHandler | undefined;

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

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

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpRequest | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpResponse | undefined;

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

@@ -0,0 +1,5 @@
+import type { AllType, ModelProperty, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => HttpRoute[] | undefined;
+export declare const getHttpRemoteRoutes: (parent: TypeModel, member: ModelProperty, reflection: ReflectionTypes, errorList: Error[]) => HttpRoute[] | undefined;

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

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

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

@@ -0,0 +1,117 @@
+import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
+import type { FunctionSignature, ServiceListener } from '@ez4/common/library';
+import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
+import type { ServiceMetadata } from '@ez4/project/library';
+import type { AuthorizationType } from '../../services/http/authorization';
+import type { HttpPath } from '../../services/http/path';
+import type { AuthHandler } from '../auth/types';
+export declare const HttpServiceType = "@ez4/http";
+export declare const HttpImportType = "@ez4/import:http";
+export declare const HttpNamespaceType = "Http";
+export type HttpDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+export type HttpService = Omit<ServiceMetadata, 'variables' | 'services'> & Required<Pick<ServiceMetadata, 'variables' | 'services'>> & {
+    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;
+};
+export type HttpAuthorization = {
+    type: AuthorizationType;
+    header: string;
+    value: string;
+};
+export type HttpRequest = {
+    identity?: ObjectSchema | UnionSchema;
+    headers?: ObjectSchema;
+    parameters?: ObjectSchema;
+    query?: ObjectSchema;
+    body?: HttpDataSchema;
+};
+export type HttpResponse = {
+    status: number | number[];
+    headers?: ObjectSchema;
+    body?: HttpDataSchema;
+};
+export type HttpHandler = FunctionSignature & {
+    provider?: HttpProvider;
+    response: HttpResponse;
+    request?: HttpRequest;
+};
+export type HttpErrors = {
+    [name: string]: number;
+};
+export type HttpRoute = {
+    name?: string;
+    path: HttpPath;
+    handler: HttpHandler;
+    listener?: ServiceListener;
+    authorizer?: AuthHandler;
+    variables?: LinkedVariables;
+    httpErrors?: HttpErrors;
+    preferences?: HttpPreferences;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+    cors?: boolean;
+    disabled?: boolean;
+};
+export type HttpDefaults = {
+    listener?: ServiceListener;
+    httpErrors?: HttpErrors;
+    preferences?: HttpPreferences;
+    logRetention?: number;
+    timeout?: number;
+    memory?: number;
+};
+export type HttpCache = {
+    authorizerTTL?: number;
+};
+export type HttpAccess = {
+    logRetention: number;
+};
+export type HttpCors = {
+    allowOrigins: string[];
+    allowMethods?: string[];
+    allowCredentials?: boolean;
+    exposeHeaders?: string[];
+    allowHeaders?: string[];
+    maxAge?: number;
+};
+export type HttpProvider = {
+    variables?: LinkedVariables;
+    services?: LinkedServices;
+};
+export declare const isHttpService: (service: ServiceMetadata) => service is HttpService;
+export declare const createHttpService: (name: string) => {
+    variables: {};
+    services: {};
+    type: "@ez4/http";
+    name: string;
+    context: Record<string, import("@ez4/project/library").LinkedContext>;
+    displayName?: string | null | undefined;
+    description?: string | null | undefined;
+    defaults?: HttpDefaults | null | undefined;
+    routes?: HttpRoute[] | null | undefined;
+    cache?: HttpCache | null | undefined;
+    access?: HttpAccess | null | undefined;
+    cors?: HttpCors | null | undefined;
+};
+export declare const isHttpImport: (service: ServiceMetadata) => service is HttpImport;
+export declare const createHttpImport: (name: string) => ServiceMetadata & import("@ez4/utils").Incomplete<HttpImport>;

package/dist/metadata/parameters.d.ts

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

package/dist/metadata/preferences.d.ts

@@ -1,3 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
-import type { HttpPreferences } from '../types/common';
-export declare const getHttpPreferences: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpPreferences | undefined;
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[], namespace: string) => WebPreferences | undefined;

package/dist/metadata/provider.d.ts

@@ -1,3 +1,4 @@
-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;
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
+import type { HttpProvider } from './http/types';
+export declare const isWebProviderDeclaration: (type: AllType, namespace: string) => type is TypeModel;
+export declare const getWebProviderMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => HttpProvider | undefined;

package/dist/metadata/query.d.ts

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

package/dist/metadata/types.d.ts

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

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

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

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/provider.d.ts

@@ -0,0 +1,4 @@
+import type { LinkedServices } from '@ez4/project/library';
+import type { AuthHandler } from '../auth/types';
+import type { HttpHandler } from '../http/types';
+export declare const attachProviderLinkedServices: (handler: HttpHandler | AuthHandler, services: LinkedServices, errorList: Error[], fileName?: string) => void;

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

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

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

@@ -0,0 +1,5 @@
+import type { LinkedServices } from '@ez4/project/library';
+import type { AuthHandler } from '../auth/types';
+import type { HttpHandler } from '../http/types';
+import type { WsHandler } from '../ws/types';
+export declare const attachValidatorLinkedServices: (handler: HttpHandler | AuthHandler | WsHandler, services: LinkedServices) => void;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsConnection | undefined;

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

@@ -0,0 +1,5 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsDefaults | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsEvent | undefined;

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

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

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsMessage | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsRequest | undefined;

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

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, 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: ReflectionTypes, errorList: Error[]) => WsResponse | undefined;

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

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

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

@@ -0,0 +1,83 @@
+import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
+import type { LinkedVariables, ServiceMetadata } from '@ez4/project/library';
+import type { FunctionSignature, ServiceListener } from '@ez4/common/library';
+import type { AuthHandler } from '../auth/types';
+export declare const WsServiceType = "@ez4/ws";
+export declare const WsNamespaceType = "Ws";
+export type WsDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
+export type WsService = Omit<ServiceMetadata, 'variables' | 'services'> & Required<Pick<ServiceMetadata, 'variables' | 'services'>> & {
+    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 = FunctionSignature & {
+    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;
+};
+export declare const isWsService: (service: ServiceMetadata) => service is WsService;
+export declare const createWsService: (name: string) => {
+    variables: {};
+    services: {};
+    type: "@ez4/ws";
+    name: string;
+    context: Record<string, import("@ez4/project/library").LinkedContext>;
+    displayName?: string | null | undefined;
+    stageName?: string | null | undefined;
+    description?: string | null | undefined;
+    defaults?: WsDefaults | null | undefined;
+    schema?: WsDataSchema | null | undefined;
+    connect?: WsConnection | null | undefined;
+    disconnect?: WsConnection | null | undefined;
+    message?: WsMessage | null | undefined;
+};

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>;
+}