@forestadmin/datasource-mongoose 1.0.0-beta.3

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @forestadmin/datasource-mongoose [1.0.0-beta.3](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-mongoose@1.0.0-beta.2...@forestadmin/datasource-mongoose@1.0.0-beta.3) (2022-05-24)
+
+
+
+
+
+### Dependencies
+
+* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.17
+
+# @forestadmin/datasource-mongoose [1.0.0-beta.2](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-mongoose@1.0.0-beta.1...@forestadmin/datasource-mongoose@1.0.0-beta.2) (2022-05-23)
+
+
+
+
+
+### Dependencies
+
+* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.17
+
+# @forestadmin/datasource-mongoose 1.0.0-beta.1 (2022-05-17)
+
+
+### Features
+
+* **mongoose:** add schema generator ([#303](https://github.com/ForestAdmin/agent-nodejs/issues/303)) ([55fa26a](https://github.com/ForestAdmin/agent-nodejs/commit/55fa26a3d1c975c35bdab6a20655573ecaceb31e))

package/dist/collection.d.ts

@@ -0,0 +1,12 @@
+import { AggregateResult, BaseCollection, DataSource, 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[]>;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.js

@@ -0,0 +1,31 @@
+"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 schema_fields_generator_1 = __importDefault(require("./utils/schema-fields-generator"));
+class MongooseCollection extends datasource_toolkit_1.BaseCollection {
+    constructor(dataSource, model) {
+        super(model.modelName, dataSource);
+        this.model = model;
+        this.addFields(schema_fields_generator_1.default.buildFieldsSchema(model));
+    }
+    async create() {
+        throw new Error('not implemented');
+    }
+    async list() {
+        throw new Error('not implemented');
+    }
+    async update() {
+        throw new Error('not implemented');
+    }
+    async delete() {
+        throw new Error('not implemented');
+    }
+    async aggregate() {
+        throw new Error('not implemented');
+    }
+}
+exports.default = MongooseCollection;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBS3lDO0FBR3pDLDhGQUFvRTtBQUVwRSxNQUFxQixrQkFBbUIsU0FBUSxtQ0FBYztJQUc1RCxZQUFZLFVBQXNCLEVBQUUsS0FBd0I7UUFDMUQsS0FBSyxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxpQ0FBcUIsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRCxLQUFLLENBQUMsTUFBTTtRQUNWLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUk7UUFDUixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELEtBQUssQ0FBQyxNQUFNO1FBQ1YsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxLQUFLLENBQUMsTUFBTTtRQUNWLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQVM7UUFDYixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNGO0FBNUJELHFDQTRCQyJ9

package/dist/datasource.d.ts

@@ -0,0 +1,9 @@
+import { BaseDataSource } from '@forestadmin/datasource-toolkit';
+import { Connection } from 'mongoose';
+import MongooseCollection from './collection';
+export default class MongooseDatasource extends BaseDataSource<MongooseCollection> {
+    private connection;
+    constructor(connection: Connection);
+    protected createCollections(): void;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const collection_1 = __importDefault(require("./collection"));
+const schema_fields_generator_1 = __importDefault(require("./utils/schema-fields-generator"));
+class MongooseDatasource extends datasource_toolkit_1.BaseDataSource {
+    constructor(connection) {
+        super();
+        if (!connection)
+            throw new Error('Invalid (null) Mongoose instance.');
+        this.connection = connection;
+        this.createCollections();
+    }
+    createCollections() {
+        Object.values(this.connection.models).forEach(model => {
+            this.addCollection(new collection_1.default(this, model));
+        });
+        schema_fields_generator_1.default.addInverseRelationships(this.collections);
+    }
+}
+exports.default = MongooseDatasource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBQWlFO0FBR2pFLDhEQUE4QztBQUM5Qyw4RkFBb0U7QUFFcEUsTUFBcUIsa0JBQW1CLFNBQVEsbUNBQWtDO0lBR2hGLFlBQVksVUFBc0I7UUFDaEMsS0FBSyxFQUFFLENBQUM7UUFFUixJQUFJLENBQUMsVUFBVTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUV0RSxJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztRQUU3QixJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRVMsaUJBQWlCO1FBQ3pCLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDcEQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLG9CQUFrQixDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQzFELENBQUMsQ0FBQyxDQUFDO1FBQ0gsaUNBQXFCLENBQUMsdUJBQXVCLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7Q0FDRjtBQW5CRCxxQ0FtQkMifQ==

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongooseDataSource = exports.MongooseDatasource = exports.MongooseCollection = void 0;
+const datasource_1 = __importDefault(require("./datasource"));
+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);
+}
+exports.createMongooseDataSource = createMongooseDataSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBR0EsOERBQThDO0FBRTlDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBQ3RDLDJDQUE2RDtBQUFwRCxpSUFBQSxPQUFPLE9BQXNCO0FBRXRDLFNBQWdCLHdCQUF3QixDQUFDLFVBQXNCO0lBQzdELE9BQU8sS0FBSyxJQUFJLEVBQUUsQ0FBQyxJQUFJLG9CQUFrQixDQUFDLFVBQVUsQ0FBQyxDQUFDO0FBQ3hELENBQUM7QUFGRCw0REFFQyJ9

package/dist/utils/filter-operator-builder.d.ts

@@ -0,0 +1,9 @@
+import { ColumnType, Operator } from '@forestadmin/datasource-toolkit';
+export default class FilterOperatorBuilder {
+    static readonly defaultOperators: Partial<Operator[]>;
+    static readonly inOperators: Partial<Operator[]>;
+    static readonly stringOperators: Partial<Operator[]>;
+    static readonly comparisonOperators: Partial<Operator[]>;
+    static getSupportedOperators(type: ColumnType): Set<Operator>;
+}
+//# sourceMappingURL=filter-operator-builder.d.ts.map

package/dist/utils/filter-operator-builder.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FilterOperatorBuilder {
+    static getSupportedOperators(type) {
+        if (!(type instanceof Array) && type instanceof Object) {
+            return new Set(FilterOperatorBuilder.defaultOperators);
+        }
+        switch (type) {
+            case 'Boolean':
+                return new Set(FilterOperatorBuilder.defaultOperators);
+            case 'Date':
+            case 'Dateonly':
+                return new Set([
+                    ...FilterOperatorBuilder.defaultOperators,
+                    ...FilterOperatorBuilder.inOperators,
+                    ...FilterOperatorBuilder.comparisonOperators,
+                ]);
+            case 'Enum':
+                return new Set([
+                    ...FilterOperatorBuilder.defaultOperators,
+                    ...FilterOperatorBuilder.inOperators,
+                ]);
+            case 'Number':
+                return new Set([
+                    ...FilterOperatorBuilder.defaultOperators,
+                    ...FilterOperatorBuilder.inOperators,
+                    ...FilterOperatorBuilder.comparisonOperators,
+                ]);
+            case 'String':
+                return new Set([
+                    ...FilterOperatorBuilder.defaultOperators,
+                    ...FilterOperatorBuilder.inOperators,
+                    ...FilterOperatorBuilder.stringOperators,
+                ]);
+            case 'Uuid':
+                return new Set([
+                    ...FilterOperatorBuilder.defaultOperators,
+                    ...FilterOperatorBuilder.stringOperators,
+                ]);
+            case 'Json':
+                return new Set(FilterOperatorBuilder.defaultOperators);
+            default:
+                return new Set();
+        }
+    }
+}
+exports.default = FilterOperatorBuilder;
+FilterOperatorBuilder.defaultOperators = ['Equal', 'NotEqual', 'Present'];
+FilterOperatorBuilder.inOperators = ['In', 'NotIn'];
+FilterOperatorBuilder.stringOperators = [
+    'Like',
+    'NotContains',
+    'LongerThan',
+    'ShorterThan',
+];
+FilterOperatorBuilder.comparisonOperators = ['GreaterThan', 'LessThan'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLW9wZXJhdG9yLWJ1aWxkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvZmlsdGVyLW9wZXJhdG9yLWJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFxQixxQkFBcUI7SUFZeEMsTUFBTSxDQUFDLHFCQUFxQixDQUFDLElBQWdCO1FBQzNDLElBQUksQ0FBQyxDQUFDLElBQUksWUFBWSxLQUFLLENBQUMsSUFBSSxJQUFJLFlBQVksTUFBTSxFQUFFO1lBQ3RELE9BQU8sSUFBSSxHQUFHLENBQVcscUJBQXFCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztTQUNsRTtRQUVELFFBQVEsSUFBSSxFQUFFO1lBQ1osS0FBSyxTQUFTO2dCQUNaLE9BQU8sSUFBSSxHQUFHLENBQVcscUJBQXFCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztZQUNuRSxLQUFLLE1BQU0sQ0FBQztZQUNaLEtBQUssVUFBVTtnQkFDYixPQUFPLElBQUksR0FBRyxDQUFXO29CQUN2QixHQUFHLHFCQUFxQixDQUFDLGdCQUFnQjtvQkFDekMsR0FBRyxxQkFBcUIsQ0FBQyxXQUFXO29CQUNwQyxHQUFHLHFCQUFxQixDQUFDLG1CQUFtQjtpQkFDN0MsQ0FBQyxDQUFDO1lBQ0wsS0FBSyxNQUFNO2dCQUNULE9BQU8sSUFBSSxHQUFHLENBQVc7b0JBQ3ZCLEdBQUcscUJBQXFCLENBQUMsZ0JBQWdCO29CQUN6QyxHQUFHLHFCQUFxQixDQUFDLFdBQVc7aUJBQ3JDLENBQUMsQ0FBQztZQUNMLEtBQUssUUFBUTtnQkFDWCxPQUFPLElBQUksR0FBRyxDQUFXO29CQUN2QixHQUFHLHFCQUFxQixDQUFDLGdCQUFnQjtvQkFDekMsR0FBRyxxQkFBcUIsQ0FBQyxXQUFXO29CQUNwQyxHQUFHLHFCQUFxQixDQUFDLG1CQUFtQjtpQkFDN0MsQ0FBQyxDQUFDO1lBQ0wsS0FBSyxRQUFRO2dCQUNYLE9BQU8sSUFBSSxHQUFHLENBQVc7b0JBQ3ZCLEdBQUcscUJBQXFCLENBQUMsZ0JBQWdCO29CQUN6QyxHQUFHLHFCQUFxQixDQUFDLFdBQVc7b0JBQ3BDLEdBQUcscUJBQXFCLENBQUMsZUFBZTtpQkFDekMsQ0FBQyxDQUFDO1lBQ0wsS0FBSyxNQUFNO2dCQUNULE9BQU8sSUFBSSxHQUFHLENBQVc7b0JBQ3ZCLEdBQUcscUJBQXFCLENBQUMsZ0JBQWdCO29CQUN6QyxHQUFHLHFCQUFxQixDQUFDLGVBQWU7aUJBQ3pDLENBQUMsQ0FBQztZQUNMLEtBQUssTUFBTTtnQkFDVCxPQUFPLElBQUksR0FBRyxDQUFXLHFCQUFxQixDQUFDLGdCQUFnQixDQUFDLENBQUM7WUFDbkU7Z0JBQ0UsT0FBTyxJQUFJLEdBQUcsRUFBWSxDQUFDO1NBQzlCO0lBQ0gsQ0FBQzs7QUF0REgsd0NBdURDO0FBdERpQixzQ0FBZ0IsR0FBd0IsQ0FBQyxPQUFPLEVBQUUsVUFBVSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQ3pFLGlDQUFXLEdBQXdCLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQ25ELHFDQUFlLEdBQXdCO0lBQ3JELE1BQU07SUFDTixhQUFhO0lBQ2IsWUFBWTtJQUNaLGFBQWE7Q0FDZCxDQUFDO0FBRWMseUNBQW1CLEdBQXdCLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDIn0=

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

@@ -0,0 +1,13 @@
+import { CollectionSchema, RecordData } from '@forestadmin/datasource-toolkit';
+import { Model } from 'mongoose';
+import MongooseCollection from '../collection';
+export default class SchemaFieldsGenerator {
+    static addInverseRelationships(collections: MongooseCollection[]): void;
+    static buildFieldsSchema(model: Model<RecordData>): CollectionSchema['fields'];
+    private static getColumnType;
+    private static buildColumnSchema;
+    private static getEnumValues;
+    private static getColumnTypeFromNested;
+    private static getColumnTypeFromNestedPath;
+}
+//# sourceMappingURL=schema-fields-generator.d.ts.map

package/dist/utils/schema-fields-generator.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_operator_builder_1 = __importDefault(require("./filter-operator-builder"));
+class SchemaFieldsGenerator {
+    static addInverseRelationships(collections) {
+        collections.forEach(collection => {
+            Object.values(collection.schema.fields).forEach(fieldSchema => {
+                if (fieldSchema.type === 'ManyToOne') {
+                    const foreignCollection = collections.find(c => c.name === fieldSchema.foreignCollection);
+                    if (!foreignCollection) {
+                        throw new Error(`The collection '${fieldSchema.foreignCollection}' does not exist`);
+                    }
+                    const field = `${foreignCollection.name}__${fieldSchema.foreignKey}__oneToMany`;
+                    foreignCollection.schema.fields[field] = {
+                        foreignCollection: collection.name,
+                        originKey: fieldSchema.foreignKey,
+                        originKeyTarget: '_id',
+                        type: 'OneToMany',
+                    };
+                }
+            });
+        });
+    }
+    static buildFieldsSchema(model) {
+        const schemaFields = {};
+        Object.entries(model.schema.paths).forEach(([fieldName, field]) => {
+            const mixedFieldPattern = '$*';
+            const privateFieldPattern = '__';
+            if (fieldName.startsWith(privateFieldPattern) || fieldName.includes(mixedFieldPattern)) {
+                return;
+            }
+            if (field.options.ref) {
+                schemaFields[`${fieldName}_manyToOne`] = {
+                    type: 'ManyToOne',
+                    foreignCollection: field.options.ref,
+                    foreignKey: field.path,
+                    foreignKeyTarget: '_id',
+                };
+                schemaFields[fieldName] = SchemaFieldsGenerator.buildColumnSchema(field, 'String');
+            }
+            schemaFields[field.path.split('.').shift()] = SchemaFieldsGenerator.buildColumnSchema(field, SchemaFieldsGenerator.getColumnType(field.instance, field));
+        });
+        return schemaFields;
+    }
+    static getColumnType(instance, field) {
+        if (field.path.includes('.')) {
+            const fieldPath = field.path.split('.');
+            fieldPath.shift();
+            field.path = fieldPath[fieldPath.length - 1];
+            return SchemaFieldsGenerator.getColumnTypeFromNestedPath(fieldPath, field);
+        }
+        const potentialEnumValues = this.getEnumValues(field);
+        if (potentialEnumValues) {
+            if (potentialEnumValues.some(value => !(typeof value === 'string'))) {
+                throw new Error('Enum support only String values');
+            }
+            return 'Enum';
+        }
+        switch (instance) {
+            case 'Array':
+                return [
+                    SchemaFieldsGenerator.getColumnType(field.schema ? 'Embedded' : field.caster.instance, field.schema ? field : field.caster),
+                ];
+            case 'String':
+            case 'ObjectID':
+            case 'Buffer':
+            case 'Decimal128':
+                return 'String';
+            case 'Number':
+                return 'Number';
+            case 'Date':
+                return 'Date';
+            case 'Boolean':
+                return 'Boolean';
+            case 'Map':
+            case 'Mixed':
+                return 'Json';
+            case 'Embedded':
+            default:
+                return SchemaFieldsGenerator.getColumnTypeFromNested(field);
+        }
+    }
+    static buildColumnSchema(field, columnType) {
+        return {
+            columnType,
+            filterOperators: filter_operator_builder_1.default.getSupportedOperators(columnType),
+            defaultValue: field.options?.default,
+            enumValues: this.getEnumValues(field),
+            isPrimaryKey: field.path === '_id',
+            isReadOnly: !!field.options?.immutable,
+            isSortable: !(columnType instanceof Object || columnType === 'Json'),
+            type: 'Column',
+            validation: field.isRequired ? [{ operator: 'Present' }] : null,
+        };
+    }
+    static getEnumValues(field) {
+        return field.options?.enum instanceof Array ? field.options.enum : field.options?.enum?.values;
+    }
+    static getColumnTypeFromNested(field) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const { singleNestedPaths } = field.schema;
+        const paths = Object.keys(singleNestedPaths).length > 0 ? singleNestedPaths : field.schema.paths;
+        return Object.entries(paths).reduce((columnType, [fieldPath, fieldSchema]) => {
+            return SchemaFieldsGenerator.getColumnTypeFromNestedPath(fieldPath.split('.'), fieldSchema, columnType);
+        }, {});
+    }
+    static getColumnTypeFromNestedPath(fieldPath, field, columnType = {}) {
+        let previousPath;
+        fieldPath.forEach((fieldName, index) => {
+            if (fieldName === '_id') {
+                return;
+            }
+            if (index !== fieldPath.length - 1) {
+                if (previousPath) {
+                    if (!previousPath[fieldName]) {
+                        previousPath[fieldName] = {};
+                    }
+                    previousPath = previousPath[fieldName];
+                }
+                else {
+                    if (!columnType[fieldName]) {
+                        columnType[fieldName] = {};
+                    }
+                    previousPath = columnType[fieldName];
+                }
+            }
+            else {
+                if (!previousPath) {
+                    previousPath = columnType;
+                }
+                previousPath[fieldName] = SchemaFieldsGenerator.getColumnType(field.instance, field);
+            }
+        });
+        return columnType;
+    }
+}
+exports.default = SchemaFieldsGenerator;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@forestadmin/datasource-mongoose",
+  "version": "1.0.0-beta.3",
+  "main": "dist/index.js",
+  "license": "GPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForestAdmin/agent-nodejs.git",
+    "directory": "packages/datasource-mongoose"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@forestadmin/datasource-toolkit": "1.0.0-beta.17",
+    "mongoose": "^6.3.2"
+  },
+  "peerDependencies": {},
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf coverage dist",
+    "lint": "eslint src test",
+    "test": "jest"
+  }
+}