@forestadmin/datasource-customizer 1.0.0-alpha.1

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

@@ -0,0 +1,4 @@
+import { TCollectionName, TColumnName, TConditionTree, TFieldType, TSchema } from '../../templates';
+import CollectionCustomizationContext from '../../context/collection-context';
+export declare type OperatorDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>, C extends TColumnName<S, N> = TColumnName<S, N>> = (value: TFieldType<S, N, C>, context: CollectionCustomizationContext<S, N>) => Promise<TConditionTree<S, N>> | TConditionTree<S, N>;
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+import { Caller, CollectionSchema, PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+/**
+ * Decorator which emulates filter operators from others.
+ */
+export default class OperatorsDecorator extends CollectionDecorator {
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    protected refineFilter(caller: Caller, filter?: PaginatedFilter): Promise<PaginatedFilter>;
+}
+//# sourceMappingURL=collection.d.ts.map

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

@@ -0,0 +1,35 @@
+"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"));
+/**
+ * Decorator which emulates filter operators from others.
+ */
+class OperatorsDecorator extends collection_decorator_1.default {
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [name, schema] of Object.entries(childSchema.fields)) {
+            if (schema.type === 'Column') {
+                const newOperators = datasource_toolkit_1.allOperators.filter(operator => datasource_toolkit_1.ConditionTreeEquivalent.hasEquivalentTree(operator, schema.filterOperators, schema.columnType));
+                fields[name] = { ...schema, filterOperators: new Set(newOperators) };
+            }
+            else {
+                fields[name] = schema;
+            }
+        }
+        return { ...childSchema, fields };
+    }
+    async refineFilter(caller, filter) {
+        return filter?.override({
+            conditionTree: filter.conditionTree?.replaceLeafs(leaf => {
+                const schema = datasource_toolkit_1.CollectionUtils.getFieldSchema(this.childCollection, leaf.field);
+                return datasource_toolkit_1.ConditionTreeEquivalent.getEquivalentTree(leaf, schema.filterOperators, schema.columnType, caller.timezone);
+            }),
+        });
+    }
+}
+exports.default = OperatorsDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL29wZXJhdG9ycy1yZXBsYWNlL2NvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSx3RUFTeUM7QUFFekMsbUZBQTBEO0FBRTFEOztHQUVHO0FBQ0gsTUFBcUIsa0JBQW1CLFNBQVEsOEJBQW1CO0lBQzlDLFlBQVksQ0FBQyxXQUE2QjtRQUMzRCxNQUFNLE1BQU0sR0FBZ0MsRUFBRSxDQUFDO1FBRS9DLEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUMvRCxJQUFJLE1BQU0sQ0FBQyxJQUFJLEtBQUssUUFBUSxFQUFFO2dCQUM1QixNQUFNLFlBQVksR0FBRyxpQ0FBWSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUNsRCw0Q0FBdUIsQ0FBQyxpQkFBaUIsQ0FDdkMsUUFBUSxFQUNSLE1BQU0sQ0FBQyxlQUFlLEVBQ3RCLE1BQU0sQ0FBQyxVQUFVLENBQ2xCLENBQ0YsQ0FBQztnQkFFRixNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLE1BQU0sRUFBRSxlQUFlLEVBQUUsSUFBSSxHQUFHLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQzthQUN0RTtpQkFBTTtnQkFDTCxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxDQUFDO2FBQ3ZCO1NBQ0Y7UUFFRCxPQUFPLEVBQUUsR0FBRyxXQUFXLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDcEMsQ0FBQztJQUVrQixLQUFLLENBQUMsWUFBWSxDQUNuQyxNQUFjLEVBQ2QsTUFBd0I7UUFFeEIsT0FBTyxNQUFNLEVBQUUsUUFBUSxDQUFDO1lBQ3RCLGFBQWEsRUFBRSxNQUFNLENBQUMsYUFBYSxFQUFFLFlBQVksQ0FBQyxJQUFJLENBQUMsRUFBRTtnQkFDdkQsTUFBTSxNQUFNLEdBQUcsb0NBQWUsQ0FBQyxjQUFjLENBQzNDLElBQUksQ0FBQyxlQUFlLEVBQ3BCLElBQUksQ0FBQyxLQUFLLENBQ0ssQ0FBQztnQkFFbEIsT0FBTyw0Q0FBdUIsQ0FBQyxpQkFBaUIsQ0FDOUMsSUFBSSxFQUNKLE1BQU0sQ0FBQyxlQUFlLEVBQ3RCLE1BQU0sQ0FBQyxVQUFVLEVBQ2pCLE1BQU0sQ0FBQyxRQUFRLENBQ2hCLENBQUM7WUFDSixDQUFDLENBQUM7U0FDSCxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUEzQ0QscUNBMkNDIn0=

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

@@ -0,0 +1,14 @@
+import { Caller, CollectionSchema, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+/** This decorator allows hiding fields */
+export default class PublicationCollectionDecorator extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<PublicationCollectionDecorator>;
+    private readonly unpublished;
+    /** Show/hide fields from the schema */
+    changeFieldVisibility(name: string, visible: boolean): void;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    private isPublished;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/publication/collection.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+/** This decorator allows hiding fields */
+class PublicationCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.unpublished = new Set();
+    }
+    /** Show/hide fields from the schema */
+    changeFieldVisibility(name, visible) {
+        const field = this.childCollection.schema.fields[name];
+        if (!field) {
+            throw new Error(`No such field '${name}'`);
+        }
+        if (field.type === 'Column' && field.isPrimaryKey) {
+            throw new Error(`Cannot hide primary key`);
+        }
+        if (!visible)
+            this.unpublished.add(name);
+        else
+            this.unpublished.delete(name);
+        this.markSchemaAsDirty();
+    }
+    async create(caller, data) {
+        const records = await super.create(caller, data);
+        return records.map(childRecord => {
+            const record = {};
+            for (const key of Object.keys(childRecord))
+                if (!this.unpublished.has(key))
+                    record[key] = childRecord[key];
+            return record;
+        });
+    }
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [name, field] of Object.entries(childSchema.fields)) {
+            if (this.isPublished(name)) {
+                fields[name] = field;
+            }
+        }
+        return { ...childSchema, fields };
+    }
+    isPublished(name) {
+        const field = this.childCollection.schema.fields[name];
+        return (!this.unpublished.has(name) &&
+            // Columns have no special requirements
+            (field.type === 'Column' ||
+                // Many to one, one to one and one to many need the foreign key to be published
+                (field.type === 'ManyToOne' && this.isPublished(field.foreignKey)) ||
+                ((field.type === 'OneToOne' || field.type === 'OneToMany') &&
+                    this.dataSource.getCollection(field.foreignCollection).isPublished(field.originKey)) ||
+                // Many to many relations depend on both foreignKey and originKey to be published
+                (field.type === 'ManyToMany' &&
+                    this.dataSource.getCollection(field.throughCollection).isPublished(field.foreignKey) &&
+                    this.dataSource.getCollection(field.throughCollection).isPublished(field.originKey))));
+    }
+}
+exports.default = PublicationCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+import { AggregateResult, Aggregation, Caller, CollectionSchema, Filter, PaginatedFilter, Projection, RecordData, RelationSchema } from '@forestadmin/datasource-toolkit';
+import { RelationDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+export default class RelationCollectionDecorator extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<RelationCollectionDecorator>;
+    protected relations: Record<string, RelationSchema>;
+    addRelation(name: string, partialJoint: RelationDefinition): void;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    protected refineFilter(caller: Caller, filter: PaginatedFilter): Promise<PaginatedFilter>;
+    private relationWithOptionalFields;
+    private checkForeignKeys;
+    private checkOriginKeys;
+    private static checkKeys;
+    private static checkColumn;
+    private rewriteField;
+    private rewriteLeaf;
+    private reprojectInPlace;
+    private reprojectRelationInPlace;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/relation/collection.js

@@ -0,0 +1,190 @@
+"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"));
+class RelationCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.relations = {};
+    }
+    addRelation(name, partialJoint) {
+        const relation = this.relationWithOptionalFields(partialJoint);
+        this.checkForeignKeys(relation);
+        this.checkOriginKeys(relation);
+        this.relations[name] = relation;
+        this.markSchemaAsDirty();
+    }
+    async list(caller, filter, projection) {
+        const newFilter = await this.refineFilter(caller, filter);
+        const newProjection = projection.replace(this.rewriteField, this).withPks(this);
+        const records = await this.childCollection.list(caller, newFilter, newProjection);
+        await this.reprojectInPlace(caller, records, projection);
+        return projection.apply(records);
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        const newFilter = await this.refineFilter(caller, filter);
+        // No emulated relations are used in the aggregation
+        if (Object.keys(aggregation.projection.relations).every(prefix => !this.relations[prefix])) {
+            return this.childCollection.aggregate(caller, newFilter, aggregation, limit);
+        }
+        // Fallback to full emulation.
+        return aggregation.apply(await this.list(caller, filter, aggregation.projection), caller.timezone, limit);
+    }
+    refineSchema(subSchema) {
+        const schema = { ...subSchema, fields: { ...subSchema.fields } };
+        for (const [name, relation] of Object.entries(this.relations)) {
+            schema.fields[name] = relation;
+        }
+        return schema;
+    }
+    async refineFilter(caller, filter) {
+        return filter?.override({
+            conditionTree: await filter.conditionTree?.replaceLeafsAsync(leaf => this.rewriteLeaf(caller, leaf), this),
+            // Replace sort in emulated relations to
+            // - sorting by the fk of the relation for many to one
+            // - removing the sort altogether for one to one
+            //
+            // This is far from ideal, but the best that can be done without taking a major
+            // performance hit.
+            // Customers which want proper sorting should enable emulation in the associated
+            // middleware
+            sort: filter.sort?.replaceClauses(clause => this.rewriteField(clause.field).map(field => ({ ...clause, field }))),
+        });
+    }
+    relationWithOptionalFields(partialJoint) {
+        const relation = { ...partialJoint };
+        const target = this.dataSource.getCollection(relation.foreignCollection);
+        if (relation.type === 'ManyToOne') {
+            relation.foreignKeyTarget ?? (relation.foreignKeyTarget = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(target.schema)[0]);
+        }
+        else if (relation.type === 'OneToOne' || relation.type === 'OneToMany') {
+            relation.originKeyTarget ?? (relation.originKeyTarget = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.schema)[0]);
+        }
+        else if (relation.type === 'ManyToMany') {
+            relation.originKeyTarget ?? (relation.originKeyTarget = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.schema)[0]);
+            relation.foreignKeyTarget ?? (relation.foreignKeyTarget = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(target.schema)[0]);
+        }
+        return relation;
+    }
+    checkForeignKeys(relation) {
+        if (relation.type === 'ManyToOne' || relation.type === 'ManyToMany') {
+            RelationCollectionDecorator.checkKeys(relation.type === 'ManyToMany'
+                ? this.dataSource.getCollection(relation.throughCollection)
+                : this, this.dataSource.getCollection(relation.foreignCollection), relation.foreignKey, relation.foreignKeyTarget);
+        }
+    }
+    checkOriginKeys(relation) {
+        if (relation.type === 'OneToMany' ||
+            relation.type === 'OneToOne' ||
+            relation.type === 'ManyToMany') {
+            RelationCollectionDecorator.checkKeys(relation.type === 'ManyToMany'
+                ? this.dataSource.getCollection(relation.throughCollection)
+                : this.dataSource.getCollection(relation.foreignCollection), this, relation.originKey, relation.originKeyTarget);
+        }
+    }
+    static checkKeys(owner, targetOwner, keyName, targetName) {
+        RelationCollectionDecorator.checkColumn(owner, keyName);
+        RelationCollectionDecorator.checkColumn(targetOwner, targetName);
+        const key = owner.schema.fields[keyName];
+        const target = targetOwner.schema.fields[targetName];
+        if (key.columnType !== target.columnType) {
+            throw new Error(`Types from '${owner.name}.${keyName}' and ` +
+                `'${targetOwner.name}.${targetName}' do not match.`);
+        }
+    }
+    static checkColumn(owner, name) {
+        const column = owner.schema.fields[name];
+        if (!column || column.type !== 'Column') {
+            throw new Error(`Column not found: '${owner.name}.${name}'`);
+        }
+        if (!column.filterOperators?.has('In')) {
+            throw new Error(`Column does not support the In operator: '${owner.name}.${name}'`);
+        }
+    }
+    rewriteField(field) {
+        const prefix = field.split(':').shift();
+        const schema = this.schema.fields[prefix];
+        if (schema.type === 'Column')
+            return [field];
+        const relation = this.dataSource.getCollection(schema.foreignCollection);
+        let result = [];
+        if (!this.relations[prefix]) {
+            result = relation
+                .rewriteField(field.substring(prefix.length + 1))
+                .map(subField => `${prefix}:${subField}`);
+        }
+        else if (schema.type === 'ManyToOne') {
+            result = [schema.foreignKey];
+        }
+        else if (schema.type === 'OneToOne' ||
+            schema.type === 'OneToMany' ||
+            schema.type === 'ManyToMany') {
+            result = [schema.originKeyTarget];
+        }
+        return result;
+    }
+    async rewriteLeaf(caller, leaf) {
+        const prefix = leaf.field.split(':').shift();
+        const schema = this.schema.fields[prefix];
+        if (schema.type === 'Column')
+            return leaf;
+        const relation = this.dataSource.getCollection(schema.foreignCollection);
+        let result = leaf;
+        if (!this.relations[prefix]) {
+            result = (await relation.rewriteLeaf(caller, leaf.unnest())).nest(prefix);
+        }
+        else if (schema.type === 'ManyToOne') {
+            const records = await relation.list(caller, new datasource_toolkit_1.Filter({ conditionTree: leaf.unnest() }), new datasource_toolkit_1.Projection(schema.foreignKeyTarget));
+            result = new datasource_toolkit_1.ConditionTreeLeaf(schema.foreignKey, 'In', [
+                ...new Set(records
+                    .map(record => datasource_toolkit_1.RecordUtils.getFieldValue(record, schema.foreignKeyTarget))
+                    .filter(v => v !== null)),
+            ]);
+        }
+        else if (schema.type === 'OneToOne') {
+            const records = await relation.list(caller, new datasource_toolkit_1.Filter({ conditionTree: leaf.unnest() }), new datasource_toolkit_1.Projection(schema.originKey));
+            result = new datasource_toolkit_1.ConditionTreeLeaf(schema.originKeyTarget, 'In', [
+                ...new Set(records
+                    .map(record => datasource_toolkit_1.RecordUtils.getFieldValue(record, schema.originKey))
+                    .filter(v => v !== null)),
+            ]);
+        }
+        return result;
+    }
+    async reprojectInPlace(caller, records, projection) {
+        const promises = Object.entries(projection.relations).map(async ([prefix, subProjection]) => this.reprojectRelationInPlace(caller, records, prefix, subProjection));
+        await Promise.all(promises);
+    }
+    async reprojectRelationInPlace(caller, records, name, projection) {
+        const schema = this.schema.fields[name];
+        const association = this.dataSource.getCollection(schema.foreignCollection);
+        if (!this.relations[name]) {
+            await association.reprojectInPlace(caller, records.map(r => r[name]).filter(Boolean), projection);
+        }
+        else if (schema.type === 'ManyToOne') {
+            const ids = records.map(record => record[schema.foreignKey]).filter(fk => fk !== null);
+            const subFilter = new datasource_toolkit_1.Filter({
+                conditionTree: new datasource_toolkit_1.ConditionTreeLeaf(schema.foreignKeyTarget, 'In', [...new Set(ids)]),
+            });
+            const subRecords = await association.list(caller, subFilter, projection.union([schema.foreignKeyTarget]));
+            for (const record of records) {
+                record[name] = subRecords.find(sr => sr[schema.foreignKeyTarget] === record[schema.foreignKey]);
+            }
+        }
+        else if (schema.type === 'OneToOne' || schema.type === 'OneToMany') {
+            const ids = records.map(record => record[schema.originKeyTarget]).filter(okt => okt !== null);
+            const subFilter = new datasource_toolkit_1.Filter({
+                conditionTree: new datasource_toolkit_1.ConditionTreeLeaf(schema.originKey, 'In', [...new Set(ids)]),
+            });
+            const subRecords = await association.list(caller, subFilter, projection.union([schema.originKey]));
+            for (const record of records) {
+                record[name] = subRecords.find(sr => sr[schema.originKey] === record[schema.originKeyTarget]);
+            }
+        }
+    }
+}
+exports.default = RelationCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../src/decorators/relation/collection.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+import { ManyToManySchema, ManyToOneSchema, OneToManySchema, OneToOneSchema } from '@forestadmin/datasource-toolkit';
+declare type PartialBy<T, K extends Extract<keyof T, string>> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare type RelationDefinition = PartialBy<ManyToOneSchema, 'foreignKeyTarget'> | PartialBy<OneToManySchema | OneToOneSchema, 'originKeyTarget'> | PartialBy<ManyToManySchema, 'foreignKeyTarget' | 'originKeyTarget'>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/decorators/relation/types.js

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

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

@@ -0,0 +1,15 @@
+import { CollectionSchema } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+import CollectionRenameDataSourceDecorator from './datasource';
+/**
+ * This decorator renames collections.
+ * It should be used with RenameCollectionDataSourceDecorator, and not the raw DataSourceDecorator
+ */
+export default class RenameCollectionCollectionDecorator extends CollectionDecorator {
+    readonly dataSource: CollectionRenameDataSourceDecorator;
+    private substitutedName;
+    get name(): string;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    private getNewName;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/rename-collection/collection.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+/**
+ * This decorator renames collections.
+ * It should be used with RenameCollectionDataSourceDecorator, and not the raw DataSourceDecorator
+ */
+class RenameCollectionCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.substitutedName = null;
+    }
+    get name() {
+        return this.substitutedName ?? this.childCollection.name;
+    }
+    /** @internal */
+    rename(name) {
+        this.substitutedName = name;
+        // Invalidate all schemas
+        for (const collection of this.dataSource.collections) {
+            collection.markSchemaAsDirty();
+        }
+    }
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [name, oldSchema] of Object.entries(childSchema.fields)) {
+            const schema = { ...oldSchema };
+            if (schema.type === 'ManyToOne') {
+                schema.foreignCollection = this.getNewName(schema.foreignCollection);
+            }
+            else if (schema.type === 'OneToMany' || schema.type === 'OneToOne') {
+                schema.foreignCollection = this.getNewName(schema.foreignCollection);
+            }
+            else if (schema.type === 'ManyToMany') {
+                schema.throughCollection = this.getNewName(schema.throughCollection);
+                schema.foreignCollection = this.getNewName(schema.foreignCollection);
+            }
+            fields[name] = schema;
+        }
+        return { ...childSchema, fields };
+    }
+    getNewName(oldName) {
+        return this.dataSource.collections.find(c => c.childCollection.name === oldName).name;
+    }
+}
+exports.default = RenameCollectionCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3JlbmFtZS1jb2xsZWN0aW9uL2NvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSxtRkFBMEQ7QUFHMUQ7OztHQUdHO0FBQ0gsTUFBcUIsbUNBQW9DLFNBQVEsOEJBQW1CO0lBQXBGOztRQUdVLG9CQUFlLEdBQVcsSUFBSSxDQUFDO0lBd0N6QyxDQUFDO0lBdENDLElBQWEsSUFBSTtRQUNmLE9BQU8sSUFBSSxDQUFDLGVBQWUsSUFBSSxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQztJQUMzRCxDQUFDO0lBRUQsZ0JBQWdCO0lBQ2hCLE1BQU0sQ0FBQyxJQUFZO1FBQ2pCLElBQUksQ0FBQyxlQUFlLEdBQUcsSUFBSSxDQUFDO1FBRTVCLHlCQUF5QjtRQUN6QixLQUFLLE1BQU0sVUFBVSxJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxFQUFFO1lBQ3BELFVBQVUsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1NBQ2hDO0lBQ0gsQ0FBQztJQUVrQixZQUFZLENBQUMsV0FBNkI7UUFDM0QsTUFBTSxNQUFNLEdBQWdDLEVBQUUsQ0FBQztRQUUvQyxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLEVBQUU7WUFDbEUsTUFBTSxNQUFNLEdBQUcsRUFBRSxHQUFHLFNBQVMsRUFBRSxDQUFDO1lBRWhDLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxXQUFXLEVBQUU7Z0JBQy9CLE1BQU0sQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO2FBQ3RFO2lCQUFNLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxVQUFVLEVBQUU7Z0JBQ3BFLE1BQU0sQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO2FBQ3RFO2lCQUFNLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxZQUFZLEVBQUU7Z0JBQ3ZDLE1BQU0sQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO2dCQUNyRSxNQUFNLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQzthQUN0RTtZQUVELE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUM7U0FDdkI7UUFFRCxPQUFPLEVBQUUsR0FBRyxXQUFXLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDcEMsQ0FBQztJQUVPLFVBQVUsQ0FBQyxPQUFlO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxJQUFJLEtBQUssT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQ3hGLENBQUM7Q0FDRjtBQTNDRCxzREEyQ0MifQ==

package/dist/decorators/rename-collection/datasource.d.ts

@@ -0,0 +1,11 @@
+import { DataSource } from '@forestadmin/datasource-toolkit';
+import DataSourceDecorator from '../datasource-decorator';
+import RenameCollectionCollectionDecorator from './collection';
+export default class RenameCollectionDataSourceDecorator extends DataSourceDecorator<RenameCollectionCollectionDecorator> {
+    constructor(childDataSource: DataSource);
+    renameCollection(oldName: string, newName: string): void;
+    renameCollections(rename?: {
+        [newName: string]: string;
+    }): void;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/decorators/rename-collection/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 datasource_decorator_1 = __importDefault(require("../datasource-decorator"));
+const collection_1 = __importDefault(require("./collection"));
+class RenameCollectionDataSourceDecorator extends datasource_decorator_1.default {
+    constructor(childDataSource) {
+        super(childDataSource, collection_1.default);
+    }
+    renameCollection(oldName, newName) {
+        if (!this._collections[oldName]) {
+            throw new Error(`The given collection name "${oldName}" does not exist`);
+        }
+        if (this._collections[newName]) {
+            throw new Error(`The given new collection name "${newName}" is already defined in the dataSource`);
+        }
+        if (oldName !== newName) {
+            const collection = this._collections[oldName];
+            collection.rename(newName);
+            this._collections[newName] = collection;
+            delete this._collections[oldName];
+        }
+    }
+    renameCollections(rename) {
+        for (const [oldName, newName] of Object.entries(rename ?? {})) {
+            this.renameCollection(oldName, newName);
+        }
+    }
+}
+exports.default = RenameCollectionDataSourceDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3JlbmFtZS1jb2xsZWN0aW9uL2RhdGFzb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSxtRkFBMEQ7QUFDMUQsOERBQStEO0FBRS9ELE1BQXFCLG1DQUFvQyxTQUFRLDhCQUF3RDtJQUN2SCxZQUFZLGVBQTJCO1FBQ3JDLEtBQUssQ0FBQyxlQUFlLEVBQUUsb0JBQW1DLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsZ0JBQWdCLENBQUMsT0FBZSxFQUFFLE9BQWU7UUFDL0MsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDL0IsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsT0FBTyxrQkFBa0IsQ0FBQyxDQUFDO1NBQzFFO1FBRUQsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQzlCLE1BQU0sSUFBSSxLQUFLLENBQ2Isa0NBQWtDLE9BQU8sd0NBQXdDLENBQ2xGLENBQUM7U0FDSDtRQUVELElBQUksT0FBTyxLQUFLLE9BQU8sRUFBRTtZQUN2QixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBd0MsQ0FBQztZQUNyRixVQUFVLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBRTNCLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsVUFBVSxDQUFDO1lBQ3hDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUNuQztJQUNILENBQUM7SUFFRCxpQkFBaUIsQ0FBQyxNQUFzQztRQUN0RCxLQUFLLE1BQU0sQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDLEVBQUU7WUFDN0QsSUFBSSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztTQUN6QztJQUNILENBQUM7Q0FDRjtBQTlCRCxzREE4QkMifQ==

package/dist/decorators/rename-field/collection.d.ts

@@ -0,0 +1,33 @@
+import { AggregateResult, Aggregation, Caller, CollectionSchema, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+/**
+ * This decorator renames fields.
+ *
+ * It works on one side, by rewriting all references to fields in aggregations, filters, projections
+ * and on the other, by rewriting records and aggregation results which are returned by the
+ * subCollection.
+ */
+export default class RenameFieldCollectionDecorator extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<RenameFieldCollectionDecorator>;
+    private readonly fromChildCollection;
+    private readonly toChildCollection;
+    /** Rename a field from the collection */
+    renameField(currentName: string, newName: string): void;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    protected refineFilter(caller: Caller, filter?: PaginatedFilter): Promise<PaginatedFilter>;
+    create(caller: Caller, records: RecordData[]): Promise<RecordData[]>;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    private markAllSchemaAsDirty;
+    /** Convert field path from child collection to this collection */
+    private pathFromChildCollection;
+    /** Convert field path from this collection to child collection */
+    private pathToChildCollection;
+    /** Convert record from this collection to the child collection */
+    private recordToChildCollection;
+    /** Convert record from the child collection to this collection */
+    private recordFromChildCollection;
+}
+//# sourceMappingURL=collection.d.ts.map