@atomiqlabs/sdk 8.9.1 → 8.9.3

package/src/api/ApiParser.ts

@@ -1,138 +1,138 @@
-import {InputSchema, InputSchemaField} from "./ApiTypes";
-
-// Errors
-function invalidInput(path: string, expected: string, value: unknown): Error {
-    const actualType = value == null ? String(value) : Array.isArray(value) ? "array" : typeof(value);
-    return new Error(`Invalid input "${path}", expected ${expected}, got ${actualType}`);
-}
-
-function missingInput(path: string): Error {
-    return new Error(`Missing required input "${path}"`);
-}
-
-function invalidAllowedValue(path: string, allowedValues: readonly (string | number | bigint)[], value: string | number | bigint): Error {
-    return new Error(
-        `Invalid input "${path}", expected one of: ${allowedValues.map(val => val.toString()).join(", ")}, got ${value.toString()}`
-    );
-}
-
-// Parsers
-function parseNumber(path: string, value: unknown): number {
-    let result: number;
-    if(typeof(value) === "number") {
-        result = value;
-    } else if(typeof(value) === "string") {
-        const trimmedValue = value.trim();
-        if(trimmedValue === "") throw invalidInput(path, "finite number", value);
-        result = Number(trimmedValue);
-    } else throw invalidInput(path, "finite number", value);
-
-    if(!Number.isFinite(result)) throw invalidInput(path, "finite number", value);
-    return result;
-}
-
-function parseBigInt(path: string, value: unknown): bigint {
-    if(typeof(value) === "bigint") return value;
-
-    if(typeof(value) === "number") {
-        if(!Number.isSafeInteger(value)) throw invalidInput(path, "safe integer", value);
-        return BigInt(value);
-    }
-
-    if(typeof(value) === "string") {
-        const trimmedValue = value.trim();
-        if(!/^[+-]?\d+$/.test(trimmedValue)) throw invalidInput(path, "integer", value);
-        return BigInt(trimmedValue);
-    }
-
-    throw invalidInput(path, "integer", value);
-}
-
-function parseBoolean(path: string, value: unknown): boolean {
-    Boolean(value);
-    if(typeof(value) === "boolean") return value;
-    if(value === "true") return true;
-    if(value === "false") return false;
-    throw invalidInput(path, "boolean", value);
-}
-
-// Object type check
-function isObject(value: unknown): value is Record<string, unknown> {
-    return value != null && typeof(value) === "object" && !Array.isArray(value);
-}
-
-// Allowed values for enums
-function applyAllowedValues<T extends string | number | bigint>(path: string, value: T, allowedValues?: readonly T[]): T {
-    if(allowedValues != null && !allowedValues.includes(value)) {
-        throw invalidAllowedValue(path, allowedValues, value);
-    }
-    return value;
-}
-
-function parseField<T>(field: InputSchemaField<T>, value: unknown, path: string): T {
-    switch(field.type) {
-        case "string": {
-            if(typeof(value) !== "string") throw invalidInput(path, "string", value);
-            return applyAllowedValues(path, value, field.allowedValues as readonly string[] | undefined) as T;
-        }
-        case "number": {
-            const parsedValue = parseNumber(path, value);
-            return applyAllowedValues(path, parsedValue, field.allowedValues as readonly number[] | undefined) as T;
-        }
-        case "bigint": {
-            const parsedValue = parseBigInt(path, value);
-            return applyAllowedValues(path, parsedValue, field.allowedValues as readonly bigint[] | undefined) as T;
-        }
-        case "boolean":
-            return parseBoolean(path, value) as T;
-        case "array": {
-            if(!Array.isArray(value)) throw invalidInput(path, "array", value);
-            if(field.items == null) return [...value] as T;
-
-            return value.map((item, index) => parseField(field.items as InputSchemaField, item, `${path}[${index}]`)) as T;
-        }
-        case "object": {
-            if(!isObject(value)) throw invalidInput(path, "object", value);
-            if(field.properties == null) return {...value} as T;
-
-            return _parseApiInput(field.properties as InputSchema<T>, value, path);
-        }
-        default:
-            throw new Error(`Unsupported input schema type for "${path}": ${(field as InputSchemaField).type}`);
-    }
-}
-
-function _parseApiInput<TInput>(inputSchema: InputSchema<TInput>, rawInput: unknown, parentPath: string = ""): TInput {
-    if(!isObject(rawInput)) {
-        throw invalidInput(parentPath || "input", "object", rawInput);
-    }
-
-    const parsedInput: Partial<TInput> = {};
-
-    for(const key in inputSchema) {
-        const field = inputSchema[key];
-        const value = rawInput[key];
-        const path = parentPath === "" ? key : `${parentPath}.${key}`;
-
-        if(value == null) {
-            if(field.required) throw missingInput(path);
-            continue;
-        }
-
-        parsedInput[key] = parseField(field as InputSchemaField<TInput[typeof key]>, value, path);
-    }
-
-    return parsedInput as TInput;
-}
-
-/**
- * Parses raw input values according to the endpoint schema.
- *
- * This accepts untyped transport input such as HTTP query params, JSON request bodies,
- * or CLI arguments and returns the normalized callback input type.
- *
- * @category API
- */
-export function parseApiInput<TInput>(inputSchema: InputSchema<TInput>, rawInput: unknown): TInput {
-    return _parseApiInput(inputSchema, rawInput);
-}
+import {InputSchema, InputSchemaField} from "./ApiTypes";
+
+// Errors
+function invalidInput(path: string, expected: string, value: unknown): Error {
+    const actualType = value == null ? String(value) : Array.isArray(value) ? "array" : typeof(value);
+    return new Error(`Invalid input "${path}", expected ${expected}, got ${actualType}`);
+}
+
+function missingInput(path: string): Error {
+    return new Error(`Missing required input "${path}"`);
+}
+
+function invalidAllowedValue(path: string, allowedValues: readonly (string | number | bigint)[], value: string | number | bigint): Error {
+    return new Error(
+        `Invalid input "${path}", expected one of: ${allowedValues.map(val => val.toString()).join(", ")}, got ${value.toString()}`
+    );
+}
+
+// Parsers
+function parseNumber(path: string, value: unknown): number {
+    let result: number;
+    if(typeof(value) === "number") {
+        result = value;
+    } else if(typeof(value) === "string") {
+        const trimmedValue = value.trim();
+        if(trimmedValue === "") throw invalidInput(path, "finite number", value);
+        result = Number(trimmedValue);
+    } else throw invalidInput(path, "finite number", value);
+
+    if(!Number.isFinite(result)) throw invalidInput(path, "finite number", value);
+    return result;
+}
+
+function parseBigInt(path: string, value: unknown): bigint {
+    if(typeof(value) === "bigint") return value;
+
+    if(typeof(value) === "number") {
+        if(!Number.isSafeInteger(value)) throw invalidInput(path, "safe integer", value);
+        return BigInt(value);
+    }
+
+    if(typeof(value) === "string") {
+        const trimmedValue = value.trim();
+        if(!/^[+-]?\d+$/.test(trimmedValue)) throw invalidInput(path, "integer", value);
+        return BigInt(trimmedValue);
+    }
+
+    throw invalidInput(path, "integer", value);
+}
+
+function parseBoolean(path: string, value: unknown): boolean {
+    Boolean(value);
+    if(typeof(value) === "boolean") return value;
+    if(value === "true") return true;
+    if(value === "false") return false;
+    throw invalidInput(path, "boolean", value);
+}
+
+// Object type check
+function isObject(value: unknown): value is Record<string, unknown> {
+    return value != null && typeof(value) === "object" && !Array.isArray(value);
+}
+
+// Allowed values for enums
+function applyAllowedValues<T extends string | number | bigint>(path: string, value: T, allowedValues?: readonly T[]): T {
+    if(allowedValues != null && !allowedValues.includes(value)) {
+        throw invalidAllowedValue(path, allowedValues, value);
+    }
+    return value;
+}
+
+function parseField<T>(field: InputSchemaField<T>, value: unknown, path: string): T {
+    switch(field.type) {
+        case "string": {
+            if(typeof(value) !== "string") throw invalidInput(path, "string", value);
+            return applyAllowedValues(path, value, field.allowedValues as readonly string[] | undefined) as T;
+        }
+        case "number": {
+            const parsedValue = parseNumber(path, value);
+            return applyAllowedValues(path, parsedValue, field.allowedValues as readonly number[] | undefined) as T;
+        }
+        case "bigint": {
+            const parsedValue = parseBigInt(path, value);
+            return applyAllowedValues(path, parsedValue, field.allowedValues as readonly bigint[] | undefined) as T;
+        }
+        case "boolean":
+            return parseBoolean(path, value) as T;
+        case "array": {
+            if(!Array.isArray(value)) throw invalidInput(path, "array", value);
+            if(field.items == null) return [...value] as T;
+
+            return value.map((item, index) => parseField(field.items as InputSchemaField, item, `${path}[${index}]`)) as T;
+        }
+        case "object": {
+            if(!isObject(value)) throw invalidInput(path, "object", value);
+            if(field.properties == null) return {...value} as T;
+
+            return _parseApiInput(field.properties as InputSchema<T>, value, path);
+        }
+        default:
+            throw new Error(`Unsupported input schema type for "${path}": ${(field as InputSchemaField).type}`);
+    }
+}
+
+function _parseApiInput<TInput>(inputSchema: InputSchema<TInput>, rawInput: unknown, parentPath: string = ""): TInput {
+    if(!isObject(rawInput)) {
+        throw invalidInput(parentPath || "input", "object", rawInput);
+    }
+
+    const parsedInput: Partial<TInput> = {};
+
+    for(const key in inputSchema) {
+        const field = inputSchema[key];
+        const value = rawInput[key];
+        const path = parentPath === "" ? key : `${parentPath}.${key}`;
+
+        if(value == null) {
+            if(field.required) throw missingInput(path);
+            continue;
+        }
+
+        parsedInput[key] = parseField(field as InputSchemaField<TInput[typeof key]>, value, path);
+    }
+
+    return parsedInput as TInput;
+}
+
+/**
+ * Parses raw input values according to the endpoint schema.
+ *
+ * This accepts untyped transport input such as HTTP query params, JSON request bodies,
+ * or CLI arguments and returns the normalized callback input type.
+ *
+ * @category API
+ */
+export function parseApiInput<TInput>(inputSchema: InputSchema<TInput>, rawInput: unknown): TInput {
+    return _parseApiInput(inputSchema, rawInput);
+}