adonis-responsive-attachment
Version:
Generate and persist optimised and responsive breakpoint images on the fly in your AdonisJS application.
185 lines (184 loc) • 8.28 kB
JavaScript
;
/*
* adonis-responsive-attachment
*
* (c) Ndianabasi Udonkang <ndianabasi@furnish.ng>
*
* For the full copyright and license information,
* please view the LICENSE file that was distributed with
* this source code.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendValidator = void 0;
const promises_1 = require("fs/promises");
const utils_1 = require("@poppinss/utils");
const image_manipulation_helper_1 = require("../Helpers/image_manipulation_helper");
var ImageDimensionsValidationRule;
(function (ImageDimensionsValidationRule) {
ImageDimensionsValidationRule["maxImageWidth"] = "maxImageWidth";
ImageDimensionsValidationRule["maxImageHeight"] = "maxImageHeight";
ImageDimensionsValidationRule["minImageWidth"] = "minImageWidth";
ImageDimensionsValidationRule["minImageHeight"] = "minImageHeight";
ImageDimensionsValidationRule["imageAspectRatio"] = "imageAspectRatio";
})(ImageDimensionsValidationRule || (ImageDimensionsValidationRule = {}));
/**
* Ensure image is complaint with expected dimensions validations
*/
class ImageDimensionsCheck {
constructor(ruleName, logger) {
this.ruleName = ruleName;
this.logger = logger;
}
/**
* Compile validation options
*/
compile(validationValue) {
/**
* Ensure options are defined with table and column name
*/
if (!validationValue) {
throw new utils_1.Exception(`"${this.ruleName}" rule expects a "validationValue"`);
}
return {
validationValue,
};
}
/**
* Validate the file
*/
async validate(file, { validationValue }, { pointer, errorReporter, arrayExpressionPointer }) {
if (!file) {
return;
}
if (!file.tmpPath) {
throw new Error('[Adonis Responsive Attachment] File is invalid');
}
const imageBuffer = await (0, promises_1.readFile)(file.tmpPath);
const { width, height } = await (0, image_manipulation_helper_1.getMetaData)(imageBuffer);
const reportError = () => {
errorReporter.report(pointer, this.ruleName, `${this.ruleName} validation failure`, arrayExpressionPointer, { [this.ruleName]: validationValue });
};
if (this.ruleName === 'minImageWidth') {
if (!width || width < validationValue) {
reportError();
}
return;
}
if (this.ruleName === 'minImageHeight') {
if (!height || height < validationValue) {
reportError();
}
return;
}
if (this.ruleName === 'maxImageWidth') {
if (!width || width > validationValue) {
reportError();
}
return;
}
if (this.ruleName === 'maxImageHeight') {
if (!height || height > validationValue) {
reportError();
}
return;
}
if (this.ruleName === 'imageAspectRatio') {
if (!height || !width || width / height !== validationValue) {
reportError();
}
return;
}
throw new Error('[Adonis Responsive Attachment] Invalid image validation operation');
}
}
function throwCatchallError(error) {
if (error.message === '[Adonis Responsive Attachment] Invalid image validation operation') {
throw error;
}
}
/**
* Extends the validator by adding `unique` and `exists`
*/
function extendValidator(validator, logger) {
const minImageWidthRuleChecker = new ImageDimensionsCheck(ImageDimensionsValidationRule.minImageWidth, logger);
validator.rule(minImageWidthRuleChecker.ruleName, async (value, compiledOptions, options) => {
try {
await minImageWidthRuleChecker.validate(value, compiledOptions, options);
}
catch (error) {
throwCatchallError(error);
logger.fatal({ err: error }, `"${minImageWidthRuleChecker.ruleName}" validation rule failed`);
return options.errorReporter.report(options.pointer, `${minImageWidthRuleChecker.ruleName}`, `${minImageWidthRuleChecker.ruleName} validation failure`, options.arrayExpressionPointer, { [minImageWidthRuleChecker.ruleName]: compiledOptions.validationValue });
}
}, (options) => {
return {
compiledOptions: minImageWidthRuleChecker.compile(options[0]),
async: true,
};
});
const minImageHeightRuleChecker = new ImageDimensionsCheck(ImageDimensionsValidationRule.minImageHeight, logger);
validator.rule(minImageHeightRuleChecker.ruleName, async (value, compiledOptions, options) => {
try {
await minImageHeightRuleChecker.validate(value, compiledOptions, options);
}
catch (error) {
throwCatchallError(error);
logger.fatal({ err: error }, `"${minImageHeightRuleChecker.ruleName}" validation rule failed`);
options.errorReporter.report(options.pointer, `${minImageHeightRuleChecker.ruleName}`, `${minImageHeightRuleChecker.ruleName} validation failure`, options.arrayExpressionPointer, { [minImageHeightRuleChecker.ruleName]: compiledOptions.validationValue });
}
}, (options) => {
return {
compiledOptions: minImageHeightRuleChecker.compile(options[0]),
async: true,
};
});
const maxImageWidthRuleChecker = new ImageDimensionsCheck(ImageDimensionsValidationRule.maxImageWidth, logger);
validator.rule(maxImageWidthRuleChecker.ruleName, async (value, compiledOptions, options) => {
try {
await maxImageWidthRuleChecker.validate(value, compiledOptions, options);
}
catch (error) {
throwCatchallError(error);
logger.fatal({ err: error }, `"${maxImageWidthRuleChecker.ruleName}" validation rule failed`);
options.errorReporter.report(options.pointer, `${maxImageWidthRuleChecker.ruleName}`, `${maxImageWidthRuleChecker.ruleName} validation failure`, options.arrayExpressionPointer, { [maxImageWidthRuleChecker.ruleName]: compiledOptions.validationValue });
}
}, (options) => {
return {
compiledOptions: maxImageWidthRuleChecker.compile(options[0]),
async: true,
};
});
const maxImageHeightRuleChecker = new ImageDimensionsCheck(ImageDimensionsValidationRule.maxImageHeight, logger);
validator.rule(maxImageHeightRuleChecker.ruleName, async (value, compiledOptions, options) => {
try {
await maxImageHeightRuleChecker.validate(value, compiledOptions, options);
}
catch (error) {
throwCatchallError(error);
logger.fatal({ err: error }, `"${maxImageHeightRuleChecker.ruleName}" validation rule failed`);
options.errorReporter.report(options.pointer, `${maxImageHeightRuleChecker.ruleName}`, `${maxImageHeightRuleChecker.ruleName} validation failure`, options.arrayExpressionPointer, { [maxImageHeightRuleChecker.ruleName]: compiledOptions.validationValue });
}
}, (options) => {
return {
compiledOptions: maxImageHeightRuleChecker.compile(options[0]),
async: true,
};
});
const aspectRatioRuleChecker = new ImageDimensionsCheck(ImageDimensionsValidationRule.imageAspectRatio, logger);
validator.rule(aspectRatioRuleChecker.ruleName, async (value, compiledOptions, options) => {
try {
await aspectRatioRuleChecker.validate(value, compiledOptions, options);
}
catch (error) {
throwCatchallError(error);
logger.fatal({ err: error }, `"${aspectRatioRuleChecker.ruleName}" validation rule failed`);
options.errorReporter.report(options.pointer, `${aspectRatioRuleChecker.ruleName}`, `${aspectRatioRuleChecker.ruleName} validation failure`, options.arrayExpressionPointer, { [aspectRatioRuleChecker.ruleName]: compiledOptions.validationValue });
}
}, (options) => {
return {
compiledOptions: aspectRatioRuleChecker.compile(options[0]),
async: true,
};
});
}
exports.extendValidator = extendValidator;