@restorecommerce/facade 1.2.0 → 1.3.1

package/dist/gql/protos/resolvers.js

@@ -1,44 +1,24 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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());
+    });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSubServiceResolvers = exports.generateResolver = exports.registerResolverFunction = exports.getGQLResolverFunctions = void 0;
-const types_1 = require("./types");
-const array_prototype_flat_1 = __importDefault(require("array.prototype.flat"));
-const registry_1 = require("./registry");
-const graphql_1 = require("./graphql");
-const utils_1 = require("./utils");
-const rc_grpc_clients_1 = require("@restorecommerce/rc-grpc-clients");
-const resource_base_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/resource_base");
-const stream = __importStar(require("stream"));
-const _ = __importStar(require("lodash"));
-const kafka_client_1 = require("@restorecommerce/kafka-client");
+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';
 const inputMethodType = new Map();
-const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
+export const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
     if (!service.method) {
         return {};
     }
@@ -50,8 +30,8 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                 return {};
             }
         }
-        const typing = (0, registry_1.getTyping)(method.inputType);
-        const outputTyping = (0, registry_1.getTyping)(method.outputType);
+        const typing = getTyping(method.inputType);
+        const outputTyping = getTyping(method.outputType);
         if (!typing) {
             throw Error(`Method '${method.name}' could not find input type: ${method.inputType}`);
         }
@@ -64,31 +44,31 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
         let subjectField = null;
         if (typing) {
             for (let field of typing.meta.field) {
-                if (field.typeName === types_1.authSubjectType) {
+                if (field.typeName === authSubjectType) {
                     subjectField = field.name;
                     break;
                 }
             }
         }
         let methodName = method.name;
-        if (graphql_1.Mutate.indexOf(method.name) > -1) {
+        if (Mutate.indexOf(method.name) > -1) {
             methodName = 'Mutate';
         }
         if (methodName in obj) {
             return obj;
         }
-        obj[methodName] = async (args, context) => {
-            var _a, _b;
+        obj[methodName] = (args, context) => __awaiter(void 0, void 0, void 0, function* () {
+            var _e, _f;
             const client = context[key].client;
             const service = client[serviceKey];
             try {
-                const converted = await (0, graphql_1.preprocessGQLInput)(args.input, typing.input);
-                const scope = (_a = args === null || args === void 0 ? void 0 : args.input) === null || _a === void 0 ? void 0 : _a.scope;
+                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 = (0, utils_1.convertEnumToInt)(typing, req);
+                req = convertEnumToInt(typing, req);
                 if (subjectField !== null) {
-                    req.subject = (0, registry_1.getTyping)(types_1.authSubjectType).processor.fromPartial({});
+                    req.subject = getTyping(authSubjectType).processor.fromPartial({});
                     const authToken = context.request.req.headers['authorization'];
                     if (authToken && authToken.startsWith('Bearer ')) {
                         req.subject.token = authToken.split(' ')[1];
@@ -98,8 +78,8 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                     }
                 }
                 let realMethod = method.name;
-                if (graphql_1.Mutate.indexOf(method.name) > -1) {
-                    const mode = (_b = args === null || args === void 0 ? void 0 : args.input) === null || _b === void 0 ? void 0 : _b.mode;
+                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');
                     }
@@ -113,14 +93,14 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                         realMethod = 'Upsert';
                     }
                 }
-                const methodFunc = service[(0, utils_1.camelCase)(realMethod)] || service[realMethod];
-                const rawResult = await methodFunc(req);
-                const result = (0, graphql_1.postProcessGQLValue)(rawResult, outputTyping.output);
+                const methodFunc = service[camelCase(realMethod)] || service[realMethod];
+                const rawResult = yield methodFunc(req);
+                const result = postProcessGQLValue(rawResult, outputTyping.output);
                 const grpcClientConfig = cfg.client;
-                const bufferFields = (0, utils_1.getKeys)(grpcClientConfig === null || grpcClientConfig === void 0 ? void 0 : grpcClientConfig.bufferFields);
+                const bufferFields = getKeys(grpcClientConfig === null || grpcClientConfig === void 0 ? void 0 : grpcClientConfig.bufferFields);
                 if (result instanceof stream.Readable) {
                     let operationStatus = { code: 0, message: '' };
-                    let aggregatedResponse = await new Promise((resolve, reject) => {
+                    let aggregatedResponse = yield new Promise((resolve, reject) => {
                         let response = {};
                         let combinedChunks = {};
                         result.on('data', (chunk) => {
@@ -173,17 +153,17 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                     return { details: aggregatedResponse, operationStatus };
                 }
                 if ('items' in result) {
-                    let items = (0, utils_1.decodeBufferFields)(result.items, bufferFields);
+                    let items = decodeBufferFields(result.items, bufferFields);
                     return {
                         details: {
-                            items: items,
+                            items,
                             operationStatus: result.operationStatus // overall status
                         },
                     };
                 }
                 else {
                     return {
-                        details: (0, utils_1.decodeBufferFields)([result], bufferFields)[0]
+                        details: decodeBufferFields([result], bufferFields)[0]
                     };
                 }
             }
@@ -199,14 +179,13 @@ const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
                     }
                 };
             }
-        };
+        });
         return obj;
     }, {});
 };
-exports.getGQLResolverFunctions = getGQLResolverFunctions;
 const namespaceResolverRegistry = new Map();
 const subscriptionResolvers = {};
-const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined, service) => {
+export const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined, service) => {
     if (!namespaceResolverRegistry.has(namespace)) {
         namespaceResolverRegistry.set(namespace, new Map());
     }
@@ -237,8 +216,7 @@ const registerResolverFunction = (namespace, name, func, mutation = false, subsp
     }
     space.set(name, func);
 };
-exports.registerResolverFunction = registerResolverFunction;
-const generateResolver = (...namespaces) => {
+export const generateResolver = (...namespaces) => {
     const queryResolvers = {};
     const mutationResolvers = {};
     namespaces.forEach(ns => {
@@ -282,30 +260,29 @@ const generateResolver = (...namespaces) => {
     }
     return resolvers;
 };
-exports.generateResolver = generateResolver;
-const generateSubServiceResolvers = (subServices, config, namespace) => {
+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 = (0, utils_1.getServiceName)(service.name);
-                const { mutations, queries } = (0, graphql_1.getWhitelistBlacklistConfig)(service, config, meta, subName);
-                const func = (0, exports.getGQLResolverFunctions)(service, namespace, subName || namespace, config);
+                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;
-                    (0, exports.registerResolverFunction)(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, service);
+                    registerResolverFunction(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, service);
                 });
             }
         });
-        if (utils_1.useSubscriptions) {
+        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 + (0, utils_1.capitalize)(kafkaSubscriber.plural);
+                    const fieldName = namespace + capitalize(kafkaSubscriber.plural);
                     const baseMessageName = meta.fileDescriptor.package + '.' + messageName;
-                    const typing = (0, registry_1.getTyping)('.' + baseMessageName);
+                    const typing = getTyping('.' + baseMessageName);
                     if (typing) {
                         subscriptionResolvers[fieldName] = {
                             // resolve: (parent, args, context, info) => {
@@ -323,7 +300,7 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
                             //   // TODO Implement user lookup
                             //   return obj;
                             // },
-                            subscribe: async (parent, args, context, info) => {
+                            subscribe: (parent, args, context, info) => __awaiter(void 0, void 0, void 0, function* () {
                                 const action = args.action || 'CREATED';
                                 let event = kafkaSubscriber.created;
                                 switch (action) {
@@ -334,17 +311,15 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
                                         event = kafkaSubscriber.deleted;
                                         break;
                                 }
-                                const events = new kafka_client_1.Events({
+                                const events = new Events({
                                     provider: 'kafka',
-                                    kafka: {
-                                        ...context.kafkaConfig
-                                    },
+                                    kafka: Object.assign({}, context.kafkaConfig),
                                     [event]: {
                                         messageObject: baseMessageName
                                     }
                                 }, context.logger);
-                                await events.start();
-                                const commandTopic = await events.topic(kafkaSubscriber.topic);
+                                yield events.start();
+                                const commandTopic = yield events.topic(kafkaSubscriber.topic);
                                 let deferred = null;
                                 const pending = [];
                                 commandTopic.on(event, (message) => {
@@ -355,23 +330,23 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
                                     [Symbol.asyncIterator]() {
                                         return this;
                                     },
-                                    async next() {
+                                    next: () => __awaiter(void 0, void 0, void 0, function* () {
                                         if (pending.length) {
                                             return { value: { [fieldName]: pending.shift() } };
                                         }
-                                        return (await new Promise((resolve, reject) => (deferred = { resolve, reject })))
+                                        return (yield new Promise((resolve, reject) => (deferred = { resolve, reject })))
                                             ? { done: true, value: undefined }
                                             : { value: { [fieldName]: pending.shift() } };
-                                    },
-                                    async throw(err) {
+                                    }),
+                                    throw: (err) => __awaiter(void 0, void 0, void 0, function* () {
                                         throw err;
-                                    },
-                                    async return() {
-                                        await events.stop();
+                                    }),
+                                    return: () => __awaiter(void 0, void 0, void 0, function* () {
+                                        yield events.stop();
                                         return { done: true, value: undefined };
-                                    },
+                                    }),
                                 };
-                            }
+                            })
                         };
                     }
                 }
@@ -379,32 +354,32 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
         }
     });
     if (config.root) {
-        return (0, exports.generateResolver)(...(0, array_prototype_flat_1.default)(subServices.map(meta => {
+        return generateResolver(...flat(subServices.map(meta => {
             return meta.fileDescriptor.service.map(service => {
                 if (service.name) {
-                    return (0, utils_1.getServiceName)(service.name);
+                    return getServiceName(service.name);
                 }
                 return '';
             }).filter(s => s !== '');
         })));
     }
-    const finalResolver = (0, exports.generateResolver)(namespace);
+    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 = (0, registry_1.getTyping)('.' + meta.fileDescriptor.package + '.' + key);
+                        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 = (0, utils_1.snakeToCamel)(fieldName);
+                                    const fieldJsonName = snakeToCamel(fieldName);
                                     const resolver = field['resolver'];
                                     // TODO This creates an N+1 problem!
-                                    result[resolver.fieldName] = async (parent, _, ctx) => {
+                                    result[resolver.fieldName] = (parent, _, ctx) => __awaiter(void 0, void 0, void 0, function* () {
                                         if (!parent || !(fieldJsonName in parent) || parent[fieldJsonName] === undefined) {
                                             return undefined;
                                         }
@@ -412,24 +387,24 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
                                         const service = client[resolver.targetSubService];
                                         const idList = Array.isArray(parent[fieldJsonName]) ? parent[fieldJsonName] : [parent[fieldJsonName]];
                                         // TODO Support custom input messages
-                                        const req = rc_grpc_clients_1.ReadRequest.fromPartial({
+                                        const req = ReadRequest.fromPartial({
                                             filters: [{
                                                     filter: idList.map(id => ({
                                                         field: 'id',
-                                                        operation: resource_base_1.Filter_Operation.eq,
+                                                        operation: Filter_Operation.eq,
                                                         value: id,
-                                                        type: resource_base_1.Filter_ValueType.STRING
+                                                        type: Filter_ValueType.STRING
                                                     })),
-                                                    operator: resource_base_1.FilterOp_Operator.or
+                                                    operator: FilterOp_Operator.or
                                                 }]
                                         });
-                                        req.subject = (0, registry_1.getTyping)(types_1.authSubjectType).processor.fromPartial({});
+                                        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[(0, utils_1.camelCase)(resolver.targetMethod)] || service[resolver.targetMethod];
-                                        const result = await methodFunc(req);
+                                        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);
@@ -439,7 +414,7 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
                                             }
                                         }
                                         return undefined;
-                                    };
+                                    });
                                 }
                             }
                             finalResolver[typing.output.name] = result;
@@ -451,4 +426,3 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
     });
     return finalResolver;
 };
-exports.generateSubServiceResolvers = generateSubServiceResolvers;

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

@@ -1,7 +1,7 @@
-import { MethodDescriptorProto, ServiceDescriptorProto } from 'ts-proto-descriptors';
-import { ProtoMetadata, ServiceConfig, SubSpaceServiceConfig } from './types';
-import { GraphQLSchema, ThunkObjMap } from 'graphql';
-import { GraphQLFieldConfig, GraphQLFieldConfigMap } from 'graphql/type/definition';
+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>>>;

package/dist/gql/protos/schema.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSubServiceSchemas = exports.generateSchema = exports.registerResolverSchema = exports.getGQLSchemas = exports.getGQLSchema = void 0;
-const graphql_1 = require("graphql");
-const array_prototype_flat_1 = __importDefault(require("array.prototype.flat"));
-const graphql_2 = require("./graphql");
-const utils_1 = require("./utils");
-const registry_1 = require("./registry");
+import { GraphQLSchema, GraphQLNonNull, GraphQLObjectType, GraphQLString, GraphQLEnumType } from 'graphql';
+import flat from 'array.prototype.flat';
+import { getWhitelistBlacklistConfig, Mutate } from './graphql.js';
+import { capitalize, capitalizeProtoName, useSubscriptions, getServiceName } from './utils.js';
+import { getTyping } from './registry.js';
 const typeCache = new Map();
-const subscriptionAction = new graphql_1.GraphQLEnumType({
+const subscriptionAction = new GraphQLEnumType({
     name: 'SubscriptionAction',
     values: {
         CREATED: { value: 'CREATED' },
@@ -23,17 +17,17 @@ const subscriptionInput = {
         type: subscriptionAction
     }
 };
-const subscriptionOutput = new graphql_1.GraphQLObjectType({
+const subscriptionOutput = new GraphQLObjectType({
     name: 'SubscriptionOutput',
     fields: {
         id: {
-            type: graphql_1.GraphQLString
+            type: GraphQLString
         }
     }
 });
-const getGQLSchema = (method) => {
+export const getGQLSchema = (method) => {
     const fields = {};
-    const responseTyping = (0, registry_1.getTyping)(method.outputType);
+    const responseTyping = getTyping(method.outputType);
     if (!responseTyping) {
         throw Error('Method doesn\'t have registered typings: ' + method.outputType);
     }
@@ -42,16 +36,16 @@ const getGQLSchema = (method) => {
             type: responseTyping.output,
         };
     }
-    const outName = 'Proto' + (0, utils_1.capitalizeProtoName)(method.outputType);
+    const outName = 'Proto' + capitalizeProtoName(method.outputType);
     let out = typeCache.get(outName);
     if (!out) {
-        out = new graphql_1.GraphQLObjectType({
+        out = new GraphQLObjectType({
             name: outName,
             fields,
         });
         typeCache.set(outName, out);
     }
-    const typing = (0, registry_1.getTyping)(method.inputType);
+    const typing = getTyping(method.inputType);
     if (!typing) {
         throw Error('Method doesn\'t have registered typings: ' + method.inputType);
     }
@@ -59,23 +53,21 @@ const getGQLSchema = (method) => {
         type: out,
         args: method.inputType === '.google.protobuf.Empty' ? undefined : {
             input: {
-                type: new graphql_1.GraphQLNonNull(typing.input)
+                type: new GraphQLNonNull(typing.input)
             }
         }
     };
 };
-exports.getGQLSchema = getGQLSchema;
-const getGQLSchemas = (service) => {
+export const getGQLSchemas = (service) => {
     var _a;
     return (_a = service.method) === null || _a === void 0 ? void 0 : _a.reduce((obj, method) => {
-        obj[method.name] = (0, exports.getGQLSchema)(method);
+        obj[method.name] = getGQLSchema(method);
         return obj;
     }, {});
 };
-exports.getGQLSchemas = getGQLSchemas;
 const namespaceResolverSchemaRegistry = new Map();
 const subscriptionFields = {};
-const registerResolverSchema = (namespace, name, schema, mutation = false, subspace = undefined, config) => {
+export const registerResolverSchema = (namespace, name, schema, mutation = false, subspace = undefined, config) => {
     if (!namespaceResolverSchemaRegistry.has(namespace)) {
         namespaceResolverSchemaRegistry.set(namespace, new Map());
     }
@@ -104,13 +96,12 @@ const registerResolverSchema = (namespace, name, schema, mutation = false, subsp
         }
     }
     // register create, update and upsert with Mutate
-    if (graphql_2.Mutate.indexOf(name) > -1) {
+    if (Mutate.indexOf(name) > -1) {
         name = 'Mutate';
     }
     space.set(name, schema);
 };
-exports.registerResolverSchema = registerResolverSchema;
-const generateSchema = (setup) => {
+export const generateSchema = (setup) => {
     const queryFields = {};
     const mutationFields = {};
     setup.forEach(s => {
@@ -121,9 +112,9 @@ const generateSchema = (setup) => {
             const fields = {};
             namespaceResolverSchemaRegistry.get(s.namespace).get(false).forEach((value, key) => {
                 if (value instanceof Map) {
-                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
+                    const capitalName = capitalizeProtoName(key);
                     fields[key] = {
-                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                        type: new GraphQLNonNull(new GraphQLObjectType({
                             name: s.prefix + capitalName + 'Query',
                             fields: Object.fromEntries(value),
                         }))
@@ -134,7 +125,7 @@ const generateSchema = (setup) => {
                 }
             });
             queryFields[s.namespace] = {
-                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                type: new GraphQLNonNull(new GraphQLObjectType({
                     name: s.prefix + 'Query',
                     fields
                 }))
@@ -144,9 +135,9 @@ const generateSchema = (setup) => {
             const fields = {};
             namespaceResolverSchemaRegistry.get(s.namespace).get(true).forEach((value, key) => {
                 if (value instanceof Map) {
-                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
+                    const capitalName = capitalizeProtoName(key);
                     fields[key] = {
-                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                        type: new GraphQLNonNull(new GraphQLObjectType({
                             name: s.prefix + capitalName + 'Mutation',
                             fields: Object.fromEntries(value),
                         }))
@@ -157,7 +148,7 @@ const generateSchema = (setup) => {
                 }
             });
             mutationFields[s.namespace] = {
-                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                type: new GraphQLNonNull(new GraphQLObjectType({
                     name: s.prefix + 'Mutation',
                     fields
                 }))
@@ -166,46 +157,43 @@ const generateSchema = (setup) => {
     });
     const config = {};
     if (Object.keys(queryFields).length > 0) {
-        config.query = new graphql_1.GraphQLObjectType({
+        config.query = new GraphQLObjectType({
             name: 'Query',
             fields: queryFields
         });
     }
     if (Object.keys(mutationFields).length > 0) {
-        config.mutation = new graphql_1.GraphQLObjectType({
+        config.mutation = new GraphQLObjectType({
             name: 'Mutation',
             fields: mutationFields
         });
     }
     if (Object.keys(subscriptionFields).length > 0) {
-        config.subscription = new graphql_1.GraphQLObjectType({
+        config.subscription = new GraphQLObjectType({
             name: 'Subscription',
             fields: subscriptionFields
         });
     }
-    return new graphql_1.GraphQLSchema({
-        ...config,
-    });
+    return new GraphQLSchema(Object.assign({}, config));
 };
-exports.generateSchema = generateSchema;
-const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
+export const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
     subServices.forEach((meta) => {
         var _a;
         meta.fileDescriptor.service.forEach(service => {
             if (service.name) {
-                const subName = (0, utils_1.getServiceName)(service.name);
-                const { mutations, queries } = (0, graphql_2.getWhitelistBlacklistConfig)(service, config, meta, subName);
-                const schemas = (0, exports.getGQLSchemas)(service);
+                const subName = getServiceName(service.name);
+                const { mutations, queries } = getWhitelistBlacklistConfig(service, config, meta, subName);
+                const schemas = getGQLSchemas(service);
                 Object.keys(schemas).forEach(key => {
-                    (0, exports.registerResolverSchema)(config.root ? subName : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : subName, config);
+                    registerResolverSchema(config.root ? subName : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : subName, config);
                 });
             }
         });
-        if (utils_1.useSubscriptions) {
+        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 fieldName = namespace + (0, utils_1.capitalize)(option.options.kafka_subscriber.plural);
-                    const typing = (0, registry_1.getTyping)('.' + meta.fileDescriptor.package + '.' + messageName);
+                    const fieldName = namespace + capitalize(option.options.kafka_subscriber.plural);
+                    const typing = getTyping('.' + meta.fileDescriptor.package + '.' + messageName);
                     if (typing) {
                         subscriptionFields[fieldName] = {
                             // TODO Implement user lookup
@@ -219,10 +207,10 @@ const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
         }
     });
     if (config.root) {
-        return (0, exports.generateSchema)((0, array_prototype_flat_1.default)(subServices.map(meta => {
+        return generateSchema(flat(subServices.map(meta => {
             return meta.fileDescriptor.service.map(service => {
                 if (service.name) {
-                    const subName = (0, utils_1.getServiceName)(service.name);
+                    const subName = getServiceName(service.name);
                     return {
                         prefix: prefix + subName.substring(0, 1).toUpperCase() + subName.substring(1).toLowerCase(),
                         namespace: subName
@@ -232,6 +220,5 @@ const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
             }).filter(s => s !== null);
         })));
     }
-    return (0, exports.generateSchema)([{ prefix, namespace }]);
+    return generateSchema([{ prefix, namespace }]);
 };
-exports.generateSubServiceSchemas = generateSubServiceSchemas;

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

@@ -1,6 +1,6 @@
-import { GrpcClientConfig } from "@restorecommerce/grpc-client";
-import { FileDescriptorProto } from "ts-proto-descriptors";
-import { GraphQLSchema, GraphQLFieldResolver, GraphQLScalarType } from 'graphql';
+import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
+import { type FileDescriptorProto } from 'ts-proto-descriptors';
+import { type GraphQLSchema, type GraphQLFieldResolver, type GraphQLScalarType } from 'graphql';
 export interface GraphQLResolverMap<TContext = {}> {
     [typeName: string]: {
         [fieldName: string]: GraphQLFieldResolver<any, TContext, any> | {

package/dist/gql/protos/types.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.authSubjectType = void 0;
-exports.authSubjectType = '.io.restorecommerce.auth.Subject';
+export const authSubjectType = '.io.restorecommerce.auth.Subject';