@forestadmin/datasource-customizer 1.0.0-alpha.1

package/dist/context/agent-context.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_1 = __importDefault(require("./relaxed-wrappers/datasource"));
+class AgentCustomizationContext {
+    constructor(dataSource, caller) {
+        this.realDataSource = dataSource;
+        this._caller = caller;
+    }
+    get dataSource() {
+        return new datasource_1.default(this.realDataSource, this._caller);
+    }
+    get caller() {
+        return Object.freeze(this._caller);
+    }
+}
+exports.default = AgentCustomizationContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQtY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250ZXh0L2FnZW50LWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFFQSwrRUFBOEQ7QUFFOUQsTUFBcUIseUJBQXlCO0lBUTVDLFlBQVksVUFBc0IsRUFBRSxNQUFjO1FBQ2hELElBQUksQ0FBQyxjQUFjLEdBQUcsVUFBVSxDQUFDO1FBQ2pDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3hCLENBQUM7SUFQRCxJQUFJLFVBQVU7UUFDWixPQUFPLElBQUksb0JBQWlCLENBQUksSUFBSSxDQUFDLGNBQWMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckUsQ0FBQztJQU9ELElBQUksTUFBTTtRQUNSLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNGO0FBaEJELDRDQWdCQyJ9

package/dist/context/collection-context.d.ts

@@ -0,0 +1,10 @@
+import { Caller, Collection } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TSchema } from '../templates';
+import AgentCustomizationContext from './agent-context';
+import RelaxedCollection from './relaxed-wrappers/collection';
+export default class CollectionCustomizationContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends AgentCustomizationContext<S> {
+    protected realCollection: Collection;
+    get collection(): RelaxedCollection<S, N>;
+    constructor(collection: Collection, caller: Caller);
+}
+//# sourceMappingURL=collection-context.d.ts.map

package/dist/context/collection-context.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_context_1 = __importDefault(require("./agent-context"));
+const collection_1 = __importDefault(require("./relaxed-wrappers/collection"));
+class CollectionCustomizationContext extends agent_context_1.default {
+    constructor(collection, caller) {
+        super(collection.dataSource, caller);
+        this.realCollection = collection;
+    }
+    get collection() {
+        return new collection_1.default(this.realCollection, this.caller);
+    }
+}
+exports.default = CollectionCustomizationContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi1jb250ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRleHQvY29sbGVjdGlvbi1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsb0VBQXdEO0FBQ3hELCtFQUE4RDtBQUU5RCxNQUFxQiw4QkFHbkIsU0FBUSx1QkFBNEI7SUFPcEMsWUFBWSxVQUFzQixFQUFFLE1BQWM7UUFDaEQsS0FBSyxDQUFDLFVBQVUsQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDckMsSUFBSSxDQUFDLGNBQWMsR0FBRyxVQUFVLENBQUM7SUFDbkMsQ0FBQztJQVBELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxvQkFBaUIsQ0FBQyxJQUFJLENBQUMsY0FBYyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqRSxDQUFDO0NBTUY7QUFkRCxpREFjQyJ9

package/dist/context/relaxed-wrappers/collection.d.ts

@@ -0,0 +1,112 @@
+import { ActionField, ActionResult, Caller, Collection, RecordData } from '@forestadmin/datasource-toolkit';
+import { TAggregateResult, TAggregation, TCollectionName, TFieldName, TFilter, TPaginatedFilter, TPartialSimpleRow, TRow, TSchema, TSimpleRow } from '../../templates';
+/** Collection wrapper which accepts plain objects in all methods */
+export default class RelaxedCollection<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> {
+    private collection;
+    private caller;
+    constructor(collection: Collection, caller: Caller);
+    /**
+     * Execute a given action
+     * @param name the name of the action
+     * @param formValues the values of the form, if the action rely on an action form
+     * @param filter the filter used to represent the selected records to use the action on
+     * @example
+     * .execute(
+     *    'Refund',
+     *    { reason: 'Article is broken' },
+     *    {
+     *      conditionTree: {
+     *        field: 'id',
+     *        operator: 'Equal',
+     *        value: 1
+     *      }
+     *    }
+     * );
+     */
+    execute(name: string, formValues: RecordData, filter?: TFilter<S, N>): Promise<ActionResult>;
+    getForm(name: string, formValues?: RecordData, filter?: TFilter<S, N>): Promise<ActionField[]>;
+    /**
+     * Create a list of records
+     * @param data An array of records to create
+     * @example
+     * .create([
+     *    { amountInEur: 150, description: 'Buy dvd' },
+     *    { amountInEur: -100, description: 'Refund' },
+     * ]);
+     */
+    create(data: TSimpleRow<S, N>[]): Promise<TSimpleRow<S, N>[]>;
+    /**
+     * List multiple records
+     * @param filter the filter used to select the records to list
+     * @param projection an array of fields name representing the data to select
+     * @example
+     * .list({
+     *    conditionTree: {
+     *      aggregator: 'And',
+     *      conditions: [{
+     *        field: 'amountInEur',
+     *        operator: 'GreaterThan',
+     *        value: 1000
+     *      }, {
+     *        field: 'description',
+     *        operator: 'Contains',
+     *        value: 'Refund',
+     *      }],
+     *      page: { limit: 10, skip: 0 },
+     *      sort: [{ field: 'id', ascending: true }]
+     *   }
+     * }, ['id', 'amountInEur', 'description']);
+     */
+    list(filter: TPaginatedFilter<S, N>, projection: TFieldName<S, N>[]): Promise<TRow<S, N>[]>;
+    /**
+     * Update a list of records
+     * @param filter the filter that represent the list of records to update
+     * @param patch the patch to apply on the selected records
+     * @example
+     * .update({
+     *    conditionTree: {
+     *      field: 'isActive',
+     *      operator: 'Equal',
+     *      value: false
+     *    },
+     * }, { isActive: true });
+     */
+    update(filter: TFilter<S, N>, patch: TPartialSimpleRow<S, N>): Promise<void>;
+    /**
+     * Delete a list of records
+     * @param filter the filter that represent the list of records to update
+     * @example
+     * .delete({
+     *    conditionTree: {
+     *      field: 'isBlocked',
+     *      operator: 'Equal',
+     *      value: false,
+     *    },
+     * });
+     */
+    delete(filter: TFilter<S, N>): Promise<void>;
+    /**
+     * Aggregate a list of records
+     * @param filter the filter used to list the records to aggregate
+     * @param aggregation the aggregation to apply
+     * @param limit the maximum number of result to return
+     * @example
+     * .aggregate({
+     *    conditionTree: {
+     *      field: "user:company:id",
+     *      operator: "In",
+     *      value: records.map((r) => r.id),
+     *    },
+     * }, {
+     *    operation: "Sum",
+     *    field: "amountInEur",
+     *    groups: [{ field: "user:company:id" }],
+     * }, 10);
+     */
+    aggregate(filter: TFilter<S, N>, aggregation: TAggregation<S, N>, limit?: number): Promise<TAggregateResult<S, N>[]>;
+    private buildFilter;
+    private buildPaginatedFilter;
+    private buildProjection;
+    private buildAggregation;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/context/relaxed-wrappers/collection.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+/** Collection wrapper which accepts plain objects in all methods */
+class RelaxedCollection {
+    constructor(collection, caller) {
+        this.collection = collection;
+        this.caller = caller;
+    }
+    /**
+     * Execute a given action
+     * @param name the name of the action
+     * @param formValues the values of the form, if the action rely on an action form
+     * @param filter the filter used to represent the selected records to use the action on
+     * @example
+     * .execute(
+     *    'Refund',
+     *    { reason: 'Article is broken' },
+     *    {
+     *      conditionTree: {
+     *        field: 'id',
+     *        operator: 'Equal',
+     *        value: 1
+     *      }
+     *    }
+     * );
+     */
+    execute(name, formValues, filter) {
+        const filterInstance = this.buildFilter(filter);
+        return this.collection.execute(this.caller, name, formValues, filterInstance);
+    }
+    getForm(name, formValues, filter) {
+        const filterInstance = this.buildFilter(filter);
+        return this.collection.getForm(this.caller, name, formValues, filterInstance);
+    }
+    /**
+     * Create a list of records
+     * @param data An array of records to create
+     * @example
+     * .create([
+     *    { amountInEur: 150, description: 'Buy dvd' },
+     *    { amountInEur: -100, description: 'Refund' },
+     * ]);
+     */
+    create(data) {
+        return this.collection.create(this.caller, data);
+    }
+    /**
+     * List multiple records
+     * @param filter the filter used to select the records to list
+     * @param projection an array of fields name representing the data to select
+     * @example
+     * .list({
+     *    conditionTree: {
+     *      aggregator: 'And',
+     *      conditions: [{
+     *        field: 'amountInEur',
+     *        operator: 'GreaterThan',
+     *        value: 1000
+     *      }, {
+     *        field: 'description',
+     *        operator: 'Contains',
+     *        value: 'Refund',
+     *      }],
+     *      page: { limit: 10, skip: 0 },
+     *      sort: [{ field: 'id', ascending: true }]
+     *   }
+     * }, ['id', 'amountInEur', 'description']);
+     */
+    list(filter, projection) {
+        const filterInstance = this.buildPaginatedFilter(filter);
+        const projectionInstance = this.buildProjection(projection);
+        const rows = this.collection.list(this.caller, filterInstance, projectionInstance);
+        return rows;
+    }
+    /**
+     * Update a list of records
+     * @param filter the filter that represent the list of records to update
+     * @param patch the patch to apply on the selected records
+     * @example
+     * .update({
+     *    conditionTree: {
+     *      field: 'isActive',
+     *      operator: 'Equal',
+     *      value: false
+     *    },
+     * }, { isActive: true });
+     */
+    update(filter, patch) {
+        const filterInstance = this.buildFilter(filter);
+        return this.collection.update(this.caller, filterInstance, patch);
+    }
+    /**
+     * Delete a list of records
+     * @param filter the filter that represent the list of records to update
+     * @example
+     * .delete({
+     *    conditionTree: {
+     *      field: 'isBlocked',
+     *      operator: 'Equal',
+     *      value: false,
+     *    },
+     * });
+     */
+    delete(filter) {
+        const filterInstance = this.buildFilter(filter);
+        return this.collection.delete(this.caller, filterInstance);
+    }
+    /**
+     * Aggregate a list of records
+     * @param filter the filter used to list the records to aggregate
+     * @param aggregation the aggregation to apply
+     * @param limit the maximum number of result to return
+     * @example
+     * .aggregate({
+     *    conditionTree: {
+     *      field: "user:company:id",
+     *      operator: "In",
+     *      value: records.map((r) => r.id),
+     *    },
+     * }, {
+     *    operation: "Sum",
+     *    field: "amountInEur",
+     *    groups: [{ field: "user:company:id" }],
+     * }, 10);
+     */
+    async aggregate(filter, aggregation, limit) {
+        const filterInstance = this.buildFilter(filter);
+        const aggregationInstance = this.buildAggregation(aggregation);
+        const result = await this.collection.aggregate(this.caller, filterInstance, aggregationInstance, limit);
+        return result;
+    }
+    buildFilter(filter) {
+        return filter
+            ? new datasource_toolkit_1.Filter({
+                ...filter,
+                conditionTree: filter.conditionTree
+                    ? datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(filter.conditionTree)
+                    : undefined,
+            })
+            : null;
+    }
+    buildPaginatedFilter(filter) {
+        return new datasource_toolkit_1.PaginatedFilter({
+            ...filter,
+            conditionTree: filter?.conditionTree
+                ? datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(filter.conditionTree)
+                : undefined,
+            sort: filter.sort ? new datasource_toolkit_1.Sort(...filter.sort) : undefined,
+            page: filter.page ? new datasource_toolkit_1.Page(filter.page.skip, filter.page.limit) : undefined,
+        });
+    }
+    buildProjection(projection) {
+        return new datasource_toolkit_1.Projection(...projection);
+    }
+    buildAggregation(aggregation) {
+        return new datasource_toolkit_1.Aggregation(aggregation);
+    }
+}
+exports.default = RelaxedCollection;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/context/relaxed-wrappers/datasource.d.ts

@@ -0,0 +1,15 @@
+import { Caller, DataSource } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TSchema } from '../../templates';
+import RelaxedCollection from './collection';
+/** DataSource wrapper which accepts plain objects in all methods */
+export default class RelaxedDataSource<S extends TSchema = TSchema> {
+    private dataSource;
+    private caller;
+    constructor(dataSource: DataSource, caller: Caller);
+    /**
+     * Get a collection from a datasource
+     * @param name the name of the collection
+     */
+    getCollection<N extends TCollectionName<S>>(name: N): RelaxedCollection<S, N>;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/context/relaxed-wrappers/datasource.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_1 = __importDefault(require("./collection"));
+/** DataSource wrapper which accepts plain objects in all methods */
+class RelaxedDataSource {
+    constructor(dataSource, caller) {
+        this.dataSource = dataSource;
+        this.caller = caller;
+    }
+    /**
+     * Get a collection from a datasource
+     * @param name the name of the collection
+     */
+    getCollection(name) {
+        return new collection_1.default(this.dataSource.getCollection(name), this.caller);
+    }
+}
+exports.default = RelaxedDataSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb250ZXh0L3JlbGF4ZWQtd3JhcHBlcnMvZGF0YXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLDhEQUE2QztBQUU3QyxvRUFBb0U7QUFDcEUsTUFBcUIsaUJBQWlCO0lBSXBDLFlBQVksVUFBc0IsRUFBRSxNQUFjO1FBQ2hELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO1FBQzdCLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO0lBQ3ZCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxhQUFhLENBQStCLElBQU87UUFDakQsT0FBTyxJQUFJLG9CQUFpQixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqRixDQUFDO0NBQ0Y7QUFoQkQsb0NBZ0JDIn0=

package/dist/datasource-customizer.d.ts

@@ -0,0 +1,53 @@
+import { DataSource, DataSourceFactory, Logger } from '@forestadmin/datasource-toolkit';
+import { ChartDefinition } from './decorators/chart/types';
+import { DataSourceOptions } from './types';
+import { TCollectionName, TSchema } from './templates';
+import CollectionCustomizer from './collection-customizer';
+/**
+ * Allow to create a new Forest Admin agent from scratch.
+ * Builds the application by composing and configuring all the collection decorators.
+ *
+ * Minimal code to add a datasource
+ * @example
+ * new AgentBuilder(options)
+ *  .addDataSource(new SomeDataSource())
+ *  .start();
+ */
+export default class DataSourceCustomizer<S extends TSchema = TSchema> {
+    private readonly compositeDataSource;
+    private readonly stack;
+    private customizations;
+    constructor();
+    /**
+     * Add a datasource
+     * @param factory the datasource to add
+     * @param options the options
+     */
+    addDataSource(factory: DataSourceFactory, options?: DataSourceOptions): this;
+    /**
+     * Create a new API chart
+     * @param name name of the chart
+     * @param definition definition of the chart
+     * @example
+     * .addChart('numCustomers', {
+     *   type: 'Value',
+     *   render: (context, resultBuilder) => {
+     *     return resultBuilder.value(123);
+     *   }
+     * })
+     */
+    addChart(name: string, definition: ChartDefinition<S>): this;
+    /**
+     * Allow to interact with a decorated collection
+     * @param name the name of the collection to manipulate
+     * @param handle a function that provide a
+     *   collection builder on the given collection name
+     * @example
+     * .customizeCollection('books', books => books.renameField('xx', 'yy'))
+     */
+    customizeCollection<N extends TCollectionName<S>>(name: N, handle: (collection: CollectionCustomizer<S, N>) => unknown): this;
+    getDataSource(logger: Logger): Promise<DataSource>;
+    getFactory(): DataSourceFactory;
+    updateTypesOnFileSystem(typingsPath: string, typingsMaxDepth: number): Promise<void>;
+}
+//# sourceMappingURL=datasource-customizer.d.ts.map

package/dist/datasource-customizer.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_customizer_1 = __importDefault(require("./collection-customizer"));
+const composite_datasource_1 = __importDefault(require("./decorators/composite-datasource"));
+const decorators_stack_1 = __importDefault(require("./decorators/decorators-stack"));
+const datasource_1 = __importDefault(require("./decorators/rename-collection/datasource"));
+const typing_generator_1 = __importDefault(require("./typing-generator"));
+/**
+ * Allow to create a new Forest Admin agent from scratch.
+ * Builds the application by composing and configuring all the collection decorators.
+ *
+ * Minimal code to add a datasource
+ * @example
+ * new AgentBuilder(options)
+ *  .addDataSource(new SomeDataSource())
+ *  .start();
+ */
+class DataSourceCustomizer {
+    constructor() {
+        this.customizations = [];
+        this.compositeDataSource = new composite_datasource_1.default();
+        this.stack = new decorators_stack_1.default(this.compositeDataSource);
+    }
+    /**
+     * Add a datasource
+     * @param factory the datasource to add
+     * @param options the options
+     */
+    addDataSource(factory, options) {
+        this.customizations.push(async (logger) => {
+            const dataSource = await factory(logger);
+            const renamedDecorator = new datasource_1.default(dataSource);
+            renamedDecorator.renameCollections(options?.rename);
+            this.compositeDataSource.addDataSource(renamedDecorator);
+        });
+        return this;
+    }
+    /**
+     * Create a new API chart
+     * @param name name of the chart
+     * @param definition definition of the chart
+     * @example
+     * .addChart('numCustomers', {
+     *   type: 'Value',
+     *   render: (context, resultBuilder) => {
+     *     return resultBuilder.value(123);
+     *   }
+     * })
+     */
+    addChart(name, definition) {
+        this.customizations.push(async () => {
+            this.stack.chart.addChart(name, definition);
+        });
+        return this;
+    }
+    /**
+     * Allow to interact with a decorated collection
+     * @param name the name of the collection to manipulate
+     * @param handle a function that provide a
+     *   collection builder on the given collection name
+     * @example
+     * .customizeCollection('books', books => books.renameField('xx', 'yy'))
+     */
+    customizeCollection(name, handle) {
+        this.customizations.push(async () => {
+            if (this.stack.dataSource.getCollection(name)) {
+                handle(new collection_customizer_1.default(this.stack, name));
+            }
+        });
+        return this;
+    }
+    async getDataSource(logger) {
+        while (this.customizations.length) {
+            await this.customizations.shift()(logger); // eslint-disable-line no-await-in-loop
+        }
+        return this.stack.dataSource;
+    }
+    getFactory() {
+        return async (logger) => this.getDataSource(logger);
+    }
+    async updateTypesOnFileSystem(typingsPath, typingsMaxDepth) {
+        return typing_generator_1.default.updateTypesOnFileSystem(this.stack.hook, typingsPath, typingsMaxDepth);
+    }
+}
+exports.default = DataSourceCustomizer;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/actions/collection.d.ts

@@ -0,0 +1,18 @@
+import { ActionField, ActionResult, Caller, CollectionSchema, Filter, RecordData } from '@forestadmin/datasource-toolkit';
+import { ActionDefinition } from './types/actions';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+export default class ActionCollectionDecorator extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<ActionCollectionDecorator>;
+    private actions;
+    addAction(name: string, action: ActionDefinition): void;
+    execute(caller: Caller, name: string, data: RecordData, filter: Filter): Promise<ActionResult>;
+    getForm(caller: Caller, name: string, data?: RecordData, filter?: Filter): Promise<ActionField[]>;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    private getContext;
+    private dropDefaults;
+    private dropIfs;
+    private dropDeferred;
+    private evaluate;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/actions/collection.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./context/base"));
+const single_1 = __importDefault(require("./context/single"));
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+const result_builder_1 = __importDefault(require("./result-builder"));
+class ActionCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.actions = {};
+    }
+    addAction(name, action) {
+        this.actions[name] = action;
+        this.markSchemaAsDirty();
+    }
+    async execute(caller, name, data, filter) {
+        const action = this.actions[name];
+        if (!action)
+            return this.childCollection.execute(caller, name, data, filter);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const context = this.getContext(caller, action, data, filter);
+        const resultBuilder = new result_builder_1.default();
+        const result = await action.execute(context, resultBuilder);
+        return (result || {
+            type: 'Success',
+            invalidated: new Set(),
+            message: 'Success',
+        });
+    }
+    async getForm(caller, name, data, filter) {
+        const action = this.actions[name];
+        if (!action)
+            return this.childCollection.getForm(caller, name, data, filter);
+        if (!action.form)
+            return [];
+        const formValues = data ? { ...data } : {};
+        const used = new Set();
+        const context = this.getContext(caller, action, formValues, filter, used);
+        // Convert DynamicField to ActionField in successive steps.
+        let dynamicFields;
+        dynamicFields = action.form.map(c => ({ ...c }));
+        dynamicFields = await this.dropDefaults(context, dynamicFields, !data, formValues);
+        dynamicFields = await this.dropIfs(context, dynamicFields);
+        const fields = await this.dropDeferred(context, dynamicFields);
+        for (const field of fields) {
+            // customer did not define a handler to rewrite the previous value => reuse current one.
+            if (field.value === undefined)
+                field.value = formValues[field.label];
+            // fields that were accessed through the context.formValues.X getter should be watched.
+            field.watchChanges = used.has(field.label);
+        }
+        return fields;
+    }
+    refineSchema(subSchema) {
+        const newSchema = { ...subSchema, actions: { ...subSchema.actions } };
+        for (const [name, { form, scope, generateFile }] of Object.entries(this.actions)) {
+            // An action form can be send in the schema to avoid calling the load handler
+            // as long as there is nothing dynamic in it.
+            const isDynamic = form?.some(field => Object.values(field).some(value => typeof value === 'function'));
+            newSchema.actions[name] = { scope, generateFile: !!generateFile, staticForm: !isDynamic };
+        }
+        return newSchema;
+    }
+    getContext(caller, action, formValues, filter, used) {
+        return new {
+            Global: base_1.default,
+            Bulk: base_1.default,
+            Single: single_1.default,
+        }[action.scope](this, caller, formValues, filter, used);
+    }
+    async dropDefaults(context, fields, isFirstCall, data) {
+        if (isFirstCall) {
+            const defaults = await Promise.all(fields.map(field => this.evaluate(context, field.defaultValue)));
+            fields.forEach((field, index) => {
+                data[field.label] = defaults[index];
+            });
+        }
+        fields.forEach(field => delete field.defaultValue);
+        return fields;
+    }
+    async dropIfs(context, fields) {
+        // Remove fields which have falsy if
+        const ifValues = await Promise.all(fields.map(field => !field.if || this.evaluate(context, field.if)));
+        const newFields = fields.filter((_, index) => ifValues[index]);
+        newFields.forEach(field => delete field.if);
+        return newFields;
+    }
+    async dropDeferred(context, fields) {
+        const newFields = fields.map(async (field) => {
+            const keys = Object.keys(field);
+            const values = await Promise.all(Object.values(field).map(value => this.evaluate(context, value)));
+            return keys.reduce((memo, key, index) => ({ ...memo, [key]: values[index] }), {});
+        });
+        return Promise.all(newFields);
+    }
+    async evaluate(context, value) {
+        return typeof value === 'function' ? value(context) : value;
+    }
+}
+exports.default = ActionCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,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