gingersnap 0.22.0

package/stream/call.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var types = require('../networking/types.cjs');
+var CallExecutionError = require('../errors/CallExecutionError.cjs');
+var MissingArgumentsError = require('../errors/MissingArgumentsError.cjs');
+var model = require('../data/model/model.cjs');
+require('ramda');
+var types$1 = require('../data/model/types.cjs');
+require('../data/model/credentials.cjs');
+var stream = require('../stream.cjs');
+var stream_state = require('./state.cjs');
+var future = require('../future/future.cjs');
+
+/**
+ * Abstract Callable class with generic processing functionalities
+ */
+class Callable extends stream.Stream {
+    constructor(executor, ModelClass, responseType, arrayResponse = false) {
+        super(((v) => {
+            const result = executor(v);
+            if (result instanceof Promise)
+                return result.then((v) => new stream_state.ExecutorState(true, v));
+            return new stream_state.ExecutorState(true, result);
+        }));
+        if (ModelClass != null && responseType === undefined) {
+            throw new MissingArgumentsError.MissingArgumentsError(["responseType"]);
+        }
+        if (responseType != null && ModelClass === undefined && responseType !== types.ResponseType.BINARY) {
+            throw new MissingArgumentsError.MissingArgumentsError(["responseType"]);
+        }
+        this.ModelClass = ModelClass;
+        this.responseType = responseType;
+        this.arrayResponseSupport = arrayResponse;
+    }
+    /**
+     * Converts json object to a Model instance/Array of Models
+     * @param json json object
+     * @param resp optional Response object
+     * @protected
+     */
+    __process_json__(json, resp) {
+        var _a, _b;
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.ModelClass) === null || _a === void 0 ? void 0 : _a.name) === String.name && !this.arrayResponseSupport) {
+                throw new CallExecutionError.CallExecutionError("Invalid decorator combination. Cannot use String model with JSON formatting", resp);
+            }
+            if (Array.isArray(json) && this.arrayResponseSupport && ((_b = this.ModelClass) === null || _b === void 0 ? void 0 : _b.name) === String.name) {
+                return json.map((v) => (typeof v !== "string" ? String(v) : v));
+            }
+            const invoker = this.ModelClass.prototype instanceof model.Model ? this.ModelClass.fromJSON : this.ModelClass;
+            if ((json instanceof Array || Array.isArray(json)) && this.arrayResponseSupport) {
+                return json.map((v) => invoker(v));
+            }
+            else if (!(json instanceof Array || Array.isArray(json)) && !this.arrayResponseSupport) {
+                return invoker(json);
+            }
+            throw new CallExecutionError.CallExecutionError("Invalid data format received", resp);
+        });
+    }
+    /**
+     * Processes the response body to appropriate return type for a Callable
+     * @param resp response object
+     * @param responseType ResponseType
+     * @protected
+     */
+    __process_response__(resp, responseType) {
+        var _a;
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            switch (responseType) {
+                case types.ResponseType.JSON: {
+                    const result = yield resp.json();
+                    return yield this.__process_json__(result, resp);
+                }
+                case types.ResponseType.STRING: {
+                    const result = yield resp.text();
+                    return String(result);
+                }
+                case types.ResponseType.XML: {
+                    if (((_a = this.ModelClass) === null || _a === void 0 ? void 0 : _a.name) === String.name) {
+                        throw new CallExecutionError.CallExecutionError("Invalid decorator combination. Cannot use String model with JSON formatting", resp);
+                    }
+                    const invoker = this.ModelClass.prototype instanceof model.Model ? this.ModelClass.fromString : this.ModelClass;
+                    return invoker(yield resp.text(), types$1.DataFormat.XML);
+                }
+                case types.ResponseType.BINARY: {
+                    return (yield resp.blob());
+                }
+                default:
+                    return null;
+            }
+        });
+    }
+}
+/**
+ * A Callable structure for executing single network request
+ */
+class Call extends Callable {
+    constructor(executor, callback, ModelClass, throttle, responseType, arrayResponse = false) {
+        super(executor, ModelClass, responseType, arrayResponse);
+        this.callback = callback;
+        this.throttle = throttle;
+        this.executingCallback = false;
+    }
+    clone() {
+        const newStream = new Call(this.executor, this.callback, this.ModelClass, this.throttle, this.responseType, this.arrayResponseSupport);
+        newStream.executor = this.executor;
+        newStream.actions = [...this.actions];
+        newStream.executed = this.executed;
+        newStream.done = this.done;
+        newStream.backlog = [...this.backlog];
+        return newStream;
+    }
+    execute(rawResponse = false) {
+        const _super = Object.create(null, {
+            execute: { get: () => super.execute }
+        });
+        return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.throttle && this.executingCallback)
+                this.cancel();
+            this.executingCallback = true;
+            if ((_a = this.throttle) === null || _a === void 0 ? void 0 : _a.waitPeriodInMs) {
+                yield future.Future.sleep({ milliseconds: this.throttle.waitPeriodInMs }, signal);
+            }
+            const resp = (yield _super.execute.call(this).registerSignal(signal));
+            this.executingCallback = false;
+            if (!resp)
+                return resp;
+            if (!(resp instanceof Response))
+                return resolve(resp);
+            if (!resp.ok) {
+                return reject(new CallExecutionError.CallExecutionError(`Received response status code of ${resp.status}`, resp));
+            }
+            const response = rawResponse
+                ? (yield resp.blob())
+                : yield this.__process_response__(resp, this.responseType);
+            let callbackResponse = (_b = this.callback) === null || _b === void 0 ? void 0 : _b.bind({ context: response })();
+            if (callbackResponse instanceof Promise) {
+                callbackResponse = yield callbackResponse;
+            }
+            else if (callbackResponse instanceof Callable) {
+                callbackResponse = yield callbackResponse.execute().registerSignal(signal);
+            }
+            if (callbackResponse)
+                return resolve(callbackResponse);
+            resolve(response);
+        })).schedule();
+    }
+    __execute__() {
+        const preprocessor = (v) => (v instanceof Response ? this.__process_response__(v, this.responseType) : v);
+        return super.__execute__(preprocessor);
+    }
+}
+
+exports.Call = Call;
+exports.Callable = Callable;

package/stream/call.d.ts

@@ -0,0 +1,66 @@
+import { NONE, ResponseType, ThrottleByProps } from "../networking/types";
+import { Model } from "../data/model";
+import { Executor, Stream } from "./index";
+import { Future } from "../future";
+/**
+ * Abstract Callable class with generic processing functionalities
+ */
+export declare class Callable<T extends Model | Model[] | String | String[] | string | string[] | Blob | Blob[] | NONE> extends Stream<T> {
+    /**
+     * Type of response body expected from the callback's Response Object
+     * @protected
+     */
+    protected readonly responseType?: ResponseType;
+    /**
+     * Model used to deserialize response object retrieved from the network request
+     * @protected
+     */
+    protected readonly ModelClass?: typeof Model | typeof String;
+    /**
+     * Used to check if the response is expected to be an array of ModelClass
+     * @protected
+     */
+    protected readonly arrayResponseSupport: boolean;
+    protected constructor(executor: Executor, ModelClass?: typeof Model | typeof String, responseType?: ResponseType, arrayResponse?: boolean);
+    /**
+     * Converts json object to a Model instance/Array of Models
+     * @param json json object
+     * @param resp optional Response object
+     * @protected
+     */
+    protected __process_json__(json: Object | Object[], resp?: Response): Promise<T>;
+    /**
+     * Processes the response body to appropriate return type for a Callable
+     * @param resp response object
+     * @param responseType ResponseType
+     * @protected
+     */
+    protected __process_response__(resp: Response, responseType?: ResponseType): Promise<T>;
+}
+/**
+ * A Callable structure for executing single network request
+ */
+export declare class Call<T extends Model | Model[] | String | string | string[] | Blob | NONE> extends Callable<T> {
+    /**
+     * Callback function to do post-processing once network request has successfully completed
+     * @private
+     */
+    protected readonly callback?: Function;
+    /**
+     * Throttle configuration for the call
+     * @private
+     */
+    protected readonly throttle?: ThrottleByProps;
+    /**
+     * Checks if the callable is currently executing
+     * @private
+     */
+    private executingCallback;
+    constructor(executor: Executor, callback?: Function, ModelClass?: typeof Model | typeof String, throttle?: ThrottleByProps, responseType?: ResponseType, arrayResponse?: boolean);
+    clone(): Call<T>;
+    execute(rawResponse?: boolean): Future<T>;
+    protected __execute__(): Future<{
+        state: import("./index").State;
+        value?: T;
+    }>;
+}

package/stream/call.mjs

@@ -0,0 +1,154 @@
+import { __awaiter } from '../_virtual/_tslib.mjs';
+import { ResponseType } from '../networking/types.mjs';
+import { CallExecutionError } from '../errors/CallExecutionError.mjs';
+import { MissingArgumentsError } from '../errors/MissingArgumentsError.mjs';
+import { Model } from '../data/model/model.mjs';
+import 'ramda';
+import { DataFormat } from '../data/model/types.mjs';
+import '../data/model/credentials.mjs';
+import { Stream } from '../stream.mjs';
+import { ExecutorState } from './state.mjs';
+import { Future } from '../future/future.mjs';
+
+/**
+ * Abstract Callable class with generic processing functionalities
+ */
+class Callable extends Stream {
+    constructor(executor, ModelClass, responseType, arrayResponse = false) {
+        super(((v) => {
+            const result = executor(v);
+            if (result instanceof Promise)
+                return result.then((v) => new ExecutorState(true, v));
+            return new ExecutorState(true, result);
+        }));
+        if (ModelClass != null && responseType === undefined) {
+            throw new MissingArgumentsError(["responseType"]);
+        }
+        if (responseType != null && ModelClass === undefined && responseType !== ResponseType.BINARY) {
+            throw new MissingArgumentsError(["responseType"]);
+        }
+        this.ModelClass = ModelClass;
+        this.responseType = responseType;
+        this.arrayResponseSupport = arrayResponse;
+    }
+    /**
+     * Converts json object to a Model instance/Array of Models
+     * @param json json object
+     * @param resp optional Response object
+     * @protected
+     */
+    __process_json__(json, resp) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.ModelClass) === null || _a === void 0 ? void 0 : _a.name) === String.name && !this.arrayResponseSupport) {
+                throw new CallExecutionError("Invalid decorator combination. Cannot use String model with JSON formatting", resp);
+            }
+            if (Array.isArray(json) && this.arrayResponseSupport && ((_b = this.ModelClass) === null || _b === void 0 ? void 0 : _b.name) === String.name) {
+                return json.map((v) => (typeof v !== "string" ? String(v) : v));
+            }
+            const invoker = this.ModelClass.prototype instanceof Model ? this.ModelClass.fromJSON : this.ModelClass;
+            if ((json instanceof Array || Array.isArray(json)) && this.arrayResponseSupport) {
+                return json.map((v) => invoker(v));
+            }
+            else if (!(json instanceof Array || Array.isArray(json)) && !this.arrayResponseSupport) {
+                return invoker(json);
+            }
+            throw new CallExecutionError("Invalid data format received", resp);
+        });
+    }
+    /**
+     * Processes the response body to appropriate return type for a Callable
+     * @param resp response object
+     * @param responseType ResponseType
+     * @protected
+     */
+    __process_response__(resp, responseType) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (responseType) {
+                case ResponseType.JSON: {
+                    const result = yield resp.json();
+                    return yield this.__process_json__(result, resp);
+                }
+                case ResponseType.STRING: {
+                    const result = yield resp.text();
+                    return String(result);
+                }
+                case ResponseType.XML: {
+                    if (((_a = this.ModelClass) === null || _a === void 0 ? void 0 : _a.name) === String.name) {
+                        throw new CallExecutionError("Invalid decorator combination. Cannot use String model with JSON formatting", resp);
+                    }
+                    const invoker = this.ModelClass.prototype instanceof Model ? this.ModelClass.fromString : this.ModelClass;
+                    return invoker(yield resp.text(), DataFormat.XML);
+                }
+                case ResponseType.BINARY: {
+                    return (yield resp.blob());
+                }
+                default:
+                    return null;
+            }
+        });
+    }
+}
+/**
+ * A Callable structure for executing single network request
+ */
+class Call extends Callable {
+    constructor(executor, callback, ModelClass, throttle, responseType, arrayResponse = false) {
+        super(executor, ModelClass, responseType, arrayResponse);
+        this.callback = callback;
+        this.throttle = throttle;
+        this.executingCallback = false;
+    }
+    clone() {
+        const newStream = new Call(this.executor, this.callback, this.ModelClass, this.throttle, this.responseType, this.arrayResponseSupport);
+        newStream.executor = this.executor;
+        newStream.actions = [...this.actions];
+        newStream.executed = this.executed;
+        newStream.done = this.done;
+        newStream.backlog = [...this.backlog];
+        return newStream;
+    }
+    execute(rawResponse = false) {
+        const _super = Object.create(null, {
+            execute: { get: () => super.execute }
+        });
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.throttle && this.executingCallback)
+                this.cancel();
+            this.executingCallback = true;
+            if ((_a = this.throttle) === null || _a === void 0 ? void 0 : _a.waitPeriodInMs) {
+                yield Future.sleep({ milliseconds: this.throttle.waitPeriodInMs }, signal);
+            }
+            const resp = (yield _super.execute.call(this).registerSignal(signal));
+            this.executingCallback = false;
+            if (!resp)
+                return resp;
+            if (!(resp instanceof Response))
+                return resolve(resp);
+            if (!resp.ok) {
+                return reject(new CallExecutionError(`Received response status code of ${resp.status}`, resp));
+            }
+            const response = rawResponse
+                ? (yield resp.blob())
+                : yield this.__process_response__(resp, this.responseType);
+            let callbackResponse = (_b = this.callback) === null || _b === void 0 ? void 0 : _b.bind({ context: response })();
+            if (callbackResponse instanceof Promise) {
+                callbackResponse = yield callbackResponse;
+            }
+            else if (callbackResponse instanceof Callable) {
+                callbackResponse = yield callbackResponse.execute().registerSignal(signal);
+            }
+            if (callbackResponse)
+                return resolve(callbackResponse);
+            resolve(response);
+        })).schedule();
+    }
+    __execute__() {
+        const preprocessor = (v) => (v instanceof Response ? this.__process_response__(v, this.responseType) : v);
+        return super.__execute__(preprocessor);
+    }
+}
+
+export { Call, Callable };

package/stream/collector.cjs

@@ -0,0 +1,217 @@
+'use strict';
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var future = require('../future/future.cjs');
+require('ramda');
+require('../stream.cjs');
+var Stack = require('../data-structures/array/Stack.cjs');
+require('../data-structures/object/WatchableObject.cjs');
+require('object-hash');
+require('uuid');
+var AbortError = require('../errors/AbortError.cjs');
+var SimpleQueue = require('../data-structures/object/SimpleQueue.cjs');
+
+class Collectors {
+    static read(functor) {
+        return (stream) => stream.forEach(functor);
+    }
+    static asList() {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                const collection = [];
+                try {
+                    for (var _d = true, stream_1 = _tslib.__asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a;) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            collection.push(value);
+                            if (signal.aborted) {
+                                reject(new AbortError.AbortError());
+                                break;
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                resolve(collection);
+            }));
+        };
+    }
+    static asSet() {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, e_2, _b, _c;
+                const collection = new Set();
+                try {
+                    for (var _d = true, stream_2 = _tslib.__asyncValues(stream), stream_2_1; stream_2_1 = yield stream_2.next(), _a = stream_2_1.done, !_a;) {
+                        _c = stream_2_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            collection.add(value);
+                            if (signal.aborted) {
+                                reject(new AbortError.AbortError());
+                                break;
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_2.return)) yield _b.call(stream_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                resolve(collection);
+            }));
+        };
+    }
+    static joining(delimiter = "") {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                let data = "";
+                let value;
+                const iterator = stream[Symbol.asyncIterator]();
+                value = yield iterator.next();
+                if (!value.done) {
+                    do {
+                        const nextValue = yield iterator.next();
+                        if (!nextValue.done) {
+                            data += value.value + delimiter;
+                            value = nextValue;
+                        }
+                        else
+                            break;
+                    } while (!signal.aborted);
+                }
+                if (signal.aborted) {
+                    reject(new AbortError.AbortError());
+                    return;
+                }
+                if (value.value !== undefined && value.value !== null) {
+                    data += value.value;
+                }
+                resolve(data);
+            }));
+        };
+    }
+    static asStack(maxSize = undefined) {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, e_3, _b, _c;
+                const collection = new Stack.Stack(maxSize);
+                try {
+                    for (var _d = true, stream_3 = _tslib.__asyncValues(stream), stream_3_1; stream_3_1 = yield stream_3.next(), _a = stream_3_1.done, !_a;) {
+                        _c = stream_3_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            collection.push(value);
+                            if (collection.full) {
+                                break;
+                            }
+                            else if (signal.aborted) {
+                                reject(new AbortError.AbortError());
+                                break;
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_3.return)) yield _b.call(stream_3);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                resolve(collection);
+            }));
+        };
+    }
+    static asQueue() {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, e_4, _b, _c;
+                const collection = new SimpleQueue.SimpleQueue();
+                try {
+                    for (var _d = true, stream_4 = _tslib.__asyncValues(stream), stream_4_1; stream_4_1 = yield stream_4.next(), _a = stream_4_1.done, !_a;) {
+                        _c = stream_4_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            collection.enqueue(value);
+                            if (signal.aborted) {
+                                reject(new AbortError.AbortError());
+                                break;
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_4.return)) yield _b.call(stream_4);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                resolve(collection);
+            }));
+        };
+    }
+    static counting() {
+        return (stream) => {
+            return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a, e_5, _b, _c;
+                let total = 0;
+                try {
+                    for (var _d = true, stream_5 = _tslib.__asyncValues(stream), stream_5_1; stream_5_1 = yield stream_5.next(), _a = stream_5_1.done, !_a;) {
+                        _c = stream_5_1.value;
+                        _d = false;
+                        try {
+                            const _ = _c;
+                            total++;
+                            if (signal.aborted) {
+                                reject(new AbortError.AbortError());
+                                break;
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_5.return)) yield _b.call(stream_5);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                resolve(total);
+            }));
+        };
+    }
+}
+
+exports.Collectors = Collectors;

package/stream/collector.d.ts

@@ -0,0 +1,14 @@
+import { Stream } from "./index";
+import { Future } from "../future";
+import { Stack } from "../data-structures/array";
+import { SimpleQueue } from "../data-structures/object";
+export type Collector<T, K> = (stream: Stream<K>) => Future<T>;
+export declare class Collectors {
+    static read<K>(functor: (value: K) => void | Future<void>): (stream: Stream<K>) => Future<void>;
+    static asList(): <K>(stream: Stream<K>) => Future<K[]>;
+    static asSet(): <K>(stream: Stream<K>) => Future<Set<K>>;
+    static joining(delimiter?: string): <K>(stream: Stream<K>) => Future<string>;
+    static asStack(maxSize?: number | undefined): <K>(stream: Stream<K>) => Future<Stack<K>>;
+    static asQueue(): <K>(stream: Stream<K>) => Future<SimpleQueue<K>>;
+    static counting(): <K>(stream: Stream<K>) => Future<number>;
+}