@dav3/gql-of-power 1.0.0

package/dist/src/entities/gql-entity.js

@@ -0,0 +1,381 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Field, FieldResolver, getMetadataStorage, InputType, Int, ObjectType, registerEnumType, Resolver, } from 'type-graphql';
+import { Sort, } from '../types';
+import { keys } from '../utils';
+import { logger } from '../variables';
+const TypeMap = {};
+const FieldsOptionsMap = {};
+const CustomFieldsMap = {};
+const aclMap = {};
+let gqlTypesSuffix = '';
+export const setGlobalConfig = (config) => {
+    gqlTypesSuffix = config.gqlTypesSuffix;
+};
+export const getFieldsOptionsFor = (name) => FieldsOptionsMap[name] ?? {};
+export const getFieldByAlias = (entityName, alias) => FieldsOptionsMap[entityName ?? '__no__use__']?.[alias] ?? alias;
+export const getCustomFieldsFor = (name) => CustomFieldsMap[name] ?? {};
+export const getACLFor = (name) => aclMap[name] ?? {};
+export const getGQLEntityNameFor = (name) => `${name}${gqlTypesSuffix}`;
+export const getGQLEntityNameForClass = (classType) => getGQLEntityNameFor(classType.name);
+export const getGQLEntityFieldResolverName = (gqlEntityName) => `${gqlEntityName}FieldsResolver`;
+export const getGQLEntityFieldResolverNameFor = (classType) => getGQLEntityFieldResolverName(getGQLEntityNameForClass(classType));
+export const getGQLEntityTypeFor = (classType) => getGQLEntityFieldResolverName(TypeMap[getGQLEntityNameForClass(classType)]);
+registerEnumType(Sort, {
+    name: `Sort${gqlTypesSuffix}`,
+});
+export function createGQLTypes(classType, opts, { customFields, acl, } = {}) {
+    const metadata = getMetadataStorage();
+    const gqlEntityName = getGQLEntityNameForClass(classType);
+    aclMap[gqlEntityName] = acl ?? {};
+    const fields = keys(opts);
+    class GQLEntity {
+        _____name = gqlEntityName;
+    }
+    Object.defineProperty(GQLEntity, 'name', { value: gqlEntityName });
+    TypeMap[gqlEntityName] = GQLEntity;
+    class GQLEntityFilterInput {
+        _and;
+        _or;
+        _not;
+    }
+    __decorate([
+        Field(() => [GQLEntityFilterInput], { nullable: true })
+    ], GQLEntityFilterInput.prototype, "_and", void 0);
+    __decorate([
+        Field(() => [GQLEntityFilterInput], { nullable: true })
+    ], GQLEntityFilterInput.prototype, "_or", void 0);
+    __decorate([
+        Field(() => [GQLEntityFilterInput], { nullable: true })
+    ], GQLEntityFilterInput.prototype, "_not", void 0);
+    Object.defineProperty(GQLEntityFilterInput, 'name', {
+        value: gqlEntityName + 'FilterInput',
+    });
+    TypeMap[gqlEntityName + 'FilterInput'] = GQLEntityFilterInput;
+    class GQLEntityOrderBy {
+    }
+    Object.defineProperty(GQLEntityOrderBy, 'name', {
+        value: gqlEntityName + 'OrderBy',
+    });
+    TypeMap[gqlEntityName + 'OrderBy'] = GQLEntityOrderBy;
+    let FieldsResolver = class FieldsResolver {
+    };
+    FieldsResolver = __decorate([
+        Resolver(() => GQLEntity)
+    ], FieldsResolver);
+    if (customFields) {
+        CustomFieldsMap[gqlEntityName] = customFields;
+        logger.info('CustomFieldsMap', gqlEntityName, customFields);
+        for (const fieldName of keys(customFields)) {
+            const fieldOptions = fieldName in customFields ? customFields[fieldName] : undefined;
+            if (!fieldOptions) {
+                continue;
+            }
+            const fieldNameOverride = fieldOptions.alias;
+            if (fieldNameOverride) {
+                FieldsOptionsMap[gqlEntityName] = FieldsOptionsMap[gqlEntityName] || {};
+                FieldsOptionsMap[gqlEntityName][fieldNameOverride] = fieldName;
+            }
+            const fieldNameToUse = fieldNameOverride ?? fieldName;
+            metadata.collectClassFieldMetadata({
+                target: GQLEntity,
+                name: fieldNameToUse,
+                schemaName: fieldNameToUse,
+                getType: fieldOptions.type,
+                typeOptions: {
+                    ...('array' in fieldOptions && fieldOptions.array ? { array: true, arrayDepth: 1 } : {}),
+                    ...fieldOptions.options,
+                },
+                complexity: undefined,
+                description: fieldNameToUse,
+                deprecationReason: undefined,
+            });
+            if (fieldOptions.resolve) {
+                Object.defineProperty(FieldsResolver.prototype, fieldNameToUse, {
+                    // value: desc.value,
+                    value: fieldOptions.resolve,
+                    writable: true,
+                    configurable: true,
+                });
+                FieldResolver(fieldOptions.type, {
+                    ...('array' in fieldOptions && fieldOptions.array ? { array: true, arrayDepth: 1 } : {}),
+                    ...fieldOptions.options,
+                    name: fieldNameToUse,
+                })(FieldsResolver.prototype, fieldNameToUse, Object.getOwnPropertyDescriptor(FieldsResolver.prototype, fieldNameToUse));
+                fieldOptions.resolveDecorators?.forEach((decorator, i) => {
+                    decorator(FieldsResolver.prototype, fieldNameToUse, i);
+                });
+                // Root()(FieldsResolver.prototype, fieldResolverName, 0);
+            }
+        }
+    }
+    InputType(gqlEntityName + 'OrderBy')(GQLEntityOrderBy);
+    const paginationTypeName = `${gqlEntityName}PaginationInput`;
+    let GQLEntityPaginationInputField = class GQLEntityPaginationInputField {
+        limit;
+        offset;
+        orderBy;
+    };
+    __decorate([
+        Field(() => Int, {
+            nullable: true,
+        })
+    ], GQLEntityPaginationInputField.prototype, "limit", void 0);
+    __decorate([
+        Field(() => Int, {
+            nullable: true,
+        })
+    ], GQLEntityPaginationInputField.prototype, "offset", void 0);
+    __decorate([
+        Field(() => [GQLEntityOrderBy], { nullable: true })
+    ], GQLEntityPaginationInputField.prototype, "orderBy", void 0);
+    GQLEntityPaginationInputField = __decorate([
+        InputType(paginationTypeName)
+    ], GQLEntityPaginationInputField);
+    Object.defineProperty(GQLEntityPaginationInputField, 'name', {
+        value: paginationTypeName,
+    });
+    TypeMap[paginationTypeName] = GQLEntityPaginationInputField;
+    for (const fieldName of fields) {
+        const fieldOptions = fieldName in opts ? opts[fieldName] : undefined;
+        if (!fieldOptions) {
+            continue;
+        }
+        const fieldNameOverride = fieldOptions.alias;
+        if (fieldNameOverride) {
+            FieldsOptionsMap[gqlEntityName] = FieldsOptionsMap[gqlEntityName] || {};
+            FieldsOptionsMap[gqlEntityName][fieldNameOverride] = fieldName;
+        }
+        const fieldNameToUse = fieldNameOverride ?? fieldName;
+        createGQLEntityFields(fieldOptions, fieldNameToUse, GQLEntity, metadata, GQLEntityOrderBy, gqlEntityName, GQLEntityFilterInput);
+    }
+    //   acl && AuthorizeAccess(acl)({ name: gqlEntityName } as any);
+    ObjectType(gqlEntityName)(GQLEntity);
+    InputType(gqlEntityName + 'FilterInput')(GQLEntityFilterInput);
+    return {
+        GQLEntity,
+        GQLEntityFilterInput: GQLEntityFilterInput,
+        GQLEntityPaginationInputField: GQLEntityPaginationInputField,
+        /**
+         * this can be used alongside `getGQLEntityTypeFor` to get the type of the entity, not sure it will be ever needed
+         */
+        gqlEntityName,
+        relatedEntityName: classType.name,
+        FieldsResolver,
+        bindFieldResolvers: (c) => { },
+    };
+}
+export function createGQLEntityFields(fieldOptions, fieldName, GQLEntity, metadata, GQLEntityOrderBy, gqlEntityName, GQLEntityFilterInput) {
+    const getType = fieldOptions.type;
+    const isArray = 'array' in fieldOptions && fieldOptions.array;
+    const field = {
+        target: GQLEntity,
+        name: fieldName,
+        schemaName: fieldName,
+        getType: fieldOptions.type,
+        complexity: undefined,
+        description: fieldName,
+        deprecationReason: undefined,
+        options: {
+            ...fieldOptions.options,
+            ...(isArray ? { array: true, arrayDepth: 1 } : {}),
+        },
+        typeOptions: {
+            ...(isArray ? { array: true, arrayDepth: 1 } : {}),
+            ...fieldOptions.options,
+        },
+    };
+    metadata.collectClassFieldMetadata(field);
+    if (fieldOptions.enum) {
+        const enumObj = fieldOptions.enum[0];
+        const enumValues = fieldOptions.enum[1];
+        metadata.collectEnumMetadata({
+            enumObj,
+            description: enumValues.description ?? `${enumObj}`,
+            name: enumValues.name,
+            valuesConfig: enumValues.valuesConfig ?? {},
+        });
+    }
+    const UppercasedFieldName = fieldName[0].toUpperCase() + fieldName.slice(1);
+    if (fieldOptions.generateFilter) {
+        /**
+         * SORTING
+         * right now sorting by reference is not supported
+         */
+        if (!isArray) {
+            const orderByField = {
+                target: GQLEntityOrderBy,
+                name: fieldName,
+                schemaName: fieldName,
+                complexity: undefined,
+                description: fieldName,
+                deprecationReason: undefined,
+                getType: () => Sort,
+                options: { ...fieldOptions.options, nullable: true },
+                typeOptions: { ...fieldOptions.options, nullable: true },
+            };
+            metadata.collectClassFieldMetadata(orderByField);
+        }
+        /**
+         * FILTERING
+         */
+        const inputFieldName = `${gqlEntityName}_${UppercasedFieldName}`;
+        let GQLEntityFilterInputField = class GQLEntityFilterInputField {
+            _and;
+            _or;
+            _not;
+        };
+        __decorate([
+            Field(() => [GQLEntityFilterInputField], {
+                nullable: true,
+                deprecationReason: 'this is the same as using an object with multiple values',
+            })
+        ], GQLEntityFilterInputField.prototype, "_and", void 0);
+        __decorate([
+            Field(() => [GQLEntityFilterInputField], { nullable: true })
+        ], GQLEntityFilterInputField.prototype, "_or", void 0);
+        __decorate([
+            Field(() => [GQLEntityFilterInputField], { nullable: true })
+        ], GQLEntityFilterInputField.prototype, "_not", void 0);
+        GQLEntityFilterInputField = __decorate([
+            InputType(inputFieldName)
+        ], GQLEntityFilterInputField);
+        Object.defineProperty(GQLEntityFilterInputField, 'name', {
+            value: inputFieldName,
+        });
+        TypeMap[inputFieldName] = GQLEntityFilterInputField;
+        const options = [
+            { key: '_eq' },
+            { key: '_ne' },
+            { key: '_in', array: true },
+            { key: '_nin', array: true },
+            { key: '_gt' },
+            { key: '_gte' },
+            { key: '_lt' },
+            { key: '_lte' },
+            { key: '_like' },
+            { key: '_re' },
+            { key: '_ilike' },
+            { key: '_fulltext' },
+            { key: '_overlap', appliesToArray: true },
+            { key: '_contains', array: true, appliesToArray: true },
+            { key: '_contained' },
+            { key: '_exists' },
+            { key: '_between', array: true },
+        ];
+        const canFilterForField = 'type' in fieldOptions;
+        const includeNotArrays = !('relatedEntityName' in fieldOptions);
+        // const includeAppliesToArray = 'array' in fieldOptions && fieldOptions.array;
+        const getFilterType = 'getFilterType' in fieldOptions && fieldOptions.getFilterType;
+        const applicableOptions = canFilterForField
+            ? options.filter(({ appliesToArray }) => (!appliesToArray && includeNotArrays) || (appliesToArray && getFilterType))
+            : [];
+        if (canFilterForField && applicableOptions.length > 0) {
+            for (const option of applicableOptions) {
+                const optionGQLName = fieldName + option.key;
+                const backCompFieldFilterOpt = {
+                    target: GQLEntityFilterInput,
+                    name: optionGQLName,
+                    schemaName: optionGQLName,
+                    getType: option.appliesToArray && getFilterType ? getFilterType : getType,
+                    options: {
+                        ...fieldOptions.options,
+                        ...(option.array || option.appliesToArray ? { array: true, arrayDepth: 1 } : {}),
+                        nullable: true,
+                    },
+                    typeOptions: {
+                        ...(option.array || option.appliesToArray ? { array: true, arrayDepth: 1 } : {}),
+                        nullable: true,
+                    },
+                    complexity: undefined,
+                    description: optionGQLName,
+                    deprecationReason: undefined,
+                };
+                metadata.collectClassFieldMetadata(backCompFieldFilterOpt);
+                const fieldFilterOpt = {
+                    target: GQLEntityFilterInputField,
+                    name: option.key,
+                    schemaName: option.key,
+                    getType: option.appliesToArray && getFilterType ? getFilterType : getType,
+                    options: {
+                        ...fieldOptions.options,
+                        ...(option.array || option.appliesToArray ? { array: true, arrayDepth: 1 } : {}),
+                        nullable: true,
+                    },
+                    typeOptions: {
+                        ...(option.array || option.appliesToArray ? { array: true, arrayDepth: 1 } : {}),
+                        nullable: true,
+                    },
+                    complexity: undefined,
+                    description: option.key,
+                    deprecationReason: undefined,
+                };
+                metadata.collectClassFieldMetadata(fieldFilterOpt);
+            }
+        }
+        if (!('relatedEntityName' in fieldOptions)) {
+            const fieldFilterValue = {
+                target: GQLEntityFilterInput,
+                name: fieldName,
+                schemaName: fieldName,
+                getType: getType,
+                options: fieldOptions.options,
+                typeOptions: { nullable: true },
+                complexity: undefined,
+                description: fieldName,
+                deprecationReason: undefined,
+            };
+            metadata.collectClassFieldMetadata(fieldFilterValue);
+        }
+        const fieldFilter = {
+            target: GQLEntityFilterInput,
+            name: UppercasedFieldName,
+            schemaName: UppercasedFieldName,
+            getType: 'relatedEntityName' in fieldOptions
+                ? () => {
+                    return (TypeMap[getGQLEntityNameFor(fieldOptions.relatedEntityName()) + 'FilterInput'] ??
+                        GQLEntityFilterInputField);
+                }
+                : () => GQLEntityFilterInputField,
+            options: { ...fieldOptions.options, nullable: true },
+            typeOptions: { nullable: true },
+            complexity: undefined,
+            description: fieldName,
+            deprecationReason: undefined,
+        };
+        metadata.collectClassFieldMetadata(fieldFilter);
+        if ('array' in fieldOptions) {
+            const relatedEntityName = getGQLEntityNameFor(fieldOptions.relatedEntityName());
+            metadata.collectHandlerParamMetadata({
+                kind: 'arg',
+                name: 'filter',
+                description: undefined,
+                methodName: fieldName,
+                index: 0,
+                getType: () => TypeMap[relatedEntityName + 'FilterInput'],
+                target: GQLEntity,
+                typeOptions: { nullable: true },
+                deprecationReason: undefined,
+                validateFn: undefined,
+                validateSettings: undefined,
+            });
+            metadata.collectHandlerParamMetadata({
+                kind: 'arg',
+                name: 'pagination',
+                description: undefined,
+                methodName: fieldName,
+                index: 1,
+                getType: () => TypeMap[`${relatedEntityName}PaginationInput`],
+                target: GQLEntity,
+                typeOptions: { nullable: true },
+                deprecationReason: undefined,
+                validateFn: undefined,
+                validateSettings: undefined,
+            });
+        }
+    }
+}

package/dist/src/entities/index.d.ts

@@ -0,0 +1 @@
+export * from './gql-entity';

package/dist/src/entities/index.js

@@ -0,0 +1 @@
+export * from './gql-entity';

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entities';
+export * from './queries';
+export * from './query-manager';
+export * from './types';
+export * from './utils';

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export * from './entities';
+export * from './queries';
+export * from './query-manager';
+export * from './types';
+export * from './utils';

package/dist/src/operations.d.ts

@@ -0,0 +1,116 @@
+import { Alias } from './queries';
+import { EntityMetadata, GQLEntityFilterInputFieldType, MappingsType } from './types';
+export type ClassOperationInputType<T> = {
+    entityMetadata: EntityMetadata<T>;
+    gqlFilters: GQLEntityFilterInputFieldType<T>[];
+    fieldName: string & keyof Pick<MappingsType, '_and' | '_not' | '_or'>;
+    parentAlias: Alias;
+    alias: Alias;
+    mapping: MappingsType;
+    mappings: Map<string, MappingsType>;
+};
+export declare abstract class ClassOperations {
+    abstract _and(input: ClassOperationInputType<any>): any;
+    abstract _or(input: ClassOperationInputType<any>): any;
+    abstract _not(input: ClassOperationInputType<any>): any;
+}
+export declare abstract class ClassOperationsClass<T> {
+    abstract _and: T[];
+    abstract _or: T[];
+    abstract _not: T[];
+}
+export declare abstract class FieldOperationsClass<T> {
+    abstract _and: T;
+    abstract _eq: T;
+    abstract _ne: T;
+    abstract _in: T[];
+    abstract _nin: T[];
+    abstract _gt: T;
+    abstract _gte: T;
+    abstract _lt: T;
+    abstract _lte: T;
+    abstract _like: T;
+    abstract _re: T;
+    abstract _ilike: T;
+    abstract _fulltext: T;
+    abstract _overlap: T[];
+    abstract _contains: T;
+    abstract _contained: T;
+    abstract _between: T[];
+    abstract _exists: T;
+}
+export declare const FieldOperations: {
+    _and: ([l]: string[], [_]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _eq: ([l, r]: string[], [_, rv]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _ne: ([l, r]: string[], [_, rv]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _in: ([l, r, ..._args]: string[], [_, ...values]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: {};
+    };
+    _nin: ([l, r, ..._args]: string[], [_, ...values]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: {};
+    };
+    _gt: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _gte: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _lt: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _lte: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _like: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _re: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _ilike: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _fulltext: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _overlap: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _contains: ([l, r, ..._args]: string[], [_, ...values]: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: {};
+    };
+    _contained: ([l, r]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _between: ([l, r1, r2]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+    _exists: ([l]: string[], []: Array<string | number | boolean | bigint | null>) => {
+        where: string;
+        value: undefined;
+    };
+};
+export type FieldOperationsType = typeof FieldOperations;

package/dist/src/operations.js

@@ -0,0 +1,81 @@
+export class ClassOperations {
+}
+export class ClassOperationsClass {
+}
+export class FieldOperationsClass {
+}
+export const FieldOperations = {
+    _and: ([l], [_]) => ({
+        where: `and (${l})`,
+        value: undefined,
+    }),
+    _eq: ([l, r], [_, rv]) => ({
+        where: `${l} ${rv !== null && rv !== 'null' ? `= ${r}` : 'is null'}`,
+        value: undefined,
+    }),
+    _ne: ([l, r], [_, rv]) => ({
+        where: `${l} ${rv !== null && rv !== 'null' ? `!= ${r}` : 'is not null'}`,
+        value: undefined,
+    }),
+    _in: ([l, r, ..._args], [_, ...values]) => ({
+        where: `${l} in (${values.map((_, i) => r + '__' + i).join(', ')})`,
+        value: values.reduce((acc, v, i) => ({ ...acc, [r.slice(1) + '__' + i]: v }), {}),
+    }),
+    _nin: ([l, r, ..._args], [_, ...values]) => ({
+        where: `${l} not in (${values.map((_, i) => r + '__' + i).join(', ')})`,
+        value: values.reduce((acc, v, i) => ({ ...acc, [r.slice(1) + '__' + i]: v }), {}),
+    }),
+    _gt: ([l, r], []) => ({
+        where: `${l} > ${r}`,
+        value: undefined,
+    }),
+    _gte: ([l, r], []) => ({
+        where: `${l} >= ${r}`,
+        value: undefined,
+    }),
+    _lt: ([l, r], []) => ({
+        where: `${l} < ${r}`,
+        value: undefined,
+    }),
+    _lte: ([l, r], []) => ({
+        where: `${l} <= ${r}`,
+        value: undefined,
+    }),
+    _like: ([l, r], []) => ({
+        where: `${l} like ${r}`,
+        value: undefined,
+    }),
+    _re: ([l, r], []) => ({
+        where: `${l} ~ ${r}`,
+        value: undefined,
+    }),
+    _ilike: ([l, r], []) => ({
+        where: `${l} ilike ${r}`,
+        value: undefined,
+    }),
+    _fulltext: ([l, r], []) => ({
+        where: `${l}::tsvector @@ ${r}::tsquery`,
+        value: undefined,
+    }),
+    _overlap: ([l, r], []) => ({
+        where: `ARRAY[${l}] && ARRAY[${r}]`,
+        value: undefined,
+    }),
+    // this is possibly not implemented correctly
+    _contains: ([l, r, ..._args], [_, ...values]) => ({
+        where: `ARRAY[${l}] @> ARRAY[${values.map((_, i) => r + '__' + i).join(', ')}]`,
+        value: values.reduce((acc, v, i) => ({ ...acc, [r.slice(1) + '__' + i]: v }), {}),
+    }),
+    _contained: ([l, r], []) => ({
+        where: `${l} contained ${r}`,
+        value: undefined,
+    }),
+    _between: ([l, r1, r2], []) => ({
+        where: `${l} between ${r1} and ${r2}`,
+        value: undefined,
+    }),
+    _exists: ([l], []) => ({
+        where: `exists ${l}`,
+        value: undefined,
+    }),
+};

package/dist/src/queries/alias.d.ts

@@ -0,0 +1,25 @@
+export declare enum AliasType {
+    entity = "entity",
+    field = "field",
+    value = "value"
+}
+export declare class Alias {
+    private type;
+    private index;
+    private prefix;
+    constructor(type: AliasType, index: number, prefix: string);
+    toString(): string;
+    toColumnName(value: string): string;
+    toParamName(childAlias: string | number): string;
+    concat(...text: string[]): string;
+    get pref(): string;
+}
+export declare class AliasManager {
+    private ALIAS_INDEX_MAP;
+    private checkMap;
+    resetAll(): void;
+    reset(type: AliasType, prefix: string): Alias;
+    restartFrom(type: AliasType, prefix: string, index: number): Alias;
+    start(prefix: string): Alias;
+    next(type: AliasType, prefix: string): Alias;
+}

package/dist/src/queries/alias.js

@@ -0,0 +1,66 @@
+import { logger } from '../variables';
+export var AliasType;
+(function (AliasType) {
+    AliasType["entity"] = "entity";
+    AliasType["field"] = "field";
+    AliasType["value"] = "value";
+})(AliasType || (AliasType = {}));
+export class Alias {
+    type;
+    index;
+    prefix;
+    constructor(type, index, prefix) {
+        this.type = type;
+        this.index = index;
+        this.prefix = prefix;
+    }
+    toString() {
+        return `${this.type[0]}_${this.prefix}${this.index}`;
+    }
+    toColumnName(value) {
+        return `${this.type[0]}_${this.prefix}${this.index}.${value}`;
+    }
+    toParamName(childAlias) {
+        return `${this.type[0]}_${this.prefix}${this.index}_${childAlias}`;
+    }
+    concat(...text) {
+        return `${text.join('')} - ${this.type[0]}_${this.prefix}${this.index}`;
+    }
+    get pref() {
+        return this.prefix;
+    }
+}
+export class AliasManager {
+    ALIAS_INDEX_MAP = new Map();
+    checkMap(type, prefix) {
+        if (!this.ALIAS_INDEX_MAP.has(type)) {
+            this.ALIAS_INDEX_MAP.set(type, new Map());
+        }
+        if (!this.ALIAS_INDEX_MAP.get(type)?.has(prefix)) {
+            this.ALIAS_INDEX_MAP.get(type)?.set(prefix, 0);
+        }
+    }
+    resetAll() {
+        this.ALIAS_INDEX_MAP.clear();
+    }
+    reset(type, prefix) {
+        return this.restartFrom(type, prefix, 1);
+    }
+    restartFrom(type, prefix, index) {
+        this.checkMap(type, prefix);
+        this.ALIAS_INDEX_MAP.get(type)?.set(prefix, index);
+        return new Alias(type, index, prefix);
+    }
+    start(prefix) {
+        return this.next(AliasType.entity, prefix);
+    }
+    next(type, prefix) {
+        this.checkMap(type, prefix);
+        const existingIndex = this.ALIAS_INDEX_MAP.get(type)?.get(prefix) ?? 0;
+        logger.log('AliasManager.next', type, prefix, existingIndex);
+        const index = existingIndex + 1;
+        this.ALIAS_INDEX_MAP.get(type)?.set(prefix, index);
+        // this will automatically pick the last index
+        return new Alias(type, index, prefix);
+    }
+}