@atomiqlabs/lp-lib 16.1.2 → 16.2.1

package/dist/utils/paramcoders/SchemaVerifier.js

@@ -1,84 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifySchema = exports.FieldTypeEnum = exports.parseBigInt = void 0;
-function parseBigInt(str) {
-    if (str == null)
-        return null;
-    if (typeof (str) !== "string" && typeof (str) !== "number")
-        return null;
-    try {
-        return BigInt(str);
-    }
-    catch (e) {
-        return null;
-    }
-}
-exports.parseBigInt = parseBigInt;
-var FieldTypeEnum;
-(function (FieldTypeEnum) {
-    FieldTypeEnum[FieldTypeEnum["String"] = 0] = "String";
-    FieldTypeEnum[FieldTypeEnum["Boolean"] = 1] = "Boolean";
-    FieldTypeEnum[FieldTypeEnum["Number"] = 2] = "Number";
-    FieldTypeEnum[FieldTypeEnum["BigInt"] = 3] = "BigInt";
-    FieldTypeEnum[FieldTypeEnum["Any"] = 4] = "Any";
-    FieldTypeEnum[FieldTypeEnum["StringOptional"] = 100] = "StringOptional";
-    FieldTypeEnum[FieldTypeEnum["BooleanOptional"] = 101] = "BooleanOptional";
-    FieldTypeEnum[FieldTypeEnum["NumberOptional"] = 102] = "NumberOptional";
-    FieldTypeEnum[FieldTypeEnum["BigIntOptional"] = 103] = "BigIntOptional";
-    FieldTypeEnum[FieldTypeEnum["AnyOptional"] = 104] = "AnyOptional";
-})(FieldTypeEnum = exports.FieldTypeEnum || (exports.FieldTypeEnum = {}));
-function verifySchema(req, schema) {
-    if (req == null)
-        return null;
-    const resultSchema = {};
-    for (let fieldName in schema) {
-        const val = req[fieldName];
-        const type = schema[fieldName];
-        if (typeof (type) === "function") {
-            const result = type(val);
-            if (result == null)
-                return null;
-            resultSchema[fieldName] = result;
-            continue;
-        }
-        if (val == null && type >= 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))
-                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);
-            if (result == null)
-                return null;
-            resultSchema[fieldName] = result;
-        }
-    }
-    return resultSchema;
-}
-exports.verifySchema = verifySchema;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySchema = exports.FieldTypeEnum = exports.parseBigInt = void 0;
+function parseBigInt(str) {
+    if (str == null)
+        return null;
+    if (typeof (str) !== "string" && typeof (str) !== "number")
+        return null;
+    try {
+        return BigInt(str);
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.parseBigInt = parseBigInt;
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum[FieldTypeEnum["String"] = 0] = "String";
+    FieldTypeEnum[FieldTypeEnum["Boolean"] = 1] = "Boolean";
+    FieldTypeEnum[FieldTypeEnum["Number"] = 2] = "Number";
+    FieldTypeEnum[FieldTypeEnum["BigInt"] = 3] = "BigInt";
+    FieldTypeEnum[FieldTypeEnum["Any"] = 4] = "Any";
+    FieldTypeEnum[FieldTypeEnum["StringOptional"] = 100] = "StringOptional";
+    FieldTypeEnum[FieldTypeEnum["BooleanOptional"] = 101] = "BooleanOptional";
+    FieldTypeEnum[FieldTypeEnum["NumberOptional"] = 102] = "NumberOptional";
+    FieldTypeEnum[FieldTypeEnum["BigIntOptional"] = 103] = "BigIntOptional";
+    FieldTypeEnum[FieldTypeEnum["AnyOptional"] = 104] = "AnyOptional";
+})(FieldTypeEnum = exports.FieldTypeEnum || (exports.FieldTypeEnum = {}));
+function verifySchema(req, schema) {
+    if (req == null)
+        return null;
+    const resultSchema = {};
+    for (let fieldName in schema) {
+        const val = req[fieldName];
+        const type = schema[fieldName];
+        if (typeof (type) === "function") {
+            const result = type(val);
+            if (result == null)
+                return null;
+            resultSchema[fieldName] = result;
+            continue;
+        }
+        if (val == null && type >= 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))
+                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);
+            if (result == null)
+                return null;
+            resultSchema[fieldName] = result;
+        }
+    }
+    return resultSchema;
+}
+exports.verifySchema = verifySchema;

package/dist/utils/paramcoders/server/ServerParamDecoder.d.ts

@@ -1,8 +1,8 @@
-import { Request, Response } from "express";
-export declare class RequestTimeoutError extends Error {
-    constructor();
-}
-export declare class RequestParsingError extends Error {
-    constructor();
-}
-export declare const serverParamDecoder: (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => void;
+import { Request, Response } from "express";
+export declare class RequestTimeoutError extends Error {
+    constructor();
+}
+export declare class RequestParsingError extends Error {
+    constructor();
+}
+export declare const serverParamDecoder: (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => void;

package/dist/utils/paramcoders/server/ServerParamDecoder.js

@@ -1,107 +1,107 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serverParamDecoder = exports.RequestParsingError = exports.RequestTimeoutError = void 0;
-const SchemaVerifier_1 = require("../SchemaVerifier");
-const ParamDecoder_1 = require("../ParamDecoder");
-const ServerParamEncoder_1 = require("./ServerParamEncoder");
-const Utils_1 = require("../../Utils");
-class RequestTimeoutError extends Error {
-    constructor() {
-        super("Request timed out");
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
-    }
-}
-exports.RequestTimeoutError = RequestTimeoutError;
-class RequestParsingError extends Error {
-    constructor() {
-        super("Request cannot be parsed");
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, RequestParsingError.prototype);
-    }
-}
-exports.RequestParsingError = RequestParsingError;
-const logger = (0, Utils_1.getLogger)("ServerParamDecoder: ");
-const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
-    let timeout;
-    res.responseStream = new ServerParamEncoder_1.ServerParamEncoder(res, 200, req);
-    if (req.headers['content-type'] !== "application/x-multiple-json") {
-        const dataBuffers = [];
-        req.on("data", (data) => {
-            dataBuffers.push(data);
-        });
-        req.on("end", () => {
-            try {
-                const body = dataBuffers.length === 0 ? {} : JSON.parse(Buffer.concat(dataBuffers).toString());
-                const paramReader = {
-                    getParams: (schema) => {
-                        return Promise.resolve((0, SchemaVerifier_1.verifySchema)(body, schema));
-                    },
-                    getExistingParamsOrNull: (schema) => {
-                        return (0, SchemaVerifier_1.verifySchema)(body, schema);
-                    }
-                };
-                req.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_1.ParamDecoder();
-    req.on("data", (data) => {
-        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.paramReader = decoder;
-    next();
-    return;
-};
-exports.serverParamDecoder = serverParamDecoder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverParamDecoder = exports.RequestParsingError = exports.RequestTimeoutError = void 0;
+const SchemaVerifier_1 = require("../SchemaVerifier");
+const ParamDecoder_1 = require("../ParamDecoder");
+const ServerParamEncoder_1 = require("./ServerParamEncoder");
+const Utils_1 = require("../../Utils");
+class RequestTimeoutError extends Error {
+    constructor() {
+        super("Request timed out");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestTimeoutError.prototype);
+    }
+}
+exports.RequestTimeoutError = RequestTimeoutError;
+class RequestParsingError extends Error {
+    constructor() {
+        super("Request cannot be parsed");
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, RequestParsingError.prototype);
+    }
+}
+exports.RequestParsingError = RequestParsingError;
+const logger = (0, Utils_1.getLogger)("ServerParamDecoder: ");
+const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
+    let timeout;
+    res.responseStream = new ServerParamEncoder_1.ServerParamEncoder(res, 200, req);
+    if (req.headers['content-type'] !== "application/x-multiple-json") {
+        const dataBuffers = [];
+        req.on("data", (data) => {
+            dataBuffers.push(data);
+        });
+        req.on("end", () => {
+            try {
+                const body = dataBuffers.length === 0 ? {} : JSON.parse(Buffer.concat(dataBuffers).toString());
+                const paramReader = {
+                    getParams: (schema) => {
+                        return Promise.resolve((0, SchemaVerifier_1.verifySchema)(body, schema));
+                    },
+                    getExistingParamsOrNull: (schema) => {
+                        return (0, SchemaVerifier_1.verifySchema)(body, schema);
+                    }
+                };
+                req.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_1.ParamDecoder();
+    req.on("data", (data) => {
+        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.paramReader = decoder;
+    next();
+    return;
+};
+exports.serverParamDecoder = serverParamDecoder;

package/dist/utils/paramcoders/server/ServerParamEncoder.d.ts

@@ -1,11 +1,11 @@
-import { Response, Request } from "express";
-export declare class ServerParamEncoder {
-    private response;
-    private controller;
-    private paramWriter;
-    constructor(response: Response, statusCode: number, request: Request);
-    writeParams(params: any): Promise<void>;
-    end(): Promise<void>;
-    writeParamsAndEnd(params: any): Promise<void>;
-    getAbortSignal(): AbortSignal;
-}
+import { Response, Request } from "express";
+export declare class ServerParamEncoder {
+    private response;
+    private controller;
+    private paramWriter;
+    constructor(response: Response, statusCode: number, request: Request);
+    writeParams(params: any): Promise<void>;
+    end(): Promise<void>;
+    writeParamsAndEnd(params: any): Promise<void>;
+    getAbortSignal(): AbortSignal;
+}

package/dist/utils/paramcoders/server/ServerParamEncoder.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerParamEncoder = void 0;
-const ParamEncoder_1 = require("../ParamEncoder");
-const LegacyParamEncoder_1 = require("../LegacyParamEncoder");
-class ServerParamEncoder {
-    constructor(response, statusCode, 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(resolve => response.end(() => resolve()));
-            return Promise.resolve();
-        };
-        const onWrite = (data) => {
-            if (responseShouldEnd)
-                return Promise.resolve();
-            if (firstWrite) {
-                response.writeHead(statusCode);
-                firstWrite = false;
-            }
-            return new Promise((resolve, reject) => response.write(data, (error) => {
-                if (error != null) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            }));
-        };
-        let firstWrite = false;
-        if (legacy) {
-            response.header("Content-Type", "application/json");
-            this.paramWriter = new LegacyParamEncoder_1.LegacyParamEncoder(onWrite, onEnd);
-        }
-        else {
-            response.header("Content-Type", "application/x-multiple-json");
-            this.paramWriter = new ParamEncoder_1.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) => this.controller.abort(err));
-    }
-    writeParams(params) {
-        return this.paramWriter.writeParams(params);
-    }
-    end() {
-        return this.paramWriter.end();
-    }
-    async writeParamsAndEnd(params) {
-        await this.writeParams(params);
-        await this.end();
-    }
-    getAbortSignal() {
-        return this.controller.signal;
-    }
-}
-exports.ServerParamEncoder = ServerParamEncoder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerParamEncoder = void 0;
+const ParamEncoder_1 = require("../ParamEncoder");
+const LegacyParamEncoder_1 = require("../LegacyParamEncoder");
+class ServerParamEncoder {
+    constructor(response, statusCode, 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(resolve => response.end(() => resolve()));
+            return Promise.resolve();
+        };
+        const onWrite = (data) => {
+            if (responseShouldEnd)
+                return Promise.resolve();
+            if (firstWrite) {
+                response.writeHead(statusCode);
+                firstWrite = false;
+            }
+            return new Promise((resolve, reject) => response.write(data, (error) => {
+                if (error != null) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            }));
+        };
+        let firstWrite = false;
+        if (legacy) {
+            response.header("Content-Type", "application/json");
+            this.paramWriter = new LegacyParamEncoder_1.LegacyParamEncoder(onWrite, onEnd);
+        }
+        else {
+            response.header("Content-Type", "application/x-multiple-json");
+            this.paramWriter = new ParamEncoder_1.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) => this.controller.abort(err));
+    }
+    writeParams(params) {
+        return this.paramWriter.writeParams(params);
+    }
+    end() {
+        return this.paramWriter.end();
+    }
+    async writeParamsAndEnd(params) {
+        await this.writeParams(params);
+        await this.end();
+    }
+    getAbortSignal() {
+        return this.controller.signal;
+    }
+}
+exports.ServerParamEncoder = ServerParamEncoder;