ducktyper/lib/functions/duckorate.js

A tool for validating input based on the fundamental js idea of duck typing. The object of this is to allow for clearer input validation and specification from the perspective of the developer. It will reduce the amount of time it takes to do input valida

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.duckorate = exports.classifyDuck = exports.dtoToIsDuck = void 0;
const mergeObjects_1 = __importDefault(require("./mergeObjects"));
require("reflect-metadata");
const settings_1 = require("./settings");
const class_validator_1 = require("class-validator");
const duckdto_1 = require("../classes/duckdto");
const isObject_1 = __importDefault(require("./is/isObject"));
function dtoToIsDuck(ADuckDto) {
    if (ADuckDto.prototype instanceof duckdto_1.DuckDto) {
        function isDuck(val, options) {
            let obj = new ADuckDto();
            if ( //if object
            typeof val === 'object' &&
                !Array.isArray(val) &&
                val !== null &&
                (0, isObject_1.default)(val)) { //initialize and test
                obj = Object.assign(obj, val);
                return classifyDuck(obj, options);
            }
            else { //fail
                return classifyDuck(obj, Object.assign({}, options));
            }
        }
        isDuck.isDuck = true;
        return isDuck;
    }
    else {
        throw new Error("Must be an instance of DuckDto to be turned into isDuck");
    }
}
exports.dtoToIsDuck = dtoToIsDuck;
function classifyDuck(dto, options) {
    options = (0, mergeObjects_1.default)(settings_1.CLASIFYDUCK_OPTIONS, options || {});
    if (options.forceDuck && !(dto instanceof duckdto_1.DuckDto)) {
        throw new Error("Must be an instance of DuckDto to be clasified");
    }
    try {
        //change dto to {} when it is undefined since {} and undefined are basically the same in this case
        var [err] = (0, class_validator_1.validateSync)(dto || {});
        if (err && err.constraints) {
            err = err.constraints.customText;
        }
    }
    catch (e) {
        var err = e.message;
    }
    if (err && options.throw) {
        if (options.message) {
            throw new Error(options.message);
        }
        else {
            throw new Error(err);
        }
    }
    return err ? false : true;
}
exports.classifyDuck = classifyDuck;
function duckorate(duck, options) {
    const duckDecorator = makePropertyDuckorator(duck, options);
    return function combinedDecorator(target, key) {
        duckDecorator(target, key);
        initializeToNull(target, key);
    };
}
exports.duckorate = duckorate;
function makePropertyDuckorator(duck, options) {
    options = options || {};
    let DuckValidation = class DuckValidation {
        validate(val, args) {
            return duck(val, Object.assign(Object.assign({}, options), { throw: false }));
        }
        defaultMessage(args) {
            try {
                duck(undefined, {
                    allowUndefined: false,
                    throw: true,
                });
            }
            catch (error) {
                return options.message || error.message;
            }
        }
    };
    DuckValidation = __decorate([
        (0, class_validator_1.ValidatorConstraint)({ name: 'customText', async: false })
    ], DuckValidation);
    //this is used to protect the user from adding duckorator to a non DuckDto class 
    return function forceDuckDto(target, name) {
        if (target instanceof duckdto_1.DuckDto) {
            return (0, class_validator_1.Validate)(DuckValidation)(target, name);
        }
        else {
            throw new Error("Duckorator must be used in a class that extends DuckDto");
        }
    };
}
function initializeToNull(target, key) {
    target[key] = null;
}