@lakutata/entrypoint 3.0.0-beta.0

package/dist/esm/decorators/UseMiddlewares.js

@@ -0,0 +1,55 @@
+import { addMiddlewares, validateMiddlewares } from '../lib/Middleware.js';
+/**
+ * Add middlewares to all the actions of a controller (on the class) or to one action (on the method). A middleware is a
+ * function `(invocation, next) => Promise<unknown>` or a class extending `Middleware`, created in the container of each
+ * request (its dependencies injected). It receives the request's context, whose data is the input before validation,
+ * and returns the result of `next()` (the rest of the pipeline), or another value without calling it, which is then
+ * answered instead of the action's result; an error it throws is answered as the action's error.
+ *
+ * The order of a request: the entrypoint's `middlewares`, the adapter's `middlewares`, the ones of the controller classes
+ * (the parent classes first), of the action options, of the action method, then the input validation, the access
+ * control and the action. Several `@UseMiddlewares` on a target run from top to bottom, the middlewares of each in their
+ * order. The middlewares of a method are taken from the nearest class declaring them for it: an overriding method
+ * replaces them.
+ * @param middlewares The middleware functions and classes, in their running order.
+ * @returns The class or method decorator.
+ * @throws {InvalidMiddlewareException} When the decorator is called, if a middleware is neither a function nor a class
+ * extending `Middleware`.
+ * @example
+ * ```typescript
+ * import {Controller, Middleware, type ActionInvocation, type Next} from 'lakutata/com/entrypoint'
+ * import {GET, UseMiddlewares} from 'lakutata/decorator/ctrl'
+ *
+ * //A middleware function: logs the duration of each action of the controller
+ * async function Timing(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *     const started: number = Date.now()
+ *     try {
+ *         return await next()
+ *     } finally {
+ *         console.log(`${invocation.action.name}: ${Date.now() - started}ms`)
+ *     }
+ * }
+ *
+ * //A middleware class: answers without running the action during a maintenance
+ * class Maintenance extends Middleware {
+ *     public async handle(invocation: ActionInvocation, next: Next): Promise<unknown> {
+ *         if (process.env.MAINTENANCE) return {maintenance: true}
+ *         return await next()
+ *     }
+ * }
+ *
+ * @UseMiddlewares(Timing)
+ * class StatusController extends Controller {
+ *     //Timing, then Maintenance, then the action
+ *     @GET('/status')
+ *     @UseMiddlewares(Maintenance)
+ *     public async status(): Promise<{ ok: boolean }> {
+ *         return {ok: true}
+ *     }
+ * }
+ * ```
+ */
+export function UseMiddlewares(...middlewares) {
+    validateMiddlewares(middlewares);
+    return (target, propertyKey) => addMiddlewares(target, propertyKey, middlewares);
+}

package/dist/esm/decorators/http/DELETE.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function DELETE(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'delete', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/GET.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function GET(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'get', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/HEAD.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function HEAD(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'head', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/OPTIONS.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function OPTIONS(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'options', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/PATCH.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function PATCH(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'patch', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/POST.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function POST(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'post', dtoConstructorOrOptions, options);
+}

package/dist/esm/decorators/http/PUT.js

@@ -0,0 +1,4 @@
+import { HTTPAction } from '../HTTPAction.js';
+export function PUT(r, dtoConstructorOrOptions, options) {
+    return HTTPAction(r, 'put', dtoConstructorOrOptions, options);
+}

package/dist/esm/exceptions/AccessDeniedException.js

@@ -0,0 +1,13 @@
+import { Exception } from '@lakutata/core';
+/**
+ * An access control rule denied the request: a rule of the entrypoint (`rules`) or of the action resolved `false`.
+ * Its errno is `E_ACCESS_DENY`, its HTTP status 403.
+ */
+export class AccessDeniedException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ACCESS_DENY';
+        this.message = 'Access denied';
+        this.statusCode = 403;
+    }
+}

package/dist/esm/exceptions/ControllerActionNotFoundException.js

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * No action matches the request: the service pattern, the command or the route of no controller action matches it.
+ * Its errno is `E_CONTROLLER_ACTION_NOT_FOUND`, its HTTP status 404.
+ */
+export class ControllerActionNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_CONTROLLER_ACTION_NOT_FOUND';
+        this.statusCode = 404;
+    }
+}

package/dist/esm/exceptions/DuplicateActionNameException.js

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Two actions of a channel have the same name (`name` of their options, `Class:method` by default), when the
+ * entrypoint initializes. Its errno is `E_DUPLICATE_ACTION_NAME`.
+ */
+export class DuplicateActionNameException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_DUPLICATE_ACTION_NAME';
+    }
+}

package/dist/esm/exceptions/EntrypointStoppedException.js

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * The request arrived while the entrypoint is stopping (the application exiting): it is refused, the requests in
+ * progress being waited for. Its errno is `E_ENTRYPOINT_STOPPED`, its HTTP status 503.
+ */
+export class EntrypointStoppedException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ENTRYPOINT_STOPPED';
+        this.statusCode = 503;
+    }
+}

package/dist/esm/exceptions/InvalidActionGroupException.js

@@ -0,0 +1,7 @@
+import { Exception } from '@lakutata/core';
+export class InvalidActionGroupException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_ACTION_GROUP';
+    }
+}

package/dist/esm/exceptions/InvalidChannelException.js

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A channel is defined twice under the same name, or a channel used is not defined. Its errno is
+ * `E_INVALID_CHANNEL`.
+ */
+export class InvalidChannelException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_CHANNEL';
+    }
+}

package/dist/esm/exceptions/InvalidEntrypointAdapterException.js

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * An option of the entrypoint is given an adapter of another channel, an adapter of an undefined channel, or a value
+ * which is neither an option nor an adapter, when the entrypoint initializes. Its errno is
+ * `E_INVALID_ENTRYPOINT_ADAPTER`.
+ */
+export class InvalidEntrypointAdapterException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_ENTRYPOINT_ADAPTER';
+    }
+}

package/dist/esm/exceptions/InvalidMiddlewareException.js

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A middleware is neither a function nor a class extending `Middleware`, when the entrypoint initializes. Its errno is
+ * `E_INVALID_MIDDLEWARE`.
+ */
+export class InvalidMiddlewareException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_MIDDLEWARE';
+    }
+}

package/dist/esm/exceptions/InvalidPrefixException.js

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A pattern prefix of a controller (`@Prefix`) and the pattern of one of its service actions set the same key to
+ * different values, when the entrypoint initializes. Its errno is `E_INVALID_PREFIX`.
+ */
+export class InvalidPrefixException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_INVALID_PREFIX';
+    }
+}

package/dist/esm/exceptions/MiddlewareNextCalledException.js

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A middleware called `next()` more than once for a request (the request rejects with it). Its errno is
+ * `E_MIDDLEWARE_NEXT_CALLED`.
+ */
+export class MiddlewareNextCalledException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_MIDDLEWARE_NEXT_CALLED';
+    }
+}

package/dist/esm/exceptions/RouteNotFoundException.js

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * No HTTP route matches the request (the HTTP adapters answer it). Its errno is `E_ROUTE_NOT_FOUND`, its HTTP status
+ * 404.
+ */
+export class RouteNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_ROUTE_NOT_FOUND';
+        this.statusCode = 404;
+    }
+}

package/dist/esm/exceptions/ServiceInvokeException.js

@@ -0,0 +1,10 @@
+import { Exception } from '@lakutata/core';
+/**
+ * The failure of a service invocation: the error of the remote service, with its properties (errno, errMsg, statusCode…)
+ */
+export class ServiceInvokeException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_SERVICE_INVOKE';
+    }
+}

package/dist/esm/exports/CTRLDecorators.js

@@ -0,0 +1,19 @@
+//CLI actions
+export { CLIAction } from '../decorators/CLIAction.js';
+//HTTP actions
+export { HTTPAction } from '../decorators/HTTPAction.js';
+export { DELETE } from '../decorators/http/DELETE.js';
+export { GET } from '../decorators/http/GET.js';
+export { HEAD } from '../decorators/http/HEAD.js';
+export { OPTIONS } from '../decorators/http/OPTIONS.js';
+export { PATCH } from '../decorators/http/PATCH.js';
+export { POST } from '../decorators/http/POST.js';
+export { PUT } from '../decorators/http/PUT.js';
+//Service actions
+export { ServiceAction } from '../decorators/ServiceAction.js';
+//Middlewares
+export { UseMiddlewares } from '../decorators/UseMiddlewares.js';
+//Controller prefixes
+export { Prefix } from '../decorators/Prefix.js';
+//Scheduled actions
+export { Schedule } from '../decorators/Schedule.js';

package/dist/esm/exports/Channel.js

@@ -0,0 +1,11 @@
+/**
+ * The API of the packages providing a channel or an adapter
+ */
+export { defineChannel, getChannel, hasChannel, getChannelByContextType } from '../channel/Channel.js';
+export { isEntrypointAdapter, commandMap } from '../channel/EntrypointAdapter.js';
+export { registerControllerAction } from '../lib/ControllerEntrypoint.js';
+export { getActionDTOAndOptions } from '../lib/GetActionDTOAndOptions.js';
+export { ActionOptions } from '../lib/ActionOptions.js';
+export { HTTPChannel, CLIChannel, ServiceChannel, ScheduleChannel } from '../channel/BuiltinChannels.js';
+export { ServiceResponseCodec } from '../lib/ServiceResponseCodec.js';
+export { getPrefix, setPrefix } from '../lib/Prefix.js';

package/dist/esm/exports/CommanderAdapter.js

@@ -0,0 +1 @@
+export { commanderCLIEntrypoint } from '../adapter/commander/CommanderCLIEntrypoint.js';

package/dist/esm/exports/ElectronAdapter.js

@@ -0,0 +1 @@
+export { electronIPCServiceEntrypoint, ipcEventOfContext } from '../adapter/electron/ElectronIPCServiceEntrypoint.js';

package/dist/esm/exports/Entrypoint.js

@@ -0,0 +1,22 @@
+export * from '../Entrypoint.js';
+export * from '../lib/Controller.js';
+export * from '../lib/AccessControlRule.js';
+export * from '../exceptions/AccessDeniedException.js';
+export * from '../exceptions/DuplicateActionNameException.js';
+export * from '../exceptions/ControllerActionNotFoundException.js';
+export { AccessControl } from '../lib/AccessControl.js';
+export { Middleware } from '../lib/Middleware.js';
+export * from '../exceptions/InvalidMiddlewareException.js';
+export * from '../exceptions/MiddlewareNextCalledException.js';
+export { PrefixOptions } from '../lib/Prefix.js';
+export * from '../exceptions/InvalidPrefixException.js';
+export { ActionResult } from '../lib/ActionResult.js';
+export * from '../exceptions/InvalidChannelException.js';
+export * from '../exceptions/InvalidEntrypointAdapterException.js';
+export { Result, StatusResult, FileResult, EventsResult } from '../lib/Result.js';
+export * from '../exceptions/RouteNotFoundException.js';
+export * from '../exceptions/EntrypointStoppedException.js';
+export * from '../exceptions/ServiceInvokeException.js';
+export { scheduleEntrypoint } from '../adapter/schedule/ScheduleEntrypoint.js';
+export { httpServiceEntrypoint, httpRequestOfContext } from '../adapter/http/HTTPServiceEntrypoint.js';
+export { Cron, parseDuration } from '../lib/schedule/Cron.js';

package/dist/esm/exports/ExpressAdapter.js

@@ -0,0 +1,3 @@
+export { expressHTTPEntrypoint } from '../adapter/express/ExpressHTTPEntrypoint.js';
+export { JSONResponder, jsonEnvelope, statusOfError, describeError } from '../adapter/express/Responders.js';
+export { staticUI } from '../adapter/express/StaticUI.js';

package/dist/esm/exports/FastifyAdapter.js

@@ -0,0 +1,3 @@
+export { fastifyHTTPEntrypoint } from '../adapter/fastify/FastifyHTTPEntrypoint.js';
+export { FastifyJSONResponder, fastifyJSONEnvelope } from '../adapter/fastify/Responders.js';
+export { statusOfError, describeError } from '../lib/HTTPErrors.js';

package/dist/esm/exports/JSONRPCAdapter.js

@@ -0,0 +1,2 @@
+export { jsonRPCServiceEntrypoint } from '../adapter/jsonrpc/JSONRPCServiceEntrypoint.js';
+export { JSONRPCErrorCode, jsonRPCRequestOfContext } from '../adapter/jsonrpc/JSONRPCProtocol.js';

package/dist/esm/exports/SocketIOAdapter.js

@@ -0,0 +1 @@
+export { socketIOServiceEntrypoint, socketOfContext } from '../adapter/socket.io/SocketIOServiceEntrypoint.js';

package/dist/esm/lib/AccessControl.js

@@ -0,0 +1,204 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseObject, Container, DTO } from '@lakutata/core';
+import { Configurable } from '@lakutata/core/decorator/di';
+import { AccessDeniedException } from '../exceptions/AccessDeniedException.js';
+import { AccessControlRule } from './AccessControlRule.js';
+import { As, isSubclassOf } from '@lakutata/utils';
+/**
+ * The access control of the entrypoint's actions: it checks a request to an action declared with `acl: true` against
+ * the entrypoint's rules and the action's own `rule`, or against the action's `rule` alone when `acl` is off. The
+ * entrypoint calls {@link AccessControl.run} for each request, after the input validation and before the action; a
+ * subclass of the entrypoint may replace it with a subclass (its protected `accessControl` property), for example to
+ * audit the decisions.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {AccessControl, Controller, Entrypoint} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ *
+ * //Log every access decision
+ * class AuditedAccessControl extends AccessControl {
+ *     protected async match(): Promise<boolean> {
+ *         const allowed: boolean = await super.match()
+ *         console.log(`${this.target.name}: ${allowed ? 'allowed' : 'denied'}`)
+ *         return allowed
+ *     }
+ * }
+ *
+ * class AuditedEntrypoint extends Entrypoint {
+ *     protected readonly accessControl: typeof AccessControl = AuditedAccessControl
+ * }
+ *
+ * class ReportController extends Controller {
+ *     @GET('/reports', {acl: true, rule: async (): Promise<boolean> => true})
+ *     public async list(): Promise<string[]> {
+ *         return []
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'report.app',
+ *     name: 'Report',
+ *     components: {
+ *         entrypoint: {class: AuditedEntrypoint, controllers: [ReportController]}
+ *     }
+ * }))
+ * ```
+ */
+export class AccessControl extends BaseObject {
+    /**
+     * Schema of access control rule constructors, built only when it is used
+     * @protected
+     */
+    get accessControlRuleConstructorDTO() {
+        return DTO.Class(AccessControlRule);
+    }
+    /**
+     * Check the rules and call the allow or deny callback.
+     * @protected
+     */
+    async init() {
+        try {
+            const matchResult = await this.match();
+            if (matchResult)
+                return this.allowCallback();
+            return this.denyCallback();
+        }
+        catch (e) {
+            return this.denyCallback(e);
+        }
+    }
+    /**
+     * Check the rules in order: a rule class is created in the request's container and checked when it supports the
+     * request's context type, a rule function is called with the context and the input.
+     * @returns `false` as soon as a rule resolves `false`, `true` when none does (no rule included).
+     * @throws {Error} The error a rule throws (the request is then denied with it).
+     * @protected
+     */
+    async match() {
+        for (const rule of this.rules) {
+            if (isSubclassOf(rule, AccessControlRule)) {
+                const RuleObjectConstructor = As(rule);
+                const ruleObjectInstance = await this.runtimeContainer.build(RuleObjectConstructor, {
+                    actions: this.actions,
+                    targetAction: this.target,
+                    context: this.context,
+                    input: this.input
+                });
+                if (!ruleObjectInstance.supportContextTypes.includes(this.context.type))
+                    continue;
+                if (!(await ruleObjectInstance.rule()))
+                    return false;
+            }
+            else {
+                const handler = As(rule);
+                if (!(await handler(this.context, this.input)))
+                    return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check the access to an action: with `acl: true`, against the rules then the action's own `rule`; with `acl`
+     * off, against the action's `rule` alone; without either, the request is allowed without check.
+     * @param rules The entrypoint's rule classes.
+     * @param runtimeContainer The request's container, where the access control and the rules are created.
+     * @param context The request's context.
+     * @param input The action's validated input.
+     * @param details The requested action.
+     * @param getActionsCallback Returns the descriptions of the actions of a context type's channel.
+     * @returns Whether the request is allowed, and when it is not, the error to fail it with: the error a rule
+     * threw, or an `AccessDeniedException`.
+     */
+    static async run(rules, runtimeContainer, context, input, details, getActionsCallback) {
+        const actions = getActionsCallback(context.type);
+        let allowed = !details.acl;
+        //The exception is created only when access is denied (building it captures a stack trace)
+        let exception;
+        if (!allowed) {
+            await runtimeContainer.set(this, {
+                // await runtimeContainer.build(this, {
+                rules: [...rules, details.rule].filter((rule) => !!rule),
+                runtimeContainer: runtimeContainer,
+                actions: actions,
+                context: context,
+                input: input,
+                target: details.getActionInfo(),
+                allowCallback: () => {
+                    allowed = true;
+                },
+                denyCallback: (error) => {
+                    allowed = false;
+                    exception = error ? error : exception;
+                }
+            });
+        }
+        else if (details.rule) {
+            await runtimeContainer.set(this, {
+                // await runtimeContainer.build(this, {
+                rules: [details.rule],
+                runtimeContainer: runtimeContainer,
+                actions: actions,
+                context: context,
+                input: input,
+                target: details.getActionInfo(),
+                allowCallback: () => {
+                    allowed = true;
+                },
+                denyCallback: (error) => {
+                    allowed = false;
+                    exception = error ? error : exception;
+                }
+            });
+        }
+        return [
+            allowed,
+            allowed ? undefined : (exception ? exception : new AccessDeniedException())
+        ];
+    }
+}
+__decorate([
+    Configurable(),
+    __metadata("design:type", Container
+    /**
+     * The descriptions of every action of the request's channel.
+     * @protected
+     */
+    )
+], AccessControl.prototype, "runtimeContainer", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Array)
+], AccessControl.prototype, "actions", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControl.prototype, "target", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControl.prototype, "context", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControl.prototype, "input", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Function)
+], AccessControl.prototype, "allowCallback", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Function)
+], AccessControl.prototype, "denyCallback", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Array)
+], AccessControl.prototype, "rules", void 0);

package/dist/esm/lib/AccessControlRule.js

@@ -0,0 +1,72 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseObject } from '@lakutata/core';
+import { Configurable } from '@lakutata/core/decorator/di';
+/**
+ * An access control rule, checked for the actions declared with `acl: true`: give the rule classes to the
+ * entrypoint's `rules` option. For each request to such an action, every rule supporting the request's context type
+ * is created in the request's container (its dependencies injected) and its {@link AccessControlRule.rule} called, in
+ * the order of the option; the first one resolving `false` denies the request with an `AccessDeniedException`, the
+ * first one throwing denies it with its error. A request no rule denies is allowed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {AccessControlRule, buildEntrypoints, ContextType, Controller, type HTTPContext} from 'lakutata/com/entrypoint'
+ * import {DELETE} from 'lakutata/decorator/ctrl'
+ *
+ * //Only the requests of an administrator reach the actions of the "admin" group
+ * class AdminRule extends AccessControlRule<HTTPContext> {
+ *     public get supportContextTypes(): ContextType[] {
+ *         return [ContextType.HTTP]
+ *     }
+ *
+ *     public async rule(): Promise<boolean> {
+ *         if (!this.targetAction.groups.includes('admin')) return true
+ *         return this.context.request.headers['x-role'] === 'admin'
+ *     }
+ * }
+ *
+ * class UserController extends Controller {
+ *     @DELETE('/users/:id', {acl: true, groups: ['admin']})
+ *     public async remove(input: {id: string}): Promise<void> {
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'admin.app',
+ *     name: 'Admin',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             rules: [AdminRule],
+ *             httpActionGroups: {admin: 'Administration'}
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export class AccessControlRule extends BaseObject {
+}
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControlRule.prototype, "context", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControlRule.prototype, "input", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Array)
+], AccessControlRule.prototype, "actions", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], AccessControlRule.prototype, "targetAction", void 0);