@forestadmin/datasource-customizer 1.0.0-alpha.1

package/dist/decorators/actions/context/base.d.ts

@@ -0,0 +1,28 @@
+import { Caller, Collection, CompositeId, RecordData } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFieldName, TFilter, TRow, TSchema } from '../../../templates';
+import CollectionCustomizationContext from '../../../context/collection-context';
+export default class ActionContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends CollectionCustomizationContext<S, N> {
+    readonly formValues: any;
+    readonly filter: TFilter<S, N>;
+    private queries;
+    private projection;
+    constructor(collection: Collection, caller: Caller, formValue: RecordData, filter: TFilter<S, N>, used?: Set<string>);
+    /**
+     * Get all the records selected by an action
+     * @param fields An array of fields needed in the response
+     * @example
+     * .getRecords(['id', 'isActive', 'name']);
+     */
+    getRecords(fields: TFieldName<S, N>[]): Promise<TRow<S, N>[]>;
+    /**
+     * Get all the records ids selected by an action
+     */
+    getRecordIds(): Promise<Array<string | number>>;
+    /**
+     * Get all the records ids (when the collection uses composite keys)
+     */
+    getCompositeRecordIds(): Promise<CompositeId[]>;
+    private runQuery;
+    private reset;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/decorators/actions/context/base.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-classes-per-file */
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_context_1 = __importDefault(require("../../../context/collection-context"));
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
+}
+class ActionContext extends collection_context_1.default {
+    constructor(collection, caller, formValue, filter, used) {
+        super(collection, caller);
+        this.formValues = formValue;
+        this.filter = filter;
+        this.reset();
+        // Spy on which formValues are accessed to set-up change hooks
+        if (used) {
+            this.formValues = new Proxy(this.formValues, {
+                get: (target, prop, receiver) => {
+                    if (typeof prop === 'string')
+                        used.add(prop);
+                    return Reflect.get(target, prop, receiver);
+                },
+                set: () => {
+                    throw new Error('formValues is readonly');
+                },
+            });
+        }
+    }
+    /**
+     * Get all the records selected by an action
+     * @param fields An array of fields needed in the response
+     * @example
+     * .getRecords(['id', 'isActive', 'name']);
+     */
+    async getRecords(fields) {
+        // This function just queues the request into this.queries, so that we can merge all calls
+        // to getRecords() into a single one.
+        // The call to setTimeout which resolve the promises will trigger only once all handlers in
+        // the customer's form have been called as Promises are queued before calls to setTimeout
+        // in Node.js event loop
+        // @see https://dev.to/khaosdoctor/node-js-under-the-hood-3-deep-dive-into-the-event-loop-135d\
+        //   #microtasks-and-macrotasks
+        //   Ordering of micro/macro tasks in Node.js event loop
+        //
+        // @see https://github.com/graphql/dataloader
+        //   A library from facebook from which this pattern is inspired.
+        datasource_toolkit_1.ProjectionValidator.validate(this.realCollection, fields);
+        const deferred = new Deferred();
+        const projection = new datasource_toolkit_1.Projection(...fields);
+        if (this.queries.length === 0)
+            setTimeout(() => this.runQuery());
+        this.queries.push({ projection, deferred });
+        this.projection = this.projection.union(projection);
+        return deferred.promise;
+    }
+    /**
+     * Get all the records ids selected by an action
+     */
+    async getRecordIds() {
+        const compositeIds = await this.getCompositeRecordIds();
+        return compositeIds.map(id => id[0]);
+    }
+    /**
+     * Get all the records ids (when the collection uses composite keys)
+     */
+    async getCompositeRecordIds() {
+        const projection = new datasource_toolkit_1.Projection().withPks(this.realCollection);
+        const records = await this.getRecords(projection);
+        return records.map(r => datasource_toolkit_1.RecordUtils.getPrimaryKey(this.realCollection.schema, r));
+    }
+    async runQuery() {
+        const { queries, projection } = this;
+        this.reset();
+        try {
+            // Run a single query which contains all fields / relations which were requested by
+            // the different calls made to getRecords
+            const records = await this.collection.list(this.filter, projection);
+            // Resolve each on of the promises only with the requested fields.
+            for (const query of queries)
+                query.deferred.resolve(query.projection.apply(records));
+        }
+        catch (e) {
+            // Rejecting each promises at next tick
+            // This ensures that we don't let any promise hanging forever if the customer throws in
+            // the rejection handler.
+            for (const query of queries) {
+                process.nextTick(() => query.deferred.reject(e));
+            }
+        }
+    }
+    reset() {
+        this.queries = [];
+        this.projection = new datasource_toolkit_1.Projection();
+    }
+}
+exports.default = ActionContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2FjdGlvbnMvY29udGV4dC9iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEseUNBQXlDO0FBQ3pDLHdFQVF5QztBQUd6Qyw2RkFBaUY7QUFFakYsTUFBTSxRQUFRO0lBS1o7UUFDRSxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFO1lBQzdDLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1lBQ3JCLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBRUQsTUFBcUIsYUFHbkIsU0FBUSw0QkFBb0M7SUFPNUMsWUFDRSxVQUFzQixFQUN0QixNQUFjLEVBQ2QsU0FBcUIsRUFDckIsTUFBcUIsRUFDckIsSUFBa0I7UUFFbEIsS0FBSyxDQUFDLFVBQVUsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUMxQixJQUFJLENBQUMsVUFBVSxHQUFHLFNBQVMsQ0FBQztRQUM1QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFYiw4REFBOEQ7UUFDOUQsSUFBSSxJQUFJLEVBQUU7WUFDUixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUU7Z0JBQzNDLEdBQUcsRUFBRSxDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEVBQUU7b0JBQzlCLElBQUksT0FBTyxJQUFJLEtBQUssUUFBUTt3QkFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO29CQUU3QyxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztnQkFDN0MsQ0FBQztnQkFDRCxHQUFHLEVBQUUsR0FBRyxFQUFFO29CQUNSLE1BQU0sSUFBSSxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQztnQkFDNUMsQ0FBQzthQUNGLENBQUMsQ0FBQztTQUNKO0lBQ0gsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsS0FBSyxDQUFDLFVBQVUsQ0FBQyxNQUEwQjtRQUN6QywwRkFBMEY7UUFDMUYscUNBQXFDO1FBRXJDLDJGQUEyRjtRQUMzRix5RkFBeUY7UUFDekYsd0JBQXdCO1FBRXhCLCtGQUErRjtRQUMvRiwrQkFBK0I7UUFDL0Isd0RBQXdEO1FBQ3hELEVBQUU7UUFDRiw2Q0FBNkM7UUFDN0MsaUVBQWlFO1FBRWpFLHdDQUFtQixDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsY0FBYyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBRTFELE1BQU0sUUFBUSxHQUFHLElBQUksUUFBUSxFQUFnQixDQUFDO1FBQzlDLE1BQU0sVUFBVSxHQUFHLElBQUksK0JBQVUsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFDO1FBRTdDLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEtBQUssQ0FBQztZQUFFLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztRQUNqRSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQzVDLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFcEQsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDO0lBQzFCLENBQUM7SUFFRDs7T0FFRztJQUNILEtBQUssQ0FBQyxZQUFZO1FBQ2hCLE1BQU0sWUFBWSxHQUFHLE1BQU0sSUFBSSxDQUFDLHFCQUFxQixFQUFFLENBQUM7UUFFeEQsT0FBTyxZQUFZLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLHFCQUFxQjtRQUN6QixNQUFNLFVBQVUsR0FBRyxJQUFJLCtCQUFVLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBYSxDQUFDO1FBQzdFLE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxVQUFnQyxDQUFDLENBQUM7UUFFeEUsT0FBTyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsZ0NBQVcsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNwRixDQUFDO0lBRU8sS0FBSyxDQUFDLFFBQVE7UUFDcEIsTUFBTSxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsR0FBRyxJQUFJLENBQUM7UUFDckMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBRWIsSUFBSTtZQUNGLG1GQUFtRjtZQUNuRix5Q0FBeUM7WUFDekMsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FDeEMsSUFBSSxDQUFDLE1BQU0sRUFDWCxVQUE0QyxDQUM3QyxDQUFDO1lBRUYsa0VBQWtFO1lBQ2xFLEtBQUssTUFBTSxLQUFLLElBQUksT0FBTztnQkFBRSxLQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1NBQ3RGO1FBQUMsT0FBTyxDQUFDLEVBQUU7WUFDVix1Q0FBdUM7WUFFdkMsdUZBQXVGO1lBQ3ZGLHlCQUF5QjtZQUN6QixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sRUFBRTtnQkFDM0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQ2xEO1NBQ0Y7SUFDSCxDQUFDO0lBRU8sS0FBSztRQUNYLElBQUksQ0FBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSwrQkFBVSxFQUFFLENBQUM7SUFDckMsQ0FBQztDQUNGO0FBdEhELGdDQXNIQyJ9

package/dist/decorators/actions/context/single.d.ts

@@ -0,0 +1,9 @@
+import { CompositeId } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFieldName, TRow, TSchema } from '../../../templates';
+import ActionContext from './base';
+export default class ActionContextSingle<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends ActionContext<S, N> {
+    getRecordId(): Promise<string | number>;
+    getCompositeRecordId(): Promise<CompositeId>;
+    getRecord(fields: TFieldName<S, N>[]): Promise<TRow<S, N>>;
+}
+//# sourceMappingURL=single.d.ts.map

package/dist/decorators/actions/context/single.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 base_1 = __importDefault(require("./base"));
+class ActionContextSingle extends base_1.default {
+    async getRecordId() {
+        const compositeId = await this.getCompositeRecordId();
+        return compositeId[0];
+    }
+    async getCompositeRecordId() {
+        const ids = await this.getCompositeRecordIds();
+        return ids[0];
+    }
+    async getRecord(fields) {
+        const records = await this.getRecords(fields);
+        return records[0];
+    }
+}
+exports.default = ActionContextSingle;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvYWN0aW9ucy9jb250ZXh0L3NpbmdsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLGtEQUFtQztBQUVuQyxNQUFxQixtQkFHbkIsU0FBUSxjQUFtQjtJQUMzQixLQUFLLENBQUMsV0FBVztRQUNmLE1BQU0sV0FBVyxHQUFHLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFFdEQsT0FBTyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEIsQ0FBQztJQUVELEtBQUssQ0FBQyxvQkFBb0I7UUFDeEIsTUFBTSxHQUFHLEdBQUcsTUFBTSxJQUFJLENBQUMscUJBQXFCLEVBQUUsQ0FBQztRQUUvQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNoQixDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQVMsQ0FBQyxNQUEwQjtRQUN4QyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUM7UUFFOUMsT0FBTyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEIsQ0FBQztDQUNGO0FBckJELHNDQXFCQyJ9

package/dist/decorators/actions/result-builder.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import { ActionResult } from '@forestadmin/datasource-toolkit';
+import { Readable } from 'stream';
+export default class ResultBuilder {
+    /**
+     * Returns a success response from the action
+     * @param message the success message to return
+     * @param options available options to return
+     * @example
+     * .success('Success', { html: '<blinkee>Success!</blinkee>' });
+     */
+    success(message?: string, options?: {
+        html?: string;
+        invalidated?: string[];
+    }): ActionResult;
+    /**
+     * Returns an error response from the action
+     * @param message the error message to return
+     * @param options available options to return
+     * @example
+     * .error('Failed to refund the customer!', { html: '<strong>Error!</strong>' });
+     */
+    error(message?: string, options?: {
+        html: string;
+    }): ActionResult;
+    /**
+     * Returns a webhook that the UI will trigger
+     * @param url the url of the webhook
+     * @param method the HTTP method of the webhook
+     * @param headers an object representing the list of headers to send with the webhook
+     * @param body an object representing the body of the HTTP request
+     * @example
+     * .webhook('http://my-company-name', 'POST', {}, { adminToken: 'my-admin-token' });
+     */
+    webhook(url: string, method?: 'GET' | 'POST', headers?: Record<string, string>, body?: unknown): ActionResult;
+    /**
+     * Returns a file that will be downloaded
+     * @param streamOrBufferOrString the actual file to download
+     * @param name the name of the file
+     * @param mimeType the mime type of the file
+     * @example
+     * .file('This is my file content', 'download.txt', 'text/plain');
+     */
+    file(streamOrBufferOrString: Readable | Uint8Array | string, name?: string, mimeType?: string): ActionResult;
+    /**
+     * Returns to the UI that a redirection is needed
+     * @param path the path to redirect to
+     * @example
+     * .redirectTo('https://www.google.com');
+     */
+    redirectTo(path: string): ActionResult;
+}
+//# sourceMappingURL=result-builder.d.ts.map

package/dist/decorators/actions/result-builder.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+class ResultBuilder {
+    /**
+     * Returns a success response from the action
+     * @param message the success message to return
+     * @param options available options to return
+     * @example
+     * .success('Success', { html: '<blinkee>Success!</blinkee>' });
+     */
+    success(message, options) {
+        return {
+            type: 'Success',
+            message: message ?? 'Success',
+            invalidated: new Set(options?.invalidated ?? []),
+            html: options?.html,
+        };
+    }
+    /**
+     * Returns an error response from the action
+     * @param message the error message to return
+     * @param options available options to return
+     * @example
+     * .error('Failed to refund the customer!', { html: '<strong>Error!</strong>' });
+     */
+    error(message, options) {
+        return {
+            type: 'Error',
+            message: message ?? 'Error',
+            html: options?.html,
+        };
+    }
+    /**
+     * Returns a webhook that the UI will trigger
+     * @param url the url of the webhook
+     * @param method the HTTP method of the webhook
+     * @param headers an object representing the list of headers to send with the webhook
+     * @param body an object representing the body of the HTTP request
+     * @example
+     * .webhook('http://my-company-name', 'POST', {}, { adminToken: 'my-admin-token' });
+     */
+    webhook(url, method = 'POST', headers = {}, body = {}) {
+        return {
+            type: 'Webhook',
+            url,
+            method,
+            headers,
+            body,
+        };
+    }
+    /**
+     * Returns a file that will be downloaded
+     * @param streamOrBufferOrString the actual file to download
+     * @param name the name of the file
+     * @param mimeType the mime type of the file
+     * @example
+     * .file('This is my file content', 'download.txt', 'text/plain');
+     */
+    file(streamOrBufferOrString, name = 'file', mimeType = 'application/octet-stream') {
+        return {
+            type: 'File',
+            name,
+            mimeType,
+            stream: streamOrBufferOrString instanceof stream_1.Readable
+                ? streamOrBufferOrString
+                : stream_1.Readable.from([streamOrBufferOrString]),
+        };
+    }
+    /**
+     * Returns to the UI that a redirection is needed
+     * @param path the path to redirect to
+     * @example
+     * .redirectTo('https://www.google.com');
+     */
+    redirectTo(path) {
+        return { type: 'Redirect', path };
+    }
+}
+exports.default = ResultBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LWJ1aWxkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9hY3Rpb25zL3Jlc3VsdC1idWlsZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsbUNBQWtDO0FBRWxDLE1BQXFCLGFBQWE7SUFDaEM7Ozs7OztPQU1HO0lBQ0gsT0FBTyxDQUFDLE9BQWdCLEVBQUUsT0FBbUQ7UUFDM0UsT0FBTztZQUNMLElBQUksRUFBRSxTQUFTO1lBQ2YsT0FBTyxFQUFFLE9BQU8sSUFBSSxTQUFTO1lBQzdCLFdBQVcsRUFBRSxJQUFJLEdBQUcsQ0FBQyxPQUFPLEVBQUUsV0FBVyxJQUFJLEVBQUUsQ0FBQztZQUNoRCxJQUFJLEVBQUUsT0FBTyxFQUFFLElBQUk7U0FDcEIsQ0FBQztJQUNKLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSCxLQUFLLENBQUMsT0FBZ0IsRUFBRSxPQUEwQjtRQUNoRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE9BQU87WUFDYixPQUFPLEVBQUUsT0FBTyxJQUFJLE9BQU87WUFDM0IsSUFBSSxFQUFFLE9BQU8sRUFBRSxJQUFJO1NBQ3BCLENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSCxPQUFPLENBQ0wsR0FBVyxFQUNYLFNBQXlCLE1BQU0sRUFDL0IsVUFBa0MsRUFBRSxFQUNwQyxPQUFnQixFQUFFO1FBRWxCLE9BQU87WUFDTCxJQUFJLEVBQUUsU0FBUztZQUNmLEdBQUc7WUFDSCxNQUFNO1lBQ04sT0FBTztZQUNQLElBQUk7U0FDTCxDQUFDO0lBQ0osQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxJQUFJLENBQ0Ysc0JBQXNELEVBQ3RELElBQUksR0FBRyxNQUFNLEVBQ2IsUUFBUSxHQUFHLDBCQUEwQjtRQUVyQyxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixJQUFJO1lBQ0osUUFBUTtZQUNSLE1BQU0sRUFDSixzQkFBc0IsWUFBWSxpQkFBUTtnQkFDeEMsQ0FBQyxDQUFDLHNCQUFzQjtnQkFDeEIsQ0FBQyxDQUFDLGlCQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsc0JBQXNCLENBQUMsQ0FBQztTQUM5QyxDQUFDO0lBQ0osQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsVUFBVSxDQUFDLElBQVk7UUFDckIsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDcEMsQ0FBQztDQUNGO0FBekZELGdDQXlGQyJ9

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

@@ -0,0 +1,18 @@
+import { ActionResult, ActionScope } from '@forestadmin/datasource-toolkit';
+import { DynamicField } from './fields';
+import { TCollectionName, TSchema } from '../../../templates';
+import ActionContext from '../context/base';
+import ActionContextSingle from '../context/single';
+import ResultBuilder from '../result-builder';
+interface BaseAction<S extends TSchema, N extends TCollectionName<S>, Scope extends ActionScope, Context extends ActionContext<S, N>> {
+    generateFile?: boolean;
+    scope: Scope;
+    form?: DynamicField<Context>[];
+    execute(context: Context, resultBuilder: ResultBuilder): void | ActionResult | Promise<void> | Promise<ActionResult>;
+}
+export declare type ActionGlobal<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = BaseAction<S, N, 'Global', ActionContext<S, N>>;
+export declare type ActionBulk<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = BaseAction<S, N, 'Bulk', ActionContext<S, N>>;
+export declare type ActionSingle<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = BaseAction<S, N, 'Single', ActionContextSingle<S, N>>;
+export declare type ActionDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = ActionSingle<S, N> | ActionBulk<S, N> | ActionGlobal<S, N>;
+export {};
+//# sourceMappingURL=actions.d.ts.map

package/dist/decorators/actions/types/actions.js

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

package/dist/decorators/actions/types/fields.d.ts

@@ -0,0 +1,32 @@
+import { CompositeId, Json } from '@forestadmin/datasource-toolkit';
+export declare type ValueOrHandler<Context = unknown, Result = unknown> = ((context: Context) => Promise<Result>) | ((context: Context) => Result) | Promise<Result> | Result;
+interface BaseDynamicField<Type, Context, Result> {
+    type: Type;
+    label: string;
+    description?: string;
+    isRequired?: ValueOrHandler<Context, boolean>;
+    isReadOnly?: ValueOrHandler<Context, boolean>;
+    if?: ((context: Context) => Promise<unknown>) | ((context: Context) => unknown);
+    value?: ValueOrHandler<Context, Result>;
+    defaultValue?: ValueOrHandler<Context, Result>;
+}
+interface CollectionDynamicField<Context> extends BaseDynamicField<'Collection', Context, CompositeId> {
+    collectionName: ValueOrHandler<Context, string>;
+}
+interface EnumDynamicField<Context> extends BaseDynamicField<'Enum', Context, string> {
+    enumValues: ValueOrHandler<Context, string[]>;
+}
+interface EnumListDynamicField<Context> extends BaseDynamicField<'EnumList', Context, string[]> {
+    enumValues: ValueOrHandler<Context, string[]>;
+}
+declare type BooleanDynamicField<Context> = BaseDynamicField<'Boolean', Context, boolean>;
+declare type FileDynamicField<Context> = BaseDynamicField<'File', Context, File>;
+declare type FileListDynamicField<Context> = BaseDynamicField<'FileList', Context, File[]>;
+declare type JsonDynamicField<Context> = BaseDynamicField<'Json', Context, Json>;
+declare type NumberDynamicField<Context> = BaseDynamicField<'Number', Context, number>;
+declare type NumberListDynamicField<Context> = BaseDynamicField<'NumberList', Context, number[]>;
+declare type StringDynamicField<Context> = BaseDynamicField<'Date' | 'Dateonly' | 'String', Context, string>;
+declare type StringListDynamicField<Context> = BaseDynamicField<'StringList', Context, string[]>;
+export declare type DynamicField<Context = unknown> = BooleanDynamicField<Context> | CollectionDynamicField<Context> | EnumDynamicField<Context> | EnumListDynamicField<Context> | FileDynamicField<Context> | FileListDynamicField<Context> | JsonDynamicField<Context> | NumberDynamicField<Context> | NumberListDynamicField<Context> | StringDynamicField<Context> | StringListDynamicField<Context>;
+export {};
+//# sourceMappingURL=fields.d.ts.map

package/dist/decorators/actions/types/fields.js

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

package/dist/decorators/chart/datasource.d.ts

@@ -0,0 +1,11 @@
+import { Caller, Chart, DataSource, DataSourceSchema } from '@forestadmin/datasource-toolkit';
+import { ChartDefinition } from './types';
+import DataSourceDecorator from '../datasource-decorator';
+export default class ChartDataSourceDecorator extends DataSourceDecorator {
+    private charts;
+    get schema(): DataSourceSchema;
+    constructor(childDataSource: DataSource);
+    addChart(name: string, definition: ChartDefinition): void;
+    renderChart(caller: Caller, name: string): Promise<Chart>;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/decorators/chart/datasource.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 agent_context_1 = __importDefault(require("../../context/agent-context"));
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+const datasource_decorator_1 = __importDefault(require("../datasource-decorator"));
+const result_builder_1 = __importDefault(require("./result-builder"));
+class ChartDataSourceDecorator extends datasource_decorator_1.default {
+    constructor(childDataSource) {
+        super(childDataSource, collection_decorator_1.default);
+        this.charts = {};
+    }
+    get schema() {
+        const myCharts = Object.keys(this.charts);
+        const otherCharts = this.childDataSource.schema.charts;
+        const duplicate = myCharts.find(name => otherCharts.includes(name));
+        if (duplicate)
+            throw new Error(`Chart '${duplicate}' is defined twice.`);
+        return { ...this.childDataSource.schema, charts: [...myCharts, ...otherCharts] };
+    }
+    addChart(name, definition) {
+        if (this.schema.charts.includes(name)) {
+            throw new Error(`Chart '${name}' already exists.`);
+        }
+        this.charts[name] = definition;
+    }
+    async renderChart(caller, name) {
+        const chartDefinition = this.charts[name];
+        if (chartDefinition) {
+            return chartDefinition(new agent_context_1.default(this, caller), new result_builder_1.default());
+        }
+        return super.renderChart(caller, name);
+    }
+}
+exports.default = ChartDataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2NoYXJ0L2RhdGFzb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSxnRkFBb0U7QUFDcEUsbUZBQTBEO0FBQzFELG1GQUEwRDtBQUMxRCxzRUFBNkM7QUFFN0MsTUFBcUIsd0JBQXlCLFNBQVEsOEJBQW1CO0lBYXZFLFlBQVksZUFBMkI7UUFDckMsS0FBSyxDQUFDLGVBQWUsRUFBRSw4QkFBbUIsQ0FBQyxDQUFDO1FBYnRDLFdBQU0sR0FBb0MsRUFBRSxDQUFDO0lBY3JELENBQUM7SUFaRCxJQUFhLE1BQU07UUFDakIsTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDMUMsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO1FBRXZELE1BQU0sU0FBUyxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDcEUsSUFBSSxTQUFTO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxVQUFVLFNBQVMscUJBQXFCLENBQUMsQ0FBQztRQUV6RSxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxHQUFHLFFBQVEsRUFBRSxHQUFHLFdBQVcsQ0FBQyxFQUFFLENBQUM7SUFDbkYsQ0FBQztJQU1ELFFBQVEsQ0FBQyxJQUFZLEVBQUUsVUFBMkI7UUFDaEQsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDckMsTUFBTSxJQUFJLEtBQUssQ0FBQyxVQUFVLElBQUksbUJBQW1CLENBQUMsQ0FBQztTQUNwRDtRQUVELElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsVUFBVSxDQUFDO0lBQ2pDLENBQUM7SUFFUSxLQUFLLENBQUMsV0FBVyxDQUFDLE1BQWMsRUFBRSxJQUFZO1FBQ3JELE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFMUMsSUFBSSxlQUFlLEVBQUU7WUFDbkIsT0FBTyxlQUFlLENBQUMsSUFBSSx1QkFBeUIsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLEVBQUUsSUFBSSx3QkFBYSxFQUFFLENBQUMsQ0FBQztTQUMxRjtRQUVELE9BQU8sS0FBSyxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDekMsQ0FBQztDQUNGO0FBbENELDJDQWtDQyJ9

package/dist/decorators/chart/result-builder.d.ts

@@ -0,0 +1,12 @@
+import { DateOperation, DistributionChart, LeaderboardChart, ObjectiveChart, PercentageChart, SmartChart, TimeBasedChart, ValueChart } from '@forestadmin/datasource-toolkit';
+export default class ResultBuilder {
+    private static readonly formats;
+    value(value: number, previousValue?: number): ValueChart;
+    distribution(obj: Record<string, number>): DistributionChart;
+    timeBased(timeRange: DateOperation, values: Record<string, number>): TimeBasedChart;
+    percentage(value: number): PercentageChart;
+    objective(value: number, objective: number): ObjectiveChart;
+    leaderboard(obj: Record<string, number>): LeaderboardChart;
+    smart(data: unknown): SmartChart;
+}
+//# sourceMappingURL=result-builder.d.ts.map

package/dist/decorators/chart/result-builder.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const luxon_1 = require("luxon");
+class ResultBuilder {
+    value(value, previousValue) {
+        return { countCurrent: value, countPrevious: previousValue };
+    }
+    distribution(obj) {
+        return Object.entries(obj).map(([key, value]) => ({ key, value }));
+    }
+    timeBased(timeRange, values) {
+        const format = ResultBuilder.formats[timeRange];
+        const formatted = {};
+        for (const [date, value] of Object.entries(values)) {
+            const label = luxon_1.DateTime.fromISO(date).toFormat(format);
+            formatted[label] = (formatted[label] ?? 0) + value;
+        }
+        const dataPoints = [];
+        const dates = Object.keys(values).sort((dateA, dateB) => dateA.localeCompare(dateB));
+        const first = luxon_1.DateTime.fromISO(dates[0]).startOf(timeRange.toLowerCase());
+        const last = luxon_1.DateTime.fromISO(dates[dates.length - 1]);
+        for (let current = first; current <= last; current = current.plus({ [timeRange]: 1 })) {
+            const label = current.toFormat(format);
+            dataPoints.push({ label, values: { value: formatted[label] ?? 0 } });
+        }
+        return dataPoints;
+    }
+    percentage(value) {
+        return value;
+    }
+    objective(value, objective) {
+        return { value, objective };
+    }
+    leaderboard(obj) {
+        return this.distribution(obj).sort((a, b) => b.value - a.value);
+    }
+    smart(data) {
+        return data;
+    }
+}
+exports.default = ResultBuilder;
+ResultBuilder.formats = {
+    Day: 'dd/MM/yyyy',
+    Week: "'W'W-kkkk",
+    Month: 'MMM yy',
+    Year: 'yyyy',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LWJ1aWxkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9jaGFydC9yZXN1bHQtYnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVVBLGlDQUErQztBQUUvQyxNQUFxQixhQUFhO0lBUWhDLEtBQUssQ0FBQyxLQUFhLEVBQUUsYUFBc0I7UUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsYUFBYSxFQUFFLGFBQWEsRUFBRSxDQUFDO0lBQy9ELENBQUM7SUFFRCxZQUFZLENBQUMsR0FBMkI7UUFDdEMsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBRUQsU0FBUyxDQUFDLFNBQXdCLEVBQUUsTUFBOEI7UUFDaEUsTUFBTSxNQUFNLEdBQUcsYUFBYSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNoRCxNQUFNLFNBQVMsR0FBRyxFQUFFLENBQUM7UUFFckIsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUU7WUFDbEQsTUFBTSxLQUFLLEdBQUcsZ0JBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3RELFNBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUM7U0FDcEQ7UUFFRCxNQUFNLFVBQVUsR0FBRyxFQUFFLENBQUM7UUFDdEIsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDckYsTUFBTSxLQUFLLEdBQUcsZ0JBQVEsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxXQUFXLEVBQWtCLENBQUMsQ0FBQztRQUMxRixNQUFNLElBQUksR0FBRyxnQkFBUSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXZELEtBQUssSUFBSSxPQUFPLEdBQUcsS0FBSyxFQUFFLE9BQU8sSUFBSSxJQUFJLEVBQUUsT0FBTyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUU7WUFDckYsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUN2QyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1NBQ3RFO1FBRUQsT0FBTyxVQUFVLENBQUM7SUFDcEIsQ0FBQztJQUVELFVBQVUsQ0FBQyxLQUFhO1FBQ3RCLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELFNBQVMsQ0FBQyxLQUFhLEVBQUUsU0FBaUI7UUFDeEMsT0FBTyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsQ0FBQztJQUM5QixDQUFDO0lBRUQsV0FBVyxDQUFDLEdBQTJCO1FBQ3JDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQWE7UUFDakIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDOztBQXBESCxnQ0FxREM7QUFwRHlCLHFCQUFPLEdBQWtDO0lBQy9ELEdBQUcsRUFBRSxZQUFZO0lBQ2pCLElBQUksRUFBRSxXQUFXO0lBQ2pCLEtBQUssRUFBRSxRQUFRO0lBQ2YsSUFBSSxFQUFFLE1BQU07Q0FDYixDQUFDIn0=

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

@@ -0,0 +1,6 @@
+import { Chart } from '@forestadmin/datasource-toolkit';
+import { TSchema } from '../../templates';
+import AgentCustomizationContext from '../../context/agent-context';
+import ResultBuilder from './result-builder';
+export declare type ChartDefinition<S extends TSchema = TSchema> = (context: AgentCustomizationContext<S>, resultBuilder: ResultBuilder) => Promise<Chart> | Chart;
+//# sourceMappingURL=types.d.ts.map

package/dist/decorators/chart/types.js

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

package/dist/decorators/collection-decorator.d.ts

@@ -0,0 +1,21 @@
+import { ActionField, ActionResult, AggregateResult, Aggregation, Caller, Collection, CollectionSchema, DataSource, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+export default class CollectionDecorator implements Collection {
+    readonly dataSource: DataSource;
+    protected childCollection: Collection;
+    private lastSchema;
+    private lastSubSchema;
+    get schema(): CollectionSchema;
+    get name(): string;
+    constructor(childCollection: Collection, dataSource: DataSource);
+    execute(caller: Caller, name: string, data: RecordData, filter?: Filter): Promise<ActionResult>;
+    getForm(caller: Caller, name: string, data?: RecordData, filter?: Filter): Promise<ActionField[]>;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    protected markSchemaAsDirty(): void;
+    protected refineFilter(caller: Caller, filter?: PaginatedFilter): Promise<PaginatedFilter>;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+}
+//# sourceMappingURL=collection-decorator.d.ts.map

package/dist/decorators/collection-decorator.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CollectionDecorator {
+    constructor(childCollection, dataSource) {
+        this.childCollection = childCollection;
+        this.dataSource = dataSource;
+    }
+    get schema() {
+        const subSchema = this.childCollection.schema;
+        if (!this.lastSchema || this.lastSubSchema !== subSchema) {
+            this.lastSchema = this.refineSchema(subSchema);
+            this.lastSubSchema = subSchema;
+        }
+        return this.lastSchema;
+    }
+    get name() {
+        return this.childCollection.name;
+    }
+    async execute(caller, name, data, filter) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.execute(caller, name, data, refinedFilter);
+    }
+    async getForm(caller, name, data, filter) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.getForm(caller, name, data, refinedFilter);
+    }
+    async create(caller, data) {
+        return this.childCollection.create(caller, data);
+    }
+    async list(caller, filter, projection) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.list(caller, refinedFilter, projection);
+    }
+    async update(caller, filter, patch) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.update(caller, refinedFilter, patch);
+    }
+    async delete(caller, filter) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.delete(caller, refinedFilter);
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        const refinedFilter = await this.refineFilter(caller, filter);
+        return this.childCollection.aggregate(caller, refinedFilter, aggregation, limit);
+    }
+    markSchemaAsDirty() {
+        this.lastSchema = null;
+    }
+    async refineFilter(caller, filter) {
+        return filter;
+    }
+    refineSchema(subSchema) {
+        return subSchema;
+    }
+}
+exports.default = CollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/composite-datasource.d.ts

@@ -0,0 +1,11 @@
+import { BaseDataSource, Caller, Chart, Collection, DataSource, DataSourceSchema } from '@forestadmin/datasource-toolkit';
+export default class CompositeDatasource<T extends Collection = Collection> extends BaseDataSource<T> {
+    private readonly datasourceChartMapping;
+    constructor();
+    addDataSource(dataSource: DataSource): CompositeDatasource;
+    get schema(): DataSourceSchema;
+    renderChart(caller: Caller, name: string): Promise<Chart>;
+    private addCollections;
+    private addCharts;
+}
+//# sourceMappingURL=composite-datasource.d.ts.map