@forestadmin/datasource-customizer 1.0.0-alpha.1

package/dist/decorators/hook/collection.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const aggregate_1 = require("./context/aggregate");
+const create_1 = require("./context/create");
+const delete_1 = require("./context/delete");
+const list_1 = require("./context/list");
+const update_1 = require("./context/update");
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+const hook_1 = __importDefault(require("./hook"));
+class CollectionHookDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.hooks = {
+            List: new hook_1.default(),
+            Create: new hook_1.default(),
+            Update: new hook_1.default(),
+            Delete: new hook_1.default(),
+            Aggregate: new hook_1.default(),
+        };
+    }
+    addHook(position, type, handler) {
+        this.hooks[type].addHandler(position, handler);
+    }
+    async create(caller, data) {
+        const beforeContext = new create_1.InternalHookBeforeCreateContext(this.childCollection, caller, data);
+        await this.hooks.Create.executeBefore(beforeContext);
+        const records = await this.childCollection.create(caller, beforeContext.getData());
+        const afterContext = new create_1.HookAfterCreateContext(this.childCollection, caller, data, records);
+        await this.hooks.Create.executeAfter(afterContext);
+        return records;
+    }
+    async list(caller, filter, projection) {
+        const beforeContext = new list_1.InternalHookBeforeListContext(this.childCollection, caller, filter, projection);
+        await this.hooks.List.executeBefore(beforeContext);
+        const records = await this.childCollection.list(caller, beforeContext.getFilter(), beforeContext.getProjection());
+        const afterContext = new list_1.HookAfterListContext(this.childCollection, caller, filter, projection, records);
+        await this.hooks.List.executeAfter(afterContext);
+        return records;
+    }
+    async update(caller, filter, patch) {
+        const beforeContext = new update_1.InternalHookBeforeUpdateContext(this.childCollection, caller, filter, patch);
+        await this.hooks.Update.executeBefore(beforeContext);
+        await this.childCollection.update(caller, beforeContext.getFilter(), beforeContext.patch);
+        const afterContext = new update_1.HookAfterUpdateContext(this.childCollection, caller, filter, patch);
+        await this.hooks.Update.executeAfter(afterContext);
+    }
+    async delete(caller, filter) {
+        const beforeContext = new delete_1.InternalHookBeforeDeleteContext(this.childCollection, caller, filter);
+        await this.hooks.Delete.executeBefore(beforeContext);
+        await this.childCollection.delete(caller, beforeContext.getFilter());
+        const afterContext = new delete_1.HookAfterDeleteContext(this.childCollection, caller, filter);
+        await this.hooks.Delete.executeAfter(afterContext);
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        const beforeContext = new aggregate_1.InternalHookBeforeAggregateContext(this.childCollection, caller, filter, aggregation, limit);
+        await this.hooks.Aggregate.executeBefore(beforeContext);
+        const aggregationResult = await this.childCollection.aggregate(caller, beforeContext.getFilter(), beforeContext.getAggregation(), beforeContext.limit);
+        const afterContext = new aggregate_1.HookAfterAggregateContext(this.childCollection, caller, filter, aggregation, aggregationResult, limit);
+        await this.hooks.Aggregate.executeAfter(afterContext);
+        return aggregationResult;
+    }
+}
+exports.default = CollectionHookDecorator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/hook/context/aggregate.d.ts

@@ -0,0 +1,22 @@
+import { Aggregation, Caller, Collection, Filter } from '@forestadmin/datasource-toolkit';
+import { TAggregateResult, TAggregation, TCollectionName, TFilter, TSchema } from '../../../templates';
+import HookContext from './hook';
+export declare class HookBeforeAggregateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookContext<S, N> {
+    protected _filter: Filter;
+    protected _aggregation: Aggregation;
+    protected _limit: number;
+    constructor(collection: Collection, caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number);
+    get filter(): Readonly<TFilter<S, N>>;
+    get aggregation(): Readonly<TAggregation<S, N>>;
+    get limit(): number;
+}
+export declare class InternalHookBeforeAggregateContext extends HookBeforeAggregateContext {
+    getFilter(): Filter;
+    getAggregation(): Aggregation;
+}
+export declare class HookAfterAggregateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookBeforeAggregateContext<S, N> {
+    private _aggregateResult;
+    constructor(collection: Collection, caller: Caller, filter: Filter, aggregation: Aggregation, aggregateResult: TAggregateResult<S, N>[], limit?: number);
+    get aggregateResult(): readonly TAggregateResult<S, N>[];
+}
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/decorators/hook/context/aggregate.js

@@ -0,0 +1,46 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookAfterAggregateContext = exports.InternalHookBeforeAggregateContext = exports.HookBeforeAggregateContext = void 0;
+const hook_1 = __importDefault(require("./hook"));
+class HookBeforeAggregateContext extends hook_1.default {
+    constructor(collection, caller, filter, aggregation, limit) {
+        super(collection, caller);
+        this._filter = filter;
+        this._aggregation = aggregation;
+        this._limit = limit;
+    }
+    get filter() {
+        return Object.freeze(this._filter);
+    }
+    get aggregation() {
+        return Object.freeze(this._aggregation);
+    }
+    get limit() {
+        return this._limit;
+    }
+}
+exports.HookBeforeAggregateContext = HookBeforeAggregateContext;
+class InternalHookBeforeAggregateContext extends HookBeforeAggregateContext {
+    getFilter() {
+        return this._filter;
+    }
+    getAggregation() {
+        return this._aggregation;
+    }
+}
+exports.InternalHookBeforeAggregateContext = InternalHookBeforeAggregateContext;
+class HookAfterAggregateContext extends HookBeforeAggregateContext {
+    constructor(collection, caller, filter, aggregation, aggregateResult, limit) {
+        super(collection, caller, filter, aggregation, limit);
+        this._aggregateResult = aggregateResult;
+    }
+    get aggregateResult() {
+        return Object.freeze(this._aggregateResult);
+    }
+}
+exports.HookAfterAggregateContext = HookAfterAggregateContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvaG9vay9jb250ZXh0L2FnZ3JlZ2F0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEseUNBQXlDOzs7Ozs7QUFVekMsa0RBQWlDO0FBRWpDLE1BQWEsMEJBR1gsU0FBUSxjQUFpQjtJQUt6QixZQUNFLFVBQXNCLEVBQ3RCLE1BQWMsRUFDZCxNQUFjLEVBQ2QsV0FBd0IsRUFDeEIsS0FBYztRQUVkLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFMUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDdEIsSUFBSSxDQUFDLFlBQVksR0FBRyxXQUFXLENBQUM7UUFDaEMsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7SUFDdEIsQ0FBQztJQUVELElBQUksTUFBTTtRQUNSLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBbUMsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRCxJQUFJLFdBQVc7UUFDYixPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQTZDLENBQUMsQ0FBQztJQUMzRSxDQUFDO0lBRUQsSUFBSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3JCLENBQUM7Q0FDRjtBQWpDRCxnRUFpQ0M7QUFFRCxNQUFhLGtDQUFtQyxTQUFRLDBCQUEwQjtJQUNoRixTQUFTO1FBQ1AsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUFFRCxjQUFjO1FBQ1osT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDO0lBQzNCLENBQUM7Q0FDRjtBQVJELGdGQVFDO0FBRUQsTUFBYSx5QkFHWCxTQUFRLDBCQUFnQztJQUd4QyxZQUNFLFVBQXNCLEVBQ3RCLE1BQWMsRUFDZCxNQUFjLEVBQ2QsV0FBd0IsRUFDeEIsZUFBeUMsRUFDekMsS0FBYztRQUVkLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFFdEQsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGVBQWUsQ0FBQztJQUMxQyxDQUFDO0lBRUQsSUFBSSxlQUFlO1FBQ2pCLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUM5QyxDQUFDO0NBQ0Y7QUF0QkQsOERBc0JDIn0=

package/dist/decorators/hook/context/create.d.ts

@@ -0,0 +1,17 @@
+import { Caller, Collection, RecordData } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TRow, TSchema } from '../../../templates';
+import HookContext from './hook';
+export declare class HookBeforeCreateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookContext<S, N> {
+    protected _data: RecordData[];
+    constructor(collection: Collection, caller: Caller, data: RecordData[]);
+    get data(): readonly TRow<S, N>[];
+}
+export declare class InternalHookBeforeCreateContext extends HookBeforeCreateContext {
+    getData(): RecordData[];
+}
+export declare class HookAfterCreateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookBeforeCreateContext<S, N> {
+    private _records;
+    constructor(collection: Collection, caller: Caller, data: RecordData[], records: RecordData[]);
+    get records(): readonly TRow<S, N>[];
+}
+//# sourceMappingURL=create.d.ts.map

package/dist/decorators/hook/context/create.js

@@ -0,0 +1,35 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookAfterCreateContext = exports.InternalHookBeforeCreateContext = exports.HookBeforeCreateContext = void 0;
+const hook_1 = __importDefault(require("./hook"));
+class HookBeforeCreateContext extends hook_1.default {
+    constructor(collection, caller, data) {
+        super(collection, caller);
+        this._data = data;
+    }
+    get data() {
+        return Object.freeze(this._data);
+    }
+}
+exports.HookBeforeCreateContext = HookBeforeCreateContext;
+class InternalHookBeforeCreateContext extends HookBeforeCreateContext {
+    getData() {
+        return this._data;
+    }
+}
+exports.InternalHookBeforeCreateContext = InternalHookBeforeCreateContext;
+class HookAfterCreateContext extends HookBeforeCreateContext {
+    constructor(collection, caller, data, records) {
+        super(collection, caller, data);
+        this._records = records;
+    }
+    get records() {
+        return Object.freeze(this._records);
+    }
+}
+exports.HookAfterCreateContext = HookAfterCreateContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvaG9vay9jb250ZXh0L2NyZWF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEseUNBQXlDOzs7Ozs7QUFJekMsa0RBQWlDO0FBRWpDLE1BQWEsdUJBR1gsU0FBUSxjQUFpQjtJQUd6QixZQUFZLFVBQXNCLEVBQUUsTUFBYyxFQUFFLElBQWtCO1FBQ3BFLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFMUIsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7SUFDcEIsQ0FBQztJQUVELElBQUksSUFBSTtRQUNOLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBZ0MsQ0FBQyxDQUFDO0lBQzlELENBQUM7Q0FDRjtBQWZELDBEQWVDO0FBRUQsTUFBYSwrQkFBZ0MsU0FBUSx1QkFBdUI7SUFDMUUsT0FBTztRQUNMLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0NBQ0Y7QUFKRCwwRUFJQztBQUVELE1BQWEsc0JBR1gsU0FBUSx1QkFBNkI7SUFHckMsWUFBWSxVQUFzQixFQUFFLE1BQWMsRUFBRSxJQUFrQixFQUFFLE9BQXFCO1FBQzNGLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBRWhDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBdUIsQ0FBQztJQUMxQyxDQUFDO0lBRUQsSUFBSSxPQUFPO1FBQ1QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUN0QyxDQUFDO0NBQ0Y7QUFmRCx3REFlQyJ9

package/dist/decorators/hook/context/delete.d.ts

@@ -0,0 +1,14 @@
+import { Caller, Collection, Filter } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFilter, TSchema } from '../../../templates';
+import HookContext from './hook';
+export declare class HookBeforeDeleteContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookContext<S, N> {
+    protected _filter: Filter;
+    constructor(collection: Collection, caller: Caller, filter: Filter);
+    get filter(): Readonly<TFilter<S, N>>;
+}
+export declare class InternalHookBeforeDeleteContext extends HookBeforeDeleteContext {
+    getFilter(): Filter;
+}
+export declare class HookAfterDeleteContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookBeforeDeleteContext<S, N> {
+}
+//# sourceMappingURL=delete.d.ts.map

package/dist/decorators/hook/context/delete.js

@@ -0,0 +1,28 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookAfterDeleteContext = exports.InternalHookBeforeDeleteContext = exports.HookBeforeDeleteContext = void 0;
+const hook_1 = __importDefault(require("./hook"));
+class HookBeforeDeleteContext extends hook_1.default {
+    constructor(collection, caller, filter) {
+        super(collection, caller);
+        this._filter = filter;
+    }
+    get filter() {
+        return Object.freeze(this._filter);
+    }
+}
+exports.HookBeforeDeleteContext = HookBeforeDeleteContext;
+class InternalHookBeforeDeleteContext extends HookBeforeDeleteContext {
+    getFilter() {
+        return this._filter;
+    }
+}
+exports.InternalHookBeforeDeleteContext = InternalHookBeforeDeleteContext;
+class HookAfterDeleteContext extends HookBeforeDeleteContext {
+}
+exports.HookAfterDeleteContext = HookAfterDeleteContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvaG9vay9jb250ZXh0L2RlbGV0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEseUNBQXlDOzs7Ozs7QUFJekMsa0RBQWlDO0FBRWpDLE1BQWEsdUJBR1gsU0FBUSxjQUFpQjtJQUd6QixZQUFZLFVBQXNCLEVBQUUsTUFBYyxFQUFFLE1BQWM7UUFDaEUsS0FBSyxDQUFDLFVBQVUsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUUxQixJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN4QixDQUFDO0lBRUQsSUFBSSxNQUFNO1FBQ1IsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFtQyxDQUFDLENBQUM7SUFDakUsQ0FBQztDQUNGO0FBZkQsMERBZUM7QUFFRCxNQUFhLCtCQUFnQyxTQUFRLHVCQUF1QjtJQUMxRSxTQUFTO1FBQ1AsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3RCLENBQUM7Q0FDRjtBQUpELDBFQUlDO0FBRUQsTUFBYSxzQkFHWCxTQUFRLHVCQUE2QjtDQUFHO0FBSDFDLHdEQUcwQyJ9

package/dist/decorators/hook/context/hook.d.ts

@@ -0,0 +1,26 @@
+import { TCollectionName, TSchema } from '../../../templates';
+import CollectionCustomizationContext from '../../../context/collection-context';
+export default abstract class HookContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends CollectionCustomizationContext<S, N> {
+    /**
+     * Stop hooks execution and send Validation error to the UI
+     * @param message the validation error message
+     * @example
+     * .throwValidationError('My validation error message');
+     */
+    throwValidationError(message: string): never;
+    /**
+     * Stop hooks execution and send Forbidden error to the UI
+     * @param message the forbidden error message
+     * @example
+     * .throwForbiddenError('My forbidden error message');
+     */
+    throwForbiddenError(message: string): never;
+    /**
+     * Stop hooks execution and send error to the UI
+     * @param message the error message
+     * @example
+     * .throwError('My error message');
+     */
+    throwError(message: string): never;
+}
+//# sourceMappingURL=hook.d.ts.map

package/dist/decorators/hook/context/hook.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_context_1 = __importDefault(require("../../../context/collection-context"));
+class HookContext extends collection_context_1.default {
+    /**
+     * Stop hooks execution and send Validation error to the UI
+     * @param message the validation error message
+     * @example
+     * .throwValidationError('My validation error message');
+     */
+    throwValidationError(message) {
+        throw new datasource_toolkit_1.ValidationError(message);
+    }
+    /**
+     * Stop hooks execution and send Forbidden error to the UI
+     * @param message the forbidden error message
+     * @example
+     * .throwForbiddenError('My forbidden error message');
+     */
+    throwForbiddenError(message) {
+        throw new datasource_toolkit_1.ForbiddenError(message);
+    }
+    /**
+     * Stop hooks execution and send error to the UI
+     * @param message the error message
+     * @example
+     * .throwError('My error message');
+     */
+    throwError(message) {
+        throw new datasource_toolkit_1.UnprocessableError(message);
+    }
+}
+exports.default = HookContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9vay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2hvb2svY29udGV4dC9ob29rLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBSXlDO0FBR3pDLDZGQUFpRjtBQUVqRixNQUE4QixXQUc1QixTQUFRLDRCQUFvQztJQUM1Qzs7Ozs7T0FLRztJQUNILG9CQUFvQixDQUFDLE9BQWU7UUFDbEMsTUFBTSxJQUFJLG9DQUFlLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsbUJBQW1CLENBQUMsT0FBZTtRQUNqQyxNQUFNLElBQUksbUNBQWMsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxVQUFVLENBQUMsT0FBZTtRQUN4QixNQUFNLElBQUksdUNBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEMsQ0FBQztDQUNGO0FBakNELDhCQWlDQyJ9

package/dist/decorators/hook/context/list.d.ts

@@ -0,0 +1,20 @@
+import { Caller, Collection, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFieldName, TPaginatedFilter, TRow, TSchema } from '../../../templates';
+import HookContext from './hook';
+export declare class HookBeforeListContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookContext<S, N> {
+    protected _filter: PaginatedFilter;
+    protected _projection: Projection;
+    constructor(collection: Collection, caller: Caller, filter: PaginatedFilter, projection: Projection);
+    get filter(): Readonly<TPaginatedFilter<S, N>>;
+    get projection(): readonly TFieldName<S, N>[];
+}
+export declare class InternalHookBeforeListContext extends HookBeforeListContext {
+    getFilter(): PaginatedFilter;
+    getProjection(): Projection;
+}
+export declare class HookAfterListContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookBeforeListContext<S, N> {
+    private _records;
+    constructor(collection: Collection, caller: Caller, filter: PaginatedFilter, projection: Projection, records: RecordData[]);
+    get records(): readonly TRow<S, N>[];
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/decorators/hook/context/list.js

@@ -0,0 +1,42 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookAfterListContext = exports.InternalHookBeforeListContext = exports.HookBeforeListContext = void 0;
+const hook_1 = __importDefault(require("./hook"));
+class HookBeforeListContext extends hook_1.default {
+    constructor(collection, caller, filter, projection) {
+        super(collection, caller);
+        this._filter = filter;
+        this._projection = projection;
+    }
+    get filter() {
+        return Object.freeze(this._filter);
+    }
+    get projection() {
+        return Object.freeze(this._projection);
+    }
+}
+exports.HookBeforeListContext = HookBeforeListContext;
+class InternalHookBeforeListContext extends HookBeforeListContext {
+    getFilter() {
+        return this._filter;
+    }
+    getProjection() {
+        return this._projection;
+    }
+}
+exports.InternalHookBeforeListContext = InternalHookBeforeListContext;
+class HookAfterListContext extends HookBeforeListContext {
+    constructor(collection, caller, filter, projection, records) {
+        super(collection, caller, filter, projection);
+        this._records = records;
+    }
+    get records() {
+        return Object.freeze(this._records);
+    }
+}
+exports.HookAfterListContext = HookAfterListContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2hvb2svY29udGV4dC9saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSx5Q0FBeUM7Ozs7OztBQVV6QyxrREFBaUM7QUFFakMsTUFBYSxxQkFHWCxTQUFRLGNBQWlCO0lBSXpCLFlBQ0UsVUFBc0IsRUFDdEIsTUFBYyxFQUNkLE1BQXVCLEVBQ3ZCLFVBQXNCO1FBRXRCLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFMUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDdEIsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLENBQUM7SUFDaEMsQ0FBQztJQUVELElBQUksTUFBTTtRQUNSLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBNEMsQ0FBQyxDQUFDO0lBQzFFLENBQUM7SUFFRCxJQUFJLFVBQVU7UUFDWixPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQTRDLENBQUMsQ0FBQztJQUMxRSxDQUFDO0NBQ0Y7QUExQkQsc0RBMEJDO0FBRUQsTUFBYSw2QkFBOEIsU0FBUSxxQkFBcUI7SUFDdEUsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQsYUFBYTtRQUNYLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0NBQ0Y7QUFSRCxzRUFRQztBQUVELE1BQWEsb0JBR1gsU0FBUSxxQkFBMkI7SUFHbkMsWUFDRSxVQUFzQixFQUN0QixNQUFjLEVBQ2QsTUFBdUIsRUFDdkIsVUFBc0IsRUFDdEIsT0FBcUI7UUFFckIsS0FBSyxDQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBRTlDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBdUIsQ0FBQztJQUMxQyxDQUFDO0lBRUQsSUFBSSxPQUFPO1FBQ1QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUN0QyxDQUFDO0NBQ0Y7QUFyQkQsb0RBcUJDIn0=

package/dist/decorators/hook/context/update.d.ts

@@ -0,0 +1,16 @@
+import { Caller, Collection, Filter, RecordData } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFilter, TRow, TSchema } from '../../../templates';
+import HookContext from './hook';
+export declare class HookBeforeUpdateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookContext<S, N> {
+    protected _filter: Filter;
+    protected _patch: RecordData;
+    constructor(collection: Collection, caller: Caller, filter: Filter, patch: RecordData);
+    get filter(): Readonly<TFilter<S, N>>;
+    get patch(): Readonly<TRow<S, N>>;
+}
+export declare class InternalHookBeforeUpdateContext extends HookBeforeUpdateContext {
+    getFilter(): Filter;
+}
+export declare class HookAfterUpdateContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends HookBeforeUpdateContext<S, N> {
+}
+//# sourceMappingURL=update.d.ts.map

package/dist/decorators/hook/context/update.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookAfterUpdateContext = exports.InternalHookBeforeUpdateContext = exports.HookBeforeUpdateContext = void 0;
+const hook_1 = __importDefault(require("./hook"));
+class HookBeforeUpdateContext extends hook_1.default {
+    constructor(collection, caller, filter, patch) {
+        super(collection, caller);
+        this._filter = filter;
+        this._patch = patch;
+    }
+    get filter() {
+        return Object.freeze(this._filter);
+    }
+    get patch() {
+        return Object.freeze(this._patch);
+    }
+}
+exports.HookBeforeUpdateContext = HookBeforeUpdateContext;
+class InternalHookBeforeUpdateContext extends HookBeforeUpdateContext {
+    getFilter() {
+        return this._filter;
+    }
+}
+exports.InternalHookBeforeUpdateContext = InternalHookBeforeUpdateContext;
+class HookAfterUpdateContext extends HookBeforeUpdateContext {
+}
+exports.HookAfterUpdateContext = HookAfterUpdateContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvaG9vay9jb250ZXh0L3VwZGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFHQSxrREFBaUM7QUFFakMsTUFBYSx1QkFHWCxTQUFRLGNBQWlCO0lBSXpCLFlBQVksVUFBc0IsRUFBRSxNQUFjLEVBQUUsTUFBYyxFQUFFLEtBQWlCO1FBQ25GLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFMUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDdEIsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7SUFDdEIsQ0FBQztJQUVELElBQUksTUFBTTtRQUNSLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBbUMsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRCxJQUFJLEtBQUs7UUFDUCxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQStCLENBQUMsQ0FBQztJQUM3RCxDQUFDO0NBQ0Y7QUFyQkQsMERBcUJDO0FBRUQsTUFBYSwrQkFBZ0MsU0FBUSx1QkFBdUI7SUFDMUUsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0NBQ0Y7QUFKRCwwRUFJQztBQUVELE1BQWEsc0JBR1gsU0FBUSx1QkFBNkI7Q0FBRztBQUgxQyx3REFHMEMifQ==

package/dist/decorators/hook/hook.d.ts

@@ -0,0 +1,10 @@
+import { HookHandler, HookPosition } from './types';
+import HookContext from './context/hook';
+export default class Hooks<B extends HookContext, A extends HookContext> {
+    private before;
+    private after;
+    executeBefore(context: B): Promise<void>;
+    executeAfter(context: A): Promise<void>;
+    addHandler(position: HookPosition, handler: HookHandler<A> | HookHandler<B>): void;
+}
+//# sourceMappingURL=hook.d.ts.map

package/dist/decorators/hook/hook.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Hooks {
+    constructor() {
+        this.before = [];
+        this.after = [];
+    }
+    async executeBefore(context) {
+        for (const hook of this.before) {
+            // eslint-disable-next-line no-await-in-loop
+            await hook(context);
+        }
+    }
+    async executeAfter(context) {
+        for (const hook of this.after) {
+            // eslint-disable-next-line no-await-in-loop
+            await hook(context);
+        }
+    }
+    addHandler(position, handler) {
+        if (position === 'After') {
+            this.after.push(handler);
+        }
+        else {
+            this.before.push(handler);
+        }
+    }
+}
+exports.default = Hooks;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9vay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2hvb2svaG9vay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLE1BQXFCLEtBQUs7SUFBMUI7UUFDVSxXQUFNLEdBQXFCLEVBQUUsQ0FBQztRQUM5QixVQUFLLEdBQXFCLEVBQUUsQ0FBQztJQXVCdkMsQ0FBQztJQXJCQyxLQUFLLENBQUMsYUFBYSxDQUFDLE9BQVU7UUFDNUIsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFO1lBQzlCLDRDQUE0QztZQUM1QyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUNyQjtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsWUFBWSxDQUFDLE9BQVU7UUFDM0IsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFO1lBQzdCLDRDQUE0QztZQUM1QyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUNyQjtJQUNILENBQUM7SUFFRCxVQUFVLENBQUMsUUFBc0IsRUFBRSxPQUF3QztRQUN6RSxJQUFJLFFBQVEsS0FBSyxPQUFPLEVBQUU7WUFDeEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBeUIsQ0FBQyxDQUFDO1NBQzVDO2FBQU07WUFDTCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUF5QixDQUFDLENBQUM7U0FDN0M7SUFDSCxDQUFDO0NBQ0Y7QUF6QkQsd0JBeUJDIn0=

package/dist/decorators/hook/types.d.ts

@@ -0,0 +1,27 @@
+import { HookAfterAggregateContext, HookBeforeAggregateContext } from './context/aggregate';
+import { HookAfterCreateContext, HookBeforeCreateContext } from './context/create';
+import { HookAfterDeleteContext, HookBeforeDeleteContext } from './context/delete';
+import { HookAfterListContext, HookBeforeListContext } from './context/list';
+import { HookAfterUpdateContext, HookBeforeUpdateContext } from './context/update';
+import { TCollectionName, TSchema } from '../../templates';
+import HookContext from './context/hook';
+export declare type HookHandler<C extends HookContext<S, N>, R = void, S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = (context: C) => Promise<R> | R;
+export declare type HookType<P extends HookPosition = HookPosition> = Extract<keyof HooksContext[P], string>;
+export declare type HookPosition = Extract<keyof HooksContext, string>;
+export declare type HooksContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    Before: {
+        List: HookBeforeListContext<S, N>;
+        Create: HookBeforeCreateContext<S, N>;
+        Update: HookBeforeUpdateContext<S, N>;
+        Delete: HookBeforeDeleteContext<S, N>;
+        Aggregate: HookBeforeAggregateContext<S, N>;
+    };
+    After: {
+        List: HookAfterListContext<S, N>;
+        Create: HookAfterCreateContext<S, N>;
+        Update: HookAfterUpdateContext<S, N>;
+        Delete: HookAfterDeleteContext<S, N>;
+        Aggregate: HookAfterAggregateContext<S, N>;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/decorators/hook/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9ob29rL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/decorators/operators-emulate/collection.d.ts

@@ -0,0 +1,15 @@
+import { Caller, CollectionSchema, Operator, PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import { OperatorDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+export default class OperatorsEmulate extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<OperatorsEmulate>;
+    private readonly fields;
+    emulateFieldOperator(name: string, operator: Operator): void;
+    replaceFieldOperator(name: string, operator: Operator, replaceBy: OperatorDefinition): void;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    protected refineFilter(caller: Caller, filter: PaginatedFilter): Promise<PaginatedFilter>;
+    private replaceLeaf;
+    private computeEquivalent;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/operators-emulate/collection.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_context_1 = __importDefault(require("../../context/collection-context"));
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+class OperatorsEmulate extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.fields = new Map();
+    }
+    emulateFieldOperator(name, operator) {
+        this.replaceFieldOperator(name, operator, null);
+    }
+    replaceFieldOperator(name, operator, replaceBy) {
+        // Check that the collection can actually support our rewriting
+        const pks = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.childCollection.schema);
+        pks.forEach(pk => {
+            const schema = this.childCollection.schema.fields[pk];
+            const operators = schema.filterOperators;
+            if (!operators?.has('Equal') || !operators?.has('In')) {
+                throw new Error(`Cannot override operators on collection '${this.name}': ` +
+                    `the primary key columns must support 'Equal' and 'In' operators`);
+            }
+        });
+        // Check that targeted field is valid
+        const field = this.childCollection.schema.fields[name];
+        datasource_toolkit_1.FieldValidator.validate(this, name);
+        if (!field)
+            throw new Error('Cannot replace operator for relation');
+        // Mark the field operator as replaced.
+        if (!this.fields.has(name))
+            this.fields.set(name, new Map());
+        this.fields.get(name).set(operator, replaceBy);
+        this.markSchemaAsDirty();
+    }
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [name, schema] of Object.entries(childSchema.fields)) {
+            if (this.fields.has(name)) {
+                const column = schema;
+                fields[name] = {
+                    ...column,
+                    filterOperators: new Set([
+                        ...(column.filterOperators ?? []),
+                        ...this.fields.get(name).keys(),
+                    ]),
+                };
+            }
+            else {
+                fields[name] = schema;
+            }
+        }
+        return { ...childSchema, fields };
+    }
+    async refineFilter(caller, filter) {
+        return filter?.override({
+            conditionTree: await filter.conditionTree?.replaceLeafsAsync(leaf => this.replaceLeaf(caller, leaf, [])),
+        });
+    }
+    async replaceLeaf(caller, leaf, replacements) {
+        // ConditionTree is targeting a field on another collection => recurse.
+        if (leaf.field.includes(':')) {
+            const [prefix] = leaf.field.split(':');
+            const schema = this.schema.fields[prefix];
+            const association = this.dataSource.getCollection(schema.foreignCollection);
+            const associationLeaf = await leaf
+                .unnest()
+                .replaceLeafsAsync(subLeaf => association.replaceLeaf(caller, subLeaf, replacements));
+            return associationLeaf.nest(prefix);
+        }
+        return this.fields.get(leaf.field)?.has(leaf.operator)
+            ? this.computeEquivalent(caller, leaf, replacements)
+            : leaf;
+    }
+    async computeEquivalent(caller, leaf, replacements) {
+        const handler = this.fields.get(leaf.field)?.get(leaf.operator);
+        if (handler) {
+            const replacementId = `${this.name}.${leaf.field}[${leaf.operator}]`;
+            const subReplacements = [...replacements, replacementId];
+            if (replacements.includes(replacementId)) {
+                throw new Error(`Operator replacement cycle: ${subReplacements.join(' -> ')}`);
+            }
+            const result = await handler(leaf.value, new collection_context_1.default(this, caller));
+            if (result) {
+                let equivalent = result instanceof datasource_toolkit_1.ConditionTree ? result : datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(result);
+                equivalent = await equivalent.replaceLeafsAsync(subLeaf => this.replaceLeaf(caller, subLeaf, subReplacements));
+                datasource_toolkit_1.ConditionTreeValidator.validate(equivalent, this);
+                return equivalent;
+            }
+        }
+        // Query all records on the dataSource and emulate the filter.
+        return datasource_toolkit_1.ConditionTreeFactory.matchRecords(this.schema, leaf.apply(await this.list(caller, new datasource_toolkit_1.PaginatedFilter({}), leaf.projection.withPks(this)), this, caller.timezone));
+    }
+}
+exports.default = OperatorsEmulate;
+//# sourceMappingURL=data:application/json;base64,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