@palmares/schemas 0.0.1 → 0.1.1

package/dist/cjs/src/model.js

@@ -409,218 +409,218 @@ function modelSchema(model, options) {
     lazyModelSchema.__model = model;
     // Add this callback to transform the model fields
     parentSchema.__runBeforeParseAndData = /*#__PURE__*/ _async_to_generator(function() {
-        var fieldsOfModels, fieldsAsEntries, fieldsWithAutomaticRelations, fields, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step;
+        var promise;
         return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    if (parentSchema.__alreadyAppliedModel) return [
-                        2
-                    ];
-                    parentSchema.__alreadyAppliedModel = true;
-                    fieldsOfModels = model._fields();
-                    fieldsAsEntries = Object.entries(fieldsOfModels);
-                    fieldsWithAutomaticRelations = new Map();
-                    return [
-                        4,
-                        fieldsAsEntries.reduce(function() {
-                            var _ref = _async_to_generator(function(accumulatorAsPromise, param) {
-                                var _param, key, value, schema, optionsForForeignKeyRelation, _parentSchema___getParent, newSchema, _optionsForForeignKeyRelation_foreignKeyRelation, rootSchema, existingRelations, accumulator;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-                                            if (omitAsSet.has(key)) return [
-                                                2,
-                                                accumulatorAsPromise
-                                            ];
-                                            if (showAsSet.size > 0 && !showAsSet.has(key)) return [
-                                                2,
-                                                accumulatorAsPromise
-                                            ];
-                                            schema = fieldsAsObject[key];
-                                            optionsForForeignKeyRelation = {};
-                                            if (!(!schema || _instanceof(value, _databases.ForeignKeyField))) return [
-                                                3,
-                                                2
-                                            ];
-                                            return [
-                                                4,
-                                                getSchemaFromModelField(model, value, parentSchema === null || parentSchema === void 0 ? void 0 : (_parentSchema___getParent = parentSchema.__getParent) === null || _parentSchema___getParent === void 0 ? void 0 : _parentSchema___getParent.call(parentSchema), options === null || options === void 0 ? void 0 : options.fields, options === null || options === void 0 ? void 0 : options.engineInstance, optionsForForeignKeyRelation)
-                                            ];
-                                        case 1:
-                                            newSchema = _state.sent();
-                                            if (!schema) schema = newSchema;
-                                            _state.label = 2;
-                                        case 2:
-                                            // Appends the foreign key relation to the schema automatically.
-                                            if (optionsForForeignKeyRelation.foreignKeyRelation) {
-                                                ;
-                                                rootSchema = (optionsForForeignKeyRelation === null || optionsForForeignKeyRelation === void 0 ? void 0 : (_optionsForForeignKeyRelation_foreignKeyRelation = optionsForForeignKeyRelation.foreignKeyRelation) === null || _optionsForForeignKeyRelation_foreignKeyRelation === void 0 ? void 0 : _optionsForForeignKeyRelation_foreignKeyRelation.schema) || lazyModelSchema;
-                                                existingRelations = fieldsWithAutomaticRelations.get(rootSchema) || [];
-                                                existingRelations.push({
-                                                    relationOrRelatedName: optionsForForeignKeyRelation.foreignKeyRelation.relationOrRelatedName,
-                                                    isArray: optionsForForeignKeyRelation.foreignKeyRelation.isArray,
-                                                    model: optionsForForeignKeyRelation.foreignKeyRelation.model,
-                                                    fieldToSearchOnModel: optionsForForeignKeyRelation.foreignKeyRelation.fieldToSearchOnModel,
-                                                    fieldToGetFromData: optionsForForeignKeyRelation.foreignKeyRelation.fieldToGetFromData
-                                                });
-                                                fieldsWithAutomaticRelations.set(rootSchema, existingRelations);
-                                            }
-                                            return [
-                                                4,
-                                                accumulatorAsPromise
-                                            ];
-                                        case 3:
-                                            accumulator = _state.sent();
-                                            accumulator[key] = schema;
-                                            return [
-                                                2,
-                                                accumulator
-                                            ];
+            promise = new Promise(function(resolve) {
+                var fieldsOfModels = model._fields();
+                var fieldsAsEntries = Object.entries(fieldsOfModels);
+                var fieldsWithAutomaticRelations = new Map();
+                var fields = fieldsAsObject;
+                Promise.all(fieldsAsEntries.map(function() {
+                    var _ref = _async_to_generator(function(param) {
+                        var _param, key, value, schema, optionsForForeignKeyRelation, _parentSchema___getParent, newSchema, _optionsForForeignKeyRelation_foreignKeyRelation, rootSchema, existingRelations;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                                    if (omitAsSet.has(key)) return [
+                                        2
+                                    ];
+                                    if (showAsSet.size > 0 && !showAsSet.has(key)) return [
+                                        2
+                                    ];
+                                    schema = fieldsAsObject[key];
+                                    optionsForForeignKeyRelation = {};
+                                    if (!(!schema || _instanceof(value, _databases.ForeignKeyField))) return [
+                                        3,
+                                        2
+                                    ];
+                                    return [
+                                        4,
+                                        getSchemaFromModelField(model, value, parentSchema === null || parentSchema === void 0 ? void 0 : (_parentSchema___getParent = parentSchema.__getParent) === null || _parentSchema___getParent === void 0 ? void 0 : _parentSchema___getParent.call(parentSchema), options === null || options === void 0 ? void 0 : options.fields, options === null || options === void 0 ? void 0 : options.engineInstance, optionsForForeignKeyRelation)
+                                    ];
+                                case 1:
+                                    newSchema = _state.sent();
+                                    if (!schema) schema = newSchema;
+                                    _state.label = 2;
+                                case 2:
+                                    // Appends the foreign key relation to the schema automatically.
+                                    if (optionsForForeignKeyRelation.foreignKeyRelation) {
+                                        ;
+                                        rootSchema = (optionsForForeignKeyRelation === null || optionsForForeignKeyRelation === void 0 ? void 0 : (_optionsForForeignKeyRelation_foreignKeyRelation = optionsForForeignKeyRelation.foreignKeyRelation) === null || _optionsForForeignKeyRelation_foreignKeyRelation === void 0 ? void 0 : _optionsForForeignKeyRelation_foreignKeyRelation.schema) || lazyModelSchema;
+                                        existingRelations = fieldsWithAutomaticRelations.get(rootSchema) || [];
+                                        existingRelations.push({
+                                            relationOrRelatedName: optionsForForeignKeyRelation.foreignKeyRelation.relationOrRelatedName,
+                                            isArray: optionsForForeignKeyRelation.foreignKeyRelation.isArray,
+                                            model: optionsForForeignKeyRelation.foreignKeyRelation.model,
+                                            fieldToSearchOnModel: optionsForForeignKeyRelation.foreignKeyRelation.fieldToSearchOnModel,
+                                            fieldToGetFromData: optionsForForeignKeyRelation.foreignKeyRelation.fieldToGetFromData
+                                        });
+                                        fieldsWithAutomaticRelations.set(rootSchema, existingRelations);
                                     }
-                                });
-                            });
-                            return function(accumulatorAsPromise, _) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }(), Promise.resolve(fieldsAsObject))
-                    ];
-                case 1:
-                    fields = _state.sent();
-                    if (fieldsWithAutomaticRelations.size > 0) {
-                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                        try {
-                            _loop = function() {
-                                var _step_value = _sliced_to_array(_step.value, 2), schema = _step_value[0], relations = _step_value[1];
-                                schema.toRepresentation(function() {
-                                    var _ref = _async_to_generator(function(data) {
-                                        var allData;
-                                        return _ts_generator(this, function(_state) {
-                                            switch(_state.label){
-                                                case 0:
-                                                    allData = Array.isArray(data) ? data : [
-                                                        data
-                                                    ];
-                                                    // since we are changing the data by reference, just return the data itself.
-                                                    return [
-                                                        4,
-                                                        Promise.all(allData.map(function() {
-                                                            var _ref = _async_to_generator(function(data) {
-                                                                return _ts_generator(this, function(_state) {
-                                                                    return [
-                                                                        2,
-                                                                        Promise.all(relations.map(function() {
-                                                                            var _ref = _async_to_generator(function(relation) {
-                                                                                var relationData;
-                                                                                return _ts_generator(this, function(_state) {
-                                                                                    switch(_state.label){
-                                                                                        case 0:
-                                                                                            // Ignore if the data of the relation already exists
-                                                                                            if (relation.relationOrRelatedName in data) return [
-                                                                                                2
-                                                                                            ];
-                                                                                            return [
-                                                                                                4,
-                                                                                                relation.model.default.get({
-                                                                                                    search: _define_property({}, relation.fieldToSearchOnModel, data[relation.fieldToGetFromData])
-                                                                                                })
-                                                                                            ];
-                                                                                        case 1:
-                                                                                            relationData = _state.sent();
-                                                                                            if (relation.isArray !== true) relationData = relationData[0];
-                                                                                            data[relation.relationOrRelatedName] = relationData;
-                                                                                            if (schema.__omitRelation.has(relation.relationOrRelatedName)) delete data[relation.fieldToGetFromData];
-                                                                                            return [
-                                                                                                2
-                                                                                            ];
-                                                                                    }
-                                                                                });
+                                    fieldsAsObject[key] = schema;
+                                    return [
+                                        2,
+                                        fieldsAsObject
+                                    ];
+                            }
+                        });
+                    });
+                    return function(_) {
+                        return _ref.apply(this, arguments);
+                    };
+                }())).then(/*#__PURE__*/ _async_to_generator(function() {
+                    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (fieldsWithAutomaticRelations.size > 0) {
+                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                    try {
+                                        _loop = function() {
+                                            var _step_value = _sliced_to_array(_step.value, 2), schema = _step_value[0], relations = _step_value[1];
+                                            schema.toRepresentation(function() {
+                                                var _ref = _async_to_generator(function(data) {
+                                                    var allData;
+                                                    return _ts_generator(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                allData = Array.isArray(data) ? data : [
+                                                                    data
+                                                                ];
+                                                                // since we are changing the data by reference, just return the data itself.
+                                                                return [
+                                                                    4,
+                                                                    Promise.all(allData.map(function() {
+                                                                        var _ref = _async_to_generator(function(data) {
+                                                                            return _ts_generator(this, function(_state) {
+                                                                                return [
+                                                                                    2,
+                                                                                    Promise.all(relations.map(function() {
+                                                                                        var _ref = _async_to_generator(function(relation) {
+                                                                                            var relationData;
+                                                                                            return _ts_generator(this, function(_state) {
+                                                                                                switch(_state.label){
+                                                                                                    case 0:
+                                                                                                        // Ignore if the data of the relation already exists
+                                                                                                        if (relation.relationOrRelatedName in data) return [
+                                                                                                            2
+                                                                                                        ];
+                                                                                                        return [
+                                                                                                            4,
+                                                                                                            relation.model.default.get({
+                                                                                                                search: _define_property({}, relation.fieldToSearchOnModel, data[relation.fieldToGetFromData])
+                                                                                                            })
+                                                                                                        ];
+                                                                                                    case 1:
+                                                                                                        relationData = _state.sent();
+                                                                                                        if (relation.isArray !== true) relationData = relationData[0];
+                                                                                                        data[relation.relationOrRelatedName] = relationData;
+                                                                                                        if (schema.__omitRelation.has(relation.relationOrRelatedName)) delete data[relation.fieldToGetFromData];
+                                                                                                        return [
+                                                                                                            2
+                                                                                                        ];
+                                                                                                }
+                                                                                            });
+                                                                                        });
+                                                                                        return function(relation) {
+                                                                                            return _ref.apply(this, arguments);
+                                                                                        };
+                                                                                    }()))
+                                                                                ];
                                                                             });
-                                                                            return function(relation) {
-                                                                                return _ref.apply(this, arguments);
-                                                                            };
-                                                                        }()))
-                                                                    ];
-                                                                });
-                                                            });
-                                                            return function(data) {
-                                                                return _ref.apply(this, arguments);
-                                                            };
-                                                        }()))
-                                                    ];
-                                                case 1:
-                                                    _state.sent();
-                                                    return [
-                                                        2,
-                                                        data
-                                                    ];
+                                                                        });
+                                                                        return function(data) {
+                                                                            return _ref.apply(this, arguments);
+                                                                        };
+                                                                    }()))
+                                                                ];
+                                                            case 1:
+                                                                _state.sent();
+                                                                return [
+                                                                    2,
+                                                                    data
+                                                                ];
+                                                        }
+                                                    });
+                                                });
+                                                return function(data) {
+                                                    return _ref.apply(this, arguments);
+                                                };
+                                            }(), {
+                                                after: true
+                                            });
+                                        };
+                                        // This way we can get all of the relations concurrently with Promise.all
+                                        for(_iterator = fieldsWithAutomaticRelations.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                                    } catch (err) {
+                                        _didIteratorError = true;
+                                        _iteratorError = err;
+                                    } finally{
+                                        try {
+                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                _iterator.return();
                                             }
-                                        });
-                                    });
-                                    return function(data) {
-                                        return _ref.apply(this, arguments);
-                                    };
-                                }(), {
-                                    after: true
-                                });
-                            };
-                            // This way we can get all of the relations concurrently with Promise.all
-                            for(_iterator = fieldsWithAutomaticRelations.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                        } catch (err) {
-                            _didIteratorError = true;
-                            _iteratorError = err;
-                        } finally{
-                            try {
-                                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                    _iterator.return();
-                                }
-                            } finally{
-                                if (_didIteratorError) {
-                                    throw _iteratorError;
+                                        } finally{
+                                            if (_didIteratorError) {
+                                                throw _iteratorError;
+                                            }
+                                        }
+                                    }
                                 }
-                            }
+                                lazyModelSchema.__data = fields;
+                                return [
+                                    4,
+                                    Promise.all(customFieldValues.map(function() {
+                                        var _ref = _async_to_generator(function(schema) {
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        schema['__getParent'] = function() {
+                                                            return lazyModelSchema;
+                                                        };
+                                                        if (!schema['__runBeforeParseAndData']) return [
+                                                            3,
+                                                            2
+                                                        ];
+                                                        return [
+                                                            4,
+                                                            schema['__runBeforeParseAndData'](schema)
+                                                        ];
+                                                    case 1:
+                                                        _state.sent();
+                                                        _state.label = 2;
+                                                    case 2:
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(schema) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 1:
+                                _state.sent();
+                                resolve(undefined);
+                                return [
+                                    2
+                                ];
                         }
-                    }
-                    lazyModelSchema.__data = fields;
-                    return [
-                        4,
-                        Promise.all(customFieldValues.map(function() {
-                            var _ref = _async_to_generator(function(schema) {
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            schema['__getParent'] = function() {
-                                                return lazyModelSchema;
-                                            };
-                                            if (!schema['__runBeforeParseAndData']) return [
-                                                3,
-                                                2
-                                            ];
-                                            return [
-                                                4,
-                                                schema['__runBeforeParseAndData'](schema)
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            _state.label = 2;
-                                        case 2:
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            });
-                            return function(schema) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }()))
-                    ];
-                case 2:
-                    _state.sent();
-                    return [
-                        2
-                    ];
-            }
+                    });
+                }));
+            });
+            if (parentSchema.__alreadyAppliedModel) return [
+                2,
+                parentSchema.__alreadyAppliedModel
+            ];
+            parentSchema.__alreadyAppliedModel = promise;
+            return [
+                2,
+                promise
+            ];
         });
     });
     if ((options === null || options === void 0 ? void 0 : options.ignoreExtraneousFields) !== true) lazyModelSchema.removeExtraneous();