ts-db-helper/src/core/serializers/field-serializers/field-serializer.js

Simple ORM based on TypeScript

import { ModelManager } from '../../managers/model-manager';
import { SerializerError } from '../../errors/serializer.error';
import { FieldSerializerRules } from './field-serializer-rules';
import { FieldSerializerError } from './field-serializer.error';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/Observable/empty';
import 'rxjs/add/Observable/from';
import 'rxjs/add/operator/switchMap';
import 'rxjs/add/operator/catch';
var FieldSerializer = /** @class */ (function () {
    function FieldSerializer(fieldName, jsonKey, config) {
        this.fieldName = fieldName;
        this.jsonKey = jsonKey;
        this.rules = new FieldSerializerRules();
        this.partial = false;
        if (config) {
            for (var key in config) {
                if (config.hasOwnProperty(key)) {
                    this.rules[key] = config[key];
                }
            }
        }
    }
    FieldSerializer.prototype.isValid = function (data) {
        if (data.hasOwnProperty(data)) {
            if (this.rules.isReadonly) {
                return new FieldSerializerError(this.jsonKey, 'Field is readonly', this.rules);
            }
            else {
                return this.checkFieldRules(data);
            }
        }
        else {
            if (this.rules.isOptional) {
                return null;
            }
            else {
                return new FieldSerializerError(this.jsonKey, 'Field could be missing or null', this.rules);
            }
        }
    };
    FieldSerializer.prototype.serialize = function (from, to) {
        var _this = this;
        var val = from.getFieldValue(this.fieldName);
        if (!this.rules.isWriteonly && !this.rules.formatter) {
            to[this.jsonKey] = val;
            return Observable.empty();
        }
        else if (this.rules.formatter) {
            to[this.jsonKey] = this.rules.formatter(from);
            return Observable.empty();
        }
        else if (this.rules.serializer) {
            return from.getLinked(this.rules.serializer.model).switchMap(function (qr) {
                if (_this.rules.serializer.many) {
                    _this.rules.serializer.setInstances(qr.rows.toArray());
                }
                else if (qr.rows.length) {
                    _this.rules.serializer.setInstance(qr.rows.item(0));
                }
                return _this.rules.serializer.getData().map(function (data) {
                    to[_this.jsonKey] = data;
                    return null;
                });
            });
        }
        return Observable.empty();
    };
    FieldSerializer.prototype.deserialize = function (from, to) {
        var _this = this;
        var error = this.isValid(to);
        if (!error) {
            var val = from[this.jsonKey];
            if (val !== undefined && this.partial) {
                var column = ModelManager.getInstance().getModel(to).fields[this.fieldName];
                if (!to.$$partialWithProjection) {
                    to.$$partialWithProjection = [];
                }
                to.$$partialWithProjection.push(column.name);
            }
            if (val === undefined) {
                if (!this.partial) {
                    if (this.rules.defaultValue !== null && this.rules.defaultValue !== undefined) {
                        to.setFieldValue(this.fieldName, this.rules.defaultValue);
                    }
                    else {
                        to.setFieldValue(this.fieldName, null);
                    }
                }
                return Observable.from([null]);
            }
            else if (this.rules.serializer) {
                this.rules.serializer.setData(val);
                return this.rules.serializer.getInstance().map(function (instance) {
                    to.setFieldValue(_this.fieldName, instance);
                    return null;
                }).catch(function (err) {
                    var fieldError = new FieldSerializerError(_this.jsonKey, 'Can\'t serialize model "' + _this.rules.serializer.model.name + '"', _this.rules);
                    if (err instanceof SerializerError) {
                        fieldError.error = err.fieldErrors;
                    }
                    else {
                        fieldError.error = err;
                    }
                    return Observable.from([fieldError]);
                });
            }
            else {
                to.setFieldValue(this.fieldName, from[this.jsonKey]);
                return Observable.from([null]);
            }
        }
        return Observable.from([error]);
    };
    return FieldSerializer;
}());
export { FieldSerializer };
//# sourceMappingURL=field-serializer.js.map