@restorecommerce/facade 1.2.0 → 1.3.1

package/dist/gql/protos/registry.js

@@ -1,46 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTyping = exports.registerEnumTyping = exports.registerTyping = exports.recursiveEnumCheck = exports.getNameSpaceTypeName = exports.getRegisteredEnumTypings = exports.registerPackagesRecursive = exports.clearRegistry = exports.IGoogleProtobufAny = exports.scalarTypes = exports.registeredTypings = void 0;
-const graphql_1 = require("graphql");
-const definition_1 = require("graphql/type/definition");
-const GraphQLUpload = require('graphql-upload/GraphQLUpload.js');
-const utils_1 = require("./utils");
-const types_1 = require("./types");
-const ts_proto_descriptors_1 = require("ts-proto-descriptors");
-exports.registeredTypings = new Map();
-exports.scalarTypes = ['Boolean', 'Int', 'Float', 'String', 'ID', 'Upload'];
+import { GraphQLBoolean, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from 'graphql/type/definition.js';
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js';
+import { capitalizeProtoName } from './utils.js';
+import { authSubjectType } from './types.js';
+import { FieldDescriptorProto_Label, FieldDescriptorProto_Type } from 'ts-proto-descriptors';
+export const registeredTypings = new Map();
+export const scalarTypes = ['Boolean', 'Int', 'Float', 'String', 'ID', 'Upload'];
 const typeNameAndNameSpaceMapping = new Map();
 const registeredEnumTypes = [];
-const MapScalar = new definition_1.GraphQLScalarType({
+const MapScalar = new GraphQLScalarType({
     name: 'MapScalar',
 });
-const GoogleProtobufAnyValue = new definition_1.GraphQLScalarType({
+const GoogleProtobufAnyValue = new GraphQLScalarType({
     name: 'GoogleProtobufAnyValue'
 });
 const protobufAnyFields = {
     typeUrl: {
-        type: graphql_1.GraphQLString
+        type: GraphQLString
     },
     value: {
         type: GoogleProtobufAnyValue
     }
 };
-const GoogleProtobufAny = new graphql_1.GraphQLObjectType({
+const GoogleProtobufAny = new GraphQLObjectType({
     name: 'GoogleProtobufAny',
     fields: protobufAnyFields
 });
-exports.IGoogleProtobufAny = new definition_1.GraphQLInputObjectType({
+export const IGoogleProtobufAny = new GraphQLInputObjectType({
     name: 'IGoogleProtobufAny',
     fields: protobufAnyFields
 });
-const DateTime = new definition_1.GraphQLScalarType({
+const DateTime = new GraphQLScalarType({
     name: 'DateTime',
     description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z,
                 compliant with the date-time format outlined in section 5.6 of
                 the RFC 3339 profile of the ISO 8601 standard for representation
                 of dates and times using the Gregorian calendar.`,
 });
-const IDateTime = new definition_1.GraphQLScalarType({
+const IDateTime = new GraphQLScalarType({
     name: 'IDateTime',
     description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z,
                 compliant with the date-time format outlined in section 5.6 of
@@ -51,50 +48,36 @@ const googleProtobufAnyName = '.google.protobuf.Any';
 const googleProtobufTimestampName = '.google.protobuf.Timestamp';
 const Mutate = ['Create', 'Update', 'Upsert'];
 const CRUD_TRAVERSAL_OP_NAMES = ['Cretae', 'Update', 'Upsert', 'Delete', 'Read', 'Traversal'];
-const TodoScalar = new definition_1.GraphQLScalarType({
+const TodoScalar = new GraphQLScalarType({
     name: 'TodoScalar',
     serialize: () => {
-        throw Error("Not Implemented!");
+        throw Error('Not Implemented!');
     },
     parseValue: () => {
-        throw Error("Not Implemented!");
+        throw Error('Not Implemented!');
     }
 });
-const clearRegistry = () => {
-    exports.registeredTypings.clear();
+export const clearRegistry = () => {
+    registeredTypings.clear();
 };
-exports.clearRegistry = clearRegistry;
-const registerPackagesRecursive = (...protoMetadata) => {
-    protoMetadata.forEach(meta => {
-        var _a, _b;
-        meta.dependencies && (0, exports.registerPackagesRecursive)(...meta.dependencies);
-        meta.fileDescriptor.messageType && registerMessageTypesRecursive(meta.fileDescriptor.package, (_a = meta.fileDescriptor.service[0]) === null || _a === void 0 ? void 0 : _a.method, meta.options, ...meta.fileDescriptor.messageType);
-        (_b = meta.fileDescriptor.enumType) === null || _b === void 0 ? void 0 : _b.forEach((m) => {
-            (0, exports.registerEnumTyping)(meta.fileDescriptor.package, m);
-        });
-        Object.keys(meta.references).forEach(key => {
-            exports.registeredTypings.get(key).processor = meta.references[key];
-        });
-    });
-};
-exports.registerPackagesRecursive = registerPackagesRecursive;
-const getRegisteredEnumTypings = () => {
+export const getRegisteredEnumTypings = () => {
     return registeredEnumTypes;
 };
-exports.getRegisteredEnumTypings = getRegisteredEnumTypings;
-const getNameSpaceTypeName = (typeName) => {
+export const getNameSpaceTypeName = (typeName) => {
     return typeNameAndNameSpaceMapping.get(typeName);
 };
-exports.getNameSpaceTypeName = getNameSpaceTypeName;
+export const getTyping = (type) => {
+    return registeredTypings.get(type);
+};
 // Iterate through the object and collect list of all enum types with their keys / paths
-const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) => {
-    if (exports.scalarTypes.indexOf(typeName) <= -1) {
+export const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) => {
+    if (scalarTypes.indexOf(typeName) <= -1) {
         if (typeName && typeName.startsWith('[') && typeName.endsWith('!]')) {
             typeName = typeName.substring(1, typeName.length - 2);
         }
-        const objectNameSpace = (0, exports.getNameSpaceTypeName)(typeName);
+        const objectNameSpace = getNameSpaceTypeName(typeName);
         if (objectNameSpace) {
-            const objectType = (0, exports.getTyping)(objectNameSpace);
+            const objectType = getTyping(objectNameSpace);
             if ((objectType === null || objectType === void 0 ? void 0 : objectType.input) && (registeredEnumTypes.indexOf(objectType.input.toString()) > -1)) {
                 enumMap.set(objectType === null || objectType === void 0 ? void 0 : objectType.input.toString(), prevFieldName);
                 prevFieldName = '';
@@ -107,7 +90,7 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
                     for (let fieldName of fieldNames) {
                         let fieldType = gqlFields[fieldName].type.toString();
                         // if fieldType is not basic type, get the object and make recursive check till no more objects are found
-                        if (exports.scalarTypes.indexOf(fieldType) <= -1) {
+                        if (scalarTypes.indexOf(fieldType) <= -1) {
                             // check if fieldName already exists in the traversedFields (to avoid circular reference for infinite loop)
                             if (traversedFields.indexOf(fieldName) <= -1) {
                                 traversedFields.push(fieldName);
@@ -116,7 +99,7 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
                                 // skip loop as this GQL type is already traversed
                                 continue;
                             }
-                            (0, exports.recursiveEnumCheck)(fieldType, enumMap, fieldName, traversedFields);
+                            recursiveEnumCheck(fieldType, enumMap, fieldName, traversedFields);
                         }
                     }
                 }
@@ -125,21 +108,93 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
     }
     return enumMap;
 };
-exports.recursiveEnumCheck = recursiveEnumCheck;
-const registerMessageTypesRecursive = (packageName, methodDef, options, ...types) => {
-    types.forEach(m => {
-        (0, exports.registerTyping)(packageName, m, methodDef, undefined, undefined, options && options.messages && options.messages[m.name]);
-        if (m.enumType) {
-            m.enumType.forEach((enumType) => {
-                (0, exports.registerEnumTyping)(packageName + '.' + m.name, enumType);
-            });
-        }
-        if (m.nestedType) {
-            registerMessageTypesRecursive(packageName + '.' + m.name, methodDef, options, ...m.nestedType);
-        }
-    });
+const resolveMeta = (key, field, rootObjType, objName, input) => {
+    var _a;
+    let result;
+    switch (field.type) {
+        case FieldDescriptorProto_Type.TYPE_BOOL:
+            result = GraphQLBoolean;
+            break;
+        case FieldDescriptorProto_Type.TYPE_STRING:
+            result = GraphQLString;
+            break;
+        case FieldDescriptorProto_Type.TYPE_ENUM:
+        case FieldDescriptorProto_Type.TYPE_MESSAGE:
+            const objType = field.typeName;
+            if (objType === googleProtobufAnyName) {
+                if (input) {
+                    result = IGoogleProtobufAny;
+                    break;
+                }
+                result = GoogleProtobufAny;
+                break;
+            }
+            if (objType === googleProtobufTimestampName) {
+                if (input) {
+                    result = IDateTime;
+                    break;
+                }
+                result = DateTime;
+                break;
+            }
+            if (!registeredTypings.has(objType)) {
+                throw new Error('Typing \'' + objType + '\' not registered for key \'' + key + '\' in object: ' + objName);
+            }
+            let typingData = registeredTypings.get(objType);
+            let mapEntry = false;
+            if (typingData.meta.options) {
+                mapEntry = !!((_a = typingData.meta.options) === null || _a === void 0 ? void 0 : _a.mapEntry);
+            }
+            // TODO Actually unroll maps into entries
+            if (mapEntry) {
+                return MapScalar;
+            }
+            if (!input) {
+                result = typingData.output;
+                break;
+            }
+            if (objType === authSubjectType) {
+                return null;
+            }
+            result = typingData.input;
+            break;
+        case FieldDescriptorProto_Type.TYPE_BYTES:
+            if (input) {
+                // TODO Why can't it be nullable?
+                result = GraphQLUpload;
+                break;
+            }
+            // TODO Output Buffer
+            result = TodoScalar;
+            break;
+        case FieldDescriptorProto_Type.TYPE_INT32:
+        case FieldDescriptorProto_Type.TYPE_UINT32:
+        case FieldDescriptorProto_Type.TYPE_INT64:
+        case FieldDescriptorProto_Type.TYPE_UINT64:
+        case FieldDescriptorProto_Type.TYPE_SINT32:
+        case FieldDescriptorProto_Type.TYPE_SINT64:
+            result = GraphQLInt;
+            break;
+        case FieldDescriptorProto_Type.TYPE_DOUBLE:
+        case FieldDescriptorProto_Type.TYPE_FLOAT:
+        case FieldDescriptorProto_Type.TYPE_FIXED64:
+        case FieldDescriptorProto_Type.TYPE_FIXED32:
+        case FieldDescriptorProto_Type.TYPE_SFIXED32:
+        case FieldDescriptorProto_Type.TYPE_SFIXED64:
+            result = GraphQLFloat;
+            break;
+        default:
+            throw new Error('unknown typing type \'' + field.type + '\' for key \'' + key + '\' in: ' + objName);
+    }
+    if (field.label === FieldDescriptorProto_Label.LABEL_REPEATED) {
+        result = new GraphQLList(new GraphQLNonNull(result));
+    }
+    if (field.label === FieldDescriptorProto_Label.LABEL_REQUIRED) {
+        result = new GraphQLNonNull(result);
+    }
+    return result;
 };
-const ModeType = new definition_1.GraphQLEnumType({
+const ModeType = new GraphQLEnumType({
     name: 'ModeType',
     values: {
         CREATE: {
@@ -153,7 +208,7 @@ const ModeType = new definition_1.GraphQLEnumType({
         },
     }
 });
-const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messageOptions) => {
+export const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messageOptions) => {
     let insertMode = false;
     let crudOperation = false;
     const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
@@ -173,25 +228,25 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messa
     if (type === googleProtobufAnyName) {
         // Do not register any type
         typeNameAndNameSpaceMapping.set(GoogleProtobufAny.name, type);
-        exports.registeredTypings.set(type, {
+        registeredTypings.set(type, {
             output: GoogleProtobufAny,
-            input: exports.IGoogleProtobufAny,
+            input: IGoogleProtobufAny,
             meta: message
         });
     }
     if (type === googleProtobufTimestampName) {
         typeNameAndNameSpaceMapping.set(DateTime.name, type);
-        exports.registeredTypings.set(type, {
+        registeredTypings.set(type, {
             output: DateTime,
             input: IDateTime,
             meta: message
         });
     }
-    if (exports.registeredTypings.has(type)) {
+    if (registeredTypings.has(type)) {
         // TODO Log debug "Typings for object are already registered"
         return;
     }
-    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || (0, utils_1.capitalizeProtoName)(type);
+    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || capitalizeProtoName(type);
     const inputName = (inputOpts === null || inputOpts === void 0 ? void 0 : inputOpts.name) || 'I' + name;
     const fields = () => {
         var _a;
@@ -208,7 +263,7 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messa
                 if (field.name in messageOptions.fields) {
                     const data = messageOptions.fields[field.name].resolver;
                     const resolved = resolveMeta(data.fieldName, {
-                        type: ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE,
+                        type: FieldDescriptorProto_Type.TYPE_MESSAGE,
                         label: field.label,
                         typeName: data.targetType
                     }, type, name, false);
@@ -244,32 +299,25 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messa
             if (!result.scope) {
                 result['scope'] = {
                     description: 'target scope',
-                    type: graphql_1.GraphQLString
+                    type: GraphQLString
                 };
             }
         }
         return result;
     };
-    const resultObj = new graphql_1.GraphQLObjectType({
-        ...(opts || { name }),
-        fields,
-    });
-    const resultInputObj = new definition_1.GraphQLInputObjectType({
-        ...(inputOpts || { name: inputName }),
-        fields: inputFields,
-    });
+    const resultObj = new GraphQLObjectType(Object.assign(Object.assign({}, (opts || { name })), { fields }));
+    const resultInputObj = new GraphQLInputObjectType(Object.assign(Object.assign({}, (inputOpts || { name: inputName })), { fields: inputFields }));
     typeNameAndNameSpaceMapping.set(resultInputObj.name, type);
-    exports.registeredTypings.set(type, {
+    registeredTypings.set(type, {
         output: resultObj,
         input: resultInputObj,
         meta: message
     });
 };
-exports.registerTyping = registerTyping;
-const registerEnumTyping = (protoPackage, message, opts) => {
+export const registerEnumTyping = (protoPackage, message, opts) => {
     var _a;
     const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
-    if (exports.registeredTypings.has(type)) {
+    if (registeredTypings.has(type)) {
         // TODO Log debug "Typings for enum are already registered"
         return;
     }
@@ -279,106 +327,39 @@ const registerEnumTyping = (protoPackage, message, opts) => {
             value: entry.number
         };
     });
-    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || (0, utils_1.capitalizeProtoName)(type);
-    const result = new definition_1.GraphQLEnumType({
-        ...(opts || { name }),
-        values
-    });
+    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || capitalizeProtoName(type);
+    const result = new GraphQLEnumType(Object.assign(Object.assign({}, (opts || { name })), { values }));
     registeredEnumTypes.push(name);
     typeNameAndNameSpaceMapping.set(name, type);
-    exports.registeredTypings.set(type, {
+    registeredTypings.set(type, {
         output: result,
         input: result,
         meta: message
     });
 };
-exports.registerEnumTyping = registerEnumTyping;
-const getTyping = (type) => {
-    return exports.registeredTypings.get(type);
+const registerMessageTypesRecursive = (packageName, methodDef, options, ...types) => {
+    types.forEach(m => {
+        registerTyping(packageName, m, methodDef, undefined, undefined, options && options.messages && options.messages[m.name]);
+        if (m.enumType) {
+            m.enumType.forEach((enumType) => {
+                registerEnumTyping(packageName + '.' + m.name, enumType);
+            });
+        }
+        if (m.nestedType) {
+            registerMessageTypesRecursive(packageName + '.' + m.name, methodDef, options, ...m.nestedType);
+        }
+    });
 };
-exports.getTyping = getTyping;
-const resolveMeta = (key, field, rootObjType, objName, input) => {
-    var _a;
-    let result;
-    switch (field.type) {
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
-            result = graphql_1.GraphQLBoolean;
-            break;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
-            result = graphql_1.GraphQLString;
-            break;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
-            const objType = field.typeName;
-            if (objType === googleProtobufAnyName) {
-                if (input) {
-                    result = exports.IGoogleProtobufAny;
-                    break;
-                }
-                result = GoogleProtobufAny;
-                break;
-            }
-            if (objType === googleProtobufTimestampName) {
-                if (input) {
-                    result = IDateTime;
-                    break;
-                }
-                result = DateTime;
-                break;
-            }
-            if (!exports.registeredTypings.has(objType)) {
-                throw new Error("Typing '" + objType + "' not registered for key '" + key + "' in object: " + objName);
-            }
-            let typingData = exports.registeredTypings.get(objType);
-            let mapEntry = false;
-            if (typingData.meta.options) {
-                mapEntry = !!((_a = typingData.meta.options) === null || _a === void 0 ? void 0 : _a.mapEntry);
-            }
-            // TODO Actually unroll maps into entries
-            if (mapEntry) {
-                return MapScalar;
-            }
-            if (!input) {
-                result = typingData.output;
-                break;
-            }
-            if (objType === types_1.authSubjectType) {
-                return null;
-            }
-            result = typingData.input;
-            break;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
-            if (input) {
-                result = GraphQLUpload;
-                break;
-            }
-            // TODO Output Buffer
-            result = TodoScalar;
-            break;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT32:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT32:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
-            result = graphql_1.GraphQLInt;
-            break;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
-            result = graphql_1.GraphQLFloat;
-            break;
-        default:
-            throw new Error("unknown typing type '" + field.type + "' for key '" + key + "' in: " + objName);
-    }
-    if (field.label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REPEATED) {
-        result = new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(result));
-    }
-    if (field.label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REQUIRED) {
-        result = new graphql_1.GraphQLNonNull(result);
-    }
-    return result;
+export const registerPackagesRecursive = (...protoMetadata) => {
+    protoMetadata.forEach(meta => {
+        var _a, _b;
+        meta.dependencies && registerPackagesRecursive(...meta.dependencies);
+        meta.fileDescriptor.messageType && registerMessageTypesRecursive(meta.fileDescriptor.package, (_a = meta.fileDescriptor.service[0]) === null || _a === void 0 ? void 0 : _a.method, meta.options, ...meta.fileDescriptor.messageType);
+        (_b = meta.fileDescriptor.enumType) === null || _b === void 0 ? void 0 : _b.forEach((m) => {
+            registerEnumTyping(meta.fileDescriptor.package, m);
+        });
+        Object.keys(meta.references).forEach(key => {
+            registeredTypings.get(key).processor = meta.references[key];
+        });
+    });
 };

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

@@ -1,6 +1,6 @@
-import { ProtoMetadata, ServiceClient, ServiceConfig, SubSpaceServiceConfig } from './types';
-import { ServiceDescriptorProto } from 'ts-proto-descriptors';
-import { GraphQLResolveInfo } from 'graphql';
+import { type ProtoMetadata, type ServiceClient, type ServiceConfig, type SubSpaceServiceConfig } from './types.js';
+import { type ServiceDescriptorProto } from 'ts-proto-descriptors';
+import { type GraphQLResolveInfo } from 'graphql';
 export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
 export type SubscribeResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncGenerator<TResult>;
 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, cfg: ServiceConfig) => { [key in keyof SRV]: R; };