@forestadmin/datasource-mongoose 1.0.0-beta.8 → 1.0.0

package/dist/collection.d.ts

@@ -1,12 +1,15 @@
-import { AggregateResult, BaseCollection, DataSource, RecordData } from '@forestadmin/datasource-toolkit';
+import { AggregateResult, Aggregation, BaseCollection, Caller, DataSource, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
 import { Model } from 'mongoose';
 export default class MongooseCollection extends BaseCollection {
-    private readonly model;
-    constructor(dataSource: DataSource, model: Model<RecordData>);
-    create(): Promise<RecordData[]>;
-    list(): Promise<RecordData[]>;
-    update(): Promise<void>;
-    delete(): Promise<void>;
-    aggregate(): Promise<AggregateResult[]>;
+    model: Model<RecordData>;
+    prefix: string;
+    ignoredFields: string[];
+    constructor(dataSource: DataSource, model: Model<RecordData>, prefix?: string, ignoredFields?: string[]);
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    list(caller: Caller, filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    delete(caller: Caller, filter: Filter): Promise<void>;
+    aggregate(caller: Caller, filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+    private buildBasePipeline;
 }
 //# sourceMappingURL=collection.d.ts.map

package/dist/collection.js

@@ -3,30 +3,139 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable no-underscore-dangle */
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
-const schema_fields_generator_1 = __importDefault(require("./utils/schema-fields-generator"));
+const helpers_1 = require("./utils/helpers");
+const fields_1 = __importDefault(require("./utils/schema/fields"));
+const filter_1 = __importDefault(require("./utils/pipeline/filter"));
+const group_1 = __importDefault(require("./utils/pipeline/group"));
+const lookup_1 = __importDefault(require("./utils/pipeline/lookup"));
+const schema_1 = __importDefault(require("./mongoose/schema"));
+const projection_1 = __importDefault(require("./utils/pipeline/projection"));
+const reparent_1 = __importDefault(require("./utils/pipeline/reparent"));
+const virtual_fields_1 = __importDefault(require("./utils/pipeline/virtual-fields"));
 class MongooseCollection extends datasource_toolkit_1.BaseCollection {
-    constructor(dataSource, model) {
-        super(model.modelName, dataSource);
+    constructor(dataSource, model, prefix = null, ignoredFields = []) {
+        super(prefix ? (0, helpers_1.escape)(`${model.modelName}.${prefix}`) : model.modelName, dataSource);
         this.model = model;
+        this.prefix = prefix;
+        this.ignoredFields = ignoredFields;
         this.enableCount();
-        this.addFields(schema_fields_generator_1.default.buildFieldsSchema(model));
+        this.addFields(fields_1.default.buildFieldsSchema(model, prefix, ignoredFields));
     }
-    async create() {
-        throw new Error('not implemented');
+    async create(caller, data) {
+        // If there is no prefix, we can delegate the work to mongoose directly.
+        if (!this.prefix) {
+            const { insertedIds } = await this.model.insertMany(data, { rawResult: true });
+            return data.map((record, index) => ({ _id: insertedIds[index], ...record }));
+        }
+        // Transform list of subrecords to a list of modifications that we'll apply to the root record.
+        const fieldName = this.prefix.substring(this.prefix.lastIndexOf('.') + 1);
+        const schema = schema_1.default.fromModel(this.model).getSubSchema(this.prefix);
+        const updates = new Map();
+        const results = [];
+        for (const record of data) {
+            const { _pid, ...rest } = record;
+            if (!_pid)
+                throw new datasource_toolkit_1.ValidationError('Trying to create a subrecord with no parent');
+            const [rootId, path] = (0, helpers_1.splitId)(`${_pid}.${fieldName}`);
+            if (!updates.has(rootId))
+                updates.set(rootId, { path, records: [] });
+            // unwrap 'content' on leafs
+            updates.get(rootId).records.push(schema.isLeaf ? rest.content : rest);
+            results.push({
+                _id: schema.isArray // arrays have indexes in their ids
+                    ? `${rootId}.${path}.${updates.get(rootId).records.length - 1}`
+                    : `${rootId}.${path}`,
+                ...record,
+            });
+        }
+        // Apply the modifications to the root document.
+        const promises = [...updates.entries()].map(async ([rootId, { path, records }]) => this.model.updateOne({ _id: rootId }, schema.isArray
+            ? { $push: { [path]: { $each: records, position: 0 } } }
+            : { $set: { [path]: records[0] } }, { rawResult: true }));
+        await Promise.all(promises);
+        return results;
     }
-    async list() {
-        throw new Error('not implemented');
+    async list(caller, filter, projection) {
+        const lookupProjection = projection.union(filter.conditionTree?.projection, filter.sort?.projection);
+        const records = await this.model.aggregate([
+            ...this.buildBasePipeline(filter, lookupProjection),
+            ...projection_1.default.project(projection),
+        ]);
+        return (0, helpers_1.replaceMongoTypes)(records);
     }
-    async update() {
-        throw new Error('not implemented');
+    async update(caller, filter, patch) {
+        const records = await this.list(caller, filter, new datasource_toolkit_1.Projection('_id'));
+        const ids = records.map(record => record._id);
+        if (!this.prefix) {
+            await this.model.updateMany({ _id: ids }, patch, { rawResult: true });
+            return;
+        }
+        // Clean patch
+        const schema = schema_1.default.fromModel(this.model).getSubSchema(this.prefix);
+        let cleanPatch = { ...patch };
+        delete cleanPatch._id; // Virtual field
+        delete cleanPatch._pid; // Ignore _pids: they should not be editable from the frontend.
+        if (Object.keys(cleanPatch).length === 0)
+            return;
+        if (schema.isLeaf)
+            cleanPatch = cleanPatch.content;
+        // Perform update
+        const idsByPath = (0, helpers_1.groupIdsByPath)(ids);
+        const promises = Object.entries(idsByPath).map(async ([path, rootIds]) => this.model.updateMany({ _id: rootIds }, { [path]: cleanPatch }, { rawResult: true }));
+        await Promise.all(promises);
     }
-    async delete() {
-        throw new Error('not implemented');
+    async delete(caller, filter) {
+        const records = await this.list(caller, filter, new datasource_toolkit_1.Projection('_id'));
+        const ids = records.map(record => record._id);
+        if (!this.prefix) {
+            await this.model.deleteMany({ _id: ids }, { rawResult: true });
+            return;
+        }
+        const schema = schema_1.default.fromModel(this.model).getSubSchema(this.prefix);
+        const idsByPath = (0, helpers_1.groupIdsByPath)(ids);
+        if (schema.isArray) {
+            for (const path of Object.keys(idsByPath).sort(helpers_1.compareIds).reverse()) {
+                const arrayPath = path.substring(0, path.lastIndexOf('.'));
+                const index = Number(path.substring(path.lastIndexOf('.') + 1));
+                // There is no update operator to pop items out of arrays at known positions
+                // => we use an aggregation pipeline in the update operation
+                // @see https://jira.mongodb.org/browse/SERVER-1014?focusedCommentId=2305681#comment-2305681
+                const newArrayValue = [
+                    { $slice: [`$${arrayPath}`, index] },
+                    { $slice: [`$${arrayPath}`, index + 1, { $size: `$${arrayPath}` }] },
+                ];
+                // When updating arrays, indexes will change with each request so we need to perform the
+                // request sequentially.
+                // eslint-disable-next-line no-await-in-loop
+                await this.model.collection.updateMany({ _id: { $in: idsByPath[path] } }, [{ $set: { [arrayPath]: { $concatArrays: newArrayValue } } }], {});
+            }
+        }
+        else {
+            const promises = Object.entries(idsByPath).map(([path, pathIds]) => this.model.collection.updateMany({ _id: { $in: pathIds } }, { $unset: { [path]: '' } }, {}));
+            await Promise.all(promises);
+        }
     }
-    async aggregate() {
-        throw new Error('not implemented');
+    async aggregate(caller, filter, aggregation, limit) {
+        const lookupProjection = aggregation.projection.union(filter.conditionTree?.projection);
+        const rows = await this.model.aggregate([
+            ...this.buildBasePipeline(filter, lookupProjection),
+            ...group_1.default.group(aggregation),
+            { $sort: { value: -1 } },
+            ...(limit ? [{ $limit: limit }] : []),
+        ]);
+        return (0, helpers_1.replaceMongoTypes)(rows);
+    }
+    buildBasePipeline(filter, lookupProjection) {
+        return [
+            ...reparent_1.default.reparent(this.model, this.prefix),
+            ...virtual_fields_1.default.addVirtual(this.model, this.prefix, this.ignoredFields, lookupProjection),
+            ...lookup_1.default.lookup(this.model, this.prefix, lookupProjection),
+            ...filter_1.default.filter(this.model, this.prefix, filter),
+        ];
     }
 }
 exports.default = MongooseCollection;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBS3lDO0FBR3pDLDhGQUFvRTtBQUVwRSxNQUFxQixrQkFBbUIsU0FBUSxtQ0FBYztJQUc1RCxZQUFZLFVBQXNCLEVBQUUsS0FBd0I7UUFDMUQsS0FBSyxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFFbkIsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ25CLElBQUksQ0FBQyxTQUFTLENBQUMsaUNBQXFCLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRUQsS0FBSyxDQUFDLE1BQU07UUFDVixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELEtBQUssQ0FBQyxJQUFJO1FBQ1IsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxLQUFLLENBQUMsTUFBTTtRQUNWLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsS0FBSyxDQUFDLE1BQU07UUFDVixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELEtBQUssQ0FBQyxTQUFTO1FBQ2IsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7Q0FDRjtBQTlCRCxxQ0E4QkMifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"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"}

package/dist/datasource.d.ts

@@ -1,9 +1,12 @@
 import { BaseDataSource } from '@forestadmin/datasource-toolkit';
 import { Connection } from 'mongoose';
+import { MongooseOptions } from './types';
 import MongooseCollection from './collection';
 export default class MongooseDatasource extends BaseDataSource<MongooseCollection> {
-    private connection;
-    constructor(connection: Connection);
-    protected createCollections(): void;
+    constructor(connection: Connection, options?: MongooseOptions);
+    /** Create all collections for a given model */
+    private addModel;
+    /** Get list of cuts for a given model */
+    private getCuts;
 }
 //# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.js

@@ -5,21 +5,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
 const collection_1 = __importDefault(require("./collection"));
-const schema_fields_generator_1 = __importDefault(require("./utils/schema-fields-generator"));
+const schema_1 = __importDefault(require("./mongoose/schema"));
+const relations_1 = __importDefault(require("./utils/schema/relations"));
 class MongooseDatasource extends datasource_toolkit_1.BaseDataSource {
-    constructor(connection) {
+    constructor(connection, options = {}) {
         super();
-        if (!connection)
-            throw new Error('Invalid (null) Mongoose instance.');
-        this.connection = connection;
-        this.createCollections();
+        // Create collections (with only many to one relations).
+        for (const model of Object.values(connection.models)) {
+            this.addModel(model, this.getCuts(options, model));
+        }
+        // Add one-to-many, one-to-one and many-to-many relations.
+        relations_1.default.addImplicitRelations(this.collections);
     }
-    createCollections() {
-        Object.values(this.connection.models).forEach(model => {
-            this.addCollection(new collection_1.default(this, model));
-        });
-        schema_fields_generator_1.default.addInverseRelationships(this.collections);
+    /** Create all collections for a given model */
+    addModel(model, cuts, prefix = null) {
+        const ignore = [...new Set([...cuts.columns, ...Object.keys(cuts.relations)])];
+        this.addCollection(new collection_1.default(this, model, prefix, ignore));
+        for (const name of ignore) {
+            const subProjection = cuts.relations[name] ?? new datasource_toolkit_1.Projection();
+            const subPrefix = prefix ? `${prefix}.${name}` : name;
+            this.addModel(model, subProjection, subPrefix);
+        }
+    }
+    /** Get list of cuts for a given model */
+    getCuts(options, model) {
+        // A list was provided by the customer, use it.
+        if (options?.asModels?.[model.modelName]) {
+            return new datasource_toolkit_1.Projection(...options.asModels[model.modelName].map(item => item.replace(/\./g, ':')));
+        }
+        // When no cuts are provided, only cut on list of references
+        const schema = schema_1.default.fromModel(model);
+        return new datasource_toolkit_1.Projection(...Object.keys(schema.fields).filter(field => schema.fields[field]?.['[]']?.options?.ref));
     }
 }
 exports.default = MongooseDatasource;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBQWlFO0FBR2pFLDhEQUE4QztBQUM5Qyw4RkFBb0U7QUFFcEUsTUFBcUIsa0JBQW1CLFNBQVEsbUNBQWtDO0lBR2hGLFlBQVksVUFBc0I7UUFDaEMsS0FBSyxFQUFFLENBQUM7UUFFUixJQUFJLENBQUMsVUFBVTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUV0RSxJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztRQUU3QixJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRVMsaUJBQWlCO1FBQ3pCLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDcEQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLG9CQUFrQixDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQzFELENBQUMsQ0FBQyxDQUFDO1FBQ0gsaUNBQXFCLENBQUMsdUJBQXVCLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7Q0FDRjtBQW5CRCxxQ0FtQkMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBQTZFO0FBSTdFLDhEQUE4QztBQUM5QywrREFBK0M7QUFDL0MseUVBQXlEO0FBRXpELE1BQXFCLGtCQUFtQixTQUFRLG1DQUFrQztJQUNoRixZQUFZLFVBQXNCLEVBQUUsVUFBMkIsRUFBRTtRQUMvRCxLQUFLLEVBQUUsQ0FBQztRQUVSLHdEQUF3RDtRQUN4RCxLQUFLLE1BQU0sS0FBSyxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ3BELElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7U0FDcEQ7UUFFRCwwREFBMEQ7UUFDMUQsbUJBQWlCLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFFRCwrQ0FBK0M7SUFDdkMsUUFBUSxDQUFDLEtBQXFCLEVBQUUsSUFBZ0IsRUFBRSxTQUFpQixJQUFJO1FBQzdFLE1BQU0sTUFBTSxHQUFHLENBQUMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRS9FLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxvQkFBa0IsQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBRXhFLEtBQUssTUFBTSxJQUFJLElBQUksTUFBTSxFQUFFO1lBQ3pCLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSwrQkFBVSxFQUFFLENBQUM7WUFDL0QsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLE1BQU0sSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO1lBQ3RELElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLGFBQWEsRUFBRSxTQUFTLENBQUMsQ0FBQztTQUNoRDtJQUNILENBQUM7SUFFRCx5Q0FBeUM7SUFDakMsT0FBTyxDQUFDLE9BQXdCLEVBQUUsS0FBcUI7UUFDN0QsK0NBQStDO1FBQy9DLElBQUksT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUN4QyxPQUFPLElBQUksK0JBQVUsQ0FDbkIsR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUMzRSxDQUFDO1NBQ0g7UUFFRCw0REFBNEQ7UUFDNUQsTUFBTSxNQUFNLEdBQUcsZ0JBQWMsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFL0MsT0FBTyxJQUFJLCtCQUFVLENBQ25CLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FDMUYsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQTFDRCxxQ0EwQ0MifQ==

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Connection } from 'mongoose';
 import { DataSourceFactory } from '@forestadmin/datasource-toolkit';
+import { MongooseOptions } from './types';
 export { default as MongooseCollection } from './collection';
 export { default as MongooseDatasource } from './datasource';
-export declare function createMongooseDataSource(connection: Connection): DataSourceFactory;
+export declare function createMongooseDataSource(connection: Connection, options?: MongooseOptions): DataSourceFactory;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -9,8 +9,8 @@ var collection_1 = require("./collection");
 Object.defineProperty(exports, "MongooseCollection", { enumerable: true, get: function () { return __importDefault(collection_1).default; } });
 var datasource_2 = require("./datasource");
 Object.defineProperty(exports, "MongooseDatasource", { enumerable: true, get: function () { return __importDefault(datasource_2).default; } });
-function createMongooseDataSource(connection) {
-    return async () => new datasource_1.default(connection);
+function createMongooseDataSource(connection, options = {}) {
+    return async () => new datasource_1.default(connection, options);
 }
 exports.createMongooseDataSource = createMongooseDataSource;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBR0EsOERBQThDO0FBRTlDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBQ3RDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBRXRDLFNBQWdCLHdCQUF3QixDQUFDLFVBQXNCO0lBQzdELE9BQU8sS0FBSyxJQUFJLEVBQUUsQ0FBQyxJQUFJLG9CQUFrQixDQUFDLFVBQVUsQ0FBQyxDQUFDO0FBQ3hELENBQUM7QUFGRCw0REFFQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBSUEsOERBQThDO0FBRTlDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBQ3RDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBRXRDLFNBQWdCLHdCQUF3QixDQUN0QyxVQUFzQixFQUN0QixVQUEyQixFQUFFO0lBRTdCLE9BQU8sS0FBSyxJQUFJLEVBQUUsQ0FBQyxJQUFJLG9CQUFrQixDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUNqRSxDQUFDO0FBTEQsNERBS0MifQ==

package/dist/mongoose/schema.d.ts

@@ -0,0 +1,21 @@
+import { Model, SchemaType } from 'mongoose';
+export declare type SchemaBranch = {
+    [key: string]: SchemaNode;
+};
+export declare type SchemaNode = SchemaType | SchemaBranch;
+export default class MongooseSchema {
+    readonly isArray: boolean;
+    readonly isLeaf: boolean;
+    readonly fields: SchemaBranch;
+    private models;
+    static fromModel(model: Model<unknown>): MongooseSchema;
+    get schemaType(): SchemaType;
+    constructor(models: Record<string, Model<unknown>>, fields: SchemaBranch, isArray: boolean, isLeaf: boolean);
+    getSubSchema(path: string, withParent?: boolean): MongooseSchema;
+    /**
+     * Build a tree of SchemaType from a mongoose schema.
+     * This removes most complexity from using prefixes, nested schemas and array types
+     */
+    private static buildFields;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/mongoose/schema.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const mongoose_1 = require("mongoose");
+const helpers_1 = require("../utils/helpers");
+class MongooseSchema {
+    constructor(models, fields, isArray, isLeaf) {
+        this.models = models;
+        this.fields = fields;
+        this.isArray = isArray;
+        this.isLeaf = isLeaf;
+    }
+    static fromModel(model) {
+        return new MongooseSchema(model.db.models, this.buildFields(model.schema), false, false);
+    }
+    get schemaType() {
+        if (this.fields.content instanceof mongoose_1.SchemaType) {
+            return this.fields.content;
+        }
+        throw new Error(`Schema is not a leaf.`);
+    }
+    getSubSchema(path, withParent = false) {
+        // Terminating condition
+        if (path === null)
+            return this;
+        // General case: go down the tree
+        const dotIndex = path.indexOf('.');
+        const prefix = dotIndex === -1 ? path : path.substring(0, dotIndex);
+        const suffix = dotIndex === -1 ? null : path.substring(dotIndex + 1);
+        let isArray = false;
+        let isLeaf = false;
+        let child = this.fields[prefix];
+        // Traverse relations
+        if (prefix.endsWith('__manyToOne')) {
+            const foreignKeyName = prefix.substring(0, prefix.length - '__manyToOne'.length);
+            const relationName = this.fields[foreignKeyName].options.ref;
+            child = MongooseSchema.fromModel(this.models[relationName]).fields;
+        }
+        // Traverse arrays
+        if (child['[]']) {
+            child = child['[]'];
+            isArray = true;
+        }
+        // We ended up on a field => box it.
+        if (child instanceof mongoose_1.SchemaType) {
+            child = { content: child };
+            isLeaf = true;
+        }
+        // If we want parent to be included, re-add the rootSchema
+        if (withParent && !prefix.endsWith('__manyToOne')) {
+            const id = new mongoose_1.Schema.Types.String(prefix, {}, 'String');
+            child = { ...child, _id: id, _pid: this.fields._id, parent: this.fields };
+        }
+        return new MongooseSchema(this.models, child, isArray, isLeaf).getSubSchema(suffix, withParent);
+    }
+    /**
+     * Build a tree of SchemaType from a mongoose schema.
+     * This removes most complexity from using prefixes, nested schemas and array types
+     */
+    static buildFields(schema, level = 0) {
+        const paths = {};
+        for (const [name, field] of Object.entries(schema.paths)) {
+            // Exclude mixedFieldPattern $* and privateFieldPattern __
+            if (!name.startsWith('$*') && !name.includes('__') && (name !== '_id' || level === 0)) {
+                // Flatten nested schemas and arrays
+                if (field.constructor.name === 'SubdocumentPath') {
+                    const subPaths = this.buildFields(field.schema, level + 1);
+                    for (const [subName, subField] of Object.entries(subPaths))
+                        (0, helpers_1.recursiveSet)(paths, `${name}.${subName}`, subField);
+                }
+                else if (field.constructor.name === 'DocumentArrayPath') {
+                    const subPaths = this.buildFields(field.schema, level + 1);
+                    for (const [subName, subField] of Object.entries(subPaths))
+                        (0, helpers_1.recursiveSet)(paths, `${name}.[].${subName}`, subField);
+                }
+                else if (field.constructor.name === 'SchemaArray') {
+                    (0, helpers_1.recursiveSet)(paths, `${name}.[]`, field.caster);
+                }
+                else {
+                    (0, helpers_1.recursiveSet)(paths, name, field);
+                }
+            }
+        }
+        return paths;
+    }
+}
+exports.default = MongooseSchema;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export declare type MongooseOptions = {
+    asModels?: Record<string, string[]>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

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

package/dist/utils/helpers.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Replace dots by underscores.
+ *
+ * @example
+ * escape('a.b') == 'a_b'
+ */
+export declare function escape(str: string): string;
+/**
+ * Set a value in a plain object recursively
+ *
+ * @example
+ * const a = {};
+ * recursiveSet(a, 'field.subfield', 42);
+ * a == { field: { subfield: 42 } }
+ */
+export declare function recursiveSet(target: any, path: string, value: unknown): void;
+/**
+ * Compare two ids.
+ * This is useful to ensure we perform array operations in the right order.
+ *
+ * @example
+ * compareIds('a.20.a', 'a.1.b') => 1 (because 1 < 20)
+ * compareIds('a.0.a', 'b.1.b') => -1 (because 'a' < 'b')
+ */
+export declare function compareIds(a: string, b: string): number;
+/**
+ * Split the fake ids which are generated when using the `asModel` option into rootId + path.
+ *
+ * @example
+ * splitId('123.some.path.0.to.the.item) == [123, 'some.path.0.to.the.item]
+ */
+export declare function splitId(id: string): [unknown, string];
+/**
+ * Group the fake ids which are generated when using the `asModel` option by the path they are
+ * targeting to help performing requests.
+ *
+ * @example
+ * groupIdsByPath(['123.field', '456.field']) == { field: [123, 456] }
+ */
+export declare function groupIdsByPath(ids: string[]): {
+    [path: string]: unknown[];
+};
+/**
+ * Replace ObjectId and Date instances in records by strings.
+ *
+ * @example
+ * replaceMongoTypes({_id: ObjectId('12312321313'), createdAt: Date() })
+ * == { _id: '12312321313', createdAt: '2010-01-01T00:00:00Z' }
+ */
+export declare function replaceMongoTypes(records: any): any;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/utils/helpers.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceMongoTypes = exports.groupIdsByPath = exports.splitId = exports.compareIds = exports.recursiveSet = exports.escape = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const mongoose_1 = require("mongoose");
+/**
+ * Replace dots by underscores.
+ *
+ * @example
+ * escape('a.b') == 'a_b'
+ */
+function escape(str) {
+    return str.replace(/\./g, '_');
+}
+exports.escape = escape;
+/**
+ * Set a value in a plain object recursively
+ *
+ * @example
+ * const a = {};
+ * recursiveSet(a, 'field.subfield', 42);
+ * a == { field: { subfield: 42 } }
+ */
+function recursiveSet(target, path, value) {
+    const index = path.indexOf('.');
+    if (index !== -1) {
+        const prefix = path.substring(0, index);
+        const suffix = path.substring(index + 1);
+        target[prefix] ?? (target[prefix] = {});
+        recursiveSet(target[prefix], suffix, value);
+    }
+    else {
+        target[path] = value;
+    }
+}
+exports.recursiveSet = recursiveSet;
+/**
+ * Compare two ids.
+ * This is useful to ensure we perform array operations in the right order.
+ *
+ * @example
+ * compareIds('a.20.a', 'a.1.b') => 1 (because 1 < 20)
+ * compareIds('a.0.a', 'b.1.b') => -1 (because 'a' < 'b')
+ */
+function compareIds(a, b) {
+    const isNumber = /^\d+$/;
+    const partsA = a.split('.');
+    const partsB = b.split('.');
+    const length = a.length < b.length ? a.length : b.length;
+    for (let i = 0; i < length; i += 1) {
+        if (partsA[i] !== partsB[i] && isNumber.test(partsA[i]) && isNumber.test(partsB[i]))
+            return Number(partsA[i]) - Number(partsB[i]);
+        if (partsA[i] < partsB[i])
+            return -1;
+        if (partsA[i] > partsB[i])
+            return 1;
+    }
+    if (partsA.length < partsB.length)
+        return -1;
+    if (partsA.length > partsB.length)
+        return 1;
+    return 0;
+}
+exports.compareIds = compareIds;
+/**
+ * Split the fake ids which are generated when using the `asModel` option into rootId + path.
+ *
+ * @example
+ * splitId('123.some.path.0.to.the.item) == [123, 'some.path.0.to.the.item]
+ */
+function splitId(id) {
+    const dotIndex = id.indexOf('.');
+    const rootId = id.substring(0, dotIndex);
+    const path = id.substring(dotIndex + 1);
+    // @fixme hack, we should never do that without looking at the schema
+    return (0, mongoose_1.isValidObjectId)(rootId)
+        ? [mongoose_1.Types.ObjectId.createFromHexString(rootId), path]
+        : [rootId, path];
+}
+exports.splitId = splitId;
+/**
+ * Group the fake ids which are generated when using the `asModel` option by the path they are
+ * targeting to help performing requests.
+ *
+ * @example
+ * groupIdsByPath(['123.field', '456.field']) == { field: [123, 456] }
+ */
+function groupIdsByPath(ids) {
+    const updates = {};
+    for (const id of ids) {
+        const [rootId, path] = splitId(id);
+        updates[path] ?? (updates[path] = []);
+        updates[path].push(rootId);
+    }
+    return updates;
+}
+exports.groupIdsByPath = groupIdsByPath;
+/**
+ * Replace ObjectId and Date instances in records by strings.
+ *
+ * @example
+ * replaceMongoTypes({_id: ObjectId('12312321313'), createdAt: Date() })
+ * == { _id: '12312321313', createdAt: '2010-01-01T00:00:00Z' }
+ */
+function replaceMongoTypes(records) {
+    return JSON.parse(JSON.stringify(records));
+}
+exports.replaceMongoTypes = replaceMongoTypes;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/pipeline/filter.d.ts

@@ -0,0 +1,18 @@
+import { PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import { Model, PipelineStage } from 'mongoose';
+/** Transform a forest admin filter into mongo pipeline */
+export default class FilterGenerator {
+    static filter(model: Model<unknown>, prefix: string | null, filter: PaginatedFilter): PipelineStage[];
+    private static computeMatch;
+    private static formatAndCastLeafValue;
+    private static buildMatchCondition;
+    /** @see https://stackoverflow.com/a/18418386/1897495 */
+    private static like;
+    private static computeSort;
+    private static computeFields;
+    private static formatNestedFieldPath;
+    private static formatStringFieldName;
+    private static getParentPath;
+    private static getFieldName;
+}
+//# sourceMappingURL=filter.d.ts.map