@restorecommerce/facade 1.3.3 → 1.3.5

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.5](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.4...@restorecommerce/facade@1.3.5) (2023-06-16)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
+## [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

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/dist/modules/index.d.ts

@@ -2,7 +2,7 @@ export * from './facade-status/index.js';
 export * from './identity/index.js';
 export * from './ordering/index.js';
 export * from './payment/index.js';
-export * from './resource/index.js';
+export * from './master_data/index.js';
 export * from './catalog/index.js';
 export * from './invoicing/index.js';
 export * from './fulfillment/index.js';

package/dist/modules/index.js

@@ -2,7 +2,7 @@ export * from './facade-status/index.js';
 export * from './identity/index.js';
 export * from './ordering/index.js';
 export * from './payment/index.js';
-export * from './resource/index.js';
+export * from './master_data/index.js';
 export * from './catalog/index.js';
 export * from './invoicing/index.js';
 export * from './fulfillment/index.js';

package/dist/modules/{resource → master_data}/gql/schema.generated.d.ts

@@ -53,7 +53,7 @@ export type Scalars = {
 };
 export type Query = {
     __typename?: 'Query';
-    resource: ResourceQuery;
+    master_data: ResourceQuery;
 };
 export type ResourceQuery = {
     __typename?: 'ResourceQuery';
@@ -803,7 +803,7 @@ export declare enum IoRestorecommerceCodeSector {
 }
 export type Mutation = {
     __typename?: 'Mutation';
-    resource: ResourceMutation;
+    master_data: ResourceMutation;
 };
 export type ResourceMutation = {
     __typename?: 'ResourceMutation';
@@ -1638,7 +1638,7 @@ export type ResolversParentTypes = ResolversObject<{
     SubscriptionOutput: SubscriptionOutput;
 }>;
 export type QueryResolvers<ContextType = ResourceContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
-    resource?: Resolver<ResolversTypes['ResourceQuery'], ParentType, ContextType>;
+    master_data?: Resolver<ResolversTypes['ResourceQuery'], ParentType, ContextType>;
 }>;
 export type ResourceQueryResolvers<ContextType = ResourceContext, ParentType extends ResolversParentTypes['ResourceQuery'] = ResolversParentTypes['ResourceQuery']> = ResolversObject<{
     address?: Resolver<ResolversTypes['ResourceAddressQuery'], ParentType, ContextType>;
@@ -2299,7 +2299,7 @@ export type IoRestorecommerceCodeSectorResolvers = {
     SPACE_AND_TIME: 13;
 };
 export type MutationResolvers<ContextType = ResourceContext, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = ResolversObject<{
-    resource?: Resolver<ResolversTypes['ResourceMutation'], ParentType, ContextType>;
+    master_data?: Resolver<ResolversTypes['ResourceMutation'], ParentType, ContextType>;
 }>;
 export type ResourceMutationResolvers<ContextType = ResourceContext, ParentType extends ResolversParentTypes['ResourceMutation'] = ResolversParentTypes['ResourceMutation']> = ResolversObject<{
     address?: Resolver<ResolversTypes['ResourceAddressMutation'], ParentType, ContextType>;

package/dist/modules/{resource → master_data}/interfaces.d.ts

@@ -13,4 +13,4 @@ export interface ResourceContext extends FacadeContext {
     };
 }
 export type ResourceModule = FacadeModule<ResourceContext>;
-export declare const namespace = "resource";
+export declare const namespace = "master_data";

package/dist/modules/master_data/interfaces.js

@@ -0,0 +1 @@
+export const namespace = 'master_data';

package/generate.ts

@@ -7,8 +7,8 @@ import { namespace as orderingNamespace } from './src/modules/ordering/interface
 import { schema as paymentSchema } from './src/modules/payment/gql/schema.js';
 import { namespace as paymentNamespace } from './src/modules/payment/interfaces.js';
 
-import { schema as resourceSchema } from './src/modules/resource/gql/schema.js';
-import { namespace as resourceNamespace } from './src/modules/resource/interfaces.js';
+import { schema as resourceSchema } from './src/modules/master_data/gql/schema.js';
+import { namespace as resourceNamespace } from './src/modules/master_data/interfaces.js';
 
 import { schema as catalogSchema } from './src/modules/catalog/gql/schema.js';
 import { namespace as catalogNamespace } from './src/modules/catalog/interfaces.js';
@@ -72,7 +72,7 @@ generateSchemaTypings({
 
 generateSchemaTypings({
   schema: resourceSchema(cfg.get(resourceNamespace)),
-  outputFile: './src/modules/resource/gql/schema.generated.ts',
+  outputFile: './src/modules/master_data/gql/schema.generated.ts',
   typescriptResolvers: {
     contextType: '../interfaces.js#ResourceContext'
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@restorecommerce/facade",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Facade for Restorecommerce microservices",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -26,9 +26,9 @@
     "@grpc/proto-loader": "^0.7.7",
     "@koa/cors": "^4.0.0",
     "@restorecommerce/grpc-client": "^2.0.1",
-    "@restorecommerce/kafka-client": "^1.0.9",
+    "@restorecommerce/kafka-client": "^1.0.10",
     "@restorecommerce/logger": "^1.2.3",
-    "@restorecommerce/rc-grpc-clients": "^3.1.1",
+    "@restorecommerce/rc-grpc-clients": "^3.1.2",
     "@restorecommerce/service-config": "^1.0.5",
     "array.prototype.flat": "^1.3.1",
     "co": "^4.6.0",
@@ -136,5 +136,5 @@
       }
     }
   },
-  "gitHead": "46fa3b973fb34b98eb95a6d702638f36dc4154fc"
+  "gitHead": "1caa7cb6acfb09a9ea79c9ff4349390617175854"
 }

package/dist/modules/resource/interfaces.js

@@ -1 +0,0 @@
-export const namespace = 'resource';