@ez4/gateway 0.28.0 → 0.30.0

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,
 "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(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{d as Http,o as HttpBadRequestError,p as HttpError,c as HttpForbiddenError,
+x 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 | null;

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 | null;
 export {};

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/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 | null;

package/dist/metadata/utils.d.ts

@@ -2,6 +2,7 @@ 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 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 +15,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/common.d.ts

@@ -40,7 +40,7 @@ export interface HttpCors {
     maxAge?: number;
 }
 /**
- * HTTP cache.
+ * HTTP cache configuration.
  */
 export interface HttpCache {
     /**
@@ -48,6 +48,15 @@ export interface HttpCache {
      */
     authorizerTTL: number;
 }
+/**
+ * HTTP access configuration.
+ */
+export interface HttpAccess {
+    /**
+     * Log retention (in days) for the access log.
+     */
+    logRetention: number;
+}
 /**
  * Request headers.
  */

package/dist/services/contract.d.ts

@@ -1,8 +1,8 @@
 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 { 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,13 +21,14 @@ 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.
@@ -127,6 +128,10 @@ export declare namespace Http {
          * Cache configuration.
          */
         cache?: Cache;
+        /**
+         * Access configuration.
+         */
+        access?: Access;
         /**
          * Variables associated to all routes.
          */

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,2 @@
+import type { TypeClass } from '@ez4/reflection';
+export declare const getLinkedService: (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}`;
@@ -22,17 +22,18 @@ export type HttpRequest = {
     body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema | null;
 };
 export type HttpResponse = {
-    status: number;
+    status: number | number[];
     headers?: ObjectSchema | null;
     body?: ObjectSchema | UnionSchema | ArraySchema | ScalarSchema | null;
 };
 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;
@@ -69,6 +70,9 @@ export type HttpDefaults = {
 export type HttpCache = {
     authorizerTTL?: number;
 };
+export type HttpAccess = {
+    logRetention: number;
+};
 export type HttpCors = {
     allowOrigins: string[];
     allowMethods?: string[];
@@ -77,3 +81,6 @@ export type HttpCors = {
     allowHeaders?: string[];
     maxAge?: number;
 };
+export type HttpProvider = {
+    services?: LinkedServices;
+};

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ez4/gateway",
   "description": "EZ4: Components to build gateway services",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "author": "Silas B.",
   "license": "MIT",
   "type": "module",
@@ -33,6 +33,10 @@
       "import": "./dist/utils.mjs"
     }
   },
+  "sideEffects": [
+    "./dist/library.cjs",
+    "./dist/library.mjs"
+  ],
   "workspaces": [
     "foundation/*",
     "contracts/*"
@@ -47,12 +51,12 @@
     "live:publish": "npm run build && npm publish --access public"
   },
   "dependencies": {
-    "@ez4/common": "^0.28.0",
-    "@ez4/project": "^0.28.0",
-    "@ez4/reflection": "^0.28.0",
-    "@ez4/schema": "^0.28.0",
-    "@ez4/transform": "^0.28.0",
-    "@ez4/utils": "^0.28.0",
-    "@ez4/validator": "^0.28.0"
+    "@ez4/common": "^0.30.0",
+    "@ez4/project": "^0.30.0",
+    "@ez4/reflection": "^0.30.0",
+    "@ez4/schema": "^0.30.0",
+    "@ez4/transform": "^0.30.0",
+    "@ez4/utils": "^0.30.0",
+    "@ez4/validator": "^0.30.0"
   }
 }