@1upvision/sdk 0.1.0

package/dist/server/validators.js

@@ -0,0 +1,126 @@
+export class ValidationError extends Error {
+    path;
+    constructor(message, path = "$") {
+        super(`${path}: ${message}`);
+        this.path = path;
+        this.name = "ValidationError";
+    }
+}
+function createValidator(kind, parseFn, isOptional = false) {
+    return {
+        kind,
+        isOptional,
+        parse(value, path = "$") {
+            return parseFn(value, path);
+        },
+        optional() {
+            return createValidator(kind, (value, path) => {
+                if (value === undefined)
+                    return undefined;
+                return parseFn(value, path);
+            }, true);
+        },
+    };
+}
+function typeOfValue(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function assertRecord(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new ValidationError(`expected object, received ${typeOfValue(value)}`, path);
+    }
+    return value;
+}
+function parseShape(shape, value, path) {
+    const record = assertRecord(value, path);
+    const parsed = {};
+    for (const [key, validator] of Object.entries(shape)) {
+        const nextPath = `${path}.${key}`;
+        parsed[key] = validator.parse(record[key], nextPath);
+    }
+    const knownKeys = new Set(Object.keys(shape));
+    for (const key of Object.keys(record)) {
+        if (!knownKeys.has(key)) {
+            throw new ValidationError(`unknown key \"${key}\"`, path);
+        }
+    }
+    return parsed;
+}
+export const v = {
+    string() {
+        return createValidator("string", (value, path) => {
+            if (typeof value !== "string") {
+                throw new ValidationError(`expected string, received ${typeOfValue(value)}`, path);
+            }
+            return value;
+        });
+    },
+    number() {
+        return createValidator("number", (value, path) => {
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new ValidationError(`expected finite number, received ${typeOfValue(value)}`, path);
+            }
+            return value;
+        });
+    },
+    boolean() {
+        return createValidator("boolean", (value, path) => {
+            if (typeof value !== "boolean") {
+                throw new ValidationError(`expected boolean, received ${typeOfValue(value)}`, path);
+            }
+            return value;
+        });
+    },
+    literal(value) {
+        return createValidator("literal", (input, path) => {
+            if (input !== value) {
+                throw new ValidationError(`expected literal ${JSON.stringify(value)}, received ${JSON.stringify(input)}`, path);
+            }
+            return value;
+        });
+    },
+    any() {
+        return createValidator("any", (value) => value);
+    },
+    nullable(validator) {
+        return createValidator(validator.kind, (value, path) => {
+            if (value === null)
+                return null;
+            return validator.parse(value, path);
+        });
+    },
+    optional(validator) {
+        return validator.optional();
+    },
+    array(validator) {
+        return createValidator("array", (value, path) => {
+            if (!Array.isArray(value)) {
+                throw new ValidationError(`expected array, received ${typeOfValue(value)}`, path);
+            }
+            return value.map((entry, index) => validator.parse(entry, `${path}[${index}]`));
+        });
+    },
+    object(shape) {
+        return createValidator("object", (value, path) => parseShape(shape, value, path));
+    },
+    union(...validators) {
+        return createValidator("union", (value, path) => {
+            const failures = [];
+            for (const validator of validators) {
+                try {
+                    return validator.parse(value, path);
+                }
+                catch (error) {
+                    failures.push(error instanceof Error
+                        ? error.message
+                        : "unknown validation error");
+                }
+            }
+            throw new ValidationError(`value did not match any union variant (${failures.join("; ")})`, path);
+        });
+    },
+};