@magek/core 0.0.1

package/dist/services/graphql/graphql-generator.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLGenerator = void 0;
+const common_1 = require("@magek/common");
+const graphql_1 = require("graphql");
+const inflected_1 = require("inflected");
+const command_dispatcher_1 = require("../../command-dispatcher");
+const events_reader_1 = require("../../events-reader");
+const read_models_reader_1 = require("../../read-models-reader");
+const graphql_mutation_generator_1 = require("./graphql-mutation-generator");
+const graphql_query_generator_1 = require("./graphql-query-generator");
+const graphql_subcriptions_generator_1 = require("./graphql-subcriptions-generator");
+const graphql_type_informer_1 = require("./graphql-type-informer");
+const query_dispatcher_1 = require("../../query-dispatcher");
+class GraphQLGenerator {
+    static generateSchema(config) {
+        const logger = (0, common_1.getLogger)(config, 'GraphQLGenerator#generateSchema');
+        if (!this.schema) {
+            logger.debug('Generating GraphQL schema...');
+            this.commandsDispatcher = new command_dispatcher_1.MagekCommandDispatcher(config);
+            this.queriesDispatcher = new query_dispatcher_1.MagekQueryDispatcher(config);
+            this.readModelsReader = new read_models_reader_1.MagekReadModelsReader(config);
+            this.eventsReader = new events_reader_1.MagekEventsReader(config);
+            const typeInformer = new graphql_type_informer_1.GraphQLTypeInformer(logger);
+            const generatedFiltersByTypeName = {};
+            const queryGenerator = new graphql_query_generator_1.GraphQLQueryGenerator(config, Object.values(config.readModels).map((m) => m.class), config.queryHandlers, typeInformer, this.readModelByIDResolverBuilder.bind(this, config), this.queriesResolverBuilder.bind(this), this.readModelResolverBuilder.bind(this), this.eventResolver.bind(this), generatedFiltersByTypeName);
+            const mutationGenerator = new graphql_mutation_generator_1.GraphQLMutationGenerator(config.commandHandlers, typeInformer, this.commandResolverBuilder.bind(this), config);
+            const subscriptionGenerator = new graphql_subcriptions_generator_1.GraphQLSubscriptionGenerator(Object.values(config.readModels).map((m) => m.class), typeInformer, this.subscriptionByIDResolverBuilder.bind(this, config), this.subscriptionResolverBuilder.bind(this, config), generatedFiltersByTypeName, config);
+            this.schema = new graphql_1.GraphQLSchema({
+                query: queryGenerator.generate(),
+                mutation: mutationGenerator.generate(),
+                subscription: subscriptionGenerator.generate(),
+            });
+            logger.debug('GraphQL schema generated');
+        }
+        return this.schema;
+    }
+    static readModelResolverBuilder(readModelClass) {
+        return (parent, args, context, info) => {
+            let isPaginated = false;
+            const fields = this.getFields(info);
+            let select = fields.length > 0 ? fields : undefined;
+            if ((info === null || info === void 0 ? void 0 : info.fieldName) === `List${(0, inflected_1.pluralize)(readModelClass.name)}`) {
+                isPaginated = true;
+                if (select) {
+                    // In paginated queries, the `items[].` field needs to be removed from the select fields before querying the database
+                    select = select
+                        .map((field) => {
+                        return field.split('.').slice(1).join('.');
+                    })
+                        .filter((str) => str.trim().length > 0);
+                }
+            }
+            const readModelEnvelope = toReadModelRequestEnvelope(readModelClass, args, context, isPaginated, select);
+            return this.readModelsReader.search(readModelEnvelope);
+        };
+    }
+    static readModelByIDResolverBuilder(config, readModelClass) {
+        const sequenceKeyName = config.readModelSequenceKeys[readModelClass.name];
+        return async (parent, args, context) => {
+            const readModelRequestEnvelope = this.toReadModelByIdRequestEnvelope(readModelClass, args, context, sequenceKeyName);
+            return await this.readModelsReader.findById(readModelRequestEnvelope);
+        };
+    }
+    static eventResolver(parent, args, context) {
+        const eventsRequestEnvelope = toEventSearchRequest(args, context);
+        return this.eventsReader.fetch(eventsRequestEnvelope);
+    }
+    static commandResolverBuilder(commandClass) {
+        return async (parent, args, context) => {
+            const commandEnvelope = toEnvelope(commandClass.name, args.input, context);
+            const result = await this.commandsDispatcher.dispatchCommand(commandEnvelope, context);
+            // It could be that the command didn't return anything
+            // so in that case we return `true`, as GraphQL doesn't have a `null` type
+            return result !== null && result !== void 0 ? result : true;
+        };
+    }
+    static queriesResolverBuilder(queryClass) {
+        return async (parent, args, context) => {
+            const queryEnvelope = toEnvelope(queryClass.name, args.input, context);
+            return await this.queriesDispatcher.dispatchQuery(queryEnvelope, context);
+        };
+    }
+    static subscriptionByIDResolverBuilder(config, readModelClass) {
+        return async (parent, args, context, info) => {
+            const filterArgs = { filter: { id: { eq: args.id } } };
+            return this.subscriptionResolverBuilder(config, readModelClass)(parent, filterArgs, context, info);
+        };
+    }
+    static subscriptionResolverBuilder(config, readModelClass) {
+        return async (parent, args, context) => {
+            if (!context.connectionID) {
+                throw new Error('Missing "connectionID". It is required for subscriptions');
+            }
+            const readModelRequestEnvelope = toReadModelRequestEnvelope(readModelClass, args, context);
+            if (context.storeSubscriptions) {
+                await this.readModelsReader.subscribe(context.connectionID, readModelRequestEnvelope, context.operation);
+            }
+            return context.pubSub.asyncIterator(readModelRequestEnvelope, config);
+        };
+    }
+    static toReadModelByIdRequestEnvelope(readModelClass, args, context, sequenceKeyName) {
+        const key = sequenceKeyName
+            ? {
+                id: args.id,
+                sequenceKey: {
+                    name: sequenceKeyName,
+                    value: args[sequenceKeyName],
+                },
+            }
+            : { id: args.id };
+        return {
+            currentUser: context.user,
+            requestID: context.requestID,
+            class: readModelClass,
+            className: readModelClass.name,
+            key,
+            version: 1, // TODO: How to pass the version through GraphQL?
+            filters: {},
+            sortBy: {},
+        };
+    }
+    /**
+     * Extracts the fields from a GraphQLResolveInfo object. This object is part of a GraphQL request and the goal is to
+     * identify the fields in the request. For example, for the following GraphQL query request:
+     *
+     * ```graphql
+     * query {
+     *   CartReadModel {
+     *     id
+     *     cartItems {
+     *       id
+     *       quantity
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * it will return the following list of fields: `['id', 'cartItems[].id', 'cartItems[].quantity']`
+     *
+     * @param {GraphQLResolveInfo} info - The GraphQLResolveInfo object.
+     * @returns {string[]} - The extracted fields.
+     * @private
+     */
+    static getFields(info) {
+        let fields = [];
+        /**
+         * Checks if a type is a list.
+         * @param {any} type - The type to check.
+         * @returns {boolean} - True if the type is a list, false otherwise.
+         */
+        const isList = (type) => {
+            if (type instanceof graphql_1.GraphQLNonNull) {
+                return type.ofType instanceof graphql_1.GraphQLList;
+            }
+            return type instanceof graphql_1.GraphQLList;
+        };
+        /**
+         * Extracts fields from a selection set.
+         * @param {SelectionSetNode} selectionSet - The selection set.
+         * @param {string[]} path - The current path.
+         * @param {GraphQLObjectType | any} parentType - The parent type.
+         * @param {Map<string, FragmentDefinitionNode>} fragments - The fragment definitions.
+         * @returns {string[]} - The extracted fields.
+         */
+        const extractFields = (selectionSet, path = [], parentType, fragments) => {
+            let subFields = [];
+            if (selectionSet && selectionSet.selections) {
+                selectionSet.selections.forEach((selection) => {
+                    if (selection.kind === graphql_1.Kind.FIELD) {
+                        const fieldName = selection.name.value;
+                        const field = parentType.getFields()[fieldName];
+                        if (!field) {
+                            return;
+                        }
+                        const fieldType = (0, graphql_1.getNamedType)(field.type);
+                        const currentPath = [...path, fieldName];
+                        if (isList(field.type)) {
+                            const elementType = (0, graphql_1.getNamedType)(field.type.ofType);
+                            if ((0, graphql_1.isObjectType)(elementType)) {
+                                currentPath[currentPath.length - 1] += '[]';
+                            }
+                        }
+                        if (!selection.selectionSet) {
+                            subFields.push(currentPath.join('.'));
+                        }
+                        else {
+                            const nextParentType = (0, graphql_1.isObjectType)(fieldType) ? fieldType : parentType;
+                            subFields = subFields.concat(extractFields(selection.selectionSet, currentPath, nextParentType, fragments));
+                        }
+                    }
+                    else if (selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
+                        const fragmentName = selection.name.value;
+                        const fragment = fragments.get(fragmentName);
+                        if (fragment) {
+                            subFields = subFields.concat(extractFields(fragment.selectionSet, path, parentType, fragments));
+                        }
+                    }
+                    else if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
+                        const inlineFragmentType = selection.typeCondition
+                            ? info.schema.getType(selection.typeCondition.name.value)
+                            : parentType;
+                        if ((0, graphql_1.isObjectType)(inlineFragmentType)) {
+                            subFields = subFields.concat(extractFields(selection.selectionSet, path, inlineFragmentType, fragments));
+                        }
+                    }
+                });
+            }
+            return subFields;
+        };
+        // Collect all fragment definitions
+        const fragments = new Map();
+        info.fragments &&
+            Object.keys(info.fragments).forEach((fragmentName) => {
+                fragments.set(fragmentName, info.fragments[fragmentName]);
+            });
+        info.fieldNodes.forEach((fieldNode) => {
+            const firstField = fieldNode.name.value;
+            // @ts-ignore
+            const firstFieldType = info.schema.getQueryType().getFields()[firstField].type;
+            const rootType = (0, graphql_1.getNamedType)(firstFieldType);
+            if (fieldNode.selectionSet) {
+                fields = fields.concat(extractFields(fieldNode.selectionSet, [], rootType, fragments));
+            }
+        });
+        return fields;
+    }
+}
+exports.GraphQLGenerator = GraphQLGenerator;
+function toReadModelRequestEnvelope(readModelClass, args, context, paginatedVersion = false, select) {
+    var _a, _b;
+    return {
+        requestID: context.requestID,
+        currentUser: context.user,
+        class: readModelClass,
+        className: readModelClass.name,
+        filters: (_a = args.filter) !== null && _a !== void 0 ? _a : {},
+        sortBy: (_b = args.sortBy) !== null && _b !== void 0 ? _b : {},
+        limit: args.limit,
+        afterCursor: args.afterCursor,
+        paginatedVersion,
+        version: 1, // TODO: How to pass the version through GraphQL?
+        select,
+    };
+}
+function toEventSearchRequest(args, context) {
+    return {
+        requestID: context.requestID,
+        currentUser: context.user,
+        parameters: args,
+    };
+}
+function toEnvelope(typeName, value, context) {
+    var _a, _b;
+    return {
+        requestID: context.requestID,
+        currentUser: context.user,
+        typeName: typeName,
+        value,
+        version: 1, // TODO: How to pass the version through GraphQL?
+        context: {
+            request: {
+                body: (_a = context.context) === null || _a === void 0 ? void 0 : _a.request.body,
+                headers: (_b = context.context) === null || _b === void 0 ? void 0 : _b.request.headers,
+            },
+            rawContext: context,
+        },
+    };
+}

package/dist/services/graphql/graphql-mutation-generator.d.ts

@@ -0,0 +1,12 @@
+import { ResolverBuilder, TargetTypesMap } from './common';
+import { GraphQLTypeInformer } from './graphql-type-informer';
+import { GraphQLObjectType } from 'graphql';
+import { MagekConfig } from '@magek/common';
+export declare class GraphQLMutationGenerator {
+    private readonly targetTypes;
+    private readonly typeInformer;
+    private readonly mutationResolver;
+    private readonly config;
+    constructor(targetTypes: TargetTypesMap, typeInformer: GraphQLTypeInformer, mutationResolver: ResolverBuilder, config: MagekConfig);
+    generate(): GraphQLObjectType | undefined;
+}

package/dist/services/graphql/graphql-mutation-generator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLMutationGenerator = void 0;
+const graphql_1 = require("graphql");
+const graphql_handled_fields_generator_1 = require("./query-helpers/graphql-handled-fields-generator");
+class GraphQLMutationGenerator {
+    constructor(targetTypes, typeInformer, mutationResolver, config) {
+        this.targetTypes = targetTypes;
+        this.typeInformer = typeInformer;
+        this.mutationResolver = mutationResolver;
+        this.config = config;
+    }
+    generate() {
+        const graphqlGenerateHandledFields = new graphql_handled_fields_generator_1.GraphQLHandledFieldsGenerator(this.targetTypes, this.typeInformer, this.mutationResolver, this.config);
+        const mutations = graphqlGenerateHandledFields.generateFields();
+        if (Object.keys(mutations).length === 0) {
+            return undefined;
+        }
+        return new graphql_1.GraphQLObjectType({
+            name: 'Mutation',
+            fields: mutations,
+        });
+    }
+}
+exports.GraphQLMutationGenerator = GraphQLMutationGenerator;

package/dist/services/graphql/graphql-query-generator.d.ts

@@ -0,0 +1,22 @@
+import { AnyClass, MagekConfig } from '@magek/common';
+import { GraphQLFieldResolver, GraphQLInputObjectType, GraphQLObjectType } from 'graphql';
+import { GraphQLResolverContext, ResolverBuilder, TargetTypesMap } from './common';
+import { GraphQLTypeInformer } from './graphql-type-informer';
+export declare class GraphQLQueryGenerator {
+    protected readonly config: MagekConfig;
+    protected readonly readModels: AnyClass[];
+    protected readonly targetTypes: TargetTypesMap;
+    protected readonly typeInformer: GraphQLTypeInformer;
+    protected readonly byIDResolverBuilder: ResolverBuilder;
+    protected readonly queryResolverBuilder: ResolverBuilder;
+    protected readonly filterResolverBuilder: ResolverBuilder;
+    protected readonly eventsResolver: GraphQLFieldResolver<unknown, GraphQLResolverContext, any>;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    private graphqlQueryByKeysGenerator;
+    private graphqlQueryGenerator;
+    private graphqlQueryFiltersGenerator;
+    private graphqlQueryListedGenerator;
+    private graphqlQueryEventsGenerator;
+    constructor(config: MagekConfig, readModels: AnyClass[], targetTypes: TargetTypesMap, typeInformer: GraphQLTypeInformer, byIDResolverBuilder: ResolverBuilder, queryResolverBuilder: ResolverBuilder, filterResolverBuilder: ResolverBuilder, eventsResolver: GraphQLFieldResolver<unknown, GraphQLResolverContext, any>, generatedFiltersByTypeName?: Record<string, GraphQLInputObjectType>);
+    generate(): GraphQLObjectType;
+}

package/dist/services/graphql/graphql-query-generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLQueryGenerator = void 0;
+const graphql_1 = require("graphql");
+const graphql_query_events_generator_1 = require("./query-generators/graphql-query-events-generator");
+const graphql_query_by_keys_generator_1 = require("./query-generators/graphql-query-by-keys-generator");
+const graphql_query_filters_generator_1 = require("./query-generators/graphql-query-filters-generator");
+const graphql_query_listed_generator_1 = require("./query-generators/graphql-query-listed-generator");
+const graphql_query_generator_1 = require("./query-generators/graphql-query-generator");
+class GraphQLQueryGenerator {
+    constructor(config, readModels, targetTypes, typeInformer, byIDResolverBuilder, queryResolverBuilder, filterResolverBuilder, eventsResolver, generatedFiltersByTypeName = {}) {
+        this.config = config;
+        this.readModels = readModels;
+        this.targetTypes = targetTypes;
+        this.typeInformer = typeInformer;
+        this.byIDResolverBuilder = byIDResolverBuilder;
+        this.queryResolverBuilder = queryResolverBuilder;
+        this.filterResolverBuilder = filterResolverBuilder;
+        this.eventsResolver = eventsResolver;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.graphqlQueryByKeysGenerator = new graphql_query_by_keys_generator_1.GraphqlQueryByKeysGenerator(config, readModels, typeInformer, byIDResolverBuilder);
+        this.graphqlQueryGenerator = new graphql_query_generator_1.GraphqlQueryGenerator(targetTypes, typeInformer, queryResolverBuilder, config);
+        this.graphqlQueryFiltersGenerator = new graphql_query_filters_generator_1.GraphqlQueryFiltersGenerator(readModels, typeInformer, filterResolverBuilder, generatedFiltersByTypeName, config);
+        this.graphqlQueryListedGenerator = new graphql_query_listed_generator_1.GraphqlQueryListedGenerator(readModels, typeInformer, filterResolverBuilder, generatedFiltersByTypeName, config);
+        this.graphqlQueryEventsGenerator = new graphql_query_events_generator_1.GraphqlQueryEventsGenerator(config, byIDResolverBuilder, eventsResolver);
+    }
+    generate() {
+        const byIDQueries = this.graphqlQueryByKeysGenerator.generateByKeysQueries();
+        const queries = this.graphqlQueryGenerator.generateQueries();
+        const filterQueries = this.graphqlQueryFiltersGenerator.generateFilterQueries();
+        const listedQueries = this.graphqlQueryListedGenerator.generateListedQueries();
+        const eventQueries = this.graphqlQueryEventsGenerator.generateEventQueries();
+        return new graphql_1.GraphQLObjectType({
+            name: 'Query',
+            fields: { ...byIDQueries, ...filterQueries, ...listedQueries, ...eventQueries, ...queries },
+        });
+    }
+}
+exports.GraphQLQueryGenerator = GraphQLQueryGenerator;

package/dist/services/graphql/graphql-subcriptions-generator.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLInputObjectType, GraphQLObjectType } from 'graphql';
+import { ResolverBuilder } from './common';
+import { GraphQLTypeInformer } from './graphql-type-informer';
+import { AnyClass, MagekConfig } from '@magek/common';
+export declare class GraphQLSubscriptionGenerator {
+    private readonly readModels;
+    private readonly typeInformer;
+    private readonly byIDResolverBuilder;
+    private readonly filterResolverBuilder;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    private readonly config;
+    private graphqlQueryFilterFieldsBuilder;
+    constructor(readModels: AnyClass[], typeInformer: GraphQLTypeInformer, byIDResolverBuilder: ResolverBuilder, filterResolverBuilder: ResolverBuilder, generatedFiltersByTypeName: Record<string, GraphQLInputObjectType> | undefined, config: MagekConfig);
+    generate(): GraphQLObjectType | undefined;
+    private generateByIDSubscriptions;
+    private generateFilterSubscriptions;
+}

package/dist/services/graphql/graphql-subcriptions-generator.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLSubscriptionGenerator = void 0;
+const graphql_1 = require("graphql");
+const inflected = require("inflected");
+const graphql_query_filter_fields_builder_1 = require("./query-helpers/graphql-query-filter-fields-builder");
+class GraphQLSubscriptionGenerator {
+    constructor(readModels, typeInformer, byIDResolverBuilder, filterResolverBuilder, generatedFiltersByTypeName = {}, config) {
+        this.readModels = readModels;
+        this.typeInformer = typeInformer;
+        this.byIDResolverBuilder = byIDResolverBuilder;
+        this.filterResolverBuilder = filterResolverBuilder;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.config = config;
+        this.graphqlQueryFilterFieldsBuilder = new graphql_query_filter_fields_builder_1.GraphqlQueryFilterFieldsBuilder(typeInformer, generatedFiltersByTypeName, config);
+    }
+    generate() {
+        const byIDSubscriptions = this.generateByIDSubscriptions();
+        const filterSubscriptions = this.generateFilterSubscriptions();
+        const fields = { ...byIDSubscriptions, ...filterSubscriptions };
+        if (Object.keys(fields).length === 0) {
+            return undefined;
+        }
+        return new graphql_1.GraphQLObjectType({
+            name: 'Subscription',
+            fields: fields,
+        });
+    }
+    generateByIDSubscriptions() {
+        const subscriptions = {};
+        for (const readModel of this.readModels) {
+            const excludeProps = this.config.nonExposedGraphQLMetadataKey[readModel.name];
+            const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, excludeProps);
+            subscriptions[readModel.name] = {
+                type: graphQLType,
+                args: {
+                    id: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) },
+                },
+                resolve: (source) => source,
+                subscribe: this.byIDResolverBuilder(readModel),
+            };
+        }
+        return subscriptions;
+    }
+    generateFilterSubscriptions() {
+        const subscriptions = {};
+        for (const readModel of this.readModels) {
+            const excludeProps = this.config.nonExposedGraphQLMetadataKey[readModel.name];
+            const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, excludeProps);
+            subscriptions[inflected.pluralize(readModel.name)] = {
+                type: graphQLType,
+                args: this.graphqlQueryFilterFieldsBuilder.generateFilterQueriesFields(`${readModel.name}Subscription`, readModel, excludeProps),
+                resolve: (source) => source,
+                subscribe: this.filterResolverBuilder(readModel),
+            };
+        }
+        return subscriptions;
+    }
+}
+exports.GraphQLSubscriptionGenerator = GraphQLSubscriptionGenerator;

package/dist/services/graphql/graphql-type-informer.d.ts

@@ -0,0 +1,23 @@
+import { GraphQLInputType, GraphQLOutputType, GraphQLType } from 'graphql';
+import { Logger, ClassType, TypeMetadata } from '@magek/common';
+export declare class GraphQLTypeInformer {
+    private logger;
+    private graphQLTypes;
+    constructor(logger: Logger);
+    generateGraphQLTypeForClass(type: ClassType, excludeProps: Array<string>, inputType: true): GraphQLInputType;
+    generateGraphQLTypeForClass(type: ClassType, excludeProps: Array<string>, inputType?: false): GraphQLOutputType;
+    generateGraphQLTypeForClass(type: ClassType, excludeProps: Array<string>, inputType: boolean): GraphQLType;
+    getOrCreateGraphQLType(typeMetadata: TypeMetadata, inputType: true): GraphQLInputType;
+    getOrCreateGraphQLType(typeMetadata: TypeMetadata, inputType?: false): GraphQLOutputType;
+    getOrCreateGraphQLType(typeMetadata: TypeMetadata, inputType: boolean): GraphQLType;
+    private getGraphQLName;
+    private createGraphQLType;
+    private validateUnionClasses;
+    private getUnionClasses;
+    private createEnumType;
+    private createArrayType;
+    private getOrCreateObjectType;
+    private createObjectType;
+    private getOrCreateObjectTypeForUnion;
+    private createOutputObjectType;
+}

package/dist/services/graphql/graphql-type-informer.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLTypeInformer = void 0;
+const metadata_1 = require("./../../decorators/metadata");
+const graphql_1 = require("graphql");
+const graphql_scalars_1 = require("graphql-scalars");
+const common_1 = require("./common");
+class GraphQLTypeInformer {
+    constructor(logger) {
+        this.logger = logger;
+        this.graphQLTypes = {};
+    }
+    generateGraphQLTypeForClass(type, excludeProps, inputType = false) {
+        this.logger.debug(`Generate GraphQL ${inputType ? 'input' : 'output'} type for class ${type.name}`);
+        const metadata = (0, metadata_1.getClassMetadata)(type);
+        return this.getOrCreateObjectType(metadata, inputType, excludeProps);
+    }
+    getOrCreateGraphQLType(typeMetadata, inputType = false) {
+        if (typeMetadata.typeName === 'Promise') {
+            return this.getOrCreateGraphQLType(typeMetadata.parameters[0], inputType);
+        }
+        const name = this.getGraphQLName(typeMetadata, inputType);
+        // Check if GraphQL type already exists and reuse
+        if (name && this.graphQLTypes[name]) {
+            this.logger.debug(`Found existing GraphQL ${inputType ? 'input' : 'output'} type for name ${name}`);
+            return typeMetadata.isNullable ? this.graphQLTypes[name] : new graphql_1.GraphQLNonNull(this.graphQLTypes[name]);
+        }
+        // Create new GraphQL type from metadata
+        const createdGraphQLType = this.createGraphQLType(typeMetadata, inputType);
+        // Store created GraphQL type to reuse
+        if (name)
+            this.graphQLTypes[name] = createdGraphQLType;
+        return typeMetadata.isNullable ? createdGraphQLType : new graphql_1.GraphQLNonNull(createdGraphQLType);
+    }
+    getGraphQLName(typeMetadata, inputType) {
+        if (typeMetadata.name === 'UUID' || typeMetadata.name === 'Date') {
+            // UUID is a class but should result in a scalar which doesn't need a separate input type
+            // Date is an interface which has no `type`, so we need to use `name` instead
+            return typeMetadata.name;
+        }
+        if (typeMetadata.typeGroup === 'Array' || typeMetadata.typeGroup === 'ReadonlyArray') {
+            return this.getGraphQLName(typeMetadata.parameters[0], inputType) + 'List' + (inputType ? 'Input' : '');
+        }
+        if (typeMetadata.typeName && typeMetadata.typeGroup === 'Class') {
+            return typeMetadata.typeName + (inputType ? 'Input' : '');
+        }
+        if (typeMetadata.typeGroup === 'Union')
+            return typeMetadata.name;
+        return typeMetadata.typeName || null;
+    }
+    createGraphQLType(typeMetadata, inputType) {
+        this.logger.debug(`Creating GraphQL ${inputType ? 'input' : 'output'} type for type ${typeMetadata.name}`);
+        const { name, typeGroup } = typeMetadata;
+        if (name === 'Date')
+            return common_1.DateScalar;
+        if (name === 'UUID')
+            return graphql_1.GraphQLID;
+        if (typeGroup === 'String')
+            return graphql_1.GraphQLString;
+        if (typeGroup === 'Number')
+            return graphql_1.GraphQLFloat;
+        if (typeGroup === 'Boolean')
+            return graphql_1.GraphQLBoolean;
+        if (typeGroup === 'Enum')
+            return this.createEnumType(typeMetadata);
+        if (typeGroup === 'Array' || typeGroup === 'ReadonlyArray')
+            return this.createArrayType(typeMetadata, inputType);
+        if (typeGroup === 'Class' && typeMetadata.type && !(0, common_1.isExternalType)(typeMetadata)) {
+            const metadata = (0, metadata_1.getClassMetadata)(typeMetadata.type);
+            return this.createObjectType(metadata, inputType);
+        }
+        if (typeMetadata.typeGroup === 'Union' &&
+            !(0, common_1.isExternalType)(typeMetadata) &&
+            !inputType &&
+            this.validateUnionClasses(typeMetadata.parameters)) {
+            const graphQLUnionClasses = this.getUnionClasses(typeMetadata);
+            return new graphql_1.GraphQLUnionType({
+                name: typeMetadata.name,
+                types: graphQLUnionClasses,
+                resolveType(obj) {
+                    return obj.constructor.name;
+                },
+            });
+        }
+        return graphql_scalars_1.GraphQLJSON;
+    }
+    validateUnionClasses(params) {
+        return params.every((typeMetadata) => typeMetadata.typeGroup === 'Class' && typeMetadata.type && !(0, common_1.isExternalType)(typeMetadata));
+    }
+    getUnionClasses(typeMetadata) {
+        return typeMetadata.parameters.map((param) => {
+            if (param.typeGroup === 'Class' && param.type && !(0, common_1.isExternalType)(typeMetadata)) {
+                const metadata = (0, metadata_1.getClassMetadata)(param.type);
+                return this.getOrCreateObjectTypeForUnion(metadata);
+            }
+            else {
+                throw new Error(`Union type ${typeMetadata.name} can only contain classes`);
+            }
+        });
+    }
+    createEnumType(typeMetadata) {
+        return new graphql_1.GraphQLEnumType({
+            name: typeMetadata.name,
+            values: typeMetadata.parameters.reduce((obj, el) => ({ ...obj, [el.name]: {} }), {}),
+        });
+    }
+    createArrayType(typeMetadata, inputType) {
+        const param = typeMetadata.parameters[0];
+        const GraphQLPropType = this.getOrCreateGraphQLType(param, inputType);
+        return new graphql_1.GraphQLList(GraphQLPropType);
+    }
+    getOrCreateObjectType(classMetadata, inputType, excludeProps) {
+        const typeName = classMetadata.name + (inputType ? 'Input' : '');
+        if (typeName && this.graphQLTypes[typeName])
+            return this.graphQLTypes[typeName];
+        const createdGraphQLType = this.createObjectType(classMetadata, inputType, excludeProps);
+        if (typeName)
+            this.graphQLTypes[typeName] = createdGraphQLType;
+        return createdGraphQLType;
+    }
+    createObjectType(classMetadata, inputType, excludeProps) {
+        const finalFields = (0, common_1.nonExcludedFields)(classMetadata.fields, excludeProps);
+        if (inputType) {
+            return new graphql_1.GraphQLInputObjectType({
+                name: classMetadata.name + 'Input',
+                fields: finalFields === null || finalFields === void 0 ? void 0 : finalFields.reduce((obj, prop) => {
+                    this.logger.debug(`Get or create GraphQL input type for property ${prop.name}`);
+                    return {
+                        ...obj,
+                        [prop.name]: { type: this.getOrCreateGraphQLType(prop.typeInfo, inputType) },
+                    };
+                }, {}),
+            });
+        }
+        return this.createOutputObjectType(classMetadata, excludeProps);
+    }
+    getOrCreateObjectTypeForUnion(classMetadata, excludeProps) {
+        const typeName = classMetadata.name;
+        if (typeName && this.graphQLTypes[typeName])
+            return this.graphQLTypes[typeName];
+        const createdGraphQLType = this.createOutputObjectType(classMetadata, excludeProps);
+        if (typeName)
+            this.graphQLTypes[typeName] = createdGraphQLType;
+        return createdGraphQLType;
+    }
+    createOutputObjectType(classMetadata, excludeProps) {
+        const finalFields = (0, common_1.nonExcludedFields)(classMetadata.fields, excludeProps);
+        return new graphql_1.GraphQLObjectType({
+            name: classMetadata.name,
+            fields: finalFields === null || finalFields === void 0 ? void 0 : finalFields.reduce((obj, prop) => {
+                this.logger.debug(`Get or create GraphQL output type for property ${prop.name}`);
+                return {
+                    ...obj,
+                    [prop.name]: { type: this.getOrCreateGraphQLType(prop.typeInfo, false) },
+                };
+            }, {}),
+        });
+    }
+}
+exports.GraphQLTypeInformer = GraphQLTypeInformer;

package/dist/services/graphql/query-generators/graphql-query-by-keys-generator.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLFieldConfigMap } from 'graphql';
+import { GraphQLResolverContext, ResolverBuilder } from '../common';
+import { AnyClass, MagekConfig } from '@magek/common';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+export declare class GraphqlQueryByKeysGenerator {
+    private readonly config;
+    private readonly readModels;
+    private readonly typeInformer;
+    private readonly byIDResolverBuilder;
+    constructor(config: MagekConfig, readModels: AnyClass[], typeInformer: GraphQLTypeInformer, byIDResolverBuilder: ResolverBuilder);
+    generateByKeysQueries(): GraphQLFieldConfigMap<unknown, GraphQLResolverContext>;
+    private generateByIdQuery;
+    private generateByIdAndSequenceKeyQuery;
+}