@forestadmin/datasource-customizer 1.0.0-alpha.1

package/dist/decorators/composite-datasource.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class CompositeDatasource extends datasource_toolkit_1.BaseDataSource {
+    constructor() {
+        super();
+        this.datasourceChartMapping = {};
+    }
+    addDataSource(dataSource) {
+        this.addCollections(dataSource);
+        this.addCharts(dataSource);
+        return this;
+    }
+    get schema() {
+        return { charts: Object.keys(this.datasourceChartMapping) };
+    }
+    renderChart(caller, name) {
+        if (!this.datasourceChartMapping[name]) {
+            throw new Error(`Chart '${name}' is not defined in the dataSource.`);
+        }
+        return this.datasourceChartMapping[name].renderChart(caller, name);
+    }
+    addCollections(dataSource) {
+        for (const collection of dataSource.collections) {
+            this.addCollection(collection);
+        }
+    }
+    addCharts(dataSource) {
+        for (const chartName of dataSource.schema.charts) {
+            if (this.datasourceChartMapping[chartName]) {
+                throw new Error(`Chart '${chartName}' is already defined in datasource.`);
+            }
+            this.datasourceChartMapping[chartName] = dataSource;
+        }
+    }
+}
+exports.default = CompositeDatasource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9zaXRlLWRhdGFzb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVjb3JhdG9ycy9jb21wb3NpdGUtZGF0YXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHdFQU95QztBQUV6QyxNQUFxQixtQkFFbkIsU0FBUSxtQ0FBaUI7SUFHekI7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxzQkFBc0IsR0FBRyxFQUFFLENBQUM7SUFDbkMsQ0FBQztJQUVELGFBQWEsQ0FBQyxVQUFzQjtRQUNsQyxJQUFJLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ2hDLElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFM0IsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsSUFBYSxNQUFNO1FBQ2pCLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsc0JBQXNCLENBQUMsRUFBRSxDQUFDO0lBQzlELENBQUM7SUFFUSxXQUFXLENBQUMsTUFBYyxFQUFFLElBQVk7UUFDL0MsSUFBSSxDQUFDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUN0QyxNQUFNLElBQUksS0FBSyxDQUFDLFVBQVUsSUFBSSxxQ0FBcUMsQ0FBQyxDQUFDO1NBQ3RFO1FBRUQsT0FBTyxJQUFJLENBQUMsc0JBQXNCLENBQUMsSUFBSSxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBRU8sY0FBYyxDQUFDLFVBQXNCO1FBQzNDLEtBQUssTUFBTSxVQUFVLElBQUksVUFBVSxDQUFDLFdBQVcsRUFBRTtZQUMvQyxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQWUsQ0FBQyxDQUFDO1NBQ3JDO0lBQ0gsQ0FBQztJQUVPLFNBQVMsQ0FBQyxVQUFzQjtRQUN0QyxLQUFLLE1BQU0sU0FBUyxJQUFJLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFO1lBQ2hELElBQUksSUFBSSxDQUFDLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxFQUFFO2dCQUMxQyxNQUFNLElBQUksS0FBSyxDQUFDLFVBQVUsU0FBUyxxQ0FBcUMsQ0FBQyxDQUFDO2FBQzNFO1lBRUQsSUFBSSxDQUFDLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxHQUFHLFVBQVUsQ0FBQztTQUNyRDtJQUNILENBQUM7Q0FDRjtBQTVDRCxzQ0E0Q0MifQ==

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

@@ -0,0 +1,14 @@
+import { AggregateResult, Aggregation, Caller, CollectionSchema, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import { ComputedDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+/** Decorator injects computed fields */
+export default class ComputedCollection extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<ComputedCollection>;
+    protected computeds: Record<string, ComputedDefinition>;
+    registerComputed(name: string, computed: ComputedDefinition): void;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/computed/collection.js

@@ -0,0 +1,69 @@
+"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"));
+const compute_fields_1 = __importDefault(require("./helpers/compute-fields"));
+const rewrite_projection_1 = __importDefault(require("./helpers/rewrite-projection"));
+/** Decorator injects computed fields */
+class ComputedCollection extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.computeds = {};
+    }
+    /** @internal */
+    getComputed(path) {
+        const index = path.indexOf(':');
+        if (index === -1)
+            return this.computeds[path];
+        const { foreignCollection } = this.schema.fields[path.substring(0, index)];
+        const association = this.dataSource.getCollection(foreignCollection);
+        return association.getComputed(path.substring(index + 1));
+    }
+    registerComputed(name, computed) {
+        // Check that all dependencies exist and are columns
+        for (const field of computed.dependencies) {
+            datasource_toolkit_1.FieldValidator.validate(this, field);
+        }
+        if (computed.dependencies.length <= 0) {
+            throw new Error(`Computed field '${this.name}.${name}' must have at least one dependency.`);
+        }
+        this.computeds[name] = computed;
+        this.markSchemaAsDirty();
+    }
+    async list(caller, filter, projection) {
+        const childProjection = projection.replace(path => (0, rewrite_projection_1.default)(this, path));
+        const records = await this.childCollection.list(caller, filter, childProjection);
+        const context = new collection_context_1.default(this, caller);
+        return (0, compute_fields_1.default)(context, this, childProjection, projection, records);
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        // No computed are used in the aggregation => just delegate to the underlying collection.
+        if (!aggregation.projection.some(field => this.getComputed(field))) {
+            return this.childCollection.aggregate(caller, filter, aggregation, limit);
+        }
+        // Fallback to full emulation.
+        return aggregation.apply(await this.list(caller, filter, aggregation.projection), caller.timezone, limit);
+    }
+    refineSchema(childSchema) {
+        const schema = { ...childSchema, fields: { ...childSchema.fields } };
+        for (const [name, computed] of Object.entries(this.computeds)) {
+            schema.fields[name] = {
+                columnType: computed.columnType,
+                defaultValue: computed.defaultValue,
+                enumValues: computed.enumValues,
+                filterOperators: new Set(),
+                isPrimaryKey: false,
+                isReadOnly: true,
+                isSortable: false,
+                type: 'Column',
+            };
+        }
+        return schema;
+    }
+}
+exports.default = ComputedCollection;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/computed/helpers/compute-fields.d.ts

@@ -0,0 +1,5 @@
+import { Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionCustomizationContext from '../../../context/collection-context';
+import ComputedCollection from '../collection';
+export default function computeFromRecords(ctx: CollectionCustomizationContext, collection: ComputedCollection, recordsProjection: Projection, desiredProjection: Projection, records: RecordData[]): Promise<RecordData[]>;
+//# sourceMappingURL=compute-fields.d.ts.map

package/dist/decorators/computed/helpers/compute-fields.js

@@ -0,0 +1,36 @@
+"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 flattener_1 = require("../utils/flattener");
+const deduplication_1 = __importDefault(require("../utils/deduplication"));
+async function computeField(ctx, computed, paths, promises) {
+    return (0, deduplication_1.default)((0, flattener_1.unflatten)(await Promise.all(promises), new datasource_toolkit_1.Projection(...paths)), async (uniquePartials) => computed.getValues(uniquePartials, ctx));
+}
+function queueField(ctx, collection, newPath, paths, promises) {
+    // Skip double computations (we're not checking before adding to queue).
+    if (!paths.includes(newPath)) {
+        const computed = collection.getComputed(newPath);
+        const nestedDependencies = new datasource_toolkit_1.Projection(...computed.dependencies).nest(newPath.includes(':') ? newPath.substring(0, newPath.lastIndexOf(':')) : null);
+        // Queue dependencies (so that computed can await them).
+        nestedDependencies.forEach(path => queueField(ctx, collection, path, paths, promises));
+        // Queue computed
+        const dependencyValues = nestedDependencies.map(path => promises[paths.indexOf(path)]);
+        paths.push(newPath);
+        promises.push(computeField(ctx, computed, computed.dependencies, dependencyValues));
+    }
+}
+async function computeFromRecords(ctx, collection, recordsProjection, desiredProjection, records) {
+    // Format data for easy computation (one cell per path, with all values).
+    const paths = recordsProjection.slice();
+    const promises = (0, flattener_1.flatten)(records, paths).map(values => Promise.resolve(values));
+    // Queue all computations, and perform them all at once
+    desiredProjection.forEach(path => queueField(ctx, collection, path, paths, promises));
+    const values = await Promise.all(promises);
+    // Quick reproject and unflatten.
+    return (0, flattener_1.unflatten)(desiredProjection.map(path => values[paths.indexOf(path)]), desiredProjection);
+}
+exports.default = computeFromRecords;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZS1maWVsZHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9jb21wdXRlZC9oZWxwZXJzL2NvbXB1dGUtZmllbGRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBQXlFO0FBR3pFLGtEQUF3RDtBQUd4RCwyRUFBMkQ7QUFFM0QsS0FBSyxVQUFVLFlBQVksQ0FDekIsR0FBbUMsRUFDbkMsUUFBNEIsRUFDNUIsS0FBZSxFQUNmLFFBQThCO0lBRTlCLE9BQU8sSUFBQSx1QkFBcUIsRUFDMUIsSUFBQSxxQkFBUyxFQUFDLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxJQUFJLCtCQUFVLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQyxFQUNoRSxLQUFLLEVBQUMsY0FBYyxFQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxHQUFHLENBQUMsQ0FDaEUsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLFVBQVUsQ0FDakIsR0FBbUMsRUFDbkMsVUFBOEIsRUFDOUIsT0FBZSxFQUNmLEtBQWUsRUFDZixRQUE4QjtJQUU5Qix3RUFBd0U7SUFDeEUsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEVBQUU7UUFDNUIsTUFBTSxRQUFRLEdBQUcsVUFBVSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNqRCxNQUFNLGtCQUFrQixHQUFHLElBQUksK0JBQVUsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQ3RFLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUM5RSxDQUFDO1FBRUYsd0RBQXdEO1FBQ3hELGtCQUFrQixDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUV2RixpQkFBaUI7UUFDakIsTUFBTSxnQkFBZ0IsR0FBRyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFFdkYsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNwQixRQUFRLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLEVBQUUsUUFBUSxFQUFFLFFBQVEsQ0FBQyxZQUFZLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDO0tBQ3JGO0FBQ0gsQ0FBQztBQUVjLEtBQUssVUFBVSxrQkFBa0IsQ0FDOUMsR0FBbUMsRUFDbkMsVUFBOEIsRUFDOUIsaUJBQTZCLEVBQzdCLGlCQUE2QixFQUM3QixPQUFxQjtJQUVyQix5RUFBeUU7SUFDekUsTUFBTSxLQUFLLEdBQUcsaUJBQWlCLENBQUMsS0FBSyxFQUFnQixDQUFDO0lBQ3RELE1BQU0sUUFBUSxHQUFHLElBQUEsbUJBQU8sRUFBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0lBRWhGLHVEQUF1RDtJQUN2RCxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFDdEYsTUFBTSxNQUFNLEdBQUcsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBRTNDLGlDQUFpQztJQUNqQyxPQUFPLElBQUEscUJBQVMsRUFDZCxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQzFELGlCQUFpQixDQUNsQixDQUFDO0FBQ0osQ0FBQztBQXBCRCxxQ0FvQkMifQ==

package/dist/decorators/computed/helpers/rewrite-projection.d.ts

@@ -0,0 +1,4 @@
+import { Projection } from '@forestadmin/datasource-toolkit';
+import ComputedCollection from '../collection';
+export default function rewriteField(collection: ComputedCollection, path: string): Projection;
+//# sourceMappingURL=rewrite-projection.d.ts.map

package/dist/decorators/computed/helpers/rewrite-projection.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+function rewriteField(collection, path) {
+    // Projection is targeting a field on another collection => recurse.
+    if (path.includes(':')) {
+        const [prefix] = path.split(':');
+        const schema = collection.schema.fields[prefix];
+        const association = collection.dataSource.getCollection(schema.foreignCollection);
+        return new datasource_toolkit_1.Projection(path)
+            .unnest()
+            .replace(subPath => rewriteField(association, subPath))
+            .nest(prefix);
+    }
+    // Computed field that we own: recursively replace by dependencies
+    const computed = collection.getComputed(path);
+    return computed
+        ? new datasource_toolkit_1.Projection(...computed.dependencies).replace(depPath => rewriteField(collection, depPath))
+        : new datasource_toolkit_1.Projection(path);
+}
+exports.default = rewriteField;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV3cml0ZS1wcm9qZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RlY29yYXRvcnMvY29tcHV0ZWQvaGVscGVycy9yZXdyaXRlLXByb2plY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx3RUFBNkU7QUFJN0UsU0FBd0IsWUFBWSxDQUFDLFVBQThCLEVBQUUsSUFBWTtJQUMvRSxvRUFBb0U7SUFDcEUsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ3RCLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2pDLE1BQU0sTUFBTSxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBbUIsQ0FBQztRQUNsRSxNQUFNLFdBQVcsR0FBRyxVQUFVLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUVsRixPQUFPLElBQUksK0JBQVUsQ0FBQyxJQUFJLENBQUM7YUFDeEIsTUFBTSxFQUFFO2FBQ1IsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQzthQUN0RCxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDakI7SUFFRCxrRUFBa0U7SUFDbEUsTUFBTSxRQUFRLEdBQUcsVUFBVSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUU5QyxPQUFPLFFBQVE7UUFDYixDQUFDLENBQUMsSUFBSSwrQkFBVSxDQUFDLEdBQUcsUUFBUSxDQUFDLFlBQVksQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDaEcsQ0FBQyxDQUFDLElBQUksK0JBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUMzQixDQUFDO0FBbkJELCtCQW1CQyJ9

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

@@ -0,0 +1,11 @@
+import { ColumnType } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TFieldName, TRow, TSchema } from '../../templates';
+import CollectionCustomizationContext from '../../context/collection-context';
+export interface ComputedDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> {
+    readonly columnType: ColumnType;
+    readonly dependencies: TFieldName<S, N>[];
+    readonly defaultValue?: unknown;
+    readonly enumValues?: string[];
+    getValues(records: TRow<S, N>[], context: CollectionCustomizationContext<S, N>): Promise<unknown[]> | unknown[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/decorators/computed/types.js

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

package/dist/decorators/computed/utils/deduplication.d.ts

@@ -0,0 +1,2 @@
+export default function transformUniqueValues<Input, Output>(inputs: Input[], callback: (inputs: Input[]) => Promise<Output[]>): Promise<Output[]>;
+//# sourceMappingURL=deduplication.d.ts.map

package/dist/decorators/computed/utils/deduplication.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_hash_1 = __importDefault(require("object-hash"));
+async function transformUniqueValues(inputs, callback) {
+    const indexes = {};
+    const mapping = [];
+    const uniqueInputs = [];
+    for (const input of inputs) {
+        if (input !== null) {
+            const hash = (0, object_hash_1.default)(input);
+            if (indexes[hash] === undefined) {
+                indexes[hash] = uniqueInputs.length;
+                uniqueInputs.push(input);
+            }
+            mapping.push(indexes[hash]);
+        }
+        else {
+            mapping.push(-1);
+        }
+    }
+    const uniqueOutputs = await callback(uniqueInputs);
+    return mapping.map(index => (index !== -1 ? uniqueOutputs[index] : null));
+}
+exports.default = transformUniqueValues;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVkdXBsaWNhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL2NvbXB1dGVkL3V0aWxzL2RlZHVwbGljYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw4REFBcUM7QUFFdEIsS0FBSyxVQUFVLHFCQUFxQixDQUNqRCxNQUFlLEVBQ2YsUUFBZ0Q7SUFFaEQsTUFBTSxPQUFPLEdBQTJCLEVBQUUsQ0FBQztJQUMzQyxNQUFNLE9BQU8sR0FBYSxFQUFFLENBQUM7SUFDN0IsTUFBTSxZQUFZLEdBQVksRUFBRSxDQUFDO0lBRWpDLEtBQUssTUFBTSxLQUFLLElBQUksTUFBTSxFQUFFO1FBQzFCLElBQUksS0FBSyxLQUFLLElBQUksRUFBRTtZQUNsQixNQUFNLElBQUksR0FBRyxJQUFBLHFCQUFVLEVBQUMsS0FBSyxDQUFDLENBQUM7WUFFL0IsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssU0FBUyxFQUFFO2dCQUMvQixPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQztnQkFDcEMsWUFBWSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQzthQUMxQjtZQUVELE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7U0FDN0I7YUFBTTtZQUNMLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUNsQjtLQUNGO0lBRUQsTUFBTSxhQUFhLEdBQUcsTUFBTSxRQUFRLENBQUMsWUFBWSxDQUFDLENBQUM7SUFFbkQsT0FBTyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztBQUM1RSxDQUFDO0FBMUJELHdDQTBCQyJ9

package/dist/decorators/computed/utils/flattener.d.ts

@@ -0,0 +1,6 @@
+import { Projection, RecordData } from '@forestadmin/datasource-toolkit';
+declare type FlatRecordList = Array<unknown[]>;
+export declare function unflatten(flatList: FlatRecordList, projection: Projection): RecordData[];
+export declare function flatten(records: RecordData[], projection: string[]): FlatRecordList;
+export {};
+//# sourceMappingURL=flattener.d.ts.map

package/dist/decorators/computed/utils/flattener.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = exports.unflatten = void 0;
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+function unflatten(flatList, projection) {
+    const numRecords = flatList[0]?.length ?? 0;
+    const records = [];
+    for (let i = 0; i < numRecords; i += 1)
+        records[i] = {};
+    // Set fields
+    for (const column of projection.columns) {
+        const pathIndex = projection.indexOf(column);
+        for (const [index, value] of flatList[pathIndex].entries())
+            records[index][column] = value ?? null;
+    }
+    // Set relations
+    for (const [relation, paths] of Object.entries(projection.relations)) {
+        const subFlatList = [];
+        for (const path of paths)
+            subFlatList.push(flatList[projection.indexOf(`${relation}:${path}`)]);
+        const subRecords = unflatten(subFlatList, paths);
+        for (const index of records.keys())
+            records[index][relation] = subRecords[index];
+    }
+    // Keep only objects where at least a non-null value is set
+    return records.map(r => {
+        return Object.values(r).some(v => v !== null) ? r : null;
+    });
+}
+exports.unflatten = unflatten;
+function flatten(records, projection) {
+    return projection.map(field => records.map(r => datasource_toolkit_1.RecordUtils.getFieldValue(r, field)));
+}
+exports.flatten = flatten;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { BaseDataSource, Caller, Chart, Collection, DataSource, DataSourceSchema } from '@forestadmin/datasource-toolkit';
+declare type CollectionDecoratorConstructor<CollectionDecorator extends Collection> = {
+    new (c: Collection, d: DataSource): CollectionDecorator;
+};
+export default class DataSourceDecorator<CollectionDecorator extends Collection = Collection> extends BaseDataSource<CollectionDecorator> {
+    protected readonly childDataSource: DataSource;
+    private readonly CollectionDecoratorCtor;
+    private readonly addCollectionToChildDataSource;
+    get schema(): DataSourceSchema;
+    constructor(childDataSource: DataSource, CollectionDecoratorCtor: CollectionDecoratorConstructor<CollectionDecorator>);
+    renderChart(caller: Caller, name: string): Promise<Chart>;
+    private addCollectionObserver;
+}
+export {};
+//# sourceMappingURL=datasource-decorator.d.ts.map

package/dist/decorators/datasource-decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class DataSourceDecorator extends datasource_toolkit_1.BaseDataSource {
+    constructor(childDataSource, CollectionDecoratorCtor) {
+        super();
+        this.addCollectionToChildDataSource = childDataSource.addCollection.bind(childDataSource);
+        Reflect.defineProperty(childDataSource, 'addCollection', {
+            value: this.addCollectionObserver.bind(this),
+        });
+        this.childDataSource = childDataSource;
+        this.CollectionDecoratorCtor = CollectionDecoratorCtor;
+        this.childDataSource.collections.forEach(collection => this.addCollection(new this.CollectionDecoratorCtor(collection, this)));
+    }
+    get schema() {
+        return this.childDataSource.schema;
+    }
+    renderChart(caller, name) {
+        return this.childDataSource.renderChart(caller, name);
+    }
+    addCollectionObserver(collection) {
+        this.addCollectionToChildDataSource(collection);
+        this.addCollection(new this.CollectionDecoratorCtor(collection, this));
+    }
+}
+exports.default = DataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS1kZWNvcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVjb3JhdG9ycy9kYXRhc291cmNlLWRlY29yYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHdFQU95QztBQU16QyxNQUFxQixtQkFFbkIsU0FBUSxtQ0FBbUM7SUFTM0MsWUFDRSxlQUEyQixFQUMzQix1QkFBNEU7UUFFNUUsS0FBSyxFQUFFLENBQUM7UUFFUixJQUFJLENBQUMsOEJBQThCLEdBQUcsZUFBZSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDMUYsT0FBTyxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsZUFBZSxFQUFFO1lBQ3ZELEtBQUssRUFBRSxJQUFJLENBQUMscUJBQXFCLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztTQUM3QyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsZUFBZSxHQUFHLGVBQWUsQ0FBQztRQUN2QyxJQUFJLENBQUMsdUJBQXVCLEdBQUcsdUJBQXVCLENBQUM7UUFFdkQsSUFBSSxDQUFDLGVBQWUsQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQ3BELElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxJQUFJLENBQUMsdUJBQXVCLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQ3ZFLENBQUM7SUFDSixDQUFDO0lBckJELElBQWEsTUFBTTtRQUNqQixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDO0lBQ3JDLENBQUM7SUFxQlEsV0FBVyxDQUFDLE1BQWMsRUFBRSxJQUFZO1FBQy9DLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFTyxxQkFBcUIsQ0FBQyxVQUFzQjtRQUNsRCxJQUFJLENBQUMsOEJBQThCLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDaEQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUN6RSxDQUFDO0NBQ0Y7QUF0Q0Qsc0NBc0NDIn0=

package/dist/decorators/decorators-stack.d.ts

@@ -0,0 +1,42 @@
+import { DataSource } from '@forestadmin/datasource-toolkit';
+import ActionCollectionDecorator from './actions/collection';
+import ChartDataSourceDecorator from './chart/datasource';
+import ComputedCollectionDecorator from './computed/collection';
+import DataSourceDecorator from './datasource-decorator';
+import EmptyCollectionDecorator from './empty/collection';
+import HookCollectionDecorator from './hook/collection';
+import OperatorsEmulateCollectionDecorator from './operators-emulate/collection';
+import OperatorsReplaceCollectionDecorator from './operators-replace/collection';
+import PublicationCollectionDecorator from './publication/collection';
+import RelationCollectionDecorator from './relation/collection';
+import RenameFieldCollectionDecorator from './rename-field/collection';
+import SchemaCollectionDecorator from './schema/collection';
+import SearchCollectionDecorator from './search/collection';
+import SegmentCollectionDecorator from './segment/collection';
+import SortEmulateCollectionDecorator from './sort-emulate/collection';
+import ValidationCollectionDecorator from './validation/collection';
+import WriteCollectionDecorator from './write/collection';
+export default class DecoratorsStack {
+    action: DataSourceDecorator<ActionCollectionDecorator>;
+    chart: ChartDataSourceDecorator;
+    earlyComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    earlyOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    earlyOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    empty: DataSourceDecorator<EmptyCollectionDecorator>;
+    relation: DataSourceDecorator<RelationCollectionDecorator>;
+    lateComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    lateOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    lateOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    publication: DataSourceDecorator<PublicationCollectionDecorator>;
+    renameField: DataSourceDecorator<RenameFieldCollectionDecorator>;
+    schema: DataSourceDecorator<SchemaCollectionDecorator>;
+    search: DataSourceDecorator<SearchCollectionDecorator>;
+    segment: DataSourceDecorator<SegmentCollectionDecorator>;
+    sortEmulate: DataSourceDecorator<SortEmulateCollectionDecorator>;
+    validation: DataSourceDecorator<ValidationCollectionDecorator>;
+    write: DataSourceDecorator<WriteCollectionDecorator>;
+    hook: DataSourceDecorator<HookCollectionDecorator>;
+    dataSource: DataSource;
+    constructor(dataSource: DataSource);
+}
+//# sourceMappingURL=decorators-stack.d.ts.map

package/dist/decorators/decorators-stack.js

@@ -0,0 +1,59 @@
+"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("./actions/collection"));
+const datasource_1 = __importDefault(require("./chart/datasource"));
+const collection_2 = __importDefault(require("./computed/collection"));
+const datasource_decorator_1 = __importDefault(require("./datasource-decorator"));
+const collection_3 = __importDefault(require("./empty/collection"));
+const collection_4 = __importDefault(require("./hook/collection"));
+const collection_5 = __importDefault(require("./operators-emulate/collection"));
+const collection_6 = __importDefault(require("./operators-replace/collection"));
+const collection_7 = __importDefault(require("./publication/collection"));
+const collection_8 = __importDefault(require("./relation/collection"));
+const collection_9 = __importDefault(require("./rename-field/collection"));
+const collection_10 = __importDefault(require("./schema/collection"));
+const collection_11 = __importDefault(require("./search/collection"));
+const collection_12 = __importDefault(require("./segment/collection"));
+const collection_13 = __importDefault(require("./sort-emulate/collection"));
+const collection_14 = __importDefault(require("./validation/collection"));
+const collection_15 = __importDefault(require("./write/collection"));
+class DecoratorsStack {
+    constructor(dataSource) {
+        let last = dataSource;
+        /* eslint-disable no-multi-assign */
+        // Step 0: Do not query datasource when we know the result with yield an empty set.
+        last = this.empty = new datasource_decorator_1.default(last, collection_3.default);
+        // Step 1: Computed-Relation-Computed sandwich (needed because some emulated relations depend
+        // on computed fields, and some computed fields depend on relation...)
+        // Note that replacement goes before emulation, as replacements may use emulated operators.
+        last = this.earlyComputed = new datasource_decorator_1.default(last, collection_2.default);
+        last = this.earlyOpEmulate = new datasource_decorator_1.default(last, collection_5.default);
+        last = this.earlyOpReplace = new datasource_decorator_1.default(last, collection_6.default);
+        last = this.relation = new datasource_decorator_1.default(last, collection_8.default);
+        last = this.lateComputed = new datasource_decorator_1.default(last, collection_2.default);
+        last = this.lateOpEmulate = new datasource_decorator_1.default(last, collection_5.default);
+        last = this.lateOpReplace = new datasource_decorator_1.default(last, collection_6.default);
+        // Step 2: Those need access to all fields. They can be loaded in any order.
+        last = this.search = new datasource_decorator_1.default(last, collection_11.default);
+        last = this.segment = new datasource_decorator_1.default(last, collection_12.default);
+        last = this.sortEmulate = new datasource_decorator_1.default(last, collection_13.default);
+        last = this.write = new datasource_decorator_1.default(last, collection_15.default);
+        // Step 3: Access to all fields AND emulated capabilities
+        last = this.validation = new datasource_decorator_1.default(last, collection_14.default);
+        last = this.chart = new datasource_1.default(last);
+        last = this.action = new datasource_decorator_1.default(last, collection_1.default);
+        last = this.schema = new datasource_decorator_1.default(last, collection_10.default);
+        last = this.hook = new datasource_decorator_1.default(last, collection_4.default);
+        // Step 4: Renaming must be either the very first or very last so that naming in customer code
+        // is consistent.
+        last = this.publication = new datasource_decorator_1.default(last, collection_7.default);
+        last = this.renameField = new datasource_decorator_1.default(last, collection_9.default);
+        /* eslint-enable no-multi-assign */
+        this.dataSource = last;
+    }
+}
+exports.default = DecoratorsStack;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+import { AggregateResult, Aggregation, Caller, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+/**
+ * Avoid performing useless database requests:
+ * Using segments + scopes + filters + jointure emulation often yields requests which have
+ * mutually exclusive conditions or empty "In" leafs.
+ */
+export default class EmptyCollectionDecorator extends CollectionDecorator {
+    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[]>;
+    private returnsEmptySet;
+    private leafReturnsEmptySet;
+    private orReturnsEmptySet;
+    private andReturnsEmptySet;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/empty/collection.js

@@ -0,0 +1,85 @@
+"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_decorator_1 = __importDefault(require("../collection-decorator"));
+/**
+ * Avoid performing useless database requests:
+ * Using segments + scopes + filters + jointure emulation often yields requests which have
+ * mutually exclusive conditions or empty "In" leafs.
+ */
+class EmptyCollectionDecorator extends collection_decorator_1.default {
+    async list(caller, filter, projection) {
+        if (!this.returnsEmptySet(filter.conditionTree)) {
+            return super.list(caller, filter, projection);
+        }
+        return [];
+    }
+    async update(caller, filter, patch) {
+        if (!this.returnsEmptySet(filter.conditionTree)) {
+            return super.update(caller, filter, patch);
+        }
+    }
+    async delete(caller, filter) {
+        if (!this.returnsEmptySet(filter.conditionTree)) {
+            return super.delete(caller, filter);
+        }
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        if (!this.returnsEmptySet(filter.conditionTree)) {
+            return super.aggregate(caller, filter, aggregation, limit);
+        }
+        return [];
+    }
+    returnsEmptySet(tree) {
+        if (tree instanceof datasource_toolkit_1.ConditionTreeLeaf) {
+            return this.leafReturnsEmptySet(tree);
+        }
+        if (tree instanceof datasource_toolkit_1.ConditionTreeBranch && tree.aggregator === 'Or') {
+            return this.orReturnsEmptySet(tree.conditions);
+        }
+        if (tree instanceof datasource_toolkit_1.ConditionTreeBranch && tree.aggregator === 'And') {
+            return this.andReturnsEmptySet(tree.conditions);
+        }
+        return false;
+    }
+    leafReturnsEmptySet(leaf) {
+        // Empty 'in` always return zero records.
+        return leaf.operator === 'In' && leaf.value.length === 0;
+    }
+    orReturnsEmptySet(conditions) {
+        // Or return no records when
+        // - they have no conditions
+        // - they have only conditions which return zero records.
+        return conditions.length === 0 || conditions.every(c => this.returnsEmptySet(c));
+    }
+    andReturnsEmptySet(conditions) {
+        // There is a leaf which returns zero records
+        if (conditions.some(c => this.returnsEmptySet(c))) {
+            return true;
+        }
+        // Scans for mutually exclusive conditions
+        // (this a naive implementation, it will miss many occurences)
+        const valuesByField = {};
+        const leafs = conditions.filter(condition => condition instanceof datasource_toolkit_1.ConditionTreeLeaf);
+        for (const { field, operator, value } of leafs) {
+            if (!valuesByField[field] && operator === 'Equal') {
+                valuesByField[field] = [value];
+            }
+            else if (!valuesByField[field] && operator === 'In') {
+                valuesByField[field] = value;
+            }
+            else if (valuesByField[field] && operator === 'Equal') {
+                valuesByField[field] = valuesByField[field].includes(value) ? [value] : [];
+            }
+            else if (valuesByField[field] && operator === 'In') {
+                valuesByField[field] = valuesByField[field].filter(v => value.includes(v));
+            }
+        }
+        return Object.values(valuesByField).some(v => v.length === 0);
+    }
+}
+exports.default = EmptyCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { AggregateResult, Aggregation, Caller, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import { HookHandler, HookPosition, HookType, HooksContext } from './types';
+import CollectionDecorator from '../collection-decorator';
+export default class CollectionHookDecorator extends CollectionDecorator {
+    private hooks;
+    addHook<P extends HookPosition = HookPosition, T extends HookType = HookType>(position: P, type: T, handler: HookHandler<HooksContext[P][T]>): void;
+    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[]>;
+}
+//# sourceMappingURL=collection.d.ts.map