@restorecommerce/facade 0.1.33 → 0.1.38

package/CHANGELOG.md

@@ -3,6 +3,52 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.1.38](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.37...@restorecommerce/facade@0.1.38) (2021-12-20)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
+## [0.1.37](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.36...@restorecommerce/facade@0.1.37) (2021-12-09)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
+## [0.1.36](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.35...@restorecommerce/facade@0.1.36) (2021-12-09)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
+## [0.1.35](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.34...@restorecommerce/facade@0.1.35) (2021-12-09)
+
+
+### Bug Fixes
+
+* **facade:** updated generated schema for facade module due to changes in proto files. ([c57d5fa](https://github.com/restorecommerce/libs/commit/c57d5faaea1dbd287727f7c7678e6cfe34dba92d))
+
+
+
+
+
+## [0.1.34](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.33...@restorecommerce/facade@0.1.34) (2021-12-06)
+
+
+### Bug Fixes
+
+* **facade:** Added streaming response handling for mutations and queries. ([199db2d](https://github.com/restorecommerce/libs/commit/199db2d51f5a1d08ec2af09579df9c742ae0bbb1))
+
+
+
+
+
 ## [0.1.33](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.32...@restorecommerce/facade@0.1.33) (2021-11-08)
 
 **Note:** Version bump only for package @restorecommerce/facade

package/dist/gql/protos/graphql.d.ts

@@ -2,6 +2,7 @@ import { GraphQLInputField, GraphQLResolveInfo, GraphQLSchema } from "graphql";
 import { GraphQLEnumType, GraphQLFieldConfig, GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLInputType, Thunk } from "graphql/type/definition";
 import { ServiceConfig, SubService, SubSpaceServiceConfig } from "./types";
 import { MethodDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors/google/protobuf/descriptor";
+import { GrpcClientConfig } from "@restorecommerce/grpc-client";
 export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, {
     [argName: string]: any;
 }>;
@@ -13,7 +14,7 @@ declare type ServiceClient<Context extends Pick<Context, Key>, Key extends keyof
         client: T;
     };
 };
-export declare const getGQLResolverFunctions: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, B extends keyof T = any, NS extends keyof CTX = any>(service: ServiceDescriptorProto, key: NS, serviceKey: B) => { [key in keyof SRV]: R; };
+export declare const getGQLResolverFunctions: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, B extends keyof T = any, NS extends keyof CTX = any>(service: ServiceDescriptorProto, key: NS, serviceKey: B, grpcClientConfig: GrpcClientConfig) => { [key in keyof SRV]: R; };
 export declare const registerResolverFunction: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>>(namespace: string, name: string, func: ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, mutation?: boolean, subspace?: string | undefined) => void;
 export declare const generateResolver: (...namespaces: string[]) => any;
 export declare const registerResolverSchema: (namespace: string, name: string, schema: Thunk<GraphQLFieldConfig<any, any>>, mutation?: boolean, subspace?: string | undefined) => void;

package/dist/gql/protos/graphql.js

@@ -6,6 +6,8 @@ const definition_1 = require("graphql/type/definition");
 const types_1 = require("./types");
 const registry_1 = require("./registry");
 const utils_1 = require("./utils");
+const stream = require("stream");
+const _ = require("lodash");
 const typeCache = new Map();
 const Mutate = ['Create', 'Update', 'Upsert'];
 const getGQLSchema = (method) => {
@@ -93,7 +95,7 @@ const recursiveUploadToBuffer = async (data, model) => {
     return data;
 };
 exports.recursiveUploadToBuffer = recursiveUploadToBuffer;
-const getGQLResolverFunctions = (service, key, serviceKey) => {
+const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) => {
     if (!service.method) {
         return {};
     }
@@ -117,6 +119,7 @@ const getGQLResolverFunctions = (service, key, serviceKey) => {
             }
         }
         obj[method.name] = async (args, context) => {
+            var _a;
             const client = context[key].client;
             const service = client[serviceKey];
             try {
@@ -133,11 +136,57 @@ const getGQLResolverFunctions = (service, key, serviceKey) => {
                         req.subject.token = authToken.split(' ')[1];
                     }
                 }
-                // TODO Handle client-stream methods
                 const result = await service[method.name](req);
+                const bufferFields = utils_1.getKeys((_a = grpcClientConfig) === null || _a === void 0 ? void 0 : _a.bufferFields);
+                if (result instanceof stream.Readable) {
+                    let operationStatus = { code: 0, message: '' };
+                    let aggregatedResponse = await new Promise((resolve, reject) => {
+                        let response = {};
+                        result.on('data', (chunk) => {
+                            const chunkObj = _.cloneDeep(chunk);
+                            if (!response) {
+                                response = chunk;
+                            }
+                            else {
+                                Object.assign(response, chunk);
+                            }
+                            const existingBufferFields = _.intersection(Object.keys(chunk), bufferFields);
+                            for (let bufferField of existingBufferFields) {
+                                if (chunkObj[bufferField] && chunkObj[bufferField].value) {
+                                    if (response[bufferField] && response[bufferField].value && !_.isArray(response[bufferField].value)) {
+                                        response[bufferField].value = [];
+                                    }
+                                    let data = JSON.parse(chunkObj[bufferField].value.toString());
+                                    if (_.isArray(data)) {
+                                        for (let dataObj of data) {
+                                            response[bufferField].value.push(dataObj);
+                                        }
+                                    }
+                                    else {
+                                        response[bufferField].value.push(data);
+                                    }
+                                }
+                            }
+                        });
+                        result.on('error', (err) => {
+                            console.error(err);
+                            operationStatus.code = err.code ? err.code : 500;
+                            operationStatus.message = err.message;
+                        });
+                        result.on('end', () => {
+                            if (_.isEmpty(operationStatus.message)) {
+                                operationStatus.code = 200;
+                                operationStatus.message = 'success';
+                            }
+                            resolve(response);
+                        });
+                    });
+                    return { details: aggregatedResponse, operationStatus };
+                }
+                let items = utils_1.decodeBufferFields(result.items, bufferFields);
                 return {
                     details: {
-                        items: result.items,
+                        items: items,
                         operationStatus: result.operationStatus // overall status
                     },
                 };
@@ -210,10 +259,79 @@ const MutateResolver = async (req, ctx, schema) => {
         if (authToken && authToken.startsWith('Bearer ')) {
             subject.token = authToken.split(' ')[1];
         }
+        // TODO identify google.protobufAny from config
+        for (let item of input.items) {
+            let keys = Object.keys(item);
+            for (let key of keys) {
+                if (item[key] && item[key].value) {
+                    item[key] = { typeUrl: '', value: Buffer.from(JSON.stringify(item.data.value)) };
+                }
+            }
+        }
         const result = await service[method]({
             items: input === null || input === void 0 ? void 0 : input.items,
             subject
         });
+        // TODO read from grpcClientConfig
+        // const bufferFields = getKeys((grpcClientConfig as any)?.bufferFields);
+        const bufferFields = [];
+        if (result instanceof stream.Readable) {
+            let operationStatus = { code: 0, message: '' };
+            let aggregatedResponse = await new Promise((resolve, reject) => {
+                let response = {};
+                result.on('data', (chunk) => {
+                    const chunkObj = _.cloneDeep(chunk);
+                    if (!response) {
+                        response = chunk;
+                    }
+                    else {
+                        Object.assign(response, chunk);
+                    }
+                    const existingBufferFields = _.intersection(Object.keys(chunk), bufferFields);
+                    for (let bufferField of existingBufferFields) {
+                        if (chunkObj[bufferField] && chunkObj[bufferField].value) {
+                            if (response[bufferField] && response[bufferField].value && !_.isArray(response[bufferField].value)) {
+                                response[bufferField].value = [];
+                            }
+                            let data = JSON.parse(chunkObj[bufferField].value.toString());
+                            if (_.isArray(data)) {
+                                for (let dataObj of data) {
+                                    response[bufferField].value.push(dataObj);
+                                }
+                            }
+                            else {
+                                response[bufferField].value.push(data);
+                            }
+                        }
+                    }
+                });
+                result.on('error', (err) => {
+                    console.error(err);
+                    operationStatus.code = err.code ? err.code : 500;
+                    operationStatus.message = err.message;
+                });
+                result.on('end', () => {
+                    if (_.isEmpty(operationStatus.message)) {
+                        operationStatus.code = 200;
+                        operationStatus.message = 'success';
+                    }
+                    resolve(response);
+                });
+            });
+            return { details: { items: aggregatedResponse, operationStatus } };
+        }
+        // TODO identify google.protobufAny from config
+        // let items = decodeBufferFields(result.items, bufferFields);
+        for (let item of result.items) {
+            if (item && item.payload) {
+                const keys = Object.keys(item.payload);
+                for (let bufferField of keys) {
+                    if (item.payload[bufferField] && item.payload[bufferField].value) {
+                        item.payload[bufferField].value = JSON.parse(item.payload[bufferField].value.toString());
+                    }
+                }
+            }
+        }
         return {
             details: {
                 items: result.items,
@@ -470,7 +588,7 @@ const getAndGenerateSchema = (service, namespace, prefix, cfg, queryList) => {
 exports.getAndGenerateSchema = getAndGenerateSchema;
 const getAndGenerateResolvers = (service, namespace, cfg, queryList, subspace = undefined, serviceKey = undefined) => {
     const { mutations, queries } = exports.getWhitelistBlacklistConfig(service, queryList, cfg);
-    const func = exports.getGQLResolverFunctions(service, namespace, serviceKey || subspace || namespace);
+    const func = exports.getGQLResolverFunctions(service, namespace, serviceKey || subspace || namespace, cfg.client);
     Object.keys(func).forEach(k => {
         exports.registerResolverFunction(namespace, k, func[k], !queries.has(k) && mutations.has(k), subspace);
     });
@@ -497,7 +615,7 @@ exports.generateSubServiceSchemas = generateSubServiceSchemas;
 const generateSubServiceResolvers = (subServices, config, namespace) => {
     subServices.forEach((sub) => {
         const { mutations, queries } = exports.getWhitelistBlacklistConfig(sub.service, sub.queries, config);
-        const func = exports.getGQLResolverFunctions(sub.service, namespace, sub.name || namespace);
+        const func = exports.getGQLResolverFunctions(sub.service, namespace, sub.name || namespace, config.client);
         Object.keys(func).forEach(k => {
             exports.registerResolverFunction(config.root ? sub.name : namespace, k, func[k], !queries.has(k) && mutations.has(k), config.root ? undefined : sub.name);
         });

package/dist/gql/protos/utils.d.ts

@@ -1,2 +1,4 @@
 export declare const capitalizeProtoName: (name: string) => string;
 export declare const convertyCamelToSnakeCase: (entity: string) => string;
+export declare const getKeys: (obj: any) => string[];
+export declare const decodeBufferFields: (items: any, bufferFields: string[]) => any;

package/dist/gql/protos/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertyCamelToSnakeCase = exports.capitalizeProtoName = void 0;
+exports.decodeBufferFields = exports.getKeys = exports.convertyCamelToSnakeCase = exports.capitalizeProtoName = void 0;
+const _ = require("lodash");
 const capitalizeProtoName = (name) => {
     return name.replace(/(?:\.|^|_)(\w)/g, v => v.toUpperCase()).replace(/[._]/g, '');
 };
@@ -10,3 +11,40 @@ const convertyCamelToSnakeCase = (entity) => {
     return entity.replace(/(?:^|\.?)([A-Z])/g, (x, y) => { return '_' + y.toLowerCase(); }).replace(/^_/, '');
 };
 exports.convertyCamelToSnakeCase = convertyCamelToSnakeCase;
+const getKeys = (obj) => {
+    let set = new Set();
+    if (obj) {
+        const keys = Object.keys(obj);
+        for (let key of keys) {
+            if (typeof obj[key] === 'string') {
+                set.add(obj[key]);
+            }
+            else if (Array.isArray(obj[key])) {
+                for (let value of obj[key]) {
+                    set.add(value);
+                }
+            }
+        }
+    }
+    return Array.from(set);
+};
+exports.getKeys = getKeys;
+const decodeBufferFields = (items, bufferFields) => {
+    if (bufferFields && bufferFields.length > 0 && items && items.length > 0) {
+        for (let item of items) {
+            if (item && item.payload) {
+                const existingBufferFields = _.intersection(Object.keys(item.payload), bufferFields);
+                for (let bufferField of existingBufferFields) {
+                    if (item.payload[bufferField] && item.payload[bufferField].value) {
+                        item.payload[bufferField].value = JSON.parse(item.payload[bufferField].value.toString());
+                    }
+                }
+            }
+        }
+        return items;
+    }
+    else {
+        return items;
+    }
+};
+exports.decodeBufferFields = decodeBufferFields;

package/dist/index.js

@@ -188,7 +188,6 @@ class RestoreCommerceFacade {
 }
 exports.RestoreCommerceFacade = RestoreCommerceFacade;
 function createFacade(config) {
-    var _a;
     const koa = new koa_1.default();
     if (config.env) {
         koa.env = config.env;
@@ -196,7 +195,15 @@ function createFacade(config) {
     if (config.keys) {
         koa.keys = config.keys;
     }
-    const logger = (_a = config.logger) !== null && _a !== void 0 ? _a : logger_1.createLogger(config.logger);
+    let loggerCfg;
+    if (config.logger) {
+        loggerCfg = config.logger;
+        loggerCfg.esTransformer = (msg) => {
+            msg.fields = JSON.stringify(msg.fields);
+            return msg;
+        };
+    }
+    const logger = loggerCfg !== null && loggerCfg !== void 0 ? loggerCfg : logger_1.createLogger(loggerCfg);
     koa.context.logger = logger;
     return new RestoreCommerceFacade({
         koa,

package/dist/middlewares/req-res-logger/index.js

@@ -10,8 +10,15 @@ const debug = debug_1.default('@restorecommerce/koa-req-res-logger');
  @returns {Middleware}
  */
 const reqResLogger = (opts) => {
-    var _a;
-    const logger = (_a = opts.logger) !== null && _a !== void 0 ? _a : logger_1.createLogger();
+    let loggerCfg;
+    if (opts.logger) {
+        loggerCfg = opts.logger;
+        loggerCfg.esTransformer = (msg) => {
+            msg.fields = JSON.stringify(msg.fields);
+            return msg;
+        };
+    }
+    const logger = loggerCfg !== null && loggerCfg !== void 0 ? loggerCfg : logger_1.createLogger(loggerCfg);
     const fn = async (ctx, next) => {
         const request = ctx.request;
         debug('yield middleware: %s', exports.reqResLogger.name);