@restorecommerce/facade 1.3.2 → 1.3.4

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.3.4](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.3...@restorecommerce/facade@1.3.4) (2023-06-16)
+
+
+### Bug Fixes
+
+* **facade:** convert stream to async iterable so that file is read in chunksand passed ([d73ebf6](https://github.com/restorecommerce/libs/commit/d73ebf6d1d8b5c8d32b30968074aa4e89ca08c0d))
+* **facade:** service client and async iterable for file upload request ([a0759b8](https://github.com/restorecommerce/libs/commit/a0759b86a5efd4dbad0e68af67a7d42889f228ef))
+
+
+
+
+
+## [1.3.3](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.2...@restorecommerce/facade@1.3.3) (2023-06-14)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
 ## [1.3.2](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.1...@restorecommerce/facade@1.3.2) (2023-06-14)
 
 

package/dist/gql/protos/graphql.js

@@ -7,18 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 import { GraphQLList, GraphQLNonNull, GraphQLObjectType, } from 'graphql';
 import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType, } from 'graphql/type/definition.js';
 export const Mutate = ['Create', 'Update', 'Upsert'];
 export const preprocessGQLInput = (data, model) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, e_1, _b, _c;
     if (model instanceof GraphQLEnumType) {
         return data;
     }
@@ -65,23 +57,7 @@ export const preprocessGQLInput = (data, model) => __awaiter(void 0, void 0, voi
                 let fileData = yield data;
                 const upload = yield fileData.promise;
                 const stream = upload.createReadStream();
-                const chunks = [];
-                try {
-                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
-                        _c = stream_1_1.value;
-                        _d = false;
-                        let chunk = _c;
-                        chunks.push(chunk);
-                    }
-                }
-                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; }
-                }
-                return Buffer.concat(chunks);
+                return stream;
         }
     }
     return data;

package/dist/gql/protos/resolvers.js

@@ -7,6 +7,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 import { authSubjectType } from './types.js';
 import flat from 'array.prototype.flat';
 import { getTyping } from './registry.js';
@@ -17,7 +36,29 @@ import { Filter_Operation, Filter_ValueType, FilterOp_Operator } from '@restorec
 import * as stream from 'node:stream';
 import _ from 'lodash';
 import { Events } from '@restorecommerce/kafka-client';
+import S2A from './stream-to-async-iterator.js';
 const inputMethodType = new Map();
+const streamToAsyncIterable = function (request, readableStreamKey) {
+    return __asyncGenerator(this, arguments, function* () {
+        var _a, e_1, _b, _c;
+        const readStream = _.clone(request[readableStreamKey]);
+        try {
+            for (var _d = true, _e = __asyncValues(new S2A(readStream)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const chunk = _c;
+                yield yield __await(Object.assign({}, request, { [readableStreamKey]: chunk }));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+};
 export const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
     if (!service.method) {
         return {};
@@ -60,7 +101,7 @@ export const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
         obj[methodName] = (args, context) => __awaiter(void 0, void 0, void 0, function* () {
             var _e, _f;
             const client = context[key].client;
-            const service = client[serviceKey];
+            const service = client[key];
             try {
                 const converted = yield preprocessGQLInput(args.input, typing.input);
                 const scope = (_e = args === null || args === void 0 ? void 0 : args.input) === null || _e === void 0 ? void 0 : _e.scope;
@@ -94,6 +135,16 @@ export const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                     }
                 }
                 const methodFunc = service[camelCase(realMethod)] || service[realMethod];
+                if (method.clientStreaming) {
+                    const readableStreamKey = Object.keys(req).filter((key) => {
+                        if (req[key] instanceof stream.Stream.Readable) {
+                            return key;
+                        }
+                    });
+                    if (readableStreamKey.length > 0) {
+                        req = streamToAsyncIterable(req, readableStreamKey[0]);
+                    }
+                }
                 const rawResult = yield methodFunc(req);
                 const result = postProcessGQLValue(rawResult, outputTyping.output);
                 const grpcClientConfig = cfg.client;

package/dist/gql/protos/stream-to-async-iterator.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable } from "stream";
+export type StreamToAsyncIteratorOptions = {
+    /** The size of each read from the stream for each iteration */
+    size?: number;
+};
+/**
+ * Wraps a stream into an object that can be used as an async iterator.
+ *
+ * This will keep a stream in a paused state, and will only read from the stream on each
+ * iteration. A size can be supplied to set an explicit call to `stream.read([size])` in
+ * the options for each iteration.
+ */
+export default class StreamToAsyncIterator<T = unknown> implements AsyncIterableIterator<T> {
+    /** The underlying readable stream */
+    private _stream;
+    /** Contains stream's error when stream has error'ed out */
+    private _error;
+    /** The current state of the iterator (not readable, readable, ended, errored) */
+    private _state;
+    private _size;
+    /** The rejections of promises to call when stream errors out */
+    private _rejections;
+    get closed(): boolean;
+    constructor(stream: Readable, { size }?: StreamToAsyncIteratorOptions);
+    [Symbol.asyncIterator](): this;
+    /**
+     * Returns the next iteration of data. Rejects if the stream errored out.
+     */
+    next(): Promise<IteratorResult<T, void>>;
+    /**
+     * Waits until the stream is readable. Rejects if the stream errored out.
+     * @returns Promise when stream is readable
+     */
+    private _untilReadable;
+    /**
+     * Waits until the stream is ended. Rejects if the stream errored out.
+     * @returns Promise when stream is finished
+     */
+    private _untilEnd;
+    return(): Promise<IteratorResult<T, void>>;
+    throw(err?: Error): Promise<IteratorResult<T, void>>;
+    /**
+     * Destroy the stream
+     * @param err An optional error to pass to the stream for an error event
+     */
+    close(err?: Error): void;
+    private _handleStreamError;
+    private _handleStreamEnd;
+}

package/dist/gql/protos/stream-to-async-iterator.js

@@ -0,0 +1,190 @@
+// The MIT License (MIT)
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const NOT_READABLE = Symbol("not readable");
+const READABLE = Symbol("readable");
+const ENDED = Symbol("ended");
+const ERRORED = Symbol("errored");
+const STATES = {
+    notReadable: NOT_READABLE,
+    readable: READABLE,
+    ended: ENDED,
+    errored: ERRORED,
+};
+/**
+ * Wraps a stream into an object that can be used as an async iterator.
+ *
+ * This will keep a stream in a paused state, and will only read from the stream on each
+ * iteration. A size can be supplied to set an explicit call to `stream.read([size])` in
+ * the options for each iteration.
+ */
+export default class StreamToAsyncIterator {
+    get closed() {
+        return this._state === STATES.ended;
+    }
+    constructor(stream, { size } = {}) {
+        /** The current state of the iterator (not readable, readable, ended, errored) */
+        this._state = STATES.notReadable;
+        /** The rejections of promises to call when stream errors out */
+        this._rejections = new Set();
+        this._stream = stream;
+        this._size = size;
+        const bindMethods = ["_handleStreamEnd", "_handleStreamError"];
+        for (const method of bindMethods) {
+            Object.defineProperty(this, method, {
+                configurable: true,
+                writable: true,
+                value: this[method].bind(this),
+            });
+        }
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        stream.once("error", this._handleStreamError);
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        stream.once("end", this._handleStreamEnd);
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    /**
+     * Returns the next iteration of data. Rejects if the stream errored out.
+     */
+    next() {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (this._state) {
+                case STATES.notReadable: {
+                    let untilReadable;
+                    let untilEnd;
+                    try {
+                        untilReadable = this._untilReadable();
+                        untilEnd = this._untilEnd();
+                        yield Promise.race([
+                            untilReadable.promise,
+                            untilEnd.promise,
+                        ]);
+                    }
+                    finally {
+                        // need to clean up any hanging event listeners
+                        if (untilReadable != null) {
+                            untilReadable.close();
+                        }
+                        if (untilEnd != null) {
+                            untilEnd.close();
+                        }
+                    }
+                    return this.next();
+                }
+                case STATES.ended: {
+                    this.close();
+                    return { done: true, value: undefined };
+                }
+                case STATES.errored: {
+                    this.close();
+                    throw this._error;
+                }
+                case STATES.readable: {
+                    // stream.read returns null if not readable or when stream has ended
+                    // todo: Could add a way to ensure data-type/shape of reads to make this type safe
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const data = this._size
+                        ? this._stream.read(this._size)
+                        : this._stream.read();
+                    if (data !== null) {
+                        return { done: false, value: data };
+                    }
+                    else {
+                        //we're no longer readable, need to find out what state we're in
+                        this._state = STATES.notReadable;
+                        // need to let event loop run to fill stream buffer
+                        yield new Promise(setImmediate);
+                        return this.next();
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Waits until the stream is readable. Rejects if the stream errored out.
+     * @returns Promise when stream is readable
+     */
+    _untilReadable() {
+        //let is used here instead of const because the exact reference is
+        //required to remove it, this is why it is not a curried function that
+        //accepts resolve & reject as parameters.
+        let handleReadable = undefined;
+        const promise = new Promise((resolve, reject) => {
+            handleReadable = () => {
+                this._state = STATES.readable;
+                this._rejections.delete(reject);
+                resolve();
+            };
+            this._stream.once("readable", handleReadable);
+            this._rejections.add(reject);
+        });
+        const cleanup = () => {
+            if (handleReadable != null) {
+                this._stream.removeListener("readable", handleReadable);
+            }
+        };
+        return { close: cleanup, promise };
+    }
+    /**
+     * Waits until the stream is ended. Rejects if the stream errored out.
+     * @returns Promise when stream is finished
+     */
+    _untilEnd() {
+        let handleEnd = undefined;
+        const promise = new Promise((resolve, reject) => {
+            handleEnd = () => {
+                this._state = STATES.ended;
+                this._rejections.delete(reject);
+                resolve();
+            };
+            this._stream.once("end", handleEnd);
+            this._rejections.add(reject);
+        });
+        const cleanup = () => {
+            if (handleEnd != null) {
+                this._stream.removeListener("end", handleEnd);
+            }
+        };
+        return { close: cleanup, promise };
+    }
+    return() {
+        this._state = STATES.ended;
+        return this.next();
+    }
+    throw(err) {
+        this._error = err;
+        this._state = STATES.errored;
+        return this.next();
+    }
+    /**
+     * Destroy the stream
+     * @param err An optional error to pass to the stream for an error event
+     */
+    close(err) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        this._stream.removeListener("end", this._handleStreamEnd);
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        this._stream.removeListener("error", this._handleStreamError);
+        this._state = STATES.ended;
+        this._stream.destroy(err);
+    }
+    _handleStreamError(err) {
+        this._error = err;
+        this._state = STATES.errored;
+        for (const reject of this._rejections) {
+            reject(err);
+        }
+    }
+    _handleStreamEnd() {
+        this._state = STATES.ended;
+    }
+}

package/dist/index.js

@@ -265,7 +265,7 @@ export class RestoreCommerceFacade {
                 },
             });
             yield gqlServer.start();
-            // TODO set maxFile size and maximum files via config
+            // TODO set maxFile size and maximum files via Facade config of `createFacade`
             this.koa.use(graphqlUploadKoa({
                 maxFileSize: 10000000,
                 maxFiles: 20,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@restorecommerce/facade",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Facade for Restorecommerce microservices",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -18,7 +18,7 @@
   "type": "module",
   "dependencies": {
     "@apollo/federation": "^0.38.1",
-    "@apollo/gateway": "^2.4.7",
+    "@apollo/gateway": "<2.4.0",
     "@apollo/server": "^4.7.1",
     "@as-integrations/koa": "^1.1.0",
     "@cloudnative/health": "^2.1.2",
@@ -136,5 +136,5 @@
       }
     }
   },
-  "gitHead": "4202cabe00d8363f62e3f53159755dca71781328"
+  "gitHead": "7c98ad5fc5e58f2f92c22f70b1c1c524090f8bfb"
 }