@forestadmin/datasource-customizer 1.0.0-alpha.1

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

@@ -0,0 +1,149 @@
+"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 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.
+ */
+class RenameFieldCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.fromChildCollection = {};
+        this.toChildCollection = {};
+    }
+    /** Rename a field from the collection */
+    renameField(currentName, newName) {
+        if (!this.schema.fields[currentName]) {
+            throw new Error(`No such field '${currentName}'`);
+        }
+        let initialName = currentName;
+        // Revert previous renaming (avoids conflicts and need to recurse on this.toSubCollection).
+        if (this.toChildCollection[currentName]) {
+            const childName = this.toChildCollection[currentName];
+            delete this.toChildCollection[currentName];
+            delete this.fromChildCollection[childName];
+            initialName = childName;
+            this.markAllSchemaAsDirty();
+        }
+        // Do not update arrays if renaming is a no-op (ie: customer is cancelling a previous rename).
+        if (initialName !== newName) {
+            this.fromChildCollection[initialName] = newName;
+            this.toChildCollection[newName] = initialName;
+            this.markAllSchemaAsDirty();
+        }
+    }
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [oldName, oldSchema] of Object.entries(childSchema.fields)) {
+            const schema = { ...oldSchema };
+            if (schema.type === 'ManyToOne') {
+                schema.foreignKey = this.fromChildCollection[schema.foreignKey] ?? schema.foreignKey;
+            }
+            else if (schema.type === 'OneToMany' || schema.type === 'OneToOne') {
+                const relation = this.dataSource.getCollection(schema.foreignCollection);
+                schema.originKey = relation.fromChildCollection[schema.originKey] ?? schema.originKey;
+            }
+            else if (schema.type === 'ManyToMany') {
+                const through = this.dataSource.getCollection(schema.throughCollection);
+                schema.foreignKey = through.fromChildCollection[schema.foreignKey] ?? schema.foreignKey;
+                schema.originKey = through.fromChildCollection[schema.originKey] ?? schema.originKey;
+            }
+            fields[this.fromChildCollection[oldName] ?? oldName] = schema;
+        }
+        return { ...childSchema, fields };
+    }
+    async refineFilter(caller, filter) {
+        return filter?.override({
+            conditionTree: filter.conditionTree?.replaceFields(field => this.pathToChildCollection(field)),
+            sort: filter.sort?.replaceClauses(clause => ({
+                field: this.pathToChildCollection(clause.field),
+                ascending: clause.ascending,
+            })),
+        });
+    }
+    async create(caller, records) {
+        const newRecords = await super.create(caller, records.map(record => this.recordToChildCollection(record)));
+        return newRecords.map(record => this.recordFromChildCollection(record));
+    }
+    async list(caller, filter, projection) {
+        const childProjection = projection.replace(field => this.pathToChildCollection(field));
+        const records = await super.list(caller, filter, childProjection);
+        return records.map(record => this.recordFromChildCollection(record));
+    }
+    async update(caller, filter, patch) {
+        return super.update(caller, filter, this.recordToChildCollection(patch));
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        const rows = await super.aggregate(caller, filter, aggregation.replaceFields(f => this.pathToChildCollection(f)), limit);
+        return rows.map(row => ({
+            value: row.value,
+            group: Object.entries(row.group).reduce((memo, [path, value]) => ({ ...memo, [this.pathFromChildCollection(path)]: value }), {}),
+        }));
+    }
+    markAllSchemaAsDirty() {
+        for (const collection of this.dataSource.collections) {
+            collection.markSchemaAsDirty();
+        }
+    }
+    /** Convert field path from child collection to this collection */
+    pathFromChildCollection(childPath) {
+        if (childPath.includes(':')) {
+            const dotIndex = childPath.indexOf(':');
+            const childField = childPath.substring(0, dotIndex);
+            const thisField = this.fromChildCollection[childField] ?? childField;
+            const schema = this.schema.fields[thisField];
+            const relation = this.dataSource.getCollection(schema.foreignCollection);
+            return `${thisField}:${relation.pathFromChildCollection(childPath.substring(dotIndex + 1))}`;
+        }
+        return this.fromChildCollection[childPath] ?? childPath;
+    }
+    /** Convert field path from this collection to child collection */
+    pathToChildCollection(thisPath) {
+        if (thisPath.includes(':')) {
+            const dotIndex = thisPath.indexOf(':');
+            const thisField = thisPath.substring(0, dotIndex);
+            const schema = this.schema.fields[thisField];
+            const relation = this.dataSource.getCollection(schema.foreignCollection);
+            const childField = this.toChildCollection[thisField] ?? thisField;
+            return `${childField}:${relation.pathToChildCollection(thisPath.substring(dotIndex + 1))}`;
+        }
+        return this.toChildCollection[thisPath] ?? thisPath;
+    }
+    /** Convert record from this collection to the child collection */
+    recordToChildCollection(thisRecord) {
+        const childRecord = {};
+        for (const [thisField, value] of Object.entries(thisRecord)) {
+            childRecord[this.toChildCollection[thisField] ?? thisField] = value;
+        }
+        return childRecord;
+    }
+    /** Convert record from the child collection to this collection */
+    recordFromChildCollection(childRecord) {
+        const { schema } = this;
+        const thisRecord = {};
+        for (const [childField, value] of Object.entries(childRecord)) {
+            const thisField = this.fromChildCollection[childField] ?? childField;
+            const fieldSchema = schema.fields[thisField];
+            // Perform the mapping, recurse for relations.
+            if (fieldSchema.type === 'Column') {
+                thisRecord[thisField] = value;
+            }
+            else if (value === null) {
+                thisRecord[thisField] = value;
+            }
+            else {
+                const relation = this.dataSource.getCollection(fieldSchema.foreignCollection);
+                thisRecord[thisField] = relation.recordFromChildCollection(value);
+            }
+        }
+        return thisRecord;
+    }
+}
+exports.default = RenameFieldCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../src/decorators/rename-field/collection.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,13 @@
+import { CollectionSchema } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+/**
+ * This decorator allows to override parts of the collections schema.
+ * It can be used to toggle off collection level capabilities for performance
+ * (for now, list-view counts and the search bar)
+ */
+export default class SchemaCollectionDecorator extends CollectionDecorator {
+    private schemaOverride;
+    overrideSchema(value: Partial<CollectionSchema>): void;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/schema/collection.js

@@ -0,0 +1,26 @@
+"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 to override parts of the collections schema.
+ * It can be used to toggle off collection level capabilities for performance
+ * (for now, list-view counts and the search bar)
+ */
+class SchemaCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.schemaOverride = {};
+    }
+    overrideSchema(value) {
+        Object.assign(this.schemaOverride, value);
+        this.markSchemaAsDirty();
+    }
+    refineSchema(subSchema) {
+        return { ...subSchema, ...this.schemaOverride };
+    }
+}
+exports.default = SchemaCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3NjaGVtYS9jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQ0EsbUZBQTBEO0FBRTFEOzs7O0dBSUc7QUFDSCxNQUFxQix5QkFBMEIsU0FBUSw4QkFBbUI7SUFBMUU7O1FBQ1UsbUJBQWMsR0FBOEIsRUFBRSxDQUFDO0lBVXpELENBQUM7SUFSQyxjQUFjLENBQUMsS0FBZ0M7UUFDN0MsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsY0FBYyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzFDLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFa0IsWUFBWSxDQUFDLFNBQTJCO1FBQ3pELE9BQU8sRUFBRSxHQUFHLFNBQVMsRUFBRSxHQUFHLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFYRCw0Q0FXQyJ9

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

@@ -0,0 +1,14 @@
+import { Caller, CollectionSchema, PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import { SearchDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+export default class SearchCollectionDecorator extends CollectionDecorator {
+    replacer: SearchDefinition;
+    replaceSearch(replacer: SearchDefinition): void;
+    refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    refineFilter(caller: Caller, filter?: PaginatedFilter): Promise<PaginatedFilter>;
+    private defaultReplacer;
+    private static buildCondition;
+    private static getFields;
+    private static lenientFind;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/search/collection.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const uuid_1 = require("uuid");
+const collection_context_1 = __importDefault(require("../../context/collection-context"));
+const collection_decorator_1 = __importDefault(require("../collection-decorator"));
+class SearchCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.replacer = null;
+    }
+    replaceSearch(replacer) {
+        this.replacer = replacer;
+    }
+    refineSchema(subSchema) {
+        return { ...subSchema, searchable: true };
+    }
+    async refineFilter(caller, filter) {
+        // Search string is not significant
+        if (!filter?.search?.trim().length) {
+            return filter.override({ search: null });
+        }
+        // Implement search ourselves
+        if (this.replacer || !this.childCollection.schema.searchable) {
+            const ctx = new collection_context_1.default(this, caller);
+            let tree = this.defaultReplacer(filter.search, filter.searchExtended);
+            if (this.replacer) {
+                const plainTree = await this.replacer(filter.search, filter.searchExtended, ctx);
+                tree = datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(plainTree);
+            }
+            // Note that if no fields are searchable with the provided searchString, the conditions
+            // array might be empty, which will create a condition returning zero records
+            // (this is the desired behavior).
+            return filter.override({
+                conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(filter.conditionTree, tree),
+                search: null,
+            });
+        }
+        // Let subcollection deal with the search
+        return filter;
+    }
+    defaultReplacer(search, extended) {
+        const searchableFields = SearchCollectionDecorator.getFields(this.childCollection, extended);
+        const conditions = searchableFields
+            .map(([field, schema]) => SearchCollectionDecorator.buildCondition(field, schema, search))
+            .filter(Boolean);
+        return datasource_toolkit_1.ConditionTreeFactory.union(...conditions);
+    }
+    static buildCondition(field, schema, searchString) {
+        const { columnType, enumValues, filterOperators } = schema;
+        const isNumber = Number(searchString).toString() === searchString;
+        const isUuid = (0, uuid_1.validate)(searchString);
+        if (columnType === 'Number' && isNumber && filterOperators?.has('Equal')) {
+            return new datasource_toolkit_1.ConditionTreeLeaf(field, 'Equal', Number(searchString));
+        }
+        if (columnType === 'Enum' && filterOperators?.has('Equal')) {
+            const searchValue = SearchCollectionDecorator.lenientFind(enumValues, searchString);
+            if (searchValue)
+                return new datasource_toolkit_1.ConditionTreeLeaf(field, 'Equal', searchValue);
+        }
+        if (columnType === 'String') {
+            const isCaseSensitive = searchString.toLocaleLowerCase() !== searchString.toLocaleUpperCase();
+            const supportsIContains = filterOperators?.has('IContains');
+            const supportsContains = filterOperators?.has('Contains');
+            const supportsEqual = filterOperators?.has('Equal');
+            // Perf: don't use case-insensitive operator when the search string is indifferent to case
+            let operator;
+            if (supportsIContains && (isCaseSensitive || !supportsContains))
+                operator = 'IContains';
+            else if (supportsContains)
+                operator = 'Contains';
+            else if (supportsEqual)
+                operator = 'Equal';
+            if (operator)
+                return new datasource_toolkit_1.ConditionTreeLeaf(field, operator, searchString);
+        }
+        if (columnType === 'Uuid' && isUuid && filterOperators?.has('Equal')) {
+            return new datasource_toolkit_1.ConditionTreeLeaf(field, 'Equal', searchString);
+        }
+        return null;
+    }
+    static getFields(collection, extended) {
+        const fields = [];
+        for (const [name, field] of Object.entries(collection.schema.fields)) {
+            if (field.type === 'Column')
+                fields.push([name, field]);
+            if (extended && (field.type === 'ManyToOne' || field.type === 'OneToOne')) {
+                const related = collection.dataSource.getCollection(field.foreignCollection);
+                for (const [subName, subField] of Object.entries(related.schema.fields))
+                    if (subField.type === 'Column')
+                        fields.push([`${name}:${subName}`, subField]);
+            }
+        }
+        return fields;
+    }
+    static lenientFind(haystack, needle) {
+        return (haystack?.find(v => v === needle.trim()) ??
+            haystack?.find(v => v.toLocaleLowerCase() === needle.toLocaleLowerCase().trim()));
+    }
+}
+exports.default = SearchCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/decorators/search/types.js

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

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

@@ -0,0 +1,10 @@
+import { Caller, CollectionSchema, PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import { SegmentDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+export default class SegmentCollectionDecorator extends CollectionDecorator {
+    private segments;
+    addSegment(segmentName: string, definition: SegmentDefinition): void;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    refineFilter(caller: Caller, filter?: PaginatedFilter): Promise<PaginatedFilter>;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/segment/collection.js

@@ -0,0 +1,43 @@
+"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"));
+class SegmentCollectionDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.segments = {};
+    }
+    addSegment(segmentName, definition) {
+        this.segments[segmentName] = definition;
+        this.markSchemaAsDirty();
+    }
+    refineSchema(subSchema) {
+        return {
+            ...subSchema,
+            segments: [...subSchema.segments, ...Object.keys(this.segments)],
+        };
+    }
+    async refineFilter(caller, filter) {
+        if (!filter) {
+            return null;
+        }
+        let { conditionTree, segment } = filter;
+        if (segment && this.segments[segment]) {
+            const definition = this.segments[segment];
+            const result = typeof definition === 'function'
+                ? await definition(new collection_context_1.default(this, caller))
+                : await definition;
+            const conditionTreeSegment = result instanceof datasource_toolkit_1.ConditionTree ? result : datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(result);
+            datasource_toolkit_1.ConditionTreeValidator.validate(conditionTreeSegment, this);
+            conditionTree = datasource_toolkit_1.ConditionTreeFactory.intersect(conditionTree, conditionTreeSegment);
+            segment = null;
+        }
+        return filter.override({ conditionTree, segment });
+    }
+}
+exports.default = SegmentCollectionDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3NlZ21lbnQvY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHdFQU95QztBQUV6QywwRkFBOEU7QUFDOUUsbUZBQTBEO0FBRTFELE1BQXFCLDBCQUEyQixTQUFRLDhCQUFtQjtJQUEzRTs7UUFDVSxhQUFRLEdBQTBDLEVBQUUsQ0FBQztJQTBDL0QsQ0FBQztJQXhDQyxVQUFVLENBQUMsV0FBbUIsRUFBRSxVQUE2QjtRQUMzRCxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxHQUFHLFVBQVUsQ0FBQztRQUN4QyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRWtCLFlBQVksQ0FBQyxTQUEyQjtRQUN6RCxPQUFPO1lBQ0wsR0FBRyxTQUFTO1lBQ1osUUFBUSxFQUFFLENBQUMsR0FBRyxTQUFTLENBQUMsUUFBUSxFQUFFLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDakUsQ0FBQztJQUNKLENBQUM7SUFFZSxLQUFLLENBQUMsWUFBWSxDQUNoQyxNQUFjLEVBQ2QsTUFBd0I7UUFFeEIsSUFBSSxDQUFDLE1BQU0sRUFBRTtZQUNYLE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFFRCxJQUFJLEVBQUUsYUFBYSxFQUFFLE9BQU8sRUFBRSxHQUFHLE1BQU0sQ0FBQztRQUV4QyxJQUFJLE9BQU8sSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ3JDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDMUMsTUFBTSxNQUFNLEdBQ1YsT0FBTyxVQUFVLEtBQUssVUFBVTtnQkFDOUIsQ0FBQyxDQUFDLE1BQU0sVUFBVSxDQUFDLElBQUksNEJBQThCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO2dCQUNwRSxDQUFDLENBQUMsTUFBTSxVQUFVLENBQUM7WUFFdkIsTUFBTSxvQkFBb0IsR0FDeEIsTUFBTSxZQUFZLGtDQUFhLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMseUNBQW9CLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBRTFGLDJDQUFzQixDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUU1RCxhQUFhLEdBQUcseUNBQW9CLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1lBQ3BGLE9BQU8sR0FBRyxJQUFJLENBQUM7U0FDaEI7UUFFRCxPQUFPLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxhQUFhLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUNyRCxDQUFDO0NBQ0Y7QUEzQ0QsNkNBMkNDIn0=

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

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

package/dist/decorators/segment/types.js

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

package/dist/decorators/sort-emulate/collection.d.ts

@@ -0,0 +1,15 @@
+import { Caller, CollectionSchema, PaginatedFilter, PlainSortClause, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+export default class SortEmulate extends CollectionDecorator {
+    readonly dataSource: DataSourceDecorator<SortEmulate>;
+    private readonly sorts;
+    emulateFieldSorting(name: string): void;
+    replaceFieldSorting(name: string, equivalentSort: PlainSortClause[]): void;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    private sortRecords;
+    private rewritePlainSortClause;
+    private isEmulated;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/sort-emulate/collection.js

@@ -0,0 +1,97 @@
+"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 SortEmulate extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.sorts = new Map();
+    }
+    emulateFieldSorting(name) {
+        this.replaceFieldSorting(name, null);
+    }
+    replaceFieldSorting(name, equivalentSort) {
+        datasource_toolkit_1.FieldValidator.validate(this, name);
+        const field = this.childCollection.schema.fields[name];
+        if (!field)
+            throw new Error('Cannot replace sort on relation');
+        this.sorts.set(name, equivalentSort ? new datasource_toolkit_1.Sort(...equivalentSort) : null);
+        this.markSchemaAsDirty();
+    }
+    async list(caller, filter, projection) {
+        const childFilter = filter.override({
+            sort: filter.sort?.replaceClauses(clause => this.rewritePlainSortClause(clause)),
+        });
+        if (!childFilter.sort?.some(({ field }) => this.isEmulated(field))) {
+            return this.childCollection.list(caller, childFilter, projection);
+        }
+        // Fetch the whole collection, but only with the fields we need to sort
+        let referenceRecords;
+        referenceRecords = await this.childCollection.list(caller, childFilter.override({ sort: null, page: null }), childFilter.sort.projection.withPks(this));
+        referenceRecords = childFilter.sort.apply(referenceRecords);
+        if (childFilter.page)
+            referenceRecords = childFilter.page.apply(referenceRecords);
+        // We now have the information we need to sort by the field
+        const newFilter = new datasource_toolkit_1.Filter({
+            conditionTree: datasource_toolkit_1.ConditionTreeFactory.matchRecords(this.schema, referenceRecords),
+        });
+        let records;
+        records = await this.childCollection.list(caller, newFilter, projection.withPks(this));
+        records = this.sortRecords(referenceRecords, records);
+        records = projection.apply(records);
+        return records;
+    }
+    refineSchema(childSchema) {
+        const fields = {};
+        for (const [name, schema] of Object.entries(childSchema.fields)) {
+            fields[name] =
+                this.sorts.has(name) && schema.type === 'Column' ? { ...schema, isSortable: true } : schema;
+        }
+        return { ...childSchema, fields };
+    }
+    sortRecords(referenceRecords, records) {
+        const positionById = {};
+        const sorted = new Array(records.length);
+        for (const [index, record] of referenceRecords.entries()) {
+            positionById[datasource_toolkit_1.RecordUtils.getPrimaryKey(this.schema, record).join('|')] = index;
+        }
+        for (const record of records) {
+            const id = datasource_toolkit_1.RecordUtils.getPrimaryKey(this.schema, record).join('|');
+            sorted[positionById[id]] = record;
+        }
+        return sorted;
+    }
+    rewritePlainSortClause(clause) {
+        // Order by is targeting a field on another collection => recurse.
+        if (clause.field.includes(':')) {
+            const [prefix] = clause.field.split(':');
+            const schema = this.schema.fields[prefix];
+            const association = this.dataSource.getCollection(schema.foreignCollection);
+            return new datasource_toolkit_1.Sort(clause)
+                .unnest()
+                .replaceClauses(subClause => association.rewritePlainSortClause(subClause))
+                .nest(prefix);
+        }
+        // Field that we own: recursively replace using equivalent sort
+        let equivalentSort = this.sorts.get(clause.field);
+        if (equivalentSort) {
+            if (!clause.ascending)
+                equivalentSort = equivalentSort.inverse();
+            return equivalentSort.replaceClauses(subClause => this.rewritePlainSortClause(subClause));
+        }
+        return new datasource_toolkit_1.Sort(clause);
+    }
+    isEmulated(path) {
+        const index = path.indexOf(':');
+        if (index === -1)
+            return this.sorts.has(path);
+        const { foreignCollection } = this.schema.fields[path.substring(0, index)];
+        const association = this.dataSource.getCollection(foreignCollection);
+        return association.isEmulated(path.substring(index + 1));
+    }
+}
+exports.default = SortEmulate;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { Caller, CollectionSchema, ColumnSchema, Filter, RecordData } from '@forestadmin/datasource-toolkit';
+import CollectionDecorator from '../collection-decorator';
+declare type ValidationRule = ColumnSchema['validation'][number];
+export default class ValidationDecorator extends CollectionDecorator {
+    private validation;
+    addValidation(name: string, validation: ValidationRule): void;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    protected refineSchema(subSchema: CollectionSchema): CollectionSchema;
+    private validate;
+    /**
+     * Deduplicate rules which the frontend understand
+     * We ignore other rules as duplications are not an issue within the agent
+     */
+    private static deduplicate;
+    private static min;
+    private static max;
+}
+export {};
+//# sourceMappingURL=collection.d.ts.map