@forestadmin/datasource-mongoose 1.0.0-alpha.1

package/dist/utils/pipeline/filter.js

@@ -0,0 +1,160 @@
+"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 luxon_1 = require("luxon");
+const mongoose_1 = require("mongoose");
+const schema_1 = __importDefault(require("../../mongoose/schema"));
+const STRING_OPERATORS = ['Like', 'ILike', 'NotContains', 'LongerThan', 'ShorterThan'];
+/** Transform a forest admin filter into mongo pipeline */
+class FilterGenerator {
+    static filter(model, prefix, filter) {
+        const schema = schema_1.default.fromModel(model).getSubSchema(prefix, true);
+        const fields = new Set();
+        const tree = filter?.conditionTree;
+        const match = this.computeMatch(schema, tree, fields);
+        const sort = this.computeSort(filter?.sort);
+        const pipeline = [];
+        if (fields.size)
+            pipeline.push(this.computeFields(fields));
+        if (match)
+            pipeline.push({ $match: match });
+        if (sort)
+            pipeline.push({ $sort: sort });
+        if (filter?.page?.skip !== undefined)
+            pipeline.push({ $skip: filter.page.skip });
+        if (filter?.page?.limit !== undefined)
+            pipeline.push({ $limit: filter.page.limit });
+        return pipeline;
+    }
+    static computeMatch(schema, tree, fields) {
+        if (tree instanceof datasource_toolkit_1.ConditionTreeBranch) {
+            return {
+                [`$${tree.aggregator.toLowerCase()}`]: tree.conditions.map(condition => this.computeMatch(schema, condition, fields)),
+            };
+        }
+        if (tree instanceof datasource_toolkit_1.ConditionTreeLeaf) {
+            const value = this.formatAndCastLeafValue(schema, tree, fields);
+            const condition = this.buildMatchCondition(tree.operator, value);
+            return { [this.formatNestedFieldPath(tree.field)]: condition };
+        }
+        return null;
+    }
+    static formatAndCastLeafValue(schema, leaf, fields) {
+        // @fixme not a big fan of modifying the condition tree here.
+        // those objects should be frozen, as the modification will show if the condition tree
+        // is used after the request (for instance for "after hooks").
+        let { value } = leaf;
+        leaf.field = this.formatNestedFieldPath(leaf.field);
+        const { isArray, schemaType: { instance }, } = schema.getSubSchema(leaf.field, true);
+        // @fixme I'm really not sure that this can work in all cases.
+        // It assumes that the type of the value is the same than the type of the column
+        // which is not the case for many operators.
+        if (isArray) {
+            if (instance === 'Date' &&
+                Array.isArray(value) &&
+                value.every(v => luxon_1.DateTime.fromISO(v).isValid)) {
+                value = value.map(v => new Date(v));
+            }
+            else if (instance === 'ObjectID' &&
+                Array.isArray(value) &&
+                value.every(v => (0, mongoose_1.isValidObjectId)(v))) {
+                value = value.map(id => new mongoose_1.Types.ObjectId(id));
+            }
+        }
+        else if (instance === 'ObjectID') {
+            if (STRING_OPERATORS.includes(leaf.operator)) {
+                fields.add(leaf.field);
+                leaf.field = this.formatStringFieldName(leaf.field);
+            }
+            else if (Array.isArray(value) && value.every(v => (0, mongoose_1.isValidObjectId)(v))) {
+                value = value.map(id => new mongoose_1.Types.ObjectId(id));
+            }
+            else if ((0, mongoose_1.isValidObjectId)(value)) {
+                value = new mongoose_1.Types.ObjectId(value);
+            }
+        }
+        else if (instance === 'Date') {
+            value = new Date(value);
+        }
+        return value;
+    }
+    static buildMatchCondition(operator, formattedLeafValue) {
+        switch (operator) {
+            case 'GreaterThan':
+                return { $gt: formattedLeafValue };
+            case 'LessThan':
+                return { $lt: formattedLeafValue };
+            case 'Equal':
+                return { $eq: formattedLeafValue };
+            case 'NotEqual':
+                return { $ne: formattedLeafValue };
+            case 'In':
+                return { $in: formattedLeafValue };
+            case 'IncludesAll':
+                return { $all: formattedLeafValue };
+            case 'NotContains':
+                return { $not: new RegExp(`.*${formattedLeafValue}.*`) };
+            case 'Like':
+                return this.like(formattedLeafValue, true);
+            case 'ILike':
+                return this.like(formattedLeafValue, false);
+            case 'Present':
+                return { $exists: true, $ne: null };
+            default:
+                throw new Error(`Unsupported '${operator}' operator`);
+        }
+    }
+    /** @see https://stackoverflow.com/a/18418386/1897495 */
+    static like(pattern, caseSensitive) {
+        let regexp = pattern;
+        // eslint-disable-next-line no-useless-escape
+        regexp = regexp.replace(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:\-])/g, '\\$1');
+        regexp = regexp.replace(/%/g, '.*').replace(/_/g, '.');
+        return RegExp(`^${regexp}$`, caseSensitive ? 'g' : 'gi');
+    }
+    static computeSort(sorts) {
+        if (!sorts || sorts.length === 0)
+            return null;
+        const result = {};
+        for (const { field, ascending } of sorts) {
+            const formattedField = this.formatNestedFieldPath(field);
+            result[formattedField] = ascending ? 1 : -1;
+        }
+        return result;
+    }
+    static computeFields(fields) {
+        return Array.from(fields).reduce((computed, field) => {
+            const stringField = this.formatStringFieldName(field);
+            computed.$addFields[stringField] = { $toString: `$${field}` };
+            return computed;
+        }, { $addFields: {} });
+    }
+    static formatNestedFieldPath(field) {
+        return field.replace(/:/g, '.');
+    }
+    static formatStringFieldName(field) {
+        const parentPath = this.getParentPath(field);
+        const fieldName = this.getFieldName(field);
+        if (parentPath === field) {
+            return `string_${fieldName}`;
+        }
+        return `${parentPath}.string_${fieldName}`;
+    }
+    static getParentPath(path) {
+        if (!path.includes('.')) {
+            return path;
+        }
+        return path.split('.').slice(0, -1).join('.');
+    }
+    static getFieldName(path) {
+        if (!path.includes('.')) {
+            return path;
+        }
+        return path.split('.').slice(-1).join('.');
+    }
+}
+exports.default = FilterGenerator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../../src/utils/pipeline/filter.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,15 @@
+import { Aggregation } from '@forestadmin/datasource-toolkit';
+import { PipelineStage } from 'mongoose';
+/** Transform a forest admin aggregation into mongo pipeline */
+export default class GroupGenerator {
+    private static AGGREGATION_OPERATION;
+    private static GROUP_OPERATION;
+    static group(aggregation: Aggregation): PipelineStage[];
+    /** Compute aggregation value */
+    private static computeValue;
+    /** Compute _id field for the $group pipeline stage */
+    private static computeGroups;
+    /** Move fields in _id to the root of the document */
+    private static computeGroupsProjection;
+}
+//# sourceMappingURL=group.d.ts.map

package/dist/utils/pipeline/group.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Transform a forest admin aggregation into mongo pipeline */
+class GroupGenerator {
+    static group(aggregation) {
+        return [
+            {
+                $group: {
+                    _id: this.computeGroups(aggregation.groups),
+                    value: this.computeValue(aggregation),
+                },
+            },
+            {
+                $project: {
+                    _id: 0,
+                    value: '$value',
+                    group: this.computeGroupsProjection(aggregation.groups),
+                },
+            },
+        ];
+    }
+    /** Compute aggregation value */
+    static computeValue(aggregation) {
+        // Handle count(*) case
+        if (!aggregation.field)
+            return { $sum: 1 };
+        // General case
+        const field = `$${aggregation.field.replace(/:/g, '.')}`;
+        return aggregation.operation === 'Count'
+            ? { $sum: { $cond: [{ $ne: [field, null] }, 1, 0] } }
+            : { [this.AGGREGATION_OPERATION[aggregation.operation]]: field };
+    }
+    /** Compute _id field for the $group pipeline stage */
+    static computeGroups(groups) {
+        return (groups ?? []).reduce((memo, group) => {
+            let field = `$${group.field.replace(/:/g, '.')}`;
+            if (group.operation) {
+                if (group.operation === 'Week') {
+                    const date = { $dateTrunc: { date: field, startOfWeek: 'Monday', unit: 'week' } };
+                    field = { $dateToString: { format: this.GROUP_OPERATION[group.operation], date } };
+                }
+                else {
+                    field = { $dateToString: { format: this.GROUP_OPERATION[group.operation], date: field } };
+                }
+            }
+            return { ...(memo ?? {}), [group.field]: field };
+        }, null);
+    }
+    /** Move fields in _id to the root of the document */
+    static computeGroupsProjection(groups) {
+        return groups?.length
+            ? groups.reduce((memo, group) => ({ ...memo, [group.field]: `$_id.${group.field}` }), {})
+            : { $literal: {} };
+    }
+}
+exports.default = GroupGenerator;
+GroupGenerator.AGGREGATION_OPERATION = {
+    Sum: '$sum',
+    Avg: '$avg',
+    Count: '$sum',
+    Max: '$max',
+    Min: '$min',
+};
+GroupGenerator.GROUP_OPERATION = {
+    Year: '%Y-01-01',
+    Month: '%Y-%m-01',
+    Day: '%Y-%m-%d',
+    Week: '%Y-%m-%d',
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import { Model, PipelineStage } from 'mongoose';
+import { Projection } from '@forestadmin/datasource-toolkit';
+/**
+ * Transform a forest admin projection into a mongo pipeline that performs the lookups
+ * and transformations to target them
+ */
+export default class LookupGenerator {
+    static lookup(model: Model<unknown>, prefix: string, projection: Projection): PipelineStage[];
+    private static lookupProjection;
+    private static lookupRelation;
+}
+//# sourceMappingURL=lookup.d.ts.map

package/dist/utils/pipeline/lookup.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = __importDefault(require("../../mongoose/schema"));
+/**
+ * Transform a forest admin projection into a mongo pipeline that performs the lookups
+ * and transformations to target them
+ */
+class LookupGenerator {
+    static lookup(model, prefix, projection) {
+        const childSchema = schema_1.default.fromModel(model).getSubSchema(prefix, true).fields;
+        return this.lookupProjection(model.db.models, null, childSchema, projection);
+    }
+    static lookupProjection(models, currentPath, schema, projection) {
+        const pipeline = [];
+        for (const [name, subProjection] of Object.entries(projection.relations))
+            pipeline.push(...this.lookupRelation(models, currentPath, schema, name, subProjection));
+        return pipeline;
+    }
+    static lookupRelation(models, currentPath, schema, name, subProjection) {
+        const as = currentPath ? `${currentPath}.${name}` : name;
+        // Native many to one relation
+        if (name.endsWith('__manyToOne')) {
+            const foreignKeyName = name.substring(0, name.length - '__manyToOne'.length);
+            const model = models[schema[foreignKeyName].options.ref];
+            const from = model.collection.collectionName;
+            const localField = currentPath ? `${currentPath}.${foreignKeyName}` : foreignKeyName;
+            const foreignField = '_id';
+            const subSchema = schema_1.default.fromModel(model).fields;
+            return [
+                // Push lookup to pipeline
+                { $lookup: { from, localField, foreignField, as } },
+                { $unwind: { path: `$${as}`, preserveNullAndEmptyArrays: true } },
+                // Recurse to get relations of relations
+                ...this.lookupProjection(models, as, subSchema, subProjection),
+            ];
+        }
+        // Fake relation or inverse of fake relation
+        if (name === 'parent' || schema[name]) {
+            return this.lookupProjection(models, as, schema[name], subProjection);
+        }
+        // We should have handled all possible cases.
+        throw new Error(`Unexpected relation: '${name}'`);
+    }
+}
+exports.default = LookupGenerator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+import { PipelineStage } from 'mongoose';
+import { Projection } from '@forestadmin/datasource-toolkit';
+/** Generate a mongo pipeline which applies a forest admin projection */
+export default class ProjectionGenerator {
+    static project(projection: Projection): PipelineStage[];
+}
+//# sourceMappingURL=projection.d.ts.map

package/dist/utils/pipeline/projection.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Generate a mongo pipeline which applies a forest admin projection */
+class ProjectionGenerator {
+    static project(projection) {
+        if (projection.length === 0) {
+            return [{ $replaceRoot: { newRoot: { $literal: {} } } }];
+        }
+        const project = { _id: false };
+        for (const field of projection) {
+            const formattedField = field.replace(/:/g, '.');
+            project[formattedField] = true;
+        }
+        return [{ $project: project }];
+    }
+}
+exports.default = ProjectionGenerator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9waXBlbGluZS9wcm9qZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0Esd0VBQXdFO0FBQ3hFLE1BQXFCLG1CQUFtQjtJQUN0QyxNQUFNLENBQUMsT0FBTyxDQUFDLFVBQXNCO1FBQ25DLElBQUksVUFBVSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7WUFDM0IsT0FBTyxDQUFDLEVBQUUsWUFBWSxFQUFFLEVBQUUsT0FBTyxFQUFFLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1NBQzFEO1FBRUQsTUFBTSxPQUFPLEdBQXNDLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxDQUFDO1FBRWxFLEtBQUssTUFBTSxLQUFLLElBQUksVUFBVSxFQUFFO1lBQzlCLE1BQU0sY0FBYyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQ2hELE9BQU8sQ0FBQyxjQUFjLENBQUMsR0FBRyxJQUFJLENBQUM7U0FDaEM7UUFFRCxPQUFPLENBQUMsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0Y7QUFmRCxzQ0FlQyJ9

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

@@ -0,0 +1,13 @@
+import { Model, PipelineStage } from 'mongoose';
+/**
+ * Generate pipeline to query submodels.
+ *
+ * The operations make rotations in the documents so that the root is changed to the submodel
+ * without loosing the parent (which may be needed later on).
+ */
+export default class ReparentGenerator {
+    static reparent(model: Model<unknown>, prefix: string): PipelineStage[];
+    private static reparentArray;
+    private static reparentObject;
+}
+//# sourceMappingURL=reparent.d.ts.map

package/dist/utils/pipeline/reparent.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const schema_1 = __importDefault(require("../../mongoose/schema"));
+/**
+ * Generate pipeline to query submodels.
+ *
+ * The operations make rotations in the documents so that the root is changed to the submodel
+ * without loosing the parent (which may be needed later on).
+ */
+class ReparentGenerator {
+    static reparent(model, prefix) {
+        if (!prefix?.length)
+            return [];
+        // Take only the part of the records we are interested in
+        const pipeline = [];
+        let schema = schema_1.default.fromModel(model).fields;
+        for (const part of prefix.split('.')) {
+            pipeline.push(...(schema[part]['[]']
+                ? this.reparentArray(part, schema[part]['[]'] instanceof mongoose_1.SchemaType)
+                : this.reparentObject(part, schema[part] instanceof mongoose_1.SchemaType)));
+            schema = schema[part];
+            if (schema['[]'])
+                schema = schema['[]'];
+        }
+        // If we end up on a field, create a virtual record
+        return pipeline;
+    }
+    static reparentArray(prefix, inDoc) {
+        return [
+            { $unwind: { path: `$${prefix}`, includeArrayIndex: 'index' } },
+            {
+                $replaceRoot: {
+                    newRoot: {
+                        $mergeObjects: [
+                            inDoc ? { content: `$${prefix}` } : `$${prefix}`,
+                            {
+                                _id: { $concat: [{ $toString: '$_id' }, `.${prefix}.`, { $toString: '$index' }] },
+                                _pid: '$_id',
+                                parent: '$$ROOT',
+                            },
+                        ],
+                    },
+                },
+            },
+        ];
+    }
+    static reparentObject(prefix, inDoc) {
+        return [
+            {
+                $replaceRoot: {
+                    newRoot: {
+                        $mergeObjects: [
+                            inDoc ? { content: `$${prefix}` } : `$${prefix}`,
+                            {
+                                _id: { $concat: [{ $toString: '$_id' }, `.${prefix}`] },
+                                _pid: '$_id',
+                                parent: '$$ROOT',
+                            },
+                        ],
+                    },
+                },
+            },
+        ];
+    }
+}
+exports.default = ReparentGenerator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/pipeline/virtual-fields.d.ts

@@ -0,0 +1,21 @@
+import { Model, PipelineStage } from 'mongoose';
+import { Projection } from '@forestadmin/datasource-toolkit';
+import MongooseSchema from '../../mongoose/schema';
+/**
+ * When using the `asModel` options, users can request/filter on the virtual _id and _pid fields
+ * of children (using the generated OneToOne relation).
+ *
+ * As those fields are not written to mongo, they are injected here so that they can be used like
+ * any other field.
+ *
+ * This could be also be done by preprocessing the filter, and postprocessing the records, but this
+ * solution seemed simpler, at the cost of additional pipeline stages when making queries.
+ *
+ * Note that a projection is taken as a parameter so that only fields which are actually used are
+ * injected to save resources.
+ */
+export default class VirtualFieldsGenerator {
+    static addVirtual(model: Model<unknown>, prefix: string, ignoredFields: string[], projection: Projection): PipelineStage[];
+    static getVirtuals(path: string, schema: MongooseSchema, projection: Projection): Record<string, unknown>;
+}
+//# sourceMappingURL=virtual-fields.d.ts.map

package/dist/utils/pipeline/virtual-fields.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = __importDefault(require("../../mongoose/schema"));
+/**
+ * When using the `asModel` options, users can request/filter on the virtual _id and _pid fields
+ * of children (using the generated OneToOne relation).
+ *
+ * As those fields are not written to mongo, they are injected here so that they can be used like
+ * any other field.
+ *
+ * This could be also be done by preprocessing the filter, and postprocessing the records, but this
+ * solution seemed simpler, at the cost of additional pipeline stages when making queries.
+ *
+ * Note that a projection is taken as a parameter so that only fields which are actually used are
+ * injected to save resources.
+ */
+class VirtualFieldsGenerator {
+    static addVirtual(model, prefix, ignoredFields, projection) {
+        const schema = schema_1.default.fromModel(model).getSubSchema(prefix, true);
+        const set = {};
+        for (const [relation, subProjection] of Object.entries(projection.relations)) {
+            // if it is a virtual one to one (<=> inverse of "parent")
+            if (ignoredFields.includes(relation)) {
+                const virtuals = this.getVirtuals(relation, schema.getSubSchema(relation, true), subProjection);
+                for (const [key, value] of Object.entries(virtuals)) {
+                    set[key] = value;
+                }
+            }
+        }
+        return Object.keys(set).length ? [{ $addFields: set }] : [];
+    }
+    static getVirtuals(path, schema, projection) {
+        const result = {};
+        if (projection.columns.includes('_id')) {
+            result[`${path}._id`] = { $concat: [{ $toString: '$_id' }, `.${path}`] };
+        }
+        if (projection.columns.includes('_pid')) {
+            const dotIndex = path.lastIndexOf('.');
+            const parentPath = dotIndex !== -1 ? path.substring(0, dotIndex) : null;
+            result[`${path}._pid`] = parentPath
+                ? { $concat: [{ $toString: '$_id' }, `.${parentPath}`] }
+                : '$_id';
+        }
+        if (projection.columns.includes('content') && schema.isLeaf) {
+            result[`${path}.content`] = `$${path}`;
+        }
+        for (const [relation, subProjection] of Object.entries(projection.relations)) {
+            // If we're asking for data that is inside of this mongo document (and not a __manyToOne)
+            // This condition should be equivalent to `!relation.endWith('__manyToOne')` but we want
+            // to get rid of the fact that the code depends on the naming.
+            if (schema.fields[relation]) {
+                const subVirtuals = this.getVirtuals(`${path}.${relation}`, schema.getSubSchema(relation, true), subProjection);
+                for (const [key, value] of Object.entries(subVirtuals)) {
+                    result[key] = value;
+                }
+            }
+        }
+        return result;
+    }
+}
+exports.default = VirtualFieldsGenerator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlydHVhbC1maWVsZHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvcGlwZWxpbmUvdmlydHVhbC1maWVsZHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSxtRUFBbUQ7QUFFbkQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBcUIsc0JBQXNCO0lBQ3pDLE1BQU0sQ0FBQyxVQUFVLENBQ2YsS0FBcUIsRUFDckIsTUFBYyxFQUNkLGFBQXVCLEVBQ3ZCLFVBQXNCO1FBRXRCLE1BQU0sTUFBTSxHQUFHLGdCQUFjLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDMUUsTUFBTSxHQUFHLEdBQUcsRUFBRSxDQUFDO1FBRWYsS0FBSyxNQUFNLENBQUMsUUFBUSxFQUFFLGFBQWEsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQzVFLDBEQUEwRDtZQUMxRCxJQUFJLGFBQWEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQ3BDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQy9CLFFBQVEsRUFDUixNQUFNLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsRUFDbkMsYUFBYSxDQUNkLENBQUM7Z0JBRUYsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUU7b0JBQ25ELEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxLQUFLLENBQUM7aUJBQ2xCO2FBQ0Y7U0FDRjtRQUVELE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxVQUFVLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO0lBQzlELENBQUM7SUFFRCxNQUFNLENBQUMsV0FBVyxDQUNoQixJQUFZLEVBQ1osTUFBc0IsRUFDdEIsVUFBc0I7UUFFdEIsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO1FBRWxCLElBQUksVUFBVSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDdEMsTUFBTSxDQUFDLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDO1NBQzFFO1FBRUQsSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUN2QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZDLE1BQU0sVUFBVSxHQUFHLFFBQVEsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUN4RSxNQUFNLENBQUMsR0FBRyxJQUFJLE9BQU8sQ0FBQyxHQUFHLFVBQVU7Z0JBQ2pDLENBQUMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxFQUFFLElBQUksVUFBVSxFQUFFLENBQUMsRUFBRTtnQkFDeEQsQ0FBQyxDQUFDLE1BQU0sQ0FBQztTQUNaO1FBRUQsSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsSUFBSSxNQUFNLENBQUMsTUFBTSxFQUFFO1lBQzNELE1BQU0sQ0FBQyxHQUFHLElBQUksVUFBVSxDQUFDLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztTQUN4QztRQUVELEtBQUssTUFBTSxDQUFDLFFBQVEsRUFBRSxhQUFhLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUM1RSx5RkFBeUY7WUFDekYsd0ZBQXdGO1lBQ3hGLDhEQUE4RDtZQUM5RCxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQzNCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQ2xDLEdBQUcsSUFBSSxJQUFJLFFBQVEsRUFBRSxFQUNyQixNQUFNLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsRUFDbkMsYUFBYSxDQUNkLENBQUM7Z0JBRUYsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLEVBQUU7b0JBQ3RELE1BQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxLQUFLLENBQUM7aUJBQ3JCO2FBQ0Y7U0FDRjtRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7Q0FDRjtBQXRFRCx5Q0FzRUMifQ==

package/dist/utils/schema/fields.d.ts

@@ -0,0 +1,18 @@
+import { CollectionSchema, RecordData } from '@forestadmin/datasource-toolkit';
+import { Model } from 'mongoose';
+/** Generate forest admin schema from mongoose schema */
+export default class FieldsGenerator {
+    static buildFieldsSchema(model: Model<RecordData>, prefix?: string, skips?: string[]): CollectionSchema['fields'];
+    /** Fake primary key that will be used when we're flattening collections */
+    private static buildVirtualPrimaryKey;
+    private static buildManyToOne;
+    /** Build ColumnSchema from CleanSchema */
+    private static buildColumnSchema;
+    /** Compute column type from CleanSchema */
+    private static getColumnType;
+    /** Build ColumnType from CleanSchema recursively */
+    private static getColumnTypeRec;
+    /** Get enum validator from field definition */
+    private static getEnumValues;
+}
+//# sourceMappingURL=fields.d.ts.map