@magek/core 0.0.1

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryByKeysGenerator = void 0;
+const graphql_1 = require("graphql");
+class GraphqlQueryByKeysGenerator {
+    constructor(config, readModels, typeInformer, byIDResolverBuilder) {
+        this.config = config;
+        this.readModels = readModels;
+        this.typeInformer = typeInformer;
+        this.byIDResolverBuilder = byIDResolverBuilder;
+    }
+    generateByKeysQueries() {
+        const queries = {};
+        for (const readModel of this.readModels) {
+            const readModelName = readModel.name;
+            const sequenceKeyName = this.config.readModelSequenceKeys[readModelName];
+            if (sequenceKeyName) {
+                queries[readModelName] = this.generateByIdAndSequenceKeyQuery(readModel, sequenceKeyName);
+            }
+            else {
+                queries[readModelName] = this.generateByIdQuery(readModel);
+            }
+        }
+        return queries;
+    }
+    generateByIdQuery(readModel) {
+        const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, this.config.nonExposedGraphQLMetadataKey[readModel.name]);
+        return {
+            type: graphQLType,
+            args: {
+                id: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) },
+            },
+            resolve: this.byIDResolverBuilder(readModel),
+        };
+    }
+    generateByIdAndSequenceKeyQuery(readModel, sequenceKeyName) {
+        const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, this.config.nonExposedGraphQLMetadataKey[readModel.name]);
+        return {
+            type: new graphql_1.GraphQLList(graphQLType),
+            args: {
+                id: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) },
+                [sequenceKeyName]: { type: graphql_1.GraphQLID },
+            },
+            resolve: this.byIDResolverBuilder(readModel),
+        };
+    }
+}
+exports.GraphqlQueryByKeysGenerator = GraphqlQueryByKeysGenerator;

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

@@ -0,0 +1,11 @@
+import { GraphQLFieldConfigMap, GraphQLFieldResolver } from 'graphql';
+import { GraphQLResolverContext, ResolverBuilder } from '../common';
+import { MagekConfig } from '@magek/common';
+export declare class GraphqlQueryEventsGenerator {
+    private readonly config;
+    protected readonly byIDResolverBuilder: ResolverBuilder;
+    private readonly eventsResolver;
+    constructor(config: MagekConfig, byIDResolverBuilder: ResolverBuilder, eventsResolver: GraphQLFieldResolver<unknown, GraphQLResolverContext, any>);
+    generateEventQueries(): GraphQLFieldConfigMap<unknown, GraphQLResolverContext>;
+    private static buildEventQueryResponse;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryEventsGenerator = void 0;
+const graphql_1 = require("graphql");
+const common_1 = require("../common");
+const graphql_scalars_1 = require("graphql-scalars");
+class GraphqlQueryEventsGenerator {
+    constructor(config, byIDResolverBuilder, eventsResolver) {
+        this.config = config;
+        this.byIDResolverBuilder = byIDResolverBuilder;
+        this.eventsResolver = eventsResolver;
+    }
+    generateEventQueries() {
+        const eventQueryResponse = GraphqlQueryEventsGenerator.buildEventQueryResponse();
+        return {
+            eventsByEntity: {
+                type: eventQueryResponse,
+                args: {
+                    entity: {
+                        type: new graphql_1.GraphQLNonNull((0, common_1.buildGraphqlSimpleEnumFor)('EntityType', Object.keys(this.config.entities))),
+                    },
+                    entityID: { type: graphql_1.GraphQLID },
+                    from: { type: graphql_1.GraphQLString },
+                    to: { type: graphql_1.GraphQLString },
+                    limit: { type: graphql_1.GraphQLInt },
+                },
+                resolve: this.eventsResolver,
+            },
+            eventsByType: {
+                type: eventQueryResponse,
+                args: {
+                    type: {
+                        type: new graphql_1.GraphQLNonNull((0, common_1.buildGraphqlSimpleEnumFor)('EventType', Object.keys(this.config.reducers))),
+                    },
+                    from: { type: graphql_1.GraphQLString },
+                    to: { type: graphql_1.GraphQLString },
+                    limit: { type: graphql_1.GraphQLInt },
+                },
+                resolve: this.eventsResolver,
+            },
+        };
+    }
+    static buildEventQueryResponse() {
+        return new graphql_1.GraphQLList(new graphql_1.GraphQLObjectType({
+            name: 'EventQueryResponse',
+            fields: {
+                type: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+                entity: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+                entityID: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) },
+                requestID: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) },
+                user: {
+                    type: new graphql_1.GraphQLObjectType({
+                        name: 'User',
+                        fields: {
+                            id: { type: graphql_1.GraphQLString },
+                            username: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+                            roles: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(graphql_1.GraphQLString)) },
+                        },
+                    }),
+                },
+                createdAt: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+                value: { type: new graphql_1.GraphQLNonNull(graphql_scalars_1.GraphQLJSON) },
+                deletedAt: { type: graphql_1.GraphQLString },
+            },
+        }));
+    }
+}
+exports.GraphqlQueryEventsGenerator = GraphqlQueryEventsGenerator;

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

@@ -0,0 +1,14 @@
+import { GraphQLFieldConfigMap, GraphQLInputObjectType } from 'graphql';
+import { GraphQLResolverContext, ResolverBuilder } from '../common';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+import { AnyClass, MagekConfig } from '@magek/common';
+export declare class GraphqlQueryFiltersGenerator {
+    private readonly readModels;
+    private readonly typeInformer;
+    private readonly filterResolverBuilder;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    private readonly config;
+    private graphqlQueryFilterFieldsBuilder;
+    constructor(readModels: AnyClass[], typeInformer: GraphQLTypeInformer, filterResolverBuilder: ResolverBuilder, generatedFiltersByTypeName: Record<string, GraphQLInputObjectType> | undefined, config: MagekConfig);
+    generateFilterQueries(): GraphQLFieldConfigMap<unknown, GraphQLResolverContext>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryFiltersGenerator = 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 GraphqlQueryFiltersGenerator {
+    constructor(readModels, typeInformer, filterResolverBuilder, generatedFiltersByTypeName = {}, config) {
+        this.readModels = readModels;
+        this.typeInformer = typeInformer;
+        this.filterResolverBuilder = filterResolverBuilder;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.config = config;
+        this.graphqlQueryFilterFieldsBuilder = new graphql_query_filter_fields_builder_1.GraphqlQueryFilterFieldsBuilder(typeInformer, generatedFiltersByTypeName, config);
+    }
+    generateFilterQueries() {
+        const queries = {};
+        for (const readModel of this.readModels) {
+            const excludeProp = this.config.nonExposedGraphQLMetadataKey[readModel.name];
+            const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, excludeProp);
+            queries[inflected.pluralize(readModel.name)] = {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(graphQLType))),
+                args: this.graphqlQueryFilterFieldsBuilder.generateFilterQueriesFields(readModel.name, readModel, excludeProp),
+                resolve: this.filterResolverBuilder(readModel),
+                deprecationReason: 'Method is deprecated. Use List* methods',
+            };
+        }
+        return queries;
+    }
+}
+exports.GraphqlQueryFiltersGenerator = GraphqlQueryFiltersGenerator;

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

@@ -0,0 +1,12 @@
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+import { GraphQLResolverContext, ResolverBuilder, TargetTypesMap } from '../common';
+import { GraphQLFieldConfigMap } from 'graphql';
+import { MagekConfig } from '@magek/common';
+export declare class GraphqlQueryGenerator {
+    private readonly targetTypes;
+    private readonly typeInformer;
+    private readonly queryResolveBuilder;
+    private readonly config;
+    constructor(targetTypes: TargetTypesMap, typeInformer: GraphQLTypeInformer, queryResolveBuilder: ResolverBuilder, config: MagekConfig);
+    generateQueries(): GraphQLFieldConfigMap<unknown, GraphQLResolverContext>;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryGenerator = void 0;
+const graphql_handled_fields_generator_1 = require("../query-helpers/graphql-handled-fields-generator");
+class GraphqlQueryGenerator {
+    constructor(targetTypes, typeInformer, queryResolveBuilder, config) {
+        this.targetTypes = targetTypes;
+        this.typeInformer = typeInformer;
+        this.queryResolveBuilder = queryResolveBuilder;
+        this.config = config;
+    }
+    generateQueries() {
+        const graphqlGenerateHandledFields = new graphql_handled_fields_generator_1.GraphQLHandledFieldsGenerator(this.targetTypes, this.typeInformer, this.queryResolveBuilder, this.config);
+        return graphqlGenerateHandledFields.generateFields(false);
+    }
+}
+exports.GraphqlQueryGenerator = GraphqlQueryGenerator;

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

@@ -0,0 +1,16 @@
+import { GraphQLFieldConfigMap, GraphQLInputObjectType } from 'graphql';
+import { GraphQLResolverContext, ResolverBuilder } from '../common';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+import { AnyClass, MagekConfig } from '@magek/common';
+export declare class GraphqlQueryListedGenerator {
+    private readonly readModels;
+    private readonly typeInformer;
+    private readonly filterResolverBuilder;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    private readonly config;
+    private graphqlQueryFilterArgumentsBuilder;
+    private graphqlQuerySortBuilder;
+    constructor(readModels: AnyClass[], typeInformer: GraphQLTypeInformer, filterResolverBuilder: ResolverBuilder, generatedFiltersByTypeName: Record<string, GraphQLInputObjectType> | undefined, config: MagekConfig);
+    generateListedQueries(): GraphQLFieldConfigMap<unknown, GraphQLResolverContext>;
+    private generateListedQueriesFields;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryListedGenerator = void 0;
+const graphql_1 = require("graphql");
+const inflected = require("inflected");
+const graphql_scalars_1 = require("graphql-scalars");
+const graphql_query_sort_builder_1 = require("../query-helpers/graphql-query-sort-builder");
+const graphql_query_filter_arguments_builder_1 = require("../query-helpers/graphql-query-filter-arguments-builder");
+class GraphqlQueryListedGenerator {
+    constructor(readModels, typeInformer, filterResolverBuilder, generatedFiltersByTypeName = {}, config) {
+        this.readModels = readModels;
+        this.typeInformer = typeInformer;
+        this.filterResolverBuilder = filterResolverBuilder;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.config = config;
+        this.graphqlQueryFilterArgumentsBuilder = new graphql_query_filter_arguments_builder_1.GraphqlQueryFilterArgumentsBuilder(typeInformer, generatedFiltersByTypeName, config);
+        this.graphqlQuerySortBuilder = new graphql_query_sort_builder_1.GraphqlQuerySortBuilder(typeInformer, config);
+    }
+    generateListedQueries() {
+        const queries = {};
+        for (const readModel of this.readModels) {
+            const excludeProp = this.config.nonExposedGraphQLMetadataKey[readModel.name];
+            const graphQLType = this.typeInformer.generateGraphQLTypeForClass(readModel, excludeProp);
+            queries[`List${inflected.pluralize(readModel.name)}`] = {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                    name: `${readModel.name}Connection`,
+                    fields: {
+                        items: { type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(graphQLType))) },
+                        count: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLInt) },
+                        cursor: { type: graphql_scalars_1.GraphQLJSON },
+                    },
+                })),
+                args: this.generateListedQueriesFields(readModel.name, readModel, excludeProp),
+                resolve: this.filterResolverBuilder(readModel),
+            };
+        }
+        return queries;
+    }
+    generateListedQueriesFields(name, type, excludeProps) {
+        const filterArguments = this.graphqlQueryFilterArgumentsBuilder.generateFilterArguments(type, excludeProps);
+        const filter = new graphql_1.GraphQLInputObjectType({
+            name: `List${type.name}Filter`,
+            fields: () => ({
+                ...filterArguments,
+                and: { type: new graphql_1.GraphQLList(filter) },
+                or: { type: new graphql_1.GraphQLList(filter) },
+                not: { type: filter },
+            }),
+        });
+        const sortArguments = this.graphqlQuerySortBuilder.generateSortArguments(type, excludeProps);
+        const sort = new graphql_1.GraphQLInputObjectType({
+            name: `${name}SortBy`,
+            fields: () => ({
+                ...sortArguments,
+            }),
+        });
+        return {
+            filter: { type: filter },
+            limit: { type: graphql_1.GraphQLInt },
+            sortBy: { type: sort },
+            afterCursor: { type: graphql_scalars_1.GraphQLJSON },
+        };
+    }
+}
+exports.GraphqlQueryListedGenerator = GraphqlQueryListedGenerator;

package/dist/services/graphql/query-helpers/graphql-handled-fields-generator.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLFieldConfigMap } from 'graphql';
+import { ResolverBuilder, TargetTypesMap } from '../common';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+import { MagekConfig } from '@magek/common';
+export declare class GraphQLHandledFieldsGenerator {
+    private readonly targetTypes;
+    private readonly typeInformer;
+    private readonly resolver;
+    private readonly config;
+    constructor(targetTypes: TargetTypesMap, typeInformer: GraphQLTypeInformer, resolver: ResolverBuilder, config: MagekConfig);
+    generateFields(allowVoidReturn?: boolean): GraphQLFieldConfigMap<any, any>;
+    private generateInputForType;
+    private static getHandleMethodMetadata;
+    private static getReturnMetadata;
+}

package/dist/services/graphql/query-helpers/graphql-handled-fields-generator.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLHandledFieldsGenerator = void 0;
+const graphql_1 = require("graphql");
+class GraphQLHandledFieldsGenerator {
+    constructor(targetTypes, typeInformer, resolver, config) {
+        this.targetTypes = targetTypes;
+        this.typeInformer = typeInformer;
+        this.resolver = resolver;
+        this.config = config;
+    }
+    generateFields(allowVoidReturn = true) {
+        const fields = {};
+        for (const name in this.targetTypes) {
+            const metadata = this.targetTypes[name];
+            const handleMethodMetadata = GraphQLHandledFieldsGenerator.getHandleMethodMetadata(metadata);
+            const returnMetadata = GraphQLHandledFieldsGenerator.getReturnMetadata(handleMethodMetadata, allowVoidReturn);
+            const type = this.typeInformer.getOrCreateGraphQLType(returnMetadata, false);
+            fields[name] = {
+                type: type,
+                resolve: this.resolver(metadata.class),
+            };
+            const input = this.generateInputForType(metadata);
+            if (input) {
+                fields[name].args = { ...input };
+            }
+        }
+        return fields;
+    }
+    generateInputForType(metadata) {
+        if (metadata.properties.length === 0)
+            return undefined;
+        return {
+            input: {
+                type: new graphql_1.GraphQLNonNull(this.typeInformer.generateGraphQLTypeForClass(metadata.class, this.config.nonExposedGraphQLMetadataKey[metadata.class.name], true)),
+            },
+        };
+    }
+    static getHandleMethodMetadata(metadata) {
+        var _a;
+        let handleMethodMetadata = (_a = metadata.methods.find((m) => m.name === 'handle')) === null || _a === void 0 ? void 0 : _a.typeInfo;
+        if (handleMethodMetadata && handleMethodMetadata.typeName === 'Promise') {
+            // If async function, return type is wrapped in a Promise
+            handleMethodMetadata = handleMethodMetadata.parameters[0];
+        }
+        return handleMethodMetadata;
+    }
+    static getReturnMetadata(handleMethodMetadata, allowVoidReturn) {
+        if (!handleMethodMetadata || handleMethodMetadata.name === 'never') {
+            if (!allowVoidReturn) {
+                throw Error('Unexpected void return type for Query');
+            }
+            return {
+                name: 'Boolean',
+                typeGroup: 'Boolean',
+                typeName: 'Boolean',
+                isNullable: false,
+                isGetAccessor: false,
+                parameters: [],
+            };
+        }
+        return handleMethodMetadata;
+    }
+}
+exports.GraphQLHandledFieldsGenerator = GraphQLHandledFieldsGenerator;

package/dist/services/graphql/query-helpers/graphql-query-filter-arguments-builder.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLFieldConfigArgumentMap, GraphQLInputObjectType } from 'graphql';
+import { AnyClass, MagekConfig } from '@magek/common';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+export declare class GraphqlQueryFilterArgumentsBuilder {
+    private readonly typeInformer;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    private readonly config;
+    constructor(typeInformer: GraphQLTypeInformer, generatedFiltersByTypeName: Record<string, GraphQLInputObjectType> | undefined, config: MagekConfig);
+    generateFilterArguments(type: AnyClass, excludeProps: Array<string>): GraphQLFieldConfigArgumentMap;
+    private generateFilterFor;
+    private generateArrayFilterFor;
+    private generateFilterInputTypes;
+}

package/dist/services/graphql/query-helpers/graphql-query-filter-arguments-builder.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryFilterArgumentsBuilder = void 0;
+const graphql_1 = require("graphql");
+const metadata_1 = require("../../../decorators/metadata");
+const graphql_scalars_1 = require("graphql-scalars");
+const common_1 = require("@magek/common");
+const common_2 = require("../common");
+class GraphqlQueryFilterArgumentsBuilder {
+    constructor(typeInformer, generatedFiltersByTypeName = {}, config) {
+        this.typeInformer = typeInformer;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.config = config;
+    }
+    generateFilterArguments(type, excludeProps) {
+        const metadata = (0, metadata_1.getClassMetadata)(type);
+        const args = {};
+        const finalFields = (0, common_2.nonExcludedFields)(metadata.fields, excludeProps);
+        finalFields
+            .filter((field) => !field.typeInfo.isGetAccessor)
+            .forEach((prop) => {
+            args[prop.name] = {
+                type: this.generateFilterFor(prop),
+            };
+        });
+        return args;
+    }
+    generateFilterFor(prop) {
+        let filterName = `${prop.typeInfo.name}PropertyFilter`;
+        filterName = filterName.replace(/[^_a-zA-Z]/g, '_');
+        filterName = filterName.charAt(0).toUpperCase() + filterName.substr(1);
+        if (this.generatedFiltersByTypeName[filterName])
+            return this.generatedFiltersByTypeName[filterName];
+        if (prop.typeInfo.typeGroup === 'Array')
+            return this.generateArrayFilterFor(prop);
+        let fields = {};
+        if (prop.typeInfo.name === 'UUID' || prop.typeInfo.name === 'Date') {
+            fields = this.generateFilterInputTypes(prop.typeInfo);
+        }
+        else if (prop.typeInfo.type && (prop.typeInfo.typeGroup === 'Class' || prop.typeInfo.typeGroup === 'Object')) {
+            if ((0, common_2.isExternalType)(prop.typeInfo))
+                return graphql_scalars_1.GraphQLJSON;
+            let nestedProperties = {};
+            const metadata = (0, metadata_1.getClassMetadata)(prop.typeInfo.type);
+            if (metadata.fields.length === 0)
+                return graphql_scalars_1.GraphQLJSON;
+            const excludeProps = this.config.nonExposedGraphQLMetadataKey[prop.name];
+            this.typeInformer.generateGraphQLTypeForClass(prop.typeInfo.type, excludeProps, true);
+            for (const prop of metadata.fields) {
+                const property = { [prop.name]: { type: this.generateFilterFor(prop) } };
+                nestedProperties = { ...nestedProperties, ...property };
+            }
+            fields = () => ({
+                ...nestedProperties,
+                and: { type: new graphql_1.GraphQLList(this.generatedFiltersByTypeName[filterName]) },
+                or: { type: new graphql_1.GraphQLList(this.generatedFiltersByTypeName[filterName]) },
+                not: { type: this.generatedFiltersByTypeName[filterName] },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            });
+        }
+        else if (prop.typeInfo.type && prop.typeInfo.type.name !== 'Object') {
+            fields = this.generateFilterInputTypes(prop.typeInfo);
+        }
+        else {
+            return graphql_scalars_1.GraphQLJSON;
+        }
+        this.generatedFiltersByTypeName[filterName] = new graphql_1.GraphQLInputObjectType({ name: filterName, fields });
+        return this.generatedFiltersByTypeName[filterName];
+    }
+    generateArrayFilterFor(property) {
+        let filterName = `${property.typeInfo.parameters[0].name}ArrayPropertyFilter`;
+        filterName = filterName.replace(/[^_a-zA-Z]/g, '_');
+        filterName = filterName.charAt(0).toUpperCase() + filterName.substr(1);
+        if (!this.generatedFiltersByTypeName[filterName]) {
+            const propFilters = {};
+            property.typeInfo.parameters.forEach((param) => {
+                let graphqlType;
+                switch (param.typeGroup) {
+                    case 'Boolean':
+                        graphqlType = graphql_1.GraphQLBoolean;
+                        break;
+                    case 'String':
+                        graphqlType = graphql_1.GraphQLString;
+                        break;
+                    case 'Number':
+                        graphqlType = graphql_1.GraphQLFloat;
+                        break;
+                    default:
+                        graphqlType = param.type === common_1.UUID ? graphql_1.GraphQLID : graphql_scalars_1.GraphQLJSON;
+                        break;
+                }
+                propFilters.includes = { type: graphqlType };
+            });
+            propFilters.isDefined = { type: graphql_1.GraphQLBoolean };
+            this.generatedFiltersByTypeName[filterName] = new graphql_1.GraphQLInputObjectType({
+                name: filterName,
+                fields: propFilters,
+            });
+        }
+        return this.generatedFiltersByTypeName[filterName];
+    }
+    generateFilterInputTypes(typeMetadata) {
+        const { name, typeGroup } = typeMetadata;
+        if (typeGroup === 'Boolean')
+            return {
+                eq: { type: graphql_1.GraphQLBoolean },
+                ne: { type: graphql_1.GraphQLBoolean },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        if (typeGroup === 'Number')
+            return {
+                eq: { type: graphql_1.GraphQLFloat },
+                ne: { type: graphql_1.GraphQLFloat },
+                lte: { type: graphql_1.GraphQLFloat },
+                lt: { type: graphql_1.GraphQLFloat },
+                gte: { type: graphql_1.GraphQLFloat },
+                gt: { type: graphql_1.GraphQLFloat },
+                in: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        if (typeGroup === 'String')
+            return {
+                eq: { type: graphql_1.GraphQLString },
+                ne: { type: graphql_1.GraphQLString },
+                lte: { type: graphql_1.GraphQLString },
+                lt: { type: graphql_1.GraphQLString },
+                gte: { type: graphql_1.GraphQLString },
+                gt: { type: graphql_1.GraphQLString },
+                in: { type: new graphql_1.GraphQLList(graphql_1.GraphQLString) },
+                beginsWith: { type: graphql_1.GraphQLString },
+                contains: { type: graphql_1.GraphQLString },
+                regex: { type: graphql_1.GraphQLString },
+                iRegex: { type: graphql_1.GraphQLString },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        // use `name`, `typeGroup` === 'Class'
+        if (name === 'UUID')
+            return {
+                eq: { type: graphql_1.GraphQLID },
+                ne: { type: graphql_1.GraphQLID },
+                in: { type: new graphql_1.GraphQLList(graphql_1.GraphQLID) },
+                beginsWith: { type: graphql_1.GraphQLString },
+                contains: { type: graphql_1.GraphQLString },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        // use `name`, `typeGroup` === 'Interface'.
+        if (name === 'Date')
+            return {
+                eq: { type: common_2.DateScalar },
+                ne: { type: common_2.DateScalar },
+                lte: { type: common_2.DateScalar },
+                lt: { type: common_2.DateScalar },
+                gte: { type: common_2.DateScalar },
+                gt: { type: common_2.DateScalar },
+                in: { type: new graphql_1.GraphQLList(common_2.DateScalar) },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        if (typeGroup === 'Enum') {
+            const EnumType = this.typeInformer.getOrCreateGraphQLType(typeMetadata, true);
+            return {
+                eq: { type: EnumType },
+                ne: { type: EnumType },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            };
+        }
+        throw new Error(`Type ${name} is not supported in search filters`);
+    }
+}
+exports.GraphqlQueryFilterArgumentsBuilder = GraphqlQueryFilterArgumentsBuilder;

package/dist/services/graphql/query-helpers/graphql-query-filter-fields-builder.d.ts

@@ -0,0 +1,11 @@
+import { AnyClass, MagekConfig } from '@magek/common';
+import { GraphQLFieldConfigArgumentMap, GraphQLInputObjectType } from 'graphql';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+export declare class GraphqlQueryFilterFieldsBuilder {
+    protected readonly typeInformer: GraphQLTypeInformer;
+    protected generatedFiltersByTypeName: Record<string, GraphQLInputObjectType>;
+    protected readonly config: MagekConfig;
+    private graphqlQueryFilterArgumentsBuilder;
+    constructor(typeInformer: GraphQLTypeInformer, generatedFiltersByTypeName: Record<string, GraphQLInputObjectType> | undefined, config: MagekConfig);
+    generateFilterQueriesFields(name: string, type: AnyClass, excludeProps: Array<string>): GraphQLFieldConfigArgumentMap;
+}

package/dist/services/graphql/query-helpers/graphql-query-filter-fields-builder.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlQueryFilterFieldsBuilder = void 0;
+const graphql_1 = require("graphql");
+const graphql_query_filter_arguments_builder_1 = require("./graphql-query-filter-arguments-builder");
+class GraphqlQueryFilterFieldsBuilder {
+    constructor(typeInformer, generatedFiltersByTypeName = {}, config) {
+        this.typeInformer = typeInformer;
+        this.generatedFiltersByTypeName = generatedFiltersByTypeName;
+        this.config = config;
+        this.graphqlQueryFilterArgumentsBuilder = new graphql_query_filter_arguments_builder_1.GraphqlQueryFilterArgumentsBuilder(typeInformer, generatedFiltersByTypeName, config);
+    }
+    generateFilterQueriesFields(name, type, excludeProps) {
+        const filterArguments = this.graphqlQueryFilterArgumentsBuilder.generateFilterArguments(type, excludeProps);
+        const filter = new graphql_1.GraphQLInputObjectType({
+            name: `${name}Filter`,
+            fields: () => ({
+                ...filterArguments,
+                and: { type: new graphql_1.GraphQLList(filter) },
+                or: { type: new graphql_1.GraphQLList(filter) },
+                not: { type: filter },
+                isDefined: { type: graphql_1.GraphQLBoolean },
+            }),
+        });
+        return { filter: { type: filter } };
+    }
+}
+exports.GraphqlQueryFilterFieldsBuilder = GraphqlQueryFilterFieldsBuilder;

package/dist/services/graphql/query-helpers/graphql-query-sort-builder.d.ts

@@ -0,0 +1,12 @@
+import { GraphQLFieldConfigArgumentMap } from 'graphql';
+import { GraphQLTypeInformer } from '../graphql-type-informer';
+import { AnyClass, MagekConfig } from '@magek/common';
+export declare class GraphqlQuerySortBuilder {
+    protected readonly typeInformer: GraphQLTypeInformer;
+    protected readonly config: MagekConfig;
+    private generatedSortByByTypeName;
+    private orderType;
+    constructor(typeInformer: GraphQLTypeInformer, config: MagekConfig);
+    generateSortArguments(type: AnyClass, excludeProps: Array<string>): GraphQLFieldConfigArgumentMap;
+    private generateSortFor;
+}