@restorecommerce/facade 1.3.6 → 1.3.7

package/dist/gql/protos/resolvers.js

@@ -1,479 +0,0 @@
-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());
-    });
-};
-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';
-import { getWhitelistBlacklistConfig, Mutate, postProcessGQLValue, preprocessGQLInput, } from './graphql.js';
-import { camelCase, capitalize, convertEnumToInt, decodeBufferFields, getKeys, snakeToCamel, useSubscriptions, getServiceName } from './utils.js';
-import { ReadRequest } from '@restorecommerce/rc-grpc-clients';
-import { Filter_Operation, Filter_ValueType, FilterOp_Operator } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/resource_base.js';
-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 {};
-    }
-    return service.method.reduce((obj, method) => {
-        var _a, _b, _c, _d;
-        if ((_b = (_a = cfg[serviceKey]) === null || _a === void 0 ? void 0 : _a.methods) === null || _b === void 0 ? void 0 : _b.blacklist) {
-            const blacklistMethods = (_d = (_c = cfg[serviceKey]) === null || _c === void 0 ? void 0 : _c.methods) === null || _d === void 0 ? void 0 : _d.blacklist;
-            if (blacklistMethods.includes(method.name)) {
-                return {};
-            }
-        }
-        const typing = getTyping(method.inputType);
-        const outputTyping = getTyping(method.outputType);
-        if (!typing) {
-            throw Error(`Method '${method.name}' could not find input type: ${method.inputType}`);
-        }
-        if (!outputTyping) {
-            throw Error(`Method '${method.name}' could not find output type: ${method.outputType}`);
-        }
-        if (!('fromPartial' in typing.processor)) {
-            throw Error(`Method ${method.name} input type '${method.inputType}' does not contain 'fromPartial' function`);
-        }
-        let subjectField = null;
-        if (typing) {
-            for (let field of typing.meta.field) {
-                if (field.typeName === authSubjectType) {
-                    subjectField = field.name;
-                    break;
-                }
-            }
-        }
-        let methodName = method.name;
-        if (Mutate.indexOf(method.name) > -1) {
-            methodName = 'Mutate';
-        }
-        if (methodName in obj) {
-            return obj;
-        }
-        obj[methodName] = (args, context) => __awaiter(void 0, void 0, void 0, function* () {
-            var _e, _f;
-            const client = context[key].client;
-            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;
-                let req = typing.processor.fromPartial(converted);
-                // convert enum strings to integers
-                req = convertEnumToInt(typing, req);
-                if (subjectField !== null) {
-                    req.subject = getTyping(authSubjectType).processor.fromPartial({});
-                    const authToken = context.request.req.headers['authorization'];
-                    if (authToken && authToken.startsWith('Bearer ')) {
-                        req.subject.token = authToken.split(' ')[1];
-                    }
-                    if (scope) {
-                        req.subject.scope = scope;
-                    }
-                }
-                let realMethod = method.name;
-                if (Mutate.indexOf(method.name) > -1) {
-                    const mode = (_f = args === null || args === void 0 ? void 0 : args.input) === null || _f === void 0 ? void 0 : _f.mode;
-                    if (!mode) {
-                        throw new Error('Please specify mode');
-                    }
-                    if (mode === 'CREATE') {
-                        realMethod = 'Create';
-                    }
-                    else if (mode === 'UPDATE') {
-                        realMethod = 'Update';
-                    }
-                    else if (mode === 'UPSERT') {
-                        realMethod = 'Upsert';
-                    }
-                }
-                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;
-                const bufferFields = getKeys(grpcClientConfig === null || grpcClientConfig === void 0 ? void 0 : grpcClientConfig.bufferFields);
-                if (result instanceof stream.Readable) {
-                    let operationStatus = { code: 0, message: '' };
-                    let aggregatedResponse = yield new Promise((resolve, reject) => {
-                        let response = {};
-                        let combinedChunks = {};
-                        result.on('data', (chunk) => {
-                            const chunkObj = _.cloneDeep(chunk);
-                            if (!combinedChunks) {
-                                combinedChunks = chunk;
-                            }
-                            else {
-                                Object.assign(combinedChunks, 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: [] };
-                                    }
-                                    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';
-                            }
-                            if (!_.isEmpty(response)) {
-                                resolve(response);
-                            }
-                            else if (!_.isEmpty(combinedChunks)) {
-                                resolve(combinedChunks);
-                            }
-                        });
-                    });
-                    return { details: aggregatedResponse, operationStatus };
-                }
-                if ('items' in result) {
-                    let items = decodeBufferFields(result.items, bufferFields);
-                    return {
-                        details: {
-                            items,
-                            operationStatus: result.operationStatus // overall status
-                        },
-                    };
-                }
-                else {
-                    return {
-                        details: decodeBufferFields([result], bufferFields)[0]
-                    };
-                }
-            }
-            catch (error) {
-                console.error(error);
-                return {
-                    details: {
-                        items: [],
-                        operationStatus: {
-                            code: error.code,
-                            message: error.message
-                        }
-                    }
-                };
-            }
-        });
-        return obj;
-    }, {});
-};
-const namespaceResolverRegistry = new Map();
-const subscriptionResolvers = {};
-export const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined, service) => {
-    if (!namespaceResolverRegistry.has(namespace)) {
-        namespaceResolverRegistry.set(namespace, new Map());
-    }
-    if (!namespaceResolverRegistry.get(namespace).has(mutation)) {
-        namespaceResolverRegistry.get(namespace).set(mutation, new Map());
-    }
-    let space = namespaceResolverRegistry.get(namespace).get(mutation);
-    if (subspace) {
-        if (!space.has(subspace)) {
-            space.set(subspace, new Map());
-        }
-        space = space.get(subspace);
-    }
-    if (space.has(name)) {
-        if (subspace) {
-            throw new Error(`Namespace "${namespace}"."${subspace}" already contains a function: ${name} (mutation: ${mutation})`);
-        }
-        else {
-            throw new Error(`Namespace "${namespace}" already contains a function: ${name} (mutation: ${mutation})`);
-        }
-    }
-    if (service) {
-        const key = (namespace === null || namespace === void 0 ? void 0 : namespace.toLocaleLowerCase()) + '.' + (subspace === null || subspace === void 0 ? void 0 : subspace.toLocaleLowerCase()) + '.' + (name === null || name === void 0 ? void 0 : name.toLocaleLowerCase());
-        const value = service.method.find((m) => m.name === name);
-        if (key && (value === null || value === void 0 ? void 0 : value.inputType)) {
-            inputMethodType.set(key, value.inputType);
-        }
-    }
-    space.set(name, func);
-};
-export const generateResolver = (...namespaces) => {
-    const queryResolvers = {};
-    const mutationResolvers = {};
-    namespaces.forEach(ns => {
-        if (!namespaceResolverRegistry.has(ns)) {
-            throw new Error(`Namespace "${ns}" has no registered functions`);
-        }
-        if (namespaceResolverRegistry.get(ns).has(false)) {
-            const res = {};
-            namespaceResolverRegistry.get(ns).get(false).forEach((value, key) => {
-                if (value instanceof Map) {
-                    res[key] = Object.fromEntries(value);
-                }
-                else {
-                    res[key] = value;
-                }
-            });
-            queryResolvers[ns] = () => res;
-        }
-        if (namespaceResolverRegistry.get(ns).has(true)) {
-            const res = {};
-            namespaceResolverRegistry.get(ns).get(true).forEach((value, key) => {
-                if (value instanceof Map) {
-                    res[key] = Object.fromEntries(value);
-                }
-                else {
-                    res[key] = value;
-                }
-            });
-            mutationResolvers[ns] = () => res;
-        }
-    });
-    const resolvers = {};
-    if (Object.keys(queryResolvers).length > 0) {
-        resolvers.Query = queryResolvers;
-    }
-    if (Object.keys(mutationResolvers).length > 0) {
-        resolvers.Mutation = mutationResolvers;
-    }
-    if (Object.keys(subscriptionResolvers).length > 0) {
-        resolvers.Subscription = subscriptionResolvers;
-    }
-    return resolvers;
-};
-export const generateSubServiceResolvers = (subServices, config, namespace) => {
-    subServices.forEach((meta) => {
-        var _a;
-        meta.fileDescriptor.service.forEach(service => {
-            if (service.name) {
-                // strip Service from end of String for sub service name
-                const subName = getServiceName(service.name);
-                const { mutations, queries } = getWhitelistBlacklistConfig(service, config, meta, subName);
-                const func = getGQLResolverFunctions(service, namespace, subName || namespace, config);
-                Object.keys(func).forEach(k => {
-                    const regNamespace = config.root ? subName : namespace;
-                    const regSubspace = config.root ? undefined : subName;
-                    registerResolverFunction(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, service);
-                });
-            }
-        });
-        if (useSubscriptions) {
-            Object.entries(((_a = meta.options) === null || _a === void 0 ? void 0 : _a.messages) || {}).forEach(([messageName, option]) => {
-                if (option.options && 'kafka_subscriber' in option.options) {
-                    const kafkaSubscriber = option.options.kafka_subscriber;
-                    const fieldName = namespace + capitalize(kafkaSubscriber.plural);
-                    const baseMessageName = meta.fileDescriptor.package + '.' + messageName;
-                    const typing = getTyping('.' + baseMessageName);
-                    if (typing) {
-                        subscriptionResolvers[fieldName] = {
-                            // resolve: (parent, args, context, info) => {
-                            //   const obj = parent[fieldName];
-                            //   let missing = false;
-                            //   for (const selection of info.operation.selectionSet.selections) {
-                            //     if ('name' in selection && !(selection.name.value in obj)) {
-                            //       missing = true;
-                            //       break;
-                            //     }
-                            //   }
-                            //   if (!missing) {
-                            //     return obj;
-                            //   }
-                            //   // TODO Implement user lookup
-                            //   return obj;
-                            // },
-                            subscribe: (parent, args, context, info) => __awaiter(void 0, void 0, void 0, function* () {
-                                const action = args.action || 'CREATED';
-                                let event = kafkaSubscriber.created;
-                                switch (action) {
-                                    case 'UPDATED':
-                                        event = kafkaSubscriber.updated;
-                                        break;
-                                    case 'DELETED':
-                                        event = kafkaSubscriber.deleted;
-                                        break;
-                                }
-                                const events = new Events({
-                                    provider: 'kafka',
-                                    kafka: Object.assign({}, context.kafkaConfig),
-                                    [event]: {
-                                        messageObject: baseMessageName
-                                    }
-                                }, context.logger);
-                                yield events.start();
-                                const commandTopic = yield events.topic(kafkaSubscriber.topic);
-                                let deferred = null;
-                                const pending = [];
-                                commandTopic.on(event, (message) => {
-                                    pending.push({ id: message.id });
-                                    deferred === null || deferred === void 0 ? void 0 : deferred.resolve(false);
-                                });
-                                return {
-                                    [Symbol.asyncIterator]() {
-                                        return this;
-                                    },
-                                    next: () => __awaiter(void 0, void 0, void 0, function* () {
-                                        if (pending.length) {
-                                            return { value: { [fieldName]: pending.shift() } };
-                                        }
-                                        return (yield new Promise((resolve, reject) => (deferred = { resolve, reject })))
-                                            ? { done: true, value: undefined }
-                                            : { value: { [fieldName]: pending.shift() } };
-                                    }),
-                                    throw: (err) => __awaiter(void 0, void 0, void 0, function* () {
-                                        throw err;
-                                    }),
-                                    return: () => __awaiter(void 0, void 0, void 0, function* () {
-                                        yield events.stop();
-                                        return { done: true, value: undefined };
-                                    }),
-                                };
-                            })
-                        };
-                    }
-                }
-            });
-        }
-    });
-    if (config.root) {
-        return generateResolver(...flat(subServices.map(meta => {
-            return meta.fileDescriptor.service.map(service => {
-                if (service.name) {
-                    return getServiceName(service.name);
-                }
-                return '';
-            }).filter(s => s !== '');
-        })));
-    }
-    const finalResolver = generateResolver(namespace);
-    subServices.forEach((meta) => {
-        meta.fileDescriptor.service.forEach(service => {
-            if (meta.options && meta.options.messages) {
-                for (const key of Object.keys(meta.options.messages)) {
-                    const message = meta.options.messages[key];
-                    if (message.fields) {
-                        const typing = getTyping('.' + meta.fileDescriptor.package + '.' + key);
-                        if (typing) {
-                            const result = {};
-                            for (const fieldName of Object.keys(message.fields)) {
-                                const field = message.fields[fieldName];
-                                if ('resolver' in field) {
-                                    const fieldJsonName = snakeToCamel(fieldName);
-                                    const resolver = field['resolver'];
-                                    // TODO This creates an N+1 problem!
-                                    result[resolver.fieldName] = (parent, _, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                                        if (!parent || !(fieldJsonName in parent) || parent[fieldJsonName] === undefined) {
-                                            return undefined;
-                                        }
-                                        const client = ctx[resolver.targetService].client;
-                                        const service = client[resolver.targetSubService];
-                                        const idList = Array.isArray(parent[fieldJsonName]) ? parent[fieldJsonName] : [parent[fieldJsonName]];
-                                        // TODO Support custom input messages
-                                        const req = ReadRequest.fromPartial({
-                                            filters: [{
-                                                    filter: idList.map(id => ({
-                                                        field: 'id',
-                                                        operation: Filter_Operation.eq,
-                                                        value: id,
-                                                        type: Filter_ValueType.STRING
-                                                    })),
-                                                    operator: FilterOp_Operator.or
-                                                }]
-                                        });
-                                        req.subject = getTyping(authSubjectType).processor.fromPartial({});
-                                        const authToken = ctx.request.req.headers['authorization'];
-                                        if (authToken && authToken.startsWith('Bearer ')) {
-                                            req.subject.token = authToken.split(' ')[1];
-                                        }
-                                        const methodFunc = service[camelCase(resolver.targetMethod)] || service[resolver.targetMethod];
-                                        const result = yield methodFunc(req);
-                                        if (result && result.items && result.items.length) {
-                                            if (Array.isArray(parent[fieldJsonName])) {
-                                                return result.items.map((item) => item.payload);
-                                            }
-                                            else {
-                                                return result.items[0].payload;
-                                            }
-                                        }
-                                        return undefined;
-                                    });
-                                }
-                            }
-                            finalResolver[typing.output.name] = result;
-                        }
-                    }
-                }
-            }
-        });
-    });
-    return finalResolver;
-};

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

@@ -1,14 +0,0 @@
-import { type MethodDescriptorProto, type ServiceDescriptorProto } from 'ts-proto-descriptors';
-import { type ProtoMetadata, type ServiceConfig, type SubSpaceServiceConfig } from './types.js';
-import { GraphQLSchema, type ThunkObjMap } from 'graphql';
-import { type GraphQLFieldConfig, type GraphQLFieldConfigMap } from 'graphql/type/definition.js';
-export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, any>;
-export declare const getGQLSchemas: <TSource, TContext>(service: ServiceDescriptorProto) => GraphQLFieldConfigMap<TSource, TContext>;
-type SchemaBaseOrSub = ThunkObjMap<GraphQLFieldConfig<any, any>> | Map<string, ThunkObjMap<GraphQLFieldConfig<any, any>>>;
-export declare const registerResolverSchema: (namespace: string, name: string, schema: SchemaBaseOrSub, mutation: boolean | undefined, subspace: string | undefined, config: ServiceConfig) => void;
-export declare const generateSchema: (setup: {
-    prefix: string;
-    namespace: string;
-}[]) => GraphQLSchema;
-export declare const generateSubServiceSchemas: (subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, prefix: string) => GraphQLSchema;
-export {};