@forestadmin/datasource-replica 1.0.0 → 1.0.2-alpha-widgets.1

package/dist/cache-interface/collection.d.ts

@@ -0,0 +1,54 @@
+import { TAggregateResult, TAggregation, TFilter, TPaginatedFilter, TRow } from '@forestadmin/datasource-customizer';
+import { Caller, Collection } from '@forestadmin/datasource-toolkit';
+export default class CacheCollectionInterface {
+    private collection;
+    private caller;
+    constructor(collection: Collection, caller: Caller);
+    /**
+     * 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, projection: string[]): Promise<TRow[]>;
+    /**
+     * 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, aggregation: TAggregation, limit?: number): Promise<TAggregateResult[]>;
+    private buildFilter;
+    private buildPaginatedFilter;
+    private buildProjection;
+    private buildAggregation;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/cache-interface/collection.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class CacheCollectionInterface {
+    constructor(collection, caller) {
+        this.caller = caller;
+        this.collection = collection;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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 = CacheCollectionInterface;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cache-interface/datasource.d.ts

@@ -0,0 +1,14 @@
+import type { DataSource } from '@forestadmin/datasource-toolkit';
+import CacheCollectionInterface from './collection';
+/** DataSource wrapper which accepts plain objects in all methods */
+export default class CacheDataSourceInterface {
+    private dataSource;
+    private caller;
+    constructor(dataSource: DataSource);
+    /**
+     * Get a collection from a datasource
+     * @param name the name of the collection
+     */
+    getCollection(name: string): CacheCollectionInterface;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/cache-interface/datasource.js

@@ -0,0 +1,33 @@
+"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 CacheDataSourceInterface {
+    constructor(dataSource) {
+        this.caller = {
+            id: 0,
+            email: 'datasource-replica@forestadmin.com',
+            firstName: 'Datasource',
+            lastName: 'Replica',
+            renderingId: 0,
+            role: 'system',
+            tags: {},
+            team: 'system',
+            timezone: 'UTC',
+            requestId: '',
+        };
+        this.dataSource = dataSource;
+    }
+    /**
+     * 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 = CacheDataSourceInterface;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jYWNoZS1pbnRlcmZhY2UvZGF0YXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLDhEQUFvRDtBQUVwRCxvRUFBb0U7QUFDcEUsTUFBcUIsd0JBQXdCO0lBZTNDLFlBQVksVUFBc0I7UUFiMUIsV0FBTSxHQUFXO1lBQ3ZCLEVBQUUsRUFBRSxDQUFDO1lBQ0wsS0FBSyxFQUFFLG9DQUFvQztZQUMzQyxTQUFTLEVBQUUsWUFBWTtZQUN2QixRQUFRLEVBQUUsU0FBUztZQUNuQixXQUFXLEVBQUUsQ0FBQztZQUNkLElBQUksRUFBRSxRQUFRO1lBQ2QsSUFBSSxFQUFFLEVBQUU7WUFDUixJQUFJLEVBQUUsUUFBUTtZQUNkLFFBQVEsRUFBRSxLQUFLO1lBQ2YsU0FBUyxFQUFFLEVBQUU7U0FDZCxDQUFDO1FBR0EsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDL0IsQ0FBQztJQUVEOzs7T0FHRztJQUNILGFBQWEsQ0FBQyxJQUFZO1FBQ3hCLE9BQU8sSUFBSSxvQkFBd0IsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDeEYsQ0FBQztDQUNGO0FBMUJELDJDQTBCQyJ9

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

@@ -0,0 +1,8 @@
+import { CollectionDecorator, CollectionSchema } from '@forestadmin/datasource-toolkit';
+import SchemaDataSourceDecorator from './data-source';
+export default class SchemaCollectionDecorator extends CollectionDecorator {
+    dataSource: SchemaDataSourceDecorator;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    private computeType;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/schema/collection.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const types_1 = require("../../types");
+class SchemaCollectionDecorator extends datasource_toolkit_1.CollectionDecorator {
+    refineSchema(subSchema) {
+        const baseFields = this.dataSource.getFields(this.name);
+        const newSchema = { ...subSchema, fields: { ...subSchema.fields } };
+        for (const [key, field] of Object.entries(newSchema.fields)) {
+            if (field.type === 'Column') {
+                const baseField = baseFields[key];
+                newSchema.fields[key] = {
+                    ...field,
+                    columnType: this.computeType(baseField),
+                    isReadOnly: baseField.isReadOnly,
+                    defaultValue: baseField.defaultValue,
+                    validation: baseField.validation,
+                };
+            }
+        }
+        return newSchema;
+    }
+    computeType(field) {
+        if ((0, types_1.isLeafField)(field)) {
+            return field.type === 'Integer' ? 'Number' : field.type;
+        }
+        if (Array.isArray(field)) {
+            return [this.computeType(field[0])];
+        }
+        const entries = Object.entries(field).map(([key, value]) => [key, this.computeType(value)]);
+        return Object.fromEntries(entries);
+    }
+}
+exports.default = SchemaCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3NjaGVtYS9jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsd0VBQW9HO0FBR3BHLHVDQUE0RDtBQUU1RCxNQUFxQix5QkFBMEIsU0FBUSx3Q0FBbUI7SUFHckQsWUFBWSxDQUFDLFNBQTJCO1FBQ3pELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN4RCxNQUFNLFNBQVMsR0FBRyxFQUFFLEdBQUcsU0FBUyxFQUFFLE1BQU0sRUFBRSxFQUFFLEdBQUcsU0FBUyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFFcEUsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQzNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLEVBQUU7Z0JBQzNCLE1BQU0sU0FBUyxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQWMsQ0FBQztnQkFDL0MsU0FBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsR0FBRztvQkFDdEIsR0FBRyxLQUFLO29CQUNSLFVBQVUsRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQztvQkFDdkMsVUFBVSxFQUFFLFNBQVMsQ0FBQyxVQUFVO29CQUNoQyxZQUFZLEVBQUUsU0FBUyxDQUFDLFlBQVk7b0JBQ3BDLFVBQVUsRUFBRSxTQUFTLENBQUMsVUFBVTtpQkFDakMsQ0FBQzthQUNIO1NBQ0Y7UUFFRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRU8sV0FBVyxDQUFDLEtBQVk7UUFDOUIsSUFBSSxJQUFBLG1CQUFXLEVBQUMsS0FBSyxDQUFDLEVBQUU7WUFDdEIsT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1NBQ3pEO1FBRUQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3hCLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDckM7UUFFRCxNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUU1RixPQUFPLE1BQU0sQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNGO0FBcENELDRDQW9DQyJ9

package/dist/decorators/schema/data-source.d.ts

@@ -0,0 +1,9 @@
+import { DataSource, DataSourceDecorator } from '@forestadmin/datasource-toolkit';
+import SchemaCollectionDecorator from './collection';
+import { CollectionReplicaSchema, ResolvedOptions } from '../../types';
+export default class SchemaDataSourceDecorator extends DataSourceDecorator<SchemaCollectionDecorator> {
+    private readonly flatSchema;
+    constructor(childDataSource: DataSource, options: ResolvedOptions);
+    getFields(name: string): CollectionReplicaSchema['fields'];
+}
+//# sourceMappingURL=data-source.d.ts.map

package/dist/decorators/schema/data-source.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 datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_1 = __importDefault(require("./collection"));
+class SchemaDataSourceDecorator extends datasource_toolkit_1.DataSourceDecorator {
+    constructor(childDataSource, options) {
+        super(childDataSource, collection_1.default);
+        this.flatSchema = options.flattenSchema;
+    }
+    getFields(name) {
+        return this.flatSchema.find(c => c.name === name).fields;
+    }
+}
+exports.default = SchemaDataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9zY2hlbWEvZGF0YS1zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSx3RUFBa0Y7QUFFbEYsOERBQXFEO0FBR3JELE1BQXFCLHlCQUEwQixTQUFRLHdDQUE4QztJQUduRyxZQUFZLGVBQTJCLEVBQUUsT0FBd0I7UUFDL0QsS0FBSyxDQUFDLGVBQWUsRUFBRSxvQkFBeUIsQ0FBQyxDQUFDO1FBRWxELElBQUksQ0FBQyxVQUFVLEdBQUcsT0FBTyxDQUFDLGFBQWEsQ0FBQztJQUMxQyxDQUFDO0lBRUQsU0FBUyxDQUFDLElBQVk7UUFDcEIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzNELENBQUM7Q0FDRjtBQVpELDRDQVlDIn0=

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

@@ -0,0 +1,15 @@
+import type TriggerSyncDataSourceDecorator from './data-source';
+import type { AggregateResult, Aggregation, Caller, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import { CollectionDecorator } from '@forestadmin/datasource-toolkit';
+export default class SyncCollectionDecorator extends CollectionDecorator {
+    dataSource: TriggerSyncDataSourceDecorator;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    private getLinkedCollections;
+    private getCollectionsFromProjection;
+    private getCollectionFromPath;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/sync/collection.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class SyncCollectionDecorator extends datasource_toolkit_1.CollectionDecorator {
+    async create(caller, data) {
+        const { options } = this.dataSource;
+        const records = await this.childCollection.create(caller, data);
+        if (options.pullDeltaOnAfterWrite) {
+            await options.source.queuePullDelta({
+                name: 'after-create',
+                collection: this.name,
+                caller,
+                affectedCollections: [this.name],
+                records,
+            });
+        }
+        return records;
+    }
+    async update(caller, filter, patch) {
+        const { options } = this.dataSource;
+        await super.update(caller, filter, patch);
+        if (options.pullDeltaOnAfterWrite) {
+            await options.source.queuePullDelta({
+                name: 'after-update',
+                collection: this.name,
+                affectedCollections: [this.name],
+                caller,
+                filter: filter,
+                patch,
+            });
+        }
+    }
+    async delete(caller, filter) {
+        const { options } = this.dataSource;
+        await super.delete(caller, filter);
+        if (options.pullDeltaOnAfterWrite) {
+            // Deletes may cascade to other collections!
+            // Let's find out which one are affected assuming that all deletes cascade
+            // (which is the worst case scenario)
+            await options.source.queuePullDelta({
+                name: 'after-delete',
+                collection: this.name,
+                affectedCollections: this.getLinkedCollections(new Set()),
+                caller,
+                filter: filter,
+            });
+        }
+    }
+    async list(caller, filter, projection) {
+        const { options } = this.dataSource;
+        if (options.pullDeltaOnBeforeAccess) {
+            await options.source.queuePullDelta({
+                name: 'before-list',
+                collection: this.name,
+                affectedCollections: this.getCollectionsFromProjection(projection),
+                caller,
+                filter: filter,
+                projection,
+            });
+        }
+        return super.list(caller, filter, projection);
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        const { options } = this.dataSource;
+        if (options.pullDeltaOnBeforeAccess) {
+            await options.source.queuePullDelta({
+                name: 'before-aggregate',
+                collection: this.name,
+                affectedCollections: this.getCollectionsFromProjection(aggregation.projection),
+                caller,
+                filter: filter,
+                aggregation,
+            });
+        }
+        return super.aggregate(caller, filter, aggregation, limit);
+    }
+    getLinkedCollections(exclude) {
+        const set = new Set();
+        set.add(this.name);
+        Object.values(this.schema.fields).forEach(f => {
+            if (f.type === 'ManyToOne' || f.type === 'OneToOne') {
+                const collection = this.dataSource.getCollection(f.foreignCollection);
+                if (!exclude.has(collection.name)) {
+                    collection.getLinkedCollections(set).forEach(c => set.add(c));
+                }
+            }
+        });
+        return [...set];
+    }
+    getCollectionsFromProjection(projection) {
+        const set = new Set();
+        for (const field of projection)
+            set.add(this.getCollectionFromPath(field));
+        return [...set];
+    }
+    getCollectionFromPath(path) {
+        const [prefix, suffix] = path.split(/:(.*)/);
+        const schema = this.childCollection.schema.fields[prefix];
+        // FIXME need to handle many to many relationships here
+        // the through table is not included, and it should be
+        return schema.type === 'Column'
+            ? this.name
+            : this.dataSource.getCollection(schema.foreignCollection).getCollectionFromPath(suffix);
+    }
+}
+exports.default = SyncCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3N5bmMvY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVlBLHdFQUFzRTtBQUV0RSxNQUFxQix1QkFBd0IsU0FBUSx3Q0FBbUI7SUFHN0QsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFjLEVBQUUsSUFBa0I7UUFDdEQsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7UUFDcEMsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFFaEUsSUFBSSxPQUFPLENBQUMscUJBQXFCLEVBQUU7WUFDakMsTUFBTSxPQUFPLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQztnQkFDbEMsSUFBSSxFQUFFLGNBQWM7Z0JBQ3BCLFVBQVUsRUFBRSxJQUFJLENBQUMsSUFBSTtnQkFDckIsTUFBTTtnQkFDTixtQkFBbUIsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUM7Z0JBQ2hDLE9BQU87YUFDUixDQUFDLENBQUM7U0FDSjtRQUVELE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7SUFFUSxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQWMsRUFBRSxNQUFjLEVBQUUsS0FBaUI7UUFDckUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7UUFFcEMsTUFBTSxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFFMUMsSUFBSSxPQUFPLENBQUMscUJBQXFCLEVBQUU7WUFDakMsTUFBTSxPQUFPLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQztnQkFDbEMsSUFBSSxFQUFFLGNBQWM7Z0JBQ3BCLFVBQVUsRUFBRSxJQUFJLENBQUMsSUFBSTtnQkFDckIsbUJBQW1CLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO2dCQUNoQyxNQUFNO2dCQUNOLE1BQU0sRUFBRSxNQUE0QjtnQkFDcEMsS0FBSzthQUNOLENBQUMsQ0FBQztTQUNKO0lBQ0gsQ0FBQztJQUVRLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBYyxFQUFFLE1BQWM7UUFDbEQsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7UUFFcEMsTUFBTSxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztRQUVuQyxJQUFJLE9BQU8sQ0FBQyxxQkFBcUIsRUFBRTtZQUNqQyw0Q0FBNEM7WUFDNUMsMEVBQTBFO1lBQzFFLHFDQUFxQztZQUNyQyxNQUFNLE9BQU8sQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDO2dCQUNsQyxJQUFJLEVBQUUsY0FBYztnQkFDcEIsVUFBVSxFQUFFLElBQUksQ0FBQyxJQUFJO2dCQUNyQixtQkFBbUIsRUFBRSxJQUFJLENBQUMsb0JBQW9CLENBQUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztnQkFDekQsTUFBTTtnQkFDTixNQUFNLEVBQUUsTUFBNEI7YUFDckMsQ0FBQyxDQUFDO1NBQ0o7SUFDSCxDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUksQ0FDakIsTUFBYyxFQUNkLE1BQXVCLEVBQ3ZCLFVBQXNCO1FBRXRCLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDO1FBRXBDLElBQUksT0FBTyxDQUFDLHVCQUF1QixFQUFFO1lBQ25DLE1BQU0sT0FBTyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUM7Z0JBQ2xDLElBQUksRUFBRSxhQUFhO2dCQUNuQixVQUFVLEVBQUUsSUFBSSxDQUFDLElBQUk7Z0JBQ3JCLG1CQUFtQixFQUFFLElBQUksQ0FBQyw0QkFBNEIsQ0FBQyxVQUFVLENBQUM7Z0JBQ2xFLE1BQU07Z0JBQ04sTUFBTSxFQUFFLE1BQXFDO2dCQUM3QyxVQUFVO2FBQ1gsQ0FBQyxDQUFDO1NBQ0o7UUFFRCxPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxVQUFVLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRVEsS0FBSyxDQUFDLFNBQVMsQ0FDdEIsTUFBYyxFQUNkLE1BQWMsRUFDZCxXQUF3QixFQUN4QixLQUFjO1FBRWQsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7UUFFcEMsSUFBSSxPQUFPLENBQUMsdUJBQXVCLEVBQUU7WUFDbkMsTUFBTSxPQUFPLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQztnQkFDbEMsSUFBSSxFQUFFLGtCQUFrQjtnQkFDeEIsVUFBVSxFQUFFLElBQUksQ0FBQyxJQUFJO2dCQUNyQixtQkFBbUIsRUFBRSxJQUFJLENBQUMsNEJBQTRCLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQztnQkFDOUUsTUFBTTtnQkFDTixNQUFNLEVBQUUsTUFBNEI7Z0JBQ3BDLFdBQVc7YUFDWixDQUFDLENBQUM7U0FDSjtRQUVELE9BQU8sS0FBSyxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRU8sb0JBQW9CLENBQUMsT0FBb0I7UUFDL0MsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLEVBQVUsQ0FBQztRQUM5QixHQUFHLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUVuQixNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFO1lBQzVDLElBQUksQ0FBQyxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksQ0FBQyxDQUFDLElBQUksS0FBSyxVQUFVLEVBQUU7Z0JBQ25ELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO2dCQUV0RSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUU7b0JBQ2pDLFVBQVUsQ0FBQyxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQy9EO2FBQ0Y7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFFTyw0QkFBNEIsQ0FBQyxVQUFzQjtRQUN6RCxNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBQzlCLEtBQUssTUFBTSxLQUFLLElBQUksVUFBVTtZQUFFLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFFM0UsT0FBTyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUM7SUFDbEIsQ0FBQztJQUVPLHFCQUFxQixDQUFDLElBQVk7UUFDeEMsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzdDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUUxRCx1REFBdUQ7UUFDdkQsc0RBQXNEO1FBQ3RELE9BQU8sTUFBTSxDQUFDLElBQUksS0FBSyxRQUFRO1lBQzdCLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSTtZQUNYLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM1RixDQUFDO0NBQ0Y7QUFySUQsMENBcUlDIn0=

package/dist/decorators/sync/data-source.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedOptions } from '../../types';
+import type { DataSource } from '@forestadmin/datasource-toolkit';
+import { DataSourceDecorator } from '@forestadmin/datasource-toolkit';
+import SyncCollectionDecorator from './collection';
+export default class TriggerSyncDataSourceDecorator extends DataSourceDecorator<SyncCollectionDecorator> {
+    options: ResolvedOptions;
+    constructor(childDataSource: DataSource, options: ResolvedOptions);
+}
+//# sourceMappingURL=data-source.d.ts.map

package/dist/decorators/sync/data-source.js

@@ -0,0 +1,15 @@
+"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_1 = __importDefault(require("./collection"));
+class TriggerSyncDataSourceDecorator extends datasource_toolkit_1.DataSourceDecorator {
+    constructor(childDataSource, options) {
+        super(childDataSource, collection_1.default);
+        this.options = options;
+    }
+}
+exports.default = TriggerSyncDataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9zeW5jL2RhdGEtc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBR0Esd0VBQXNFO0FBRXRFLDhEQUFtRDtBQUVuRCxNQUFxQiw4QkFBK0IsU0FBUSx3Q0FBNEM7SUFHdEcsWUFBWSxlQUEyQixFQUFFLE9BQXdCO1FBQy9ELEtBQUssQ0FBQyxlQUFlLEVBQUUsb0JBQXVCLENBQUMsQ0FBQztRQUVoRCxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDO0NBQ0Y7QUFSRCxpREFRQyJ9

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

@@ -0,0 +1,11 @@
+import type WriteDataSourceDecorator from './data-source';
+import type { Caller, Filter, RecordData } from '@forestadmin/datasource-toolkit';
+import { CollectionDecorator } from '@forestadmin/datasource-toolkit';
+export default class WriteCollectionDecorator extends CollectionDecorator {
+    dataSource: WriteDataSourceDecorator;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    private get options();
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/write/collection.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class WriteCollectionDecorator extends datasource_toolkit_1.CollectionDecorator {
+    async create(caller, data) {
+        // we actually can't tell the db not to perform the creation...
+        if (!this.options.createRecordHandler) {
+            throw new datasource_toolkit_1.UnprocessableError('This collection does not supports creations');
+        }
+        if (this.dataSource.options.schema.find(({ name }) => name === this.name)) {
+            // I am a root collection, I can forward the creation to the target
+            const promises = data.map(async (record) => {
+                const newRecord = await this.options.createRecordHandler(this.name, record);
+                Object.assign(record, newRecord ?? {});
+            });
+            await Promise.all(promises);
+        }
+        return this.childCollection.create(caller, data);
+    }
+    async update(caller, filter, patch) {
+        if (!this.options.updateRecordHandler) {
+            throw new datasource_toolkit_1.UnprocessableError('This collection does not supports updates');
+        }
+        if (this.dataSource.options.schema.find(({ name }) => name === this.name)) {
+            // I am a root collection, I can forward the update to the target
+            const recordsPks = await super.list(caller, filter, new datasource_toolkit_1.Projection().withPks(this));
+            const promises = recordsPks.map(async (record) => {
+                Object.assign(record, patch);
+                await this.options.updateRecordHandler(this.name, record);
+            });
+            await Promise.all(promises);
+        }
+        return super.update(caller, filter, patch);
+    }
+    async delete(caller, filter) {
+        if (!this.options.deleteRecordHandler) {
+            throw new datasource_toolkit_1.UnprocessableError('This collection does not supports deletes');
+        }
+        if (this.dataSource.options.schema.find(({ name }) => name === this.name)) {
+            // I am a root collection, I can forward the delete to the target
+            const recordsPks = await super.list(caller, filter, new datasource_toolkit_1.Projection().withPks(this));
+            const promises = recordsPks.map(async (record) => {
+                await this.options.deleteRecordHandler(this.name, record);
+            });
+            await Promise.all(promises);
+        }
+        return super.delete(caller, filter);
+    }
+    get options() {
+        return this.dataSource.options;
+    }
+}
+exports.default = WriteCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3dyaXRlL2NvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSx3RUFJeUM7QUFFekMsTUFBcUIsd0JBQXlCLFNBQVEsd0NBQW1CO0lBRzlELEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBYyxFQUFFLElBQWtCO1FBQ3RELCtEQUErRDtRQUMvRCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRTtZQUNyQyxNQUFNLElBQUksdUNBQWtCLENBQUMsNkNBQTZDLENBQUMsQ0FBQztTQUM3RTtRQUVELElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDekUsbUVBQW1FO1lBQ25FLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLE1BQU0sRUFBQyxFQUFFO2dCQUN2QyxNQUFNLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztnQkFDNUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsU0FBUyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ3pDLENBQUMsQ0FBQyxDQUFDO1lBRUgsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1NBQzdCO1FBRUQsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVRLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBYyxFQUFFLE1BQWMsRUFBRSxLQUFpQjtRQUNyRSxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRTtZQUNyQyxNQUFNLElBQUksdUNBQWtCLENBQUMsMkNBQTJDLENBQUMsQ0FBQztTQUMzRTtRQUVELElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDekUsaUVBQWlFO1lBQ2pFLE1BQU0sVUFBVSxHQUFHLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksK0JBQVUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQ3BGLE1BQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLE1BQU0sRUFBQyxFQUFFO2dCQUM3QyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztnQkFDN0IsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDNUQsQ0FBQyxDQUFDLENBQUM7WUFFSCxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDN0I7UUFFRCxPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRVEsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFjLEVBQUUsTUFBYztRQUNsRCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRTtZQUNyQyxNQUFNLElBQUksdUNBQWtCLENBQUMsMkNBQTJDLENBQUMsQ0FBQztTQUMzRTtRQUVELElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDekUsaUVBQWlFO1lBQ2pFLE1BQU0sVUFBVSxHQUFHLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksK0JBQVUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQ3BGLE1BQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLE1BQU0sRUFBQyxFQUFFO2dCQUM3QyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztZQUM1RCxDQUFDLENBQUMsQ0FBQztZQUVILE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUM3QjtRQUVELE9BQU8sS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUVELElBQVksT0FBTztRQUNqQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBbUMsQ0FBQztJQUM3RCxDQUFDO0NBQ0Y7QUE5REQsMkNBOERDIn0=

package/dist/decorators/write/data-source.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedOptions } from '../../types';
+import type { DataSource } from '@forestadmin/datasource-toolkit';
+import { DataSourceDecorator } from '@forestadmin/datasource-toolkit';
+export default class WriteDataSourceDecorator extends DataSourceDecorator {
+    options: ResolvedOptions;
+    constructor(childDataSource: DataSource, options: ResolvedOptions);
+}
+//# sourceMappingURL=data-source.d.ts.map

package/dist/decorators/write/data-source.js

@@ -0,0 +1,23 @@
+"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_1 = __importDefault(require("./collection"));
+class WriteDataSourceDecorator extends datasource_toolkit_1.DataSourceDecorator {
+    constructor(childDataSource, options) {
+        super(childDataSource, collection_1.default);
+        this.options = options;
+        childDataSource.collections.forEach(collection => {
+            if ((options.flattenOptions[collection.name]?.asModels.length ||
+                options.flattenOptions[collection.name]?.asFields.length) &&
+                (options.createRecordHandler || options.updateRecordHandler || options.deleteRecordHandler)) {
+                throw new Error('Cannot use flattenOptions with' +
+                    ' createRecordHandler, updateRecordHandler or deleteRecordHandler.');
+            }
+        });
+    }
+}
+exports.default = WriteDataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy93cml0ZS9kYXRhLXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUdBLHdFQUFzRTtBQUV0RSw4REFBb0Q7QUFFcEQsTUFBcUIsd0JBQXlCLFNBQVEsd0NBQW1CO0lBR3ZFLFlBQVksZUFBMkIsRUFBRSxPQUF3QjtRQUMvRCxLQUFLLENBQUMsZUFBZSxFQUFFLG9CQUF3QixDQUFDLENBQUM7UUFFakQsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFFdkIsZUFBZSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEVBQUU7WUFDL0MsSUFDRSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxFQUFFLFFBQVEsQ0FBQyxNQUFNO2dCQUN2RCxPQUFPLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLENBQUMsTUFBTSxDQUFDO2dCQUMzRCxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsSUFBSSxPQUFPLENBQUMsbUJBQW1CLElBQUksT0FBTyxDQUFDLG1CQUFtQixDQUFDLEVBQzNGO2dCQUNBLE1BQU0sSUFBSSxLQUFLLENBQ2IsZ0NBQWdDO29CQUM5QixtRUFBbUUsQ0FDdEUsQ0FBQzthQUNIO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUFyQkQsMkNBcUJDIn0=

package/dist/flattener.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionReplicaSchema, RecordDataWithCollection } from './types';
+export default function flattenRecord(recordWithCollection: RecordDataWithCollection, fields: CollectionReplicaSchema['fields'], asFields: string[], asModels: string[]): RecordDataWithCollection[];
+//# sourceMappingURL=flattener.d.ts.map

package/dist/flattener.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+function flattenRecordRec(recordWithCollection, fields, asFields, asModels) {
+    const { collection, record } = recordWithCollection;
+    const flattenedRecords = [];
+    for (let asModelIndex = 0; asModelIndex < asModels.length; asModelIndex += 1) {
+        const asModel = asModels[asModelIndex];
+        // Build subAsModels and subAsFields + remove them from asModels and asFields
+        const subAsModels = [];
+        while (asModels[asModelIndex + 1]?.startsWith(`${asModel}.`)) {
+            // asModels must be sorted for this to work
+            subAsModels.push(asModels[asModelIndex + 1].substring(asModel.length + 1));
+            asModels.splice(asModelIndex + 1, 1);
+        }
+        const subAsFields = [];
+        for (let i = 0; i < asFields.length; i += 1) {
+            if (asFields[i].startsWith(`${asModel}.`)) {
+                subAsFields.push(asFields[i].substring(asModel.length + 1));
+                asFields.splice(i, 1);
+                i -= 1;
+            }
+        }
+        // Build schema for subModel + some metadata
+        let subFields = (0, utils_1.extractValue)(fields, asModel, false);
+        const isArray = Array.isArray(subFields);
+        if (isArray)
+            [subFields] = subFields;
+        const isPrimitive = typeof subFields.type === 'string';
+        // Recurse
+        let subRecords = (0, utils_1.extractValue)(record, asModel, true);
+        if (subRecords) {
+            if (!isArray)
+                subRecords = [subRecords];
+            if (isPrimitive)
+                subRecords = subRecords.map(v => ({ value: v }));
+            for (const [index, subRecord] of subRecords.entries()) {
+                if (subRecord !== null && subRecord !== undefined) {
+                    const recordId = (0, utils_1.getRecordId)(fields, record);
+                    // eslint-disable-next-line no-underscore-dangle
+                    subRecord._fid = isArray ? `${recordId}.${asModel}.${index}` : `${recordId}.${asModel}`;
+                    // eslint-disable-next-line no-underscore-dangle
+                    subRecord._fpid = recordId;
+                    flattenedRecords.push(...flattenRecordRec({ collection: (0, utils_1.escape) `${collection}.${asModel}`, record: subRecord }, subFields, subAsFields, subAsModels));
+                }
+            }
+        }
+    }
+    for (const asField of asFields) {
+        record[asField.replace('.', '@@@')] = (0, utils_1.extractValue)(record, asField, true);
+    }
+    flattenedRecords.push(recordWithCollection);
+    return flattenedRecords;
+}
+function flattenRecord(recordWithCollection, fields, asFields, asModels) {
+    return flattenRecordRec((0, utils_1.deepclone)(recordWithCollection), fields, [...asFields].sort(), [...asModels].sort());
+}
+exports.default = flattenRecord;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhdHRlbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZsYXR0ZW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLG1DQUF1RTtBQUV2RSxTQUFTLGdCQUFnQixDQUN2QixvQkFBOEMsRUFDOUMsTUFBeUMsRUFDekMsUUFBa0IsRUFDbEIsUUFBa0I7SUFFbEIsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsR0FBRyxvQkFBb0IsQ0FBQztJQUNwRCxNQUFNLGdCQUFnQixHQUFHLEVBQUUsQ0FBQztJQUU1QixLQUFLLElBQUksWUFBWSxHQUFHLENBQUMsRUFBRSxZQUFZLEdBQUcsUUFBUSxDQUFDLE1BQU0sRUFBRSxZQUFZLElBQUksQ0FBQyxFQUFFO1FBQzVFLE1BQU0sT0FBTyxHQUFHLFFBQVEsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUV2Qyw2RUFBNkU7UUFDN0UsTUFBTSxXQUFXLEdBQUcsRUFBRSxDQUFDO1FBRXZCLE9BQU8sUUFBUSxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUMsRUFBRSxVQUFVLENBQUMsR0FBRyxPQUFPLEdBQUcsQ0FBQyxFQUFFO1lBQzVELDJDQUEyQztZQUMzQyxXQUFXLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLEdBQUcsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUMzRSxRQUFRLENBQUMsTUFBTSxDQUFDLFlBQVksR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7U0FDdEM7UUFFRCxNQUFNLFdBQVcsR0FBRyxFQUFFLENBQUM7UUFFdkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUMzQyxJQUFJLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsR0FBRyxPQUFPLEdBQUcsQ0FBQyxFQUFFO2dCQUN6QyxXQUFXLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUM1RCxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztnQkFDdEIsQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUNSO1NBQ0Y7UUFFRCw0Q0FBNEM7UUFDNUMsSUFBSSxTQUFTLEdBQUcsSUFBQSxvQkFBWSxFQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDckQsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUN6QyxJQUFJLE9BQU87WUFBRSxDQUFDLFNBQVMsQ0FBQyxHQUFHLFNBQVMsQ0FBQztRQUNyQyxNQUFNLFdBQVcsR0FBRyxPQUFPLFNBQVMsQ0FBQyxJQUFJLEtBQUssUUFBUSxDQUFDO1FBRXZELFVBQVU7UUFDVixJQUFJLFVBQVUsR0FBRyxJQUFBLG9CQUFZLEVBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztRQUVyRCxJQUFJLFVBQVUsRUFBRTtZQUNkLElBQUksQ0FBQyxPQUFPO2dCQUFFLFVBQVUsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQ3hDLElBQUksV0FBVztnQkFBRSxVQUFVLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBRWxFLEtBQUssTUFBTSxDQUFDLEtBQUssRUFBRSxTQUFTLENBQUMsSUFBSSxVQUFVLENBQUMsT0FBTyxFQUFFLEVBQUU7Z0JBQ3JELElBQUksU0FBUyxLQUFLLElBQUksSUFBSSxTQUFTLEtBQUssU0FBUyxFQUFFO29CQUNqRCxNQUFNLFFBQVEsR0FBRyxJQUFBLG1CQUFXLEVBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO29CQUM3QyxnREFBZ0Q7b0JBQ2hELFNBQVMsQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLFFBQVEsSUFBSSxPQUFPLElBQUksS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsUUFBUSxJQUFJLE9BQU8sRUFBRSxDQUFDO29CQUN4RixnREFBZ0Q7b0JBQ2hELFNBQVMsQ0FBQyxLQUFLLEdBQUcsUUFBUSxDQUFDO29CQUUzQixnQkFBZ0IsQ0FBQyxJQUFJLENBQ25CLEdBQUcsZ0JBQWdCLENBQ2pCLEVBQUUsVUFBVSxFQUFFLElBQUEsY0FBTSxFQUFBLEdBQUcsVUFBVSxJQUFJLE9BQU8sRUFBRSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsRUFDbkUsU0FBUyxFQUNULFdBQVcsRUFDWCxXQUFXLENBQ1osQ0FDRixDQUFDO2lCQUNIO2FBQ0Y7U0FDRjtLQUNGO0lBRUQsS0FBSyxNQUFNLE9BQU8sSUFBSSxRQUFRLEVBQUU7UUFDOUIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLEdBQUcsSUFBQSxvQkFBWSxFQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7S0FDM0U7SUFFRCxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUU1QyxPQUFPLGdCQUFnQixDQUFDO0FBQzFCLENBQUM7QUFFRCxTQUF3QixhQUFhLENBQ25DLG9CQUE4QyxFQUM5QyxNQUF5QyxFQUN6QyxRQUFrQixFQUNsQixRQUFrQjtJQUVsQixPQUFPLGdCQUFnQixDQUNyQixJQUFBLGlCQUFTLEVBQUMsb0JBQW9CLENBQUMsRUFDL0IsTUFBTSxFQUNOLENBQUMsR0FBRyxRQUFRLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFDcEIsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUNyQixDQUFDO0FBQ0osQ0FBQztBQVpELGdDQVlDIn0=

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { ReplicaDataSourceOptions } from './types';
+import type { DataSourceFactory } from '@forestadmin/datasource-toolkit';
+declare function createReplicaDataSource(rawOptions: ReplicaDataSourceOptions): DataSourceFactory;
+export * from './types';
+export { createReplicaDataSource };
+//# sourceMappingURL=index.d.ts.map

package/dist/options/flattener/options.d.ts

@@ -0,0 +1,5 @@
+import type { CollectionReplicaSchema, ReplicaDataSourceOptions, ResolvedOptions } from '../../types';
+type ResolvedFlattenOptions = ResolvedOptions['flattenOptions'];
+export default function computeFlattenOptions(schema: CollectionReplicaSchema[], rawOptions: ReplicaDataSourceOptions): Promise<ResolvedFlattenOptions>;
+export {};
+//# sourceMappingURL=options.d.ts.map