Open source some useful filters from Strontium

Author: AJCStriker

package.json

@@ -1,6 +1,6 @@
 {
   "name": "strontium",
-  "version": "2.8.0",
+  "version": "2.8.1",
   "description": "Strontium is a TypeScript toolkit for High Performance API servers built for Production not Projects.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

src/utils/types.ts

@@ -1,3 +1,5 @@
 export type ConstructorOf<T> = {
     new (...arg: any[]): T
 }
+
+export type UUID = string

src/validation/drivers/validators/isBase64EncodedString.ts

@@ -0,0 +1,14 @@
+import { ValidationError } from "../../../errors"
+import { isBase64 } from "validator"
+
+export const isBase64EncodedString = (i: string): string => {
+    if (isBase64(i)) {
+        return i
+    }
+
+    throw new ValidationError(
+        "IS_BASE_64",
+        "Value is not a Base64 string",
+        "This value is not a Base64 string"
+    )
+}

src/validation/drivers/validators/isDictionary.ts

@@ -0,0 +1,42 @@
+import { ValidationError } from "../../../errors"
+
+import { ValidatorFunction } from "../.."
+
+export const isDictionary = <V>(
+    keyValidator: ValidatorFunction<any, string>,
+    valueValidator: ValidatorFunction<any, V>
+) => async (
+    i: unknown
+): Promise<{
+    [index: string]: V
+}> => {
+    if (typeof i !== "object" || i === null) {
+        throw new ValidationError(
+            "IS_OBJECT",
+            "Object validation failed",
+            "This value should be an object."
+        )
+    }
+
+    let response: {
+        [index: string]: V
+    } = {}
+    for (let p in i) {
+        if (i.hasOwnProperty(p)) {
+            let validatedKey = await keyValidator(p)
+
+            // Sadly ts-ignore this as TS doesn't understand that we have strongly ensured
+            // that this property is present.
+            // @ts-ignore
+            let rawValue = i[p]
+
+            let validatedOutput = await valueValidator(rawValue)
+
+            if (validatedOutput !== undefined) {
+                response[validatedKey] = validatedOutput
+            }
+        }
+    }
+
+    return response
+}

src/validation/drivers/validators/isEnumValue.ts

@@ -0,0 +1,7 @@
+import { isExactly } from "./isExactly"
+
+export const isEnumValue = <T>(enumObject: any): ((i: unknown) => T) => {
+    let values = Object.values(enumObject)
+
+    return isExactly(values) as any
+}

src/validation/drivers/validators/isFilter.ts

@@ -0,0 +1,50 @@
+import { either } from "../helpers/either"
+import { Filter } from "../../../query"
+
+import {
+    ObjectValidator,
+    ValidatedObject,
+    ValidatorFunction,
+    isArray,
+    isObject,
+    isUndefined,
+} from "../.."
+
+export const isFilter = <V extends ObjectValidator>(
+    objectSchema: V,
+    depth: number = 0
+): ((i: unknown) => Promise<Filter<ValidatedObject<V>>>) => {
+    if (depth > 10) {
+        // Stub this to any as it is a library operational detail and would pollute the type system
+        return undefined as any
+    }
+
+    let validatorObject: { [key: string]: ValidatorFunction<any, any> } = {
+        $and: either(isUndefined, isArray(isFilter(objectSchema, depth + 1))),
+        $or: either(isUndefined, isArray(isFilter(objectSchema, depth + 1))),
+    }
+
+    for (let key of Object.keys(objectSchema)) {
+        validatorObject[key] = isFieldSelector(objectSchema[key])
+    }
+
+    // Flag as any so that TypeScript doesn't get scared about the use of a recursive builder function
+    return isObject(validatorObject) as any
+}
+
+const isFieldSelector = (keyValidator: ValidatorFunction<any, any>) =>
+    either(
+        isUndefined,
+        keyValidator,
+        isObject({
+            $in: either(isUndefined, isArray(keyValidator)),
+            $nin: either(isUndefined, isArray(keyValidator)),
+            $eq: either(isUndefined, keyValidator),
+            $neq: either(isUndefined, keyValidator),
+            $gt: either(isUndefined, keyValidator),
+            $gte: either(isUndefined, keyValidator),
+            $lt: either(isUndefined, keyValidator),
+            $lte: either(isUndefined, keyValidator),
+            $contains: either(isUndefined, keyValidator),
+        })
+    )

src/validation/drivers/validators/isUUID.ts

@@ -0,0 +1,16 @@
+import { ValidationError } from "../../../errors"
+import { UUID } from "../../../utils/types"
+
+import { isUUID as uuidValidator } from "validator"
+
+export const isUUID = (i: string): UUID => {
+    if (uuidValidator(i)) {
+        return i
+    }
+
+    throw new ValidationError(
+        "IS_UUID",
+        "Value must be a UUID V4",
+        "This value must be a UUID V4"
+    )
+}

tsconfig.json

@@ -24,8 +24,8 @@
     "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
 
     "lib": [
-      "ES6",
-      "dom"
+      "es6",
+      "es2017.object"
     ],
 
     "typeRoots": [