@punks/backend-entity-manager 0.0.95 → 0.0.97

package/dist/cjs/types/__test__/entity/foo.d.ts

@@ -6,9 +6,9 @@ import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
 import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityManager } from "../../abstractions";
-import { FooDeleteParameters } from "../providers/typeorm/entity/foo";
 import { IEntitiesDeleteResult } from "../../abstractions/repository";
 import { EntitySerializer } from "../../base";
+import { FooDeleteParameters } from "../providers/typeorm/models/foo";
 export interface FooEntity {
     id: string;
     name: string;

package/dist/cjs/types/__test__/providers/typeorm/converter/foo.d.ts

@@ -0,0 +1,9 @@
+import { IEntityConverter } from "../../../../abstractions";
+import { FooEntity } from "../entity/foo";
+import { FooCreateInput, FooDto, FooListItemDto, FooUpdateInput } from "../models/foo";
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateInput, FooUpdateInput> {
+    toListItemDto(entity: FooEntity): FooListItemDto;
+    toEntityDto(entity: FooEntity): FooDto;
+    createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
+}

package/dist/cjs/types/__test__/providers/typeorm/entity/foo.d.ts

@@ -1,89 +1,7 @@
-import { DataSource, Repository, FindOptionsWhere } from "typeorm";
-import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
-import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
-import { EntityServiceLocator } from "../../../../providers/services";
-import { TypeOrmQueryBuilder } from "../../../../integrations/repository/typeorm";
-import { IEntitiesDeleteParameters } from "../../../../abstractions/commands";
-import { EntitySerializer } from "../../../../base";
 export declare class FooEntity {
     id: string;
     name: string;
     age: number;
+    enabled: boolean;
     updatedOn: Date;
 }
-export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooDeleteParameters, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
-export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
-    constructor(repository: Repository<FooEntity>);
-}
-export interface FooSearchFilters {
-    minAge?: number;
-    maxAge?: number;
-}
-export declare enum FooSorting {
-    Name = "Name",
-    Age = "Age"
-}
-export type FooCursor = number;
-export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
-    filters?: FooSearchFilters;
-}
-export interface FooSearchSortingField extends ISearchSortingField<FooSorting> {
-    field: FooSorting;
-    direction: SortDirection;
-}
-export interface FooQuerySorting extends ISearchSorting<FooSorting> {
-    fields: FooSearchSortingField[];
-}
-export interface FooDeleteParameters extends IEntitiesDeleteParameters<FooSorting> {
-    filters?: FooSearchFilters;
-    sorting?: FooQuerySorting;
-}
-export interface FooFacets {
-}
-export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, unknown> {
-    constructor(services: EntityServiceLocator<FooEntity, string>);
-    protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
-    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
-    private buildAgeWhereClause;
-    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
-}
-export interface FooDto {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-    updatedOn: Date;
-}
-export interface FooListItemDto {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export interface FooCreateInput {
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export interface FooUpdateInput {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateInput, FooUpdateInput> {
-    toListItemDto(entity: FooEntity): FooListItemDto;
-    toEntityDto(entity: FooEntity): FooDto;
-    createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
-    updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
-}
-export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
-    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
-}
-export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
-    useConverter?: boolean;
-}) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/cjs/types/__test__/providers/typeorm/init/foo.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from "typeorm";
+import { IEntityManagerServiceRoot } from "../../../../abstractions";
+import { FooEntity } from "../entity/foo";
+export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
+    useConverter?: boolean;
+}) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/cjs/types/__test__/providers/typeorm/manager/foo.d.ts

@@ -0,0 +1,4 @@
+import { IEntityManager } from "../../../../abstractions/manager";
+import { FooEntity } from "../entity/foo";
+import { FooCursor, FooDeleteParameters, FooFacets, FooSearchParameters, FooSorting } from "../models/foo";
+export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooDeleteParameters, FooSearchParameters, FooSorting, FooCursor, FooFacets>;

package/dist/cjs/types/__test__/providers/typeorm/models/foo.d.ts

@@ -0,0 +1,56 @@
+import { IEntitiesDeleteParameters, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
+import { BooleanFilter, NumericFilter, StringFilter } from "../../../../integrations/repository/typeorm/clause";
+export interface FooSearchFilters {
+    age?: NumericFilter;
+    name?: StringFilter;
+    enabled?: BooleanFilter;
+}
+export declare enum FooSorting {
+    Name = "Name",
+    Age = "Age"
+}
+export type FooCursor = number;
+export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
+    filters?: FooSearchFilters;
+}
+export interface FooSearchSortingField extends ISearchSortingField<FooSorting> {
+    field: FooSorting;
+    direction: SortDirection;
+}
+export interface FooQuerySorting extends ISearchSorting<FooSorting> {
+    fields: FooSearchSortingField[];
+}
+export interface FooDeleteParameters extends IEntitiesDeleteParameters<FooSorting> {
+    filters?: FooSearchFilters;
+    sorting?: FooQuerySorting;
+}
+export interface FooFacets {
+}
+export interface FooDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+    updatedOn: Date;
+}
+export interface FooListItemDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooCreateInput {
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooUpdateInput {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}

package/dist/cjs/types/__test__/providers/typeorm/queries/foo.d.ts

@@ -0,0 +1,12 @@
+import { FindOptionsWhere } from "typeorm";
+import { IAuthenticationContext } from "../../../../abstractions";
+import { TypeOrmQueryBuilder } from "../../../../integrations";
+import { EntityServiceLocator } from "../../../../providers/services";
+import { FooEntity } from "../entity/foo";
+import { FooFacets, FooSearchParameters, FooSorting } from "../models/foo";
+export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, unknown> {
+    constructor(services: EntityServiceLocator<FooEntity, string>);
+    protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
+}

package/dist/cjs/types/__test__/providers/typeorm/repository/foo.d.ts

@@ -0,0 +1,6 @@
+import { Repository } from "typeorm";
+import { TypeOrmRepository } from "../../../../integrations";
+import { FooEntity } from "../entity/foo";
+export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
+    constructor(repository: Repository<FooEntity>);
+}

package/dist/cjs/types/__test__/providers/typeorm/serializer/foo.d.ts

@@ -0,0 +1,6 @@
+import { EntitySerializerSheetDefinition } from "../../../../abstractions";
+import { EntitySerializer } from "../../../../base";
+import { FooEntity } from "../entity/foo";
+export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
+    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
+}

package/dist/cjs/types/integrations/repository/typeorm/clause.d.ts

@@ -0,0 +1,32 @@
+export type NumericFilter = {
+    in?: number[];
+    eq?: number;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+};
+export type StringFilter = {
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    in?: string[];
+    eq?: string;
+    like?: string;
+    ne?: string;
+    notIn?: string[];
+    notLike?: string;
+};
+export type BooleanFilter = {
+    eq?: boolean;
+    ne?: boolean;
+};
+export type DateFilter = {
+    in?: Date[];
+    eq?: Date;
+    gt?: Date;
+    gte?: Date;
+    lt?: Date;
+    lte?: Date;
+};

package/dist/cjs/types/integrations/repository/typeorm/queryBuilder.d.ts

@@ -5,9 +5,11 @@ import { QueryBuilderBase } from "../../../templates";
 import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
 import { IEntitiesDeleteResult } from "../../../abstractions/repository";
+import { QueryClauseBuilder } from "./queryClauseBuilder";
 export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
+    protected clause: QueryClauseBuilder;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
     exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
     count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;

package/dist/cjs/types/integrations/repository/typeorm/queryClauseBuilder.d.ts

@@ -0,0 +1,8 @@
+import { FindOperator } from "typeorm";
+import { BooleanFilter, DateFilter, NumericFilter, StringFilter } from "./clause";
+export declare class QueryClauseBuilder {
+    stringFilter(filter: StringFilter): FindOperator<string>;
+    numericFilter(filter: NumericFilter): FindOperator<number>;
+    dateFilter(filter: DateFilter): FindOperator<Date>;
+    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
+}

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import { STATIC_CONTEXT } from '@nestjs/core/injector/constants';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { JwtService, JwtModule } from '@nestjs/jwt';
 import { EventEmitter2, EventEmitterModule } from '@nestjs/event-emitter';
-import { In } from 'typeorm';
+import { MoreThanOrEqual, MoreThan, LessThanOrEqual, LessThan, In, Equal, Like, Not, And } from 'typeorm';
 import { ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
@@ -145,7 +145,7 @@ class EntitySerializer {
     }
     convertSheetRecord(record) {
         if (!record._type || record._type !== this.entityName) {
-            throw new Error(`Invalid record type ${record._type}`);
+            throw new Error(`Invalid record type ${record._type} -> record: \n${JSON.stringify(record)}`);
         }
         const definition = this.getDefinition();
         const entity = {};
@@ -21434,10 +21434,90 @@ class QueryBuilderBase {
     }
 }
 
+class QueryClauseBuilder {
+    stringFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        if (!!filter?.in) {
+            clauses.push(In(filter.in));
+        }
+        if (!!filter?.eq) {
+            clauses.push(Equal(filter.eq));
+        }
+        if (!!filter?.like) {
+            clauses.push(Like(filter.like.replaceAll("*", "%")));
+        }
+        if (!!filter?.ne) {
+            clauses.push(Not(Equal(filter.ne)));
+        }
+        if (!!filter?.notIn) {
+            clauses.push(Not(In(filter.notIn)));
+        }
+        if (!!filter?.notLike) {
+            clauses.push(Not(Like(filter.notLike.replaceAll("*", "%"))));
+        }
+        return And(...clauses);
+    }
+    numericFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        return And(...clauses);
+    }
+    dateFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        return And(...clauses);
+    }
+    boolFilter(filter) {
+        const clauses = [];
+        if (!isNullOrUndefined(filter?.eq)) {
+            clauses.push(Equal(filter.eq));
+        }
+        if (!isNullOrUndefined(filter?.ne)) {
+            clauses.push(Not(Equal(filter.ne)));
+        }
+        return And(...clauses);
+    }
+}
+
 class TypeOrmQueryBuilder extends QueryBuilderBase {
     constructor(services) {
         super();
         this.services = services;
+        this.clause = new QueryClauseBuilder();
     }
     async exists(filters, context) {
         return (await this.count(filters, context)) > 0;