mage-validator
Version:
Validation utility for MAGE user commands & topics (TypeScript)
201 lines • 23.5 kB
JavaScript
;
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
const classTransformer = require("class-transformer");
const classValidator = require("class-validator");
const classes_1 = require("./classes");
const errors_1 = require("./errors");
const deepIterator = require('deep-iterator').default;
const functionArguments = require('function-arguments');
// Expose everything from class-validator and class-transformer
__export(require("class-transformer"));
__export(require("class-validator"));
/**
* wrap the class' static create method
*
* @param target
* @param key
* @param childrenType
* @param type
*/
function wrapCreate(target, key, childrenType, validateFunction, mapType) {
const { create } = target;
target.create = async (state, index, data) => {
const instance = await create.call(target, state, index, data);
const map = mapType ? new mapType() : {};
if (!instance[key]) {
return instance;
}
for (const [subkey, value] of Object.entries(instance[key])) {
map[subkey] = Object.assign(new childrenType(), value);
}
instance[key] = map;
return instance;
};
const { validate } = target.prototype;
target.prototype.validate = async function (errorMessage, code) {
await validate.call(this, errorMessage, code);
let errors = [];
if (!this[key]) {
return;
}
for (const [subkey, value] of Object.entries(this[key])) {
errors = errors.concat(await classValidator.validate(value));
if (!validateFunction) {
continue;
}
try {
validateFunction(subkey, value);
}
catch (error) {
error.message = `Validation error on ${key}.${subkey}: ${error.message}`;
const validationError = new classValidator.ValidationError();
validationError.target = target;
validationError.property = key;
validationError.value = value;
validationError.constraints = {
mapOf: error.message
};
errors.push(Object.assign(validationError, error));
}
}
if (errors.length > 0) {
this.raiseValidationError(errors, errorMessage, code);
}
};
}
/**
*
* @param type
*/
function MapOf(type, validateFunction) {
return (target, key) => {
if (!key) {
target.isMapOf = { type, validateFunction };
}
else {
wrapCreate(target.constructor, key, type, validateFunction);
}
};
}
exports.MapOf = MapOf;
/**
* Wrap @Type from class-transformer
*
* @param type The type to configure
*/
function Type(type) {
if (type.isMapOf) {
const { type: childrenType, validateFunction } = type.isMapOf;
return (target, key) => wrapCreate(target.constructor, key, childrenType, validateFunction, type);
}
if (type.prototype) {
return classTransformer.Type(/* istanbul ignore next */ () => type);
}
return classTransformer.Type(type);
}
exports.Type = Type;
/**
* Validate ValidatedObjects and throw an error if the data is invalid.
*
* @param message
* @param code
* @param state
* @param parsedData
* @param receivedData
*/
async function validateObject(message, code, state, parsedData, receivedData) {
const errors = await classValidator.validate(parsedData);
if (errors.length > 0) {
throw new errors_1.ValidationError(message, code, {
actorId: state.actorId,
userCommand: state.description,
receivedData,
parsedData
}, errors);
}
return parsedData;
}
/**
* Validate the output of an `execute` call of an user command.
*
* @param value
*/
async function validateOutput(state, value) {
const type = typeof value;
if (type !== 'object') {
return;
}
if (!Array.isArray(value)) {
return validateObject('Invalid user command return value', 'server', state, value);
}
for (const val of value) {
await validateOutput(state, val);
}
}
/**
* @Acl decorator
*
* Protect the user command with the given ACL and defined type validation
*/
function Acl(...acl) {
return function (UserCommand, key) {
if (key !== 'execute') {
throw errors_1.crash('@validate only works for usercommand.execute functions', {
method: key,
userCommand: UserCommand
});
}
const execute = UserCommand.execute;
const parameterNames = functionArguments(execute);
const types = Reflect.getMetadata('design:paramtypes', UserCommand, key);
if (!types) {
throw errors_1.crash('Reflect.getMetadata returned null.\
Did you set experimentalDecorators and emitDecoratorMetadata to true in your tsconfig.json ?', {
method: key,
userCommand: UserCommand
});
}
// We extract the state information, since we won't need it
parameterNames.shift();
types.shift();
// We attach additional information to the UserCommand class
UserCommand.acl = acl;
UserCommand.params = parameterNames;
return {
value: async (state, ...args) => {
// Map user command's parameters
const userCommandData = {};
args.forEach((arg, pos) => {
const parameterName = parameterNames[pos];
userCommandData[parameterName] = arg;
});
// Cast data into a user command instance
const userCommand = classTransformer.plainToClass(UserCommand, userCommandData);
for (const { value } of deepIterator(userCommand)) {
if (value instanceof classes_1.ValidatedTopic) {
value.setState(state);
const index = value.index || {};
await value.setIndex(index);
delete value.index;
}
}
// Validate all parameters at once
await validateObject('Invalid user command input', 'invalidInput', state, userCommand, userCommandData);
// Map casted parameters into an array of arguments
const castedArgs = args.map((_arg, pos) => {
const parameterName = parameterNames[pos];
return userCommand[parameterName];
});
// Execute the actual user command
const output = await execute(state, ...castedArgs);
await validateOutput(state, output);
return output;
}
};
};
}
exports.Acl = Acl;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import * as mage from 'mage'\nimport * as classTransformer from 'class-transformer'\nimport * as classValidator from 'class-validator'\n\nimport { ValidatedTopic } from './classes'\nimport { crash, ValidationError } from './errors'\n\nconst deepIterator = require('deep-iterator').default\nconst functionArguments = require('function-arguments')\n\n/**\n * usercommand.execute function signature\n */\ntype IExecuteFunction = <T>(state: mage.core.IState, ...args: any[]) => Promise<T>\n\n/**\n * Validate function type (currently used for MapOf)\n */\nexport type ValidateFunction = (key: string, value: any) => void\n\n// Expose everything from class-validator and class-transformer\nexport * from 'class-transformer'\nexport * from 'class-validator'\n\n/**\n * wrap the class' static create method\n *\n * @param target\n * @param key\n * @param childrenType\n * @param type\n */\nfunction wrapCreate(target: any, key: string, childrenType: any, validateFunction?: ValidateFunction, mapType?: any) {\n  const { create } = target\n\n  target.create = async (\n    state: mage.core.IState,\n    index: mage.archivist.IArchivistIndex,\n    data?: any\n  ) => {\n    const instance = await create.call(target, state, index, data)\n    const map = mapType ? new mapType() : {}\n\n    if (!instance[key]) {\n      return instance\n    }\n\n    for (const [subkey, value] of Object.entries(instance[key])) {\n      map[subkey] = Object.assign(new childrenType(), value)\n    }\n\n    instance[key] = map\n\n    return instance\n  }\n\n  const { validate } = target.prototype\n\n  target.prototype.validate = async function (errorMessage?: string, code?: string) {\n    await validate.call(this, errorMessage, code)\n    let errors: any[] = []\n\n    if (!this[key]) {\n      return\n    }\n\n    for (const [subkey, value] of Object.entries(this[key])) {\n      errors = errors.concat(await classValidator.validate(value))\n\n      if (!validateFunction) {\n        continue\n      }\n\n      try {\n        validateFunction(subkey, value)\n      } catch (error) {\n        error.message = `Validation error on ${key}.${subkey}: ${error.message}`\n\n        const validationError = new classValidator.ValidationError()\n        validationError.target = target\n        validationError.property = key\n        validationError.value = value\n        validationError.constraints = {\n          mapOf: error.message\n        }\n\n        errors.push(Object.assign(validationError, error))\n      }\n    }\n\n    if (errors.length > 0) {\n      this.raiseValidationError(errors, errorMessage, code)\n    }\n  }\n}\n\n/**\n *\n * @param type\n */\nexport function MapOf(type: any, validateFunction?: ValidateFunction) {\n  return (target: any, key?: string) => {\n    if (!key) {\n      target.isMapOf = { type, validateFunction }\n    } else {\n      wrapCreate(target.constructor, key, type, validateFunction)\n    }\n  }\n}\n\n/**\n * Wrap @Type from class-transformer\n *\n * @param type The type to configure\n */\nexport function Type(type: any) {\n  if (type.isMapOf) {\n    const { type: childrenType, validateFunction } = type.isMapOf\n    return (target: any, key: string) => wrapCreate(target.constructor, key, childrenType, validateFunction, type)\n  }\n\n  if (type.prototype) {\n    return classTransformer.Type(/* istanbul ignore next */ () => type)\n  }\n\n  return classTransformer.Type(type)\n}\n\n/**\n * Validate ValidatedObjects and throw an error if the data is invalid.\n *\n * @param message\n * @param code\n * @param state\n * @param parsedData\n * @param receivedData\n */\nasync function validateObject(message: string, code: string, state: any, parsedData: any, receivedData?: any) {\n  const errors = await classValidator.validate(parsedData)\n  if (errors.length > 0) {\n    throw new ValidationError(message, code, {\n      actorId: state.actorId,\n      userCommand: state.description,\n      receivedData,\n      parsedData\n    }, errors)\n  }\n\n  return parsedData\n}\n\n/**\n * Validate the output of an `execute` call of an user command.\n *\n * @param value\n */\nasync function validateOutput(state: mage.core.IState, value: any) {\n  const type = typeof value\n\n  if (type !== 'object') {\n    return\n  }\n\n  if (!Array.isArray(value)) {\n    return validateObject('Invalid user command return value', 'server', state, value)\n  }\n\n  for (const val of value) {\n    await validateOutput(state, val)\n  }\n}\n\n/**\n * @Acl decorator\n *\n * Protect the user command with the given ACL and defined type validation\n */\nexport function Acl(...acl: string[]) {\n  return function (UserCommand: any, key: string) {\n    if (key !== 'execute') {\n      throw crash('@validate only works for usercommand.execute functions', {\n        method: key,\n        userCommand: UserCommand\n      })\n    }\n\n    const execute = <IExecuteFunction> UserCommand.execute\n    const parameterNames = functionArguments(execute)\n    const types = Reflect.getMetadata('design:paramtypes', UserCommand, key)\n\n    if (!types) {\n        throw crash('Reflect.getMetadata returned null.\\\n        Did you set experimentalDecorators and emitDecoratorMetadata to true in your tsconfig.json ?', {\n            method: key,\n            userCommand: UserCommand\n        })\n    }\n\n    // We extract the state information, since we won't need it\n    parameterNames.shift()\n    types.shift()\n\n    // We attach additional information to the UserCommand class\n    UserCommand.acl = acl\n    UserCommand.params = parameterNames\n\n    return {\n      value: async (state: mage.core.IState, ...args: any[]) => {\n        // Map user command's parameters\n        const userCommandData: { [key: string]: any } = {}\n        args.forEach((arg, pos) => {\n          const parameterName = parameterNames[pos]\n          userCommandData[parameterName] = arg\n        })\n\n        // Cast data into a user command instance\n        const userCommand = classTransformer.plainToClass(UserCommand, userCommandData)\n        for (const { value } of deepIterator(userCommand)) {\n          if (value instanceof ValidatedTopic) {\n            value.setState(state)\n\n            const index = (<any> value).index || {}\n\n            await value.setIndex(index)\n            delete (<any> value).index\n          }\n        }\n\n        // Validate all parameters at once\n        await validateObject('Invalid user command input', 'invalidInput', state, userCommand, userCommandData)\n\n        // Map casted parameters into an array of arguments\n        const castedArgs = args.map((_arg, pos) => {\n          const parameterName = parameterNames[pos]\n          return (<any> userCommand)[parameterName]\n        })\n\n        // Execute the actual user command\n        const output = await execute(state, ...castedArgs)\n\n        await validateOutput(state, output)\n\n        return output as any\n      }\n    }\n  }\n}\n"]}