@atomiqlabs/lp-lib 16.2.0 → 16.2.1

package/src/utils/paramcoders/SchemaVerifier.ts

@@ -1,96 +1,96 @@
-
-export function parseBigInt(str: string | number): bigint | null {
-    if(str==null) return null;
-    if(typeof(str)!=="string" && typeof(str)!=="number") return null;
-    try {
-        return BigInt(str);
-    } catch (e) {
-        return null;
-    }
-}
-
-export enum FieldTypeEnum {
-    String=0,
-    Boolean=1,
-    Number=2,
-    BigInt=3,
-    Any=4,
-
-    StringOptional=100,
-    BooleanOptional=101,
-    NumberOptional=102,
-    BigIntOptional=103,
-    AnyOptional=104,
-}
-
-export type FieldType<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))> =
-    T extends FieldTypeEnum.String ? string :
-    T extends FieldTypeEnum.Boolean ? boolean :
-    T extends FieldTypeEnum.Number ? number :
-    T extends FieldTypeEnum.BigInt ? bigint :
-    T extends FieldTypeEnum.Any ? any :
-    T extends FieldTypeEnum.StringOptional ? string :
-    T extends FieldTypeEnum.BooleanOptional ? boolean :
-    T extends FieldTypeEnum.NumberOptional ? number :
-    T extends FieldTypeEnum.BigIntOptional ? bigint :
-    T extends FieldTypeEnum.AnyOptional ? any :
-    T extends RequestSchema ? RequestSchemaResult<T> :
-    T extends ((val: any) => string) ? string :
-    T extends ((val: any) => boolean) ? boolean :
-    T extends ((val: any) => number) ? number :
-    T extends ((val: any) => bigint) ? bigint :
-    T extends ((val: any) => any) ? any :
-        never;
-
-export type RequestSchemaResult<T extends RequestSchema> = {
-    [key in keyof T]: FieldType<T[key]>
-}
-
-export type RequestSchema = {
-    [fieldName: string]: FieldTypeEnum | RequestSchema | ((val: any) => any)
-}
-
-export function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> {
-    if(req==null) return null;
-    const resultSchema: any = {};
-    for(let fieldName in schema) {
-        const val: any = req[fieldName];
-
-        const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
-        if(typeof(type)==="function") {
-            const result = type(val);
-            if(result==null) return null;
-            resultSchema[fieldName] = result;
-            continue;
-        }
-
-        if(val==null && (type as number)>=100) {
-            resultSchema[fieldName] = null;
-            continue;
-        }
-
-        if(type===FieldTypeEnum.Any || type===FieldTypeEnum.AnyOptional) {
-            resultSchema[fieldName] = val;
-        } else if(type===FieldTypeEnum.Boolean || type===FieldTypeEnum.BooleanOptional) {
-            if(typeof(val)!=="boolean") return null;
-            resultSchema[fieldName] = val;
-        } else if(type===FieldTypeEnum.Number || type===FieldTypeEnum.NumberOptional) {
-            if(typeof(val)!=="number") return null;
-            if(isNaN(val as number)) return null;
-            resultSchema[fieldName] = val;
-        } else if(type===FieldTypeEnum.BigInt || type===FieldTypeEnum.BigIntOptional) {
-            const result = parseBigInt(val);
-            if(result==null) return null;
-            resultSchema[fieldName] = result;
-        } else if(type===FieldTypeEnum.String || type===FieldTypeEnum.StringOptional) {
-            if(typeof(val)!=="string") return null;
-            resultSchema[fieldName] = val;
-        } else {
-            //Probably another request schema
-            const result = verifySchema(val, type as RequestSchema);
-            if(result==null) return null;
-            resultSchema[fieldName] = result;
-        }
-    }
-    return resultSchema;
-}
+
+export function parseBigInt(str: string | number): bigint | null {
+    if(str==null) return null;
+    if(typeof(str)!=="string" && typeof(str)!=="number") return null;
+    try {
+        return BigInt(str);
+    } catch (e) {
+        return null;
+    }
+}
+
+export enum FieldTypeEnum {
+    String=0,
+    Boolean=1,
+    Number=2,
+    BigInt=3,
+    Any=4,
+
+    StringOptional=100,
+    BooleanOptional=101,
+    NumberOptional=102,
+    BigIntOptional=103,
+    AnyOptional=104,
+}
+
+export type FieldType<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))> =
+    T extends FieldTypeEnum.String ? string :
+    T extends FieldTypeEnum.Boolean ? boolean :
+    T extends FieldTypeEnum.Number ? number :
+    T extends FieldTypeEnum.BigInt ? bigint :
+    T extends FieldTypeEnum.Any ? any :
+    T extends FieldTypeEnum.StringOptional ? string :
+    T extends FieldTypeEnum.BooleanOptional ? boolean :
+    T extends FieldTypeEnum.NumberOptional ? number :
+    T extends FieldTypeEnum.BigIntOptional ? bigint :
+    T extends FieldTypeEnum.AnyOptional ? any :
+    T extends RequestSchema ? RequestSchemaResult<T> :
+    T extends ((val: any) => string) ? string :
+    T extends ((val: any) => boolean) ? boolean :
+    T extends ((val: any) => number) ? number :
+    T extends ((val: any) => bigint) ? bigint :
+    T extends ((val: any) => any) ? any :
+        never;
+
+export type RequestSchemaResult<T extends RequestSchema> = {
+    [key in keyof T]: FieldType<T[key]>
+}
+
+export type RequestSchema = {
+    [fieldName: string]: FieldTypeEnum | RequestSchema | ((val: any) => any)
+}
+
+export function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> {
+    if(req==null) return null;
+    const resultSchema: any = {};
+    for(let fieldName in schema) {
+        const val: any = req[fieldName];
+
+        const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
+        if(typeof(type)==="function") {
+            const result = type(val);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+            continue;
+        }
+
+        if(val==null && (type as number)>=100) {
+            resultSchema[fieldName] = null;
+            continue;
+        }
+
+        if(type===FieldTypeEnum.Any || type===FieldTypeEnum.AnyOptional) {
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.Boolean || type===FieldTypeEnum.BooleanOptional) {
+            if(typeof(val)!=="boolean") return null;
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.Number || type===FieldTypeEnum.NumberOptional) {
+            if(typeof(val)!=="number") return null;
+            if(isNaN(val as number)) return null;
+            resultSchema[fieldName] = val;
+        } else if(type===FieldTypeEnum.BigInt || type===FieldTypeEnum.BigIntOptional) {
+            const result = parseBigInt(val);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+        } else if(type===FieldTypeEnum.String || type===FieldTypeEnum.StringOptional) {
+            if(typeof(val)!=="string") return null;
+            resultSchema[fieldName] = val;
+        } else {
+            //Probably another request schema
+            const result = verifySchema(val, type as RequestSchema);
+            if(result==null) return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}

package/src/utils/paramcoders/server/ServerParamDecoder.ts

@@ -1,118 +1,118 @@
-import {Request, Response} from "express";
-import {RequestSchema, verifySchema} from "../SchemaVerifier";
-import {ParamDecoder} from "../ParamDecoder";
-import {ServerParamEncoder} from "./ServerParamEncoder";
-import {IParamReader} from "../IParamReader";
-import {getLogger} from "../../Utils";
-
-export class RequestTimeoutError extends Error {
-
-    constructor() {
-        super("Request timed out");
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
-    }
-
-}
-
-export class RequestParsingError extends Error {
-
-    constructor() {
-        super("Request cannot be parsed");
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, RequestParsingError.prototype);
-    }
-
-}
-
-const logger = getLogger("ServerParamDecoder: ");
-
-export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => {
-
-    let timeout;
-
-    (res as any).responseStream = new ServerParamEncoder(res, 200, req);
-
-    if(req.headers['content-type']!=="application/x-multiple-json") {
-
-        const dataBuffers: Buffer[] = [];
-        req.on("data", (data: Buffer) => {
-            dataBuffers.push(data)
-        });
-        req.on("end", () => {
-            try {
-                const body = dataBuffers.length===0 ? {} : JSON.parse(Buffer.concat(dataBuffers).toString());
-                const paramReader: IParamReader = {
-                    getParams: <T extends RequestSchema>(schema: T) => {
-                        return Promise.resolve(verifySchema(body, schema));
-                    },
-                    getExistingParamsOrNull: <T extends RequestSchema>(schema: T) => {
-                        return verifySchema(body, schema);
-                    }
-                };
-                (req as any).paramReader = paramReader;
-                next();
-            } catch (e) {
-                logger.error("error reading legacy (non-streaming) http request", e);
-                req.destroy(new RequestParsingError());
-                res.destroy(new RequestParsingError());
-            }
-            clearTimeout(timeout);
-        });
-        req.on("error", (e) => {
-            logger.error("error reading legacy (non-streaming) http request",e);
-        });
-
-        timeout = setTimeout(() => {
-            req.destroy(new RequestTimeoutError());
-            res.destroy(new RequestTimeoutError());
-        }, timeoutMillis);
-
-        return;
-
-    }
-
-    const decoder = new ParamDecoder();
-    req.on("data", (data: Buffer) => {
-        try {
-            decoder.onData(data);
-        } catch (e) {
-            logger.error("error reading streaming http request: on(\"data\")", e);
-            req.destroy(new RequestParsingError());
-            res.destroy(new RequestParsingError());
-        }
-    });
-    req.on("end", () => {
-        try {
-            decoder.onEnd();
-        } catch (e) {
-            logger.error("error reading streaming http request: on(\"end\")", e);
-            req.destroy(new RequestParsingError());
-            res.destroy(new RequestParsingError());
-        }
-        clearTimeout(timeout);
-    });
-    req.on("error", (e) => {
-        try {
-            decoder.onError(e);
-        } catch(e) {
-            logger.error("error reading streaming http request: on(\"error\")", e);
-        }
-    });
-
-    timeout = setTimeout(() => {
-        try {
-            decoder.onEnd();
-        } catch(e) {
-            logger.error("error reading streaming http request: timeout", e);
-        }
-        req.destroy(new RequestTimeoutError());
-        res.destroy(new RequestTimeoutError());
-    }, timeoutMillis);
-
-    (req as any).paramReader = decoder;
-
-    next();
-    return;
-
-}
+import {Request, Response} from "express";
+import {RequestSchema, verifySchema} from "../SchemaVerifier";
+import {ParamDecoder} from "../ParamDecoder";
+import {ServerParamEncoder} from "./ServerParamEncoder";
+import {IParamReader} from "../IParamReader";
+import {getLogger} from "../../Utils";
+
+export class RequestTimeoutError extends Error {
+
+    constructor() {
+        super("Request timed out");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+    }
+
+}
+
+export class RequestParsingError extends Error {
+
+    constructor() {
+        super("Request cannot be parsed");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestParsingError.prototype);
+    }
+
+}
+
+const logger = getLogger("ServerParamDecoder: ");
+
+export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => {
+
+    let timeout;
+
+    (res as any).responseStream = new ServerParamEncoder(res, 200, req);
+
+    if(req.headers['content-type']!=="application/x-multiple-json") {
+
+        const dataBuffers: Buffer[] = [];
+        req.on("data", (data: Buffer) => {
+            dataBuffers.push(data)
+        });
+        req.on("end", () => {
+            try {
+                const body = dataBuffers.length===0 ? {} : JSON.parse(Buffer.concat(dataBuffers).toString());
+                const paramReader: IParamReader = {
+                    getParams: <T extends RequestSchema>(schema: T) => {
+                        return Promise.resolve(verifySchema(body, schema));
+                    },
+                    getExistingParamsOrNull: <T extends RequestSchema>(schema: T) => {
+                        return verifySchema(body, schema);
+                    }
+                };
+                (req as any).paramReader = paramReader;
+                next();
+            } catch (e) {
+                logger.error("error reading legacy (non-streaming) http request", e);
+                req.destroy(new RequestParsingError());
+                res.destroy(new RequestParsingError());
+            }
+            clearTimeout(timeout);
+        });
+        req.on("error", (e) => {
+            logger.error("error reading legacy (non-streaming) http request",e);
+        });
+
+        timeout = setTimeout(() => {
+            req.destroy(new RequestTimeoutError());
+            res.destroy(new RequestTimeoutError());
+        }, timeoutMillis);
+
+        return;
+
+    }
+
+    const decoder = new ParamDecoder();
+    req.on("data", (data: Buffer) => {
+        try {
+            decoder.onData(data);
+        } catch (e) {
+            logger.error("error reading streaming http request: on(\"data\")", e);
+            req.destroy(new RequestParsingError());
+            res.destroy(new RequestParsingError());
+        }
+    });
+    req.on("end", () => {
+        try {
+            decoder.onEnd();
+        } catch (e) {
+            logger.error("error reading streaming http request: on(\"end\")", e);
+            req.destroy(new RequestParsingError());
+            res.destroy(new RequestParsingError());
+        }
+        clearTimeout(timeout);
+    });
+    req.on("error", (e) => {
+        try {
+            decoder.onError(e);
+        } catch(e) {
+            logger.error("error reading streaming http request: on(\"error\")", e);
+        }
+    });
+
+    timeout = setTimeout(() => {
+        try {
+            decoder.onEnd();
+        } catch(e) {
+            logger.error("error reading streaming http request: timeout", e);
+        }
+        req.destroy(new RequestTimeoutError());
+        res.destroy(new RequestTimeoutError());
+    }, timeoutMillis);
+
+    (req as any).paramReader = decoder;
+
+    next();
+    return;
+
+}

package/src/utils/paramcoders/server/ServerParamEncoder.ts

@@ -1,76 +1,76 @@
-import {Response, Request} from "express";
-import {IParamWriter} from "../IParamWriter";
-import {ParamEncoder} from "../ParamEncoder";
-import {LegacyParamEncoder} from "../LegacyParamEncoder";
-
-export class ServerParamEncoder {
-
-    private response: Response;
-    private controller: AbortController;
-
-    private paramWriter: IParamWriter;
-
-    constructor(response: Response, statusCode: number, request: Request) {
-        const legacy = !request.headers['accept'].includes("application/x-multiple-json");
-
-        let requestEnd = false;
-        let responseShouldEnd = false;
-        request.on("end", () => {
-            requestEnd = true;
-            if(responseShouldEnd && requestEnd) response.end();
-        });
-
-        const onEnd = () => {
-            responseShouldEnd = true;
-            if(responseShouldEnd && requestEnd) return new Promise<void>(resolve => response.end(() => resolve()));
-            return Promise.resolve();
-        };
-
-        const onWrite = (data: Buffer) => {
-            if(responseShouldEnd) return Promise.resolve();
-            if(firstWrite) {
-                response.writeHead(statusCode);
-                firstWrite = false;
-            }
-            return new Promise<void>((resolve, reject) => response.write(data, (error: any) => {
-                if(error!=null) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            }));
-        };
-
-        let firstWrite = false;
-        if(legacy) {
-            response.header("Content-Type", "application/json");
-            this.paramWriter = new LegacyParamEncoder(onWrite, onEnd);
-        } else {
-            response.header("Content-Type", "application/x-multiple-json");
-            this.paramWriter = new ParamEncoder(onWrite, onEnd);
-        }
-
-        this.response = response;
-        this.controller = new AbortController();
-        this.response.on("close", () => this.controller.abort(new Error("Response stream closed!")));
-        this.response.on("error", (err: any) => this.controller.abort(err));
-    }
-
-    writeParams(params: any): Promise<void> {
-        return this.paramWriter.writeParams(params);
-    }
-
-    end(): Promise<void> {
-        return this.paramWriter.end();
-    }
-
-    async writeParamsAndEnd(params: any): Promise<void> {
-        await this.writeParams(params);
-        await this.end();
-    }
-
-    getAbortSignal(): AbortSignal {
-        return this.controller.signal;
-    }
-
+import {Response, Request} from "express";
+import {IParamWriter} from "../IParamWriter";
+import {ParamEncoder} from "../ParamEncoder";
+import {LegacyParamEncoder} from "../LegacyParamEncoder";
+
+export class ServerParamEncoder {
+
+    private response: Response;
+    private controller: AbortController;
+
+    private paramWriter: IParamWriter;
+
+    constructor(response: Response, statusCode: number, request: Request) {
+        const legacy = !request.headers['accept'].includes("application/x-multiple-json");
+
+        let requestEnd = false;
+        let responseShouldEnd = false;
+        request.on("end", () => {
+            requestEnd = true;
+            if(responseShouldEnd && requestEnd) response.end();
+        });
+
+        const onEnd = () => {
+            responseShouldEnd = true;
+            if(responseShouldEnd && requestEnd) return new Promise<void>(resolve => response.end(() => resolve()));
+            return Promise.resolve();
+        };
+
+        const onWrite = (data: Buffer) => {
+            if(responseShouldEnd) return Promise.resolve();
+            if(firstWrite) {
+                response.writeHead(statusCode);
+                firstWrite = false;
+            }
+            return new Promise<void>((resolve, reject) => response.write(data, (error: any) => {
+                if(error!=null) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            }));
+        };
+
+        let firstWrite = false;
+        if(legacy) {
+            response.header("Content-Type", "application/json");
+            this.paramWriter = new LegacyParamEncoder(onWrite, onEnd);
+        } else {
+            response.header("Content-Type", "application/x-multiple-json");
+            this.paramWriter = new ParamEncoder(onWrite, onEnd);
+        }
+
+        this.response = response;
+        this.controller = new AbortController();
+        this.response.on("close", () => this.controller.abort(new Error("Response stream closed!")));
+        this.response.on("error", (err: any) => this.controller.abort(err));
+    }
+
+    writeParams(params: any): Promise<void> {
+        return this.paramWriter.writeParams(params);
+    }
+
+    end(): Promise<void> {
+        return this.paramWriter.end();
+    }
+
+    async writeParamsAndEnd(params: any): Promise<void> {
+        await this.writeParams(params);
+        await this.end();
+    }
+
+    getAbortSignal(): AbortSignal {
+        return this.controller.signal;
+    }
+
 }