gingersnap 0.22.0

package/mocks.mjs

@@ -0,0 +1,293 @@
+import { __awaiter } from './_virtual/_tslib.mjs';
+import { AbortError } from './errors/AbortError.mjs';
+import { VerificationError } from './errors/VerificationError.mjs';
+import './data/model/model.mjs';
+import 'ramda';
+import './data/model/types.mjs';
+import './data/model/credentials.mjs';
+import './networking/types.mjs';
+import './stream.mjs';
+import { Future } from './future/future.mjs';
+import './networking/decorators/options.mjs';
+import './networking/decorators/requests.mjs';
+import { HTTPStatus } from './networking/http.mjs';
+import 'uuid';
+import 'object-hash';
+import './data/store/manager.mjs';
+import './data-structures/object/WatchableObject.mjs';
+import 'modern-isomorphic-ws';
+import '@msgpack/msgpack';
+
+/**
+ * Tracks specific details that should be used to match specific given network request
+ */
+class RequestDetails {
+    constructor() {
+        this.headers = {};
+        this.queries = {};
+    }
+    withMethod(method) {
+        this.method = method;
+        return this;
+    }
+    withPath(path) {
+        this.path = path;
+        return this;
+    }
+    withHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    withHeaders(value) {
+        this.headers = value;
+        return this;
+    }
+    withQuery(key, value) {
+        this.queries[key] = value;
+        return this;
+    }
+    withQueries(value) {
+        this.queries = value;
+        return this;
+    }
+    withBody(value) {
+        this.body = value;
+        return this;
+    }
+}
+class ResponseBuilder {
+    constructor() {
+        this.status = HTTPStatus.OK;
+        this.headers = {};
+    }
+    withStatus(status) {
+        this.status = status;
+        return this;
+    }
+    withHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    withHeaders(value) {
+        this.headers = value;
+        return this;
+    }
+    withBody(value) {
+        this.body = value;
+        return this;
+    }
+    withURI(value) {
+        this.uri = value;
+        return this;
+    }
+    withFragment(value) {
+        this.fragment = value;
+        return this;
+    }
+    withDelay(value) {
+        this.delay = value;
+        return this;
+    }
+    build() {
+        var _a, _b;
+        let data;
+        if (this.body && typeof this.body === "string") {
+            data = new Blob([this.body]);
+        }
+        else if (this.body instanceof Blob) {
+            data = this.body;
+        }
+        const status = (_a = this.status) !== null && _a !== void 0 ? _a : HTTPStatus.OK;
+        const response = new Response(data, {
+            status,
+            statusText: (_b = Object.keys(HTTPStatus)
+                .find((key) => HTTPStatus[key] === status)) === null || _b === void 0 ? void 0 : _b.toLowerCase().split("_").map((v) => v[0].toUpperCase() + v.slice(1)).join(" "),
+            headers: Object.entries(this.headers),
+        });
+        if (this.uri) {
+            const url = new URL(this.uri);
+            if (this.fragment) {
+                url.hash = this.fragment;
+            }
+            Object.defineProperty(response, "url", { value: url.href });
+        }
+        return { response, delay: this.delay };
+    }
+}
+class API {
+    constructor() {
+        this.matchers = [];
+        this.processedRequests = [];
+    }
+    resolve(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.findMatchingResponse(req);
+            if (resp) {
+                this.processedRequests.push([req, resp]);
+                return resp;
+            }
+            return new Response(null, { status: HTTPStatus.NOT_FOUND });
+        });
+    }
+    when(request, response) {
+        this.matchers.push(this.createMatcher(request, response));
+        return this;
+    }
+    verify(request, validator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matcher = this.requestMatcher(request);
+            const responses = yield Promise.all(this.processedRequests.map(([req, resp]) => matcher(req).then((v) => (v ? resp : null))));
+            if (!validator(responses.filter((v) => v !== null))) {
+                throw new VerificationError();
+            }
+        });
+    }
+    reset() {
+        this.processedRequests = [];
+    }
+    findMatchingResponse(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const matcher of this.matchers) {
+                const resp = yield matcher(request);
+                if (resp) {
+                    return resp;
+                }
+            }
+        });
+    }
+    requestMatcher(mock) {
+        const mockRequest = mock;
+        const pathChecker = (req) => mockRequest.path ? new URL(req.url).pathname.startsWith(mockRequest.path) : true;
+        const methodChecker = (req) => mockRequest.method ? req.method.toUpperCase() === mockRequest.method : true;
+        const headersChecker = (req) => Object.entries(mockRequest.headers).every(([k, v]) => req.headers.get(k) === v);
+        const bodyChecker = (req) => {
+            if (!mockRequest.body) {
+                return Promise.resolve(true);
+            }
+            const data = typeof mockRequest.body !== "string" ? JSON.stringify(mockRequest.body) : mockRequest.body;
+            const buffer = new TextEncoder().encode(data);
+            return req.arrayBuffer().then((v) => {
+                const data = new Uint8Array(v);
+                for (let i = 0; i < buffer.length; i++) {
+                    if (buffer.at(i) !== data.at(i)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        };
+        const queriesChecker = (req) => {
+            const params = new URL(req.url).searchParams;
+            return Object.entries(mockRequest.queries).every(([k, v]) => params.get(k) === v);
+        };
+        return (req) => bodyChecker(req).then((result) => result && queriesChecker(req) && headersChecker(req) && pathChecker(req) && methodChecker(req));
+    }
+    createMatcher(mockRequest, response) {
+        const matcher = this.requestMatcher(mockRequest);
+        return (request) => matcher(request).then((match) => __awaiter(this, void 0, void 0, function* () {
+            if (match) {
+                const { response: resp, delay } = response.build();
+                if (delay) {
+                    yield Future.sleep(delay);
+                }
+                return resp;
+            }
+        }));
+    }
+}
+/**
+ * Mocks network requests send via fetch API
+ */
+class MockNetworkService {
+    /**
+     * @param blockUnmatchedOrigins check whether to block requests sent to origins not specified as
+     * an API in this network service
+     */
+    constructor(blockUnmatchedOrigins = true) {
+        this.blockUnmatchedOrigins = blockUnmatchedOrigins;
+        this.realFetch = global.fetch;
+        this.apis = new Map();
+    }
+    /**
+     * Launches the network service to monitor requests
+     */
+    start() {
+        this.future = Future.of((resolve, reject, signal) => {
+            signal.onabort = () => {
+                global.fetch = this.realFetch;
+                reject(new AbortError());
+            };
+            global.fetch = (input, init) => {
+                const req = new Request(input, init);
+                const uri = new URL(req.url);
+                const api = this.apis.get(uri.origin);
+                if (!api && this.blockUnmatchedOrigins) {
+                    return Promise.resolve(new Response(null, { status: HTTPStatus.NOT_FOUND }));
+                }
+                else if (!api) {
+                    return this.realFetch(input, init);
+                }
+                return api.resolve(req);
+            };
+        }).schedule();
+    }
+    /**
+     * Stops network monitoring
+     */
+    stop() {
+        if (this.future) {
+            this.future.cancel();
+            this.future = undefined;
+        }
+    }
+    /**
+     * Creates an API service - used to intercept requests for a given origin
+     * @param origin
+     */
+    createAPI(origin) {
+        const api = new API();
+        this.apis.set(origin, api);
+        return api;
+    }
+    /**
+     * Remove all created API services from network request routing
+     */
+    reset() {
+        this.apis.clear();
+    }
+}
+/**
+ * Validators
+ */
+/**
+ * Validates that the request was processed at least X times
+ * @param amount number of times the request was sent
+ */
+const atLeast = (amount) => (matches) => matches.length >= amount;
+/**
+ * Validates that the request was process at most X times
+ * @param amount number of times the request was sent
+ */
+const atMost = (amount) => (matches) => matches.length <= amount;
+/**
+ * Validates that the request was processed exactly X times
+ * @param amount number of times the request was sent
+ */
+const exact = (amount) => (matches) => matches.length === amount;
+/**
+ * Validates that the request was processed within the given range of times
+ * @param lower minimum times the request matched
+ * @param upper maximum times the request matched
+ * @param includeUpper if true, the upper limit provided with be included. Otherwise, the maximum will be upper - 1
+ */
+const range = (lower, upper, includeUpper = false) => (matches) => matches.length >= lower && (includeUpper ? matches.length <= upper : matches.length < upper);
+/**
+ * creates a request details instance that is used to track requests with a given set of criteria
+ */
+const request = () => new RequestDetails();
+/**
+ * creates a response builder
+ */
+const response = () => new ResponseBuilder();
+
+export { MockNetworkService, atLeast, atMost, exact, range, request, response };

package/networking/EventSourceService.cjs

@@ -0,0 +1,104 @@
+'use strict';
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var NetworkService = require('./NetworkService.cjs');
+var R = require('ramda');
+var CallExecutionError = require('../errors/CallExecutionError.cjs');
+var synchronize = require('../synchronize.cjs');
+require('uuid');
+var result = require('../future/result.cjs');
+var stream = require('../stream.cjs');
+var model = require('../data/model/model.cjs');
+require('../data/model/types.cjs');
+require('../data/model/credentials.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+class EventSourceService extends NetworkService.NetworkService {
+    constructor(config = {}) {
+        super(config);
+        this.evtSource = new EventSource(this.baseUrl);
+    }
+    /**
+     * Shutdown the event source connection
+     */
+    shutdown() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.evtSource.close();
+        });
+    }
+    __setup__() {
+        const internals = this.__internal__;
+        const socketMethods = R__namespace.filter(([_, v]) => v.socketReadStream !== undefined, R__namespace.toPairs(internals.methodConfig));
+        R__namespace.forEach(([key, config]) => {
+            var _a;
+            const oldMethod = this[key];
+            const details = (_a = internals.methodConfig[key]) === null || _a === void 0 ? void 0 : _a.socketReadStream;
+            if (!details) {
+                throw new CallExecutionError.CallExecutionError("ReadStream details is missing for EventSource");
+            }
+            this[key] = () => {
+                var _a, _b;
+                const queue = [];
+                const dataReadyEvt = new synchronize.FutureEvent();
+                this.evtSource.addEventListener(details.keyPath instanceof Array ? details.keyPath.join(".") : details.keyPath, (evt) => {
+                    queue.push(evt.data);
+                    dataReadyEvt.set();
+                });
+                let stream$1 = new stream.Stream(() => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    if (queue.length === 0) {
+                        dataReadyEvt.clear();
+                        yield dataReadyEvt.wait();
+                    }
+                    return queue.shift();
+                }));
+                if (((_a = config.socketReadStream) === null || _a === void 0 ? void 0 : _a.skip) !== undefined)
+                    stream$1 = stream$1.skip(config.socketReadStream.skip);
+                if (((_b = config.socketReadStream) === null || _b === void 0 ? void 0 : _b.take) !== undefined)
+                    stream$1 = stream$1.take(config.socketReadStream.take);
+                return stream$1
+                    .map((data) => {
+                    if (config.responseClass.prototype instanceof model.Model) {
+                        const ModelClass = config.responseClass;
+                        return ModelClass.fromString(data, config.dataFormat);
+                    }
+                    return config.responseClass(data, config.dataFormat);
+                })
+                    .flatten()
+                    .map((v) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    let result$1 = oldMethod(v);
+                    if (result$1 === null || result$1 === undefined)
+                        return v;
+                    if (result$1 instanceof Promise)
+                        result$1 = yield result$1;
+                    if (result$1 instanceof result.FutureResult)
+                        result$1 = result$1.value;
+                    return result$1;
+                }));
+            };
+        }, socketMethods);
+        const originalMethodConfig = internals.methodConfig;
+        internals.methodConfig = R__namespace.fromPairs(R__namespace.filter(([_, v]) => !(v.socketReadStream && v.socketWriteStream), R__namespace.toPairs(internals.methodConfig)));
+        super.__setup__();
+        internals.methodConfig = originalMethodConfig;
+    }
+}
+
+exports.EventSourceService = EventSourceService;

package/networking/EventSourceService.d.ts

@@ -0,0 +1,11 @@
+import { NetworkService } from "./NetworkService";
+import { GingerSnapProps } from "./index";
+export declare class EventSourceService extends NetworkService {
+    private readonly evtSource;
+    constructor(config?: GingerSnapProps);
+    /**
+     * Shutdown the event source connection
+     */
+    shutdown(): Promise<void>;
+    protected __setup__(): void;
+}

package/networking/EventSourceService.mjs

@@ -0,0 +1,83 @@
+import { __awaiter } from '../_virtual/_tslib.mjs';
+import { NetworkService } from './NetworkService.mjs';
+import * as R from 'ramda';
+import { CallExecutionError } from '../errors/CallExecutionError.mjs';
+import { FutureEvent } from '../synchronize.mjs';
+import 'uuid';
+import { FutureResult } from '../future/result.mjs';
+import { Stream } from '../stream.mjs';
+import { Model } from '../data/model/model.mjs';
+import '../data/model/types.mjs';
+import '../data/model/credentials.mjs';
+
+class EventSourceService extends NetworkService {
+    constructor(config = {}) {
+        super(config);
+        this.evtSource = new EventSource(this.baseUrl);
+    }
+    /**
+     * Shutdown the event source connection
+     */
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.evtSource.close();
+        });
+    }
+    __setup__() {
+        const internals = this.__internal__;
+        const socketMethods = R.filter(([_, v]) => v.socketReadStream !== undefined, R.toPairs(internals.methodConfig));
+        R.forEach(([key, config]) => {
+            var _a;
+            const oldMethod = this[key];
+            const details = (_a = internals.methodConfig[key]) === null || _a === void 0 ? void 0 : _a.socketReadStream;
+            if (!details) {
+                throw new CallExecutionError("ReadStream details is missing for EventSource");
+            }
+            this[key] = () => {
+                var _a, _b;
+                const queue = [];
+                const dataReadyEvt = new FutureEvent();
+                this.evtSource.addEventListener(details.keyPath instanceof Array ? details.keyPath.join(".") : details.keyPath, (evt) => {
+                    queue.push(evt.data);
+                    dataReadyEvt.set();
+                });
+                let stream = new Stream(() => __awaiter(this, void 0, void 0, function* () {
+                    if (queue.length === 0) {
+                        dataReadyEvt.clear();
+                        yield dataReadyEvt.wait();
+                    }
+                    return queue.shift();
+                }));
+                if (((_a = config.socketReadStream) === null || _a === void 0 ? void 0 : _a.skip) !== undefined)
+                    stream = stream.skip(config.socketReadStream.skip);
+                if (((_b = config.socketReadStream) === null || _b === void 0 ? void 0 : _b.take) !== undefined)
+                    stream = stream.take(config.socketReadStream.take);
+                return stream
+                    .map((data) => {
+                    if (config.responseClass.prototype instanceof Model) {
+                        const ModelClass = config.responseClass;
+                        return ModelClass.fromString(data, config.dataFormat);
+                    }
+                    return config.responseClass(data, config.dataFormat);
+                })
+                    .flatten()
+                    .map((v) => __awaiter(this, void 0, void 0, function* () {
+                    let result = oldMethod(v);
+                    if (result === null || result === undefined)
+                        return v;
+                    if (result instanceof Promise)
+                        result = yield result;
+                    if (result instanceof FutureResult)
+                        result = result.value;
+                    return result;
+                }));
+            };
+        }, socketMethods);
+        const originalMethodConfig = internals.methodConfig;
+        internals.methodConfig = R.fromPairs(R.filter(([_, v]) => !(v.socketReadStream && v.socketWriteStream), R.toPairs(internals.methodConfig)));
+        super.__setup__();
+        internals.methodConfig = originalMethodConfig;
+    }
+}
+
+export { EventSourceService };