diff --git a/src/util/instanceOf.ts b/src/util/instanceOf.ts
index d83dc39c..341374b7 100644
--- a/src/util/instanceOf.ts
+++ b/src/util/instanceOf.ts
@@ -1,14 +1,17 @@
// different version of lambert-server instanceOf with discord error format
import { NextFunction, Request, Response } from "express";
+import { TFunction } from "i18next";
import { Tuple } from "lambert-server";
+import "missing-native-js-functions";
-const OPTIONAL_PREFIX = "$";
+export const OPTIONAL_PREFIX = "$";
+export const EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
export function check(schema: any) {
return (req: Request, res: Response, next: NextFunction) => {
try {
- const result = instanceOf(schema, req.body, { path: "body" });
+ const result = instanceOf(schema, req.body, { path: "body", t: req.t, ref: { obj: null, key: "" } });
if (result === true) return next();
throw result;
} catch (error) {
@@ -17,66 +20,113 @@ export function check(schema: any) {
};
}
-class FieldError extends Error {
- constructor(public code: string, public message: string) {
+export function FieldErrors(fields: Record<string, { code?: string; message: string }>) {
+ return new FieldError(
+ 50035,
+ "Invalid Form Body",
+ fields.map(({ message, code }) => ({
+ _errors: [
+ {
+ message,
+ code: code || "BASE_TYPE_INVALID",
+ },
+ ],
+ }))
+ );
+}
+
+export class FieldError extends Error {
+ constructor(public code: string | number, public message: string, public errors?: any) {
super(message);
}
}
+export class Email {
+ constructor(public email: string) {}
+ check() {
+ return !!this.email.match(EMAIL_REGEX);
+ }
+}
+
export function instanceOf(
type: any,
value: any,
- { path = "", optional = false, errors = {} }: { path?: string; optional?: boolean; errors?: any } = {}
+ {
+ path = "",
+ optional = false,
+ errors = {},
+ t,
+ ref,
+ }: { path?: string; optional?: boolean; errors?: any; t: TFunction; ref: { key: string | number; obj: any } }
): Boolean {
try {
if (!type) return true; // no type was specified
if (value == null) {
if (optional) return true;
- throw new FieldError("BASE_TYPE_REQUIRED", `This field is required`);
+ throw new FieldError("BASE_TYPE_REQUIRED", t("common:field.BASE_TYPE_REQUIRED"));
}
switch (type) {
case String:
if (typeof value === "string") return true;
- throw new FieldError("BASE_TYPE_STRING", `This field must be a string`);
+ throw new FieldError("BASE_TYPE_STRING", t("common:field.BASE_TYPE_STRING"));
case Number:
value = Number(value);
+ ref.obj[ref.key] = value;
if (typeof value === "number" && !isNaN(value)) return true;
- throw new FieldError("BASE_TYPE_NUMBER", `This field must be a number`);
+ throw new FieldError("BASE_TYPE_NUMBER", t("common:field.BASE_TYPE_NUMBER"));
case BigInt:
try {
value = BigInt(value);
+ ref.obj[ref.key] = value;
if (typeof value === "bigint") return true;
} catch (error) {}
- throw new FieldError("BASE_TYPE_BIGINT", `This field must be a bigint`);
+ throw new FieldError("BASE_TYPE_BIGINT", t("common:field.BASE_TYPE_BIGINT"));
case Boolean:
if (value == "true") value = true;
if (value == "false") value = false;
+ ref.obj[ref.key] = value;
if (typeof value === "boolean") return true;
- throw new FieldError("BASE_TYPE_BOOLEAN", `This field must be a boolean`);
+ throw new FieldError("BASE_TYPE_BOOLEAN", t("common:field.BASE_TYPE_BOOLEAN"));
+
+ case Tuple:
+ if ((<Tuple>type).types.some((x) => instanceOf(x, value, { path, optional, errors, t, ref })))
+ return true;
+ throw new FieldError("BASE_TYPE_CHOICES", t("common:field.BASE_TYPE_CHOICES", { types: type.types }));
+ case Email:
+ if ((<Email>type).check()) return true;
+ throw new FieldError("EMAIL_TYPE_INVALID_EMAIL", t("common:field.EMAIL_TYPE_INVALID_EMAIL"));
+ case Date:
+ value = new Date(value);
+ ref.obj[ref.key] = value;
+ // value.getTime() can be < 0, if it is before 1970
+ if (!isNaN(value)) return true;
+ throw new FieldError("DATE_TYPE_PARSE", t("common:field.DATE_TYPE_PARSE"));
}
if (typeof type === "object") {
if (type?.constructor?.name != "Object") {
- if (type instanceof Tuple) {
- if ((<Tuple>type).types.some((x) => instanceOf(x, value, { path, optional, errors }))) return true;
- throw new FieldError("BASE_TYPE_CHOICES", `This field must be one of (${type.types})`);
- }
if (value instanceof type) return true;
- throw new FieldError("BASE_TYPE_CLASS", `This field must be an instance of ${type}`);
+ throw new FieldError("BASE_TYPE_CLASS", t("common:field.BASE_TYPE_CLASS", { type }));
}
- if (typeof value !== "object") throw new FieldError("BASE_TYPE_OBJECT", `This field must be a object`);
+ if (typeof value !== "object") throw new FieldError("BASE_TYPE_OBJECT", t("common:field.BASE_TYPE_OBJECT"));
if (Array.isArray(type)) {
- if (!Array.isArray(value)) throw new FieldError("BASE_TYPE_ARRAY", `This field must be an array`);
+ if (!Array.isArray(value)) throw new FieldError("BASE_TYPE_ARRAY", t("common:field.BASE_TYPE_ARRAY"));
if (!type.length) return true; // type array didn't specify any type
return (
value.every((val, i) => {
errors[i] = {};
return (
- instanceOf(type[0], val, { path: `${path}[${i}]`, optional, errors: errors[i] }) === true
+ instanceOf(type[0], val, {
+ path: `${path}[${i}]`,
+ optional,
+ errors: errors[i],
+ t,
+ ref: { key: i, obj: value },
+ }) === true
);
}) || errors
);
@@ -86,7 +136,7 @@ export function instanceOf(
Object.keys(type).map((x) => (x.startsWith(OPTIONAL_PREFIX) ? x.slice(OPTIONAL_PREFIX.length) : x))
);
- if (diff.length) throw new FieldError("UNKOWN_FIELD", `Unkown key ${diff}`);
+ if (diff.length) throw new FieldError("UNKOWN_FIELD", t("common:field.UNKOWN_FIELD", { key: diff }));
return (
Object.keys(type).every((key) => {
@@ -100,16 +150,18 @@ export function instanceOf(
path: `${path}.${newKey}`,
optional: OPTIONAL,
errors: errors[key],
+ t,
+ ref: { key: newKey, obj: value },
}) === true
);
}) || errors
);
} else if (typeof type === "number" || typeof type === "string" || typeof type === "boolean") {
if (value === type) return true;
- throw new FieldError("BASE_TYPE_CONSTANT", `This field must be ${value}`);
+ throw new FieldError("BASE_TYPE_CONSTANT", t("common:field.BASE_TYPE_CONSTANT", { value: type }));
} else if (typeof type === "bigint") {
if (BigInt(value) === type) return true;
- throw new FieldError("BASE_TYPE_CONSTANT", `This field must be ${value}`);
+ throw new FieldError("BASE_TYPE_CONSTANT", t("common:field.BASE_TYPE_CONSTANT", { value: type }));
}
return type == value;
|
