@restorecommerce/facade 1.3.6 → 1.3.7

package/dist/gql/protos/registry.js

@@ -1,366 +0,0 @@
-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 GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';
-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 GraphQLScalarType({
-    name: 'MapScalar',
-});
-const GoogleProtobufAnyValue = new GraphQLScalarType({
-    name: 'GoogleProtobufAnyValue'
-});
-const protobufAnyFields = {
-    typeUrl: {
-        type: GraphQLString
-    },
-    value: {
-        type: GoogleProtobufAnyValue
-    }
-};
-const GoogleProtobufAny = new GraphQLObjectType({
-    name: 'GoogleProtobufAny',
-    fields: protobufAnyFields
-});
-export const IGoogleProtobufAny = new GraphQLInputObjectType({
-    name: 'IGoogleProtobufAny',
-    fields: protobufAnyFields
-});
-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 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
-                the RFC 3339 profile of the ISO 8601 standard for representation
-                of dates and times using the Gregorian calendar.`,
-});
-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 GraphQLScalarType({
-    name: 'TodoScalar',
-    serialize: () => {
-        throw Error('Not Implemented!');
-    },
-    parseValue: () => {
-        throw Error('Not Implemented!');
-    }
-});
-export const clearRegistry = () => {
-    registeredTypings.clear();
-};
-export const getRegisteredEnumTypings = () => {
-    return registeredEnumTypes;
-};
-export const getNameSpaceTypeName = (typeName) => {
-    return typeNameAndNameSpaceMapping.get(typeName);
-};
-export const getTyping = (type) => {
-    return registeredTypings.get(type);
-};
-// Iterate through the object and collect list of all enum types with their keys / paths
-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 = getNameSpaceTypeName(typeName);
-        if (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 = '';
-            }
-            else if (objectType === null || objectType === void 0 ? void 0 : objectType.input) {
-                // get nested fields from this object and check recursively
-                const gqlFields = objectType.input.getFields();
-                if (gqlFields) {
-                    const fieldNames = Object.keys(gqlFields);
-                    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 (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);
-                            }
-                            else if (traversedFields.indexOf(fieldName) > -1) {
-                                // skip loop as this GQL type is already traversed
-                                continue;
-                            }
-                            recursiveEnumCheck(fieldType, enumMap, fieldName, traversedFields);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return enumMap;
-};
-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 GraphQLEnumType({
-    name: 'ModeType',
-    values: {
-        CREATE: {
-            value: 'CREATE'
-        },
-        UPDATE: {
-            value: 'UPDATE'
-        },
-        UPSERT: {
-            value: 'UPSERT'
-        },
-    }
-});
-export const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messageOptions) => {
-    let insertMode = false;
-    let crudOperation = false;
-    const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
-    if (methodDef && methodDef.length > 0) {
-        for (let method of methodDef) {
-            // if method def is Create, Read / Upsert and input types of method and message type are equal
-            // then update input type to include `mode` parameter
-            if ((Mutate.indexOf(method.name) > -1) && type === method.inputType) {
-                insertMode = true;
-            }
-            // add scope
-            if ((CRUD_TRAVERSAL_OP_NAMES.indexOf(method.name) > -1) && type === method.inputType) {
-                crudOperation = true;
-            }
-        }
-    }
-    if (type === googleProtobufAnyName) {
-        // Do not register any type
-        typeNameAndNameSpaceMapping.set(GoogleProtobufAny.name, type);
-        registeredTypings.set(type, {
-            output: GoogleProtobufAny,
-            input: IGoogleProtobufAny,
-            meta: message
-        });
-    }
-    if (type === googleProtobufTimestampName) {
-        typeNameAndNameSpaceMapping.set(DateTime.name, type);
-        registeredTypings.set(type, {
-            output: DateTime,
-            input: IDateTime,
-            meta: message
-        });
-    }
-    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) || capitalizeProtoName(type);
-    const inputName = (inputOpts === null || inputOpts === void 0 ? void 0 : inputOpts.name) || 'I' + name;
-    const fields = () => {
-        var _a;
-        const result = {};
-        (_a = message.field) === null || _a === void 0 ? void 0 : _a.forEach(field => {
-            // TODO Union types
-            const resolvedMeta = resolveMeta(field.jsonName, field, type, name, false);
-            if (resolvedMeta !== null) {
-                result[field.jsonName] = {
-                    type: resolvedMeta
-                };
-            }
-            if (messageOptions && messageOptions.fields) {
-                if (field.name in messageOptions.fields) {
-                    const data = messageOptions.fields[field.name].resolver;
-                    const resolved = resolveMeta(data.fieldName, {
-                        type: FieldDescriptorProto_Type.TYPE_MESSAGE,
-                        label: field.label,
-                        typeName: data.targetType
-                    }, type, name, false);
-                    if (resolvedMeta !== null) {
-                        result[data.fieldName] = {
-                            type: resolved
-                        };
-                    }
-                }
-            }
-        });
-        return result;
-    };
-    const inputFields = () => {
-        var _a;
-        const result = {};
-        (_a = message.field) === null || _a === void 0 ? void 0 : _a.forEach(field => {
-            // TODO Union types
-            const resolvedMeta = resolveMeta(field.jsonName, field, type, name, true);
-            if (resolvedMeta !== null) {
-                result[field.jsonName] = {
-                    type: resolvedMeta
-                };
-            }
-        });
-        if (insertMode) {
-            result['mode'] = {
-                type: ModeType
-            };
-        }
-        if (crudOperation) {
-            // add scope to all mutations / queries
-            if (!result.scope) {
-                result['scope'] = {
-                    description: 'target scope',
-                    type: GraphQLString
-                };
-            }
-        }
-        return result;
-    };
-    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);
-    registeredTypings.set(type, {
-        output: resultObj,
-        input: resultInputObj,
-        meta: message
-    });
-};
-export const registerEnumTyping = (protoPackage, message, opts) => {
-    var _a;
-    const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
-    if (registeredTypings.has(type)) {
-        // TODO Log debug "Typings for enum are already registered"
-        return;
-    }
-    const values = {};
-    (_a = message.value) === null || _a === void 0 ? void 0 : _a.forEach(entry => {
-        values[entry.name] = {
-            value: entry.number
-        };
-    });
-    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);
-    registeredTypings.set(type, {
-        output: result,
-        input: result,
-        meta: message
-    });
-};
-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);
-        }
-    });
-};
-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,9 +0,0 @@
-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; };
-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, service?: ServiceDescriptorProto) => void;
-export declare const generateResolver: (...namespaces: string[]) => any;
-export declare const generateSubServiceResolvers: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string) => T;