@atomiqlabs/sdk 8.9.1 → 8.9.3

package/dist/http/paramcoders/SchemaVerifier.js

@@ -1,145 +1,145 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifySchema = exports.verifyField = exports.isOptionalField = 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 isAllOptional(schema) {
-    for (let key in schema) {
-        if (!isOptionalField(schema[key]))
-            return false;
-    }
-    return true;
-}
-function isOptionalField(type) {
-    if (typeof (type) === "function")
-        return type(undefined) != null;
-    if (typeof (type) === "object")
-        return isAllOptional(type);
-    return type >= 100;
-}
-exports.isOptionalField = isOptionalField;
-function verifyField(fieldType, val) {
-    const type = fieldType;
-    if (typeof (type) === "function") {
-        const result = type(val);
-        if (result == null)
-            return;
-        return result;
-    }
-    if (val == null && isOptionalField(type)) {
-        return null;
-    }
-    if (type === FieldTypeEnum.Any || type === FieldTypeEnum.AnyOptional) {
-        return val;
-    }
-    else if (type === FieldTypeEnum.Boolean || type === FieldTypeEnum.BooleanOptional) {
-        if (typeof (val) !== "boolean")
-            return;
-        return val;
-    }
-    else if (type === FieldTypeEnum.Number || type === FieldTypeEnum.NumberOptional) {
-        if (typeof (val) !== "number")
-            return;
-        if (isNaN(val))
-            return;
-        return val;
-    }
-    else if (type === FieldTypeEnum.BigInt || type === FieldTypeEnum.BigIntOptional) {
-        const result = parseBigInt(val);
-        if (result == null)
-            return;
-        return result;
-    }
-    else if (type === FieldTypeEnum.String || type === FieldTypeEnum.StringOptional) {
-        if (typeof (val) !== "string")
-            return;
-        return val;
-    }
-    else {
-        //Probably another request schema
-        const result = verifySchema(val, type);
-        if (result == null)
-            return;
-        return result;
-    }
-}
-exports.verifyField = verifyField;
-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 && isOptionalField(type)) {
-            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.verifyField = exports.isOptionalField = 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 isAllOptional(schema) {
+    for (let key in schema) {
+        if (!isOptionalField(schema[key]))
+            return false;
+    }
+    return true;
+}
+function isOptionalField(type) {
+    if (typeof (type) === "function")
+        return type(undefined) != null;
+    if (typeof (type) === "object")
+        return isAllOptional(type);
+    return type >= 100;
+}
+exports.isOptionalField = isOptionalField;
+function verifyField(fieldType, val) {
+    const type = fieldType;
+    if (typeof (type) === "function") {
+        const result = type(val);
+        if (result == null)
+            return;
+        return result;
+    }
+    if (val == null && isOptionalField(type)) {
+        return null;
+    }
+    if (type === FieldTypeEnum.Any || type === FieldTypeEnum.AnyOptional) {
+        return val;
+    }
+    else if (type === FieldTypeEnum.Boolean || type === FieldTypeEnum.BooleanOptional) {
+        if (typeof (val) !== "boolean")
+            return;
+        return val;
+    }
+    else if (type === FieldTypeEnum.Number || type === FieldTypeEnum.NumberOptional) {
+        if (typeof (val) !== "number")
+            return;
+        if (isNaN(val))
+            return;
+        return val;
+    }
+    else if (type === FieldTypeEnum.BigInt || type === FieldTypeEnum.BigIntOptional) {
+        const result = parseBigInt(val);
+        if (result == null)
+            return;
+        return result;
+    }
+    else if (type === FieldTypeEnum.String || type === FieldTypeEnum.StringOptional) {
+        if (typeof (val) !== "string")
+            return;
+        return val;
+    }
+    else {
+        //Probably another request schema
+        const result = verifySchema(val, type);
+        if (result == null)
+            return;
+        return result;
+    }
+}
+exports.verifyField = verifyField;
+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 && isOptionalField(type)) {
+            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/http/paramcoders/client/ResponseParamDecoder.d.ts

@@ -1,11 +1,11 @@
-import { ParamDecoder } from "../ParamDecoder";
-export declare class ResponseParamDecoder extends ParamDecoder {
-    private readonly reader?;
-    private readonly abortSignal?;
-    constructor(resp: Response, abortSignal?: AbortSignal);
-    /**
-     * Keeps reading the response until the reader closes
-     * @private
-     */
-    private readResponse;
-}
+import { ParamDecoder } from "../ParamDecoder";
+export declare class ResponseParamDecoder extends ParamDecoder {
+    private readonly reader?;
+    private readonly abortSignal?;
+    constructor(resp: Response, abortSignal?: AbortSignal);
+    /**
+     * Keeps reading the response until the reader closes
+     * @private
+     */
+    private readResponse;
+}

package/dist/http/paramcoders/client/ResponseParamDecoder.js

@@ -1,57 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseParamDecoder = void 0;
-const ParamDecoder_1 = require("../ParamDecoder");
-const buffer_1 = require("buffer");
-const Logger_1 = require("../../../utils/Logger");
-const logger = (0, Logger_1.getLogger)("ResponseParamDecoder: ");
-class ResponseParamDecoder extends ParamDecoder_1.ParamDecoder {
-    constructor(resp, abortSignal) {
-        super();
-        this.abortSignal = abortSignal;
-        try {
-            //Read from stream
-            if (resp.body == null)
-                throw new Error("Response has no body field!");
-            this.reader = resp.body.getReader();
-            this.readResponse();
-        }
-        catch (e) {
-            //Read in one piece
-            resp.arrayBuffer().then(respBuffer => {
-                super.onData(buffer_1.Buffer.from(respBuffer));
-                super.onEnd();
-            }).catch(e => {
-                super.onError(e);
-            });
-        }
-        if (abortSignal != null)
-            abortSignal.addEventListener("abort", () => {
-                super.onError(abortSignal.reason);
-                if (this.reader != null && !this.reader.closed)
-                    this.reader.cancel(abortSignal.reason);
-            });
-    }
-    /**
-     * Keeps reading the response until the reader closes
-     * @private
-     */
-    async readResponse() {
-        if (this.reader == null)
-            return;
-        while (true) {
-            const readResp = await this.reader.read().catch(e => {
-                logger.error("readResponse(): Error reading response: ", e);
-                return null;
-            });
-            if (this.abortSignal != null && this.abortSignal.aborted)
-                return;
-            if (readResp == null || readResp.done) {
-                super.onEnd();
-                return;
-            }
-            super.onData(buffer_1.Buffer.from(readResp.value));
-        }
-    }
-}
-exports.ResponseParamDecoder = ResponseParamDecoder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseParamDecoder = void 0;
+const ParamDecoder_1 = require("../ParamDecoder");
+const buffer_1 = require("buffer");
+const Logger_1 = require("../../../utils/Logger");
+const logger = (0, Logger_1.getLogger)("ResponseParamDecoder: ");
+class ResponseParamDecoder extends ParamDecoder_1.ParamDecoder {
+    constructor(resp, abortSignal) {
+        super();
+        this.abortSignal = abortSignal;
+        try {
+            //Read from stream
+            if (resp.body == null)
+                throw new Error("Response has no body field!");
+            this.reader = resp.body.getReader();
+            this.readResponse();
+        }
+        catch (e) {
+            //Read in one piece
+            resp.arrayBuffer().then(respBuffer => {
+                super.onData(buffer_1.Buffer.from(respBuffer));
+                super.onEnd();
+            }).catch(e => {
+                super.onError(e);
+            });
+        }
+        if (abortSignal != null)
+            abortSignal.addEventListener("abort", () => {
+                super.onError(abortSignal.reason);
+                if (this.reader != null && !this.reader.closed)
+                    this.reader.cancel(abortSignal.reason);
+            });
+    }
+    /**
+     * Keeps reading the response until the reader closes
+     * @private
+     */
+    async readResponse() {
+        if (this.reader == null)
+            return;
+        while (true) {
+            const readResp = await this.reader.read().catch(e => {
+                logger.error("readResponse(): Error reading response: ", e);
+                return null;
+            });
+            if (this.abortSignal != null && this.abortSignal.aborted)
+                return;
+            if (readResp == null || readResp.done) {
+                super.onEnd();
+                return;
+            }
+            super.onData(buffer_1.Buffer.from(readResp.value));
+        }
+    }
+}
+exports.ResponseParamDecoder = ResponseParamDecoder;

package/dist/http/paramcoders/client/StreamParamEncoder.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { ParamEncoder } from "../ParamEncoder";
-import { Buffer } from "buffer";
-export declare class StreamParamEncoder extends ParamEncoder {
-    private readonly stream;
-    private closed;
-    constructor();
-    /**
-     * Returns the readable stream to be passed to the fetch API
-     */
-    getReadableStream(): ReadableStream<Buffer>;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+import { ParamEncoder } from "../ParamEncoder";
+import { Buffer } from "buffer";
+export declare class StreamParamEncoder extends ParamEncoder {
+    private readonly stream;
+    private closed;
+    constructor();
+    /**
+     * Returns the readable stream to be passed to the fetch API
+     */
+    getReadableStream(): ReadableStream<Buffer>;
+}

package/dist/http/paramcoders/client/StreamParamEncoder.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamParamEncoder = void 0;
-const ParamEncoder_1 = require("../ParamEncoder");
-class StreamParamEncoder extends ParamEncoder_1.ParamEncoder {
-    constructor() {
-        let stream = new TransformStream();
-        let writeStream = stream.writable.getWriter();
-        writeStream.closed.then(() => this.closed = true);
-        super(writeStream.write.bind(writeStream), () => {
-            if (this.closed)
-                return Promise.resolve();
-            this.closed = true;
-            return writeStream.close();
-        });
-        this.closed = false;
-        this.stream = stream;
-    }
-    /**
-     * Returns the readable stream to be passed to the fetch API
-     */
-    getReadableStream() {
-        return this.stream.readable;
-    }
-}
-exports.StreamParamEncoder = StreamParamEncoder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamParamEncoder = void 0;
+const ParamEncoder_1 = require("../ParamEncoder");
+class StreamParamEncoder extends ParamEncoder_1.ParamEncoder {
+    constructor() {
+        let stream = new TransformStream();
+        let writeStream = stream.writable.getWriter();
+        writeStream.closed.then(() => this.closed = true);
+        super(writeStream.write.bind(writeStream), () => {
+            if (this.closed)
+                return Promise.resolve();
+            this.closed = true;
+            return writeStream.close();
+        });
+        this.closed = false;
+        this.stream = stream;
+    }
+    /**
+     * Returns the readable stream to be passed to the fetch API
+     */
+    getReadableStream() {
+        return this.stream.readable;
+    }
+}
+exports.StreamParamEncoder = StreamParamEncoder;

package/dist/http/paramcoders/client/StreamingFetchPromise.d.ts

@@ -1,17 +1,17 @@
-import { RequestSchema, RequestSchemaResultPromise } from "../SchemaVerifier";
-export type RequestBody = {
-    [key: string]: Promise<any> | any;
-};
-/**
- * Sends a POST request to the specified URL in a streaming request/response mode
- *
- * @param url URL to send the request to
- * @param body An object containing properties that should be sent to the server, can be Promise or any
- * @param schema Schema of the response that should be received from the server
- * @param timeout Timeout in millseconds for the request to succeed & all its response properties to resolve
- * @param signal Abort signal
- * @param streamRequest Whether the request should be streamed or not
- * @param _headers
- * @throws {RequestError} When the response code is not 200
- */
-export declare function streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean, _headers?: Record<string, string>): Promise<RequestSchemaResultPromise<T>>;
+import { RequestSchema, RequestSchemaResultPromise } from "../SchemaVerifier";
+export type RequestBody = {
+    [key: string]: Promise<any> | any;
+};
+/**
+ * Sends a POST request to the specified URL in a streaming request/response mode
+ *
+ * @param url URL to send the request to
+ * @param body An object containing properties that should be sent to the server, can be Promise or any
+ * @param schema Schema of the response that should be received from the server
+ * @param timeout Timeout in millseconds for the request to succeed & all its response properties to resolve
+ * @param signal Abort signal
+ * @param streamRequest Whether the request should be streamed or not
+ * @param _headers
+ * @throws {RequestError} When the response code is not 200
+ */
+export declare function streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean, _headers?: Record<string, string>): Promise<RequestSchemaResultPromise<T>>;