nicot 1.2.4 → 1.2.6

package/dist/src/crud-base.d.ts

@@ -1,12 +1,14 @@
 import { CursorPaginationDto } from './dto';
-import { FindOptionsWhere, Repository, SelectQueryBuilder } from 'typeorm';
+import { FindOneOptions, FindOptionsWhere, Repository, SelectQueryBuilder } from 'typeorm';
 import { EntityHooks, PageSettingsDto, PageSettingsFactory, QueryWise } from './bases';
 import { ConsoleLogger } from '@nestjs/common';
-import { BlankReturnMessageDto, ClassType } from 'nesties';
+import { Awaitable, BlankReturnMessageDto, ClassType, GenericReturnMessageDto } from 'nesties';
 import { RelationDef } from './utility/relation-def';
+import { BindingValueMetadata } from './decorators';
 export type EntityId<T extends {
     id: any;
 }> = T['id'];
+type BindingSnapshot = Record<string, any>;
 export declare const Relation: (name: string, options?: Omit<RelationDef, "name">) => RelationDef;
 export declare const Inner: (name: string, options?: Omit<RelationDef, "name">) => RelationDef;
 export type ValidCrudEntity<T> = Record<string, any> & {
@@ -25,7 +27,7 @@ export declare class CrudBase<T extends ValidCrudEntity<T>> {
     repo: Repository<T>;
     crudOptions: CrudOptions<T>;
     readonly entityName: string;
-    readonly entityReturnMessageDto: new (statusCode: number, message: string, data: T) => import("nesties").GenericReturnMessageDto<T>;
+    readonly entityReturnMessageDto: new (statusCode: number, message: string, data: T) => GenericReturnMessageDto<T>;
     readonly importEntryDto: new () => {
         result: string;
         entry: T;
@@ -33,7 +35,7 @@ export declare class CrudBase<T extends ValidCrudEntity<T>> {
     readonly importReturnMessageDto: new (statusCode: number, message: string, data: {
         result: string;
         entry: T;
-    }[]) => import("nesties").GenericReturnMessageDto<{
+    }[]) => GenericReturnMessageDto<{
         result: string;
         entry: T;
     }[]>;
@@ -46,6 +48,19 @@ export declare class CrudBase<T extends ValidCrudEntity<T>> {
     constructor(entityClass: ClassType<T>, repo: Repository<T>, crudOptions: CrudOptions<T>);
     _cleanEntityNotInResultFields(ent: T): T;
     cleanEntityNotInResultFields<E extends T | T[]>(ents: E): E;
+    readonly _tmpBindingMap: Map<string, any>;
+    readonly _bindingCache: Map<string, BindingValueMetadata & {
+        field: string;
+    }>;
+    _lookForBindingValueField(bindingKey: string): BindingValueMetadata & {
+        field: string;
+    };
+    _resolveBindingValue<K extends keyof T>(entityField: K): T[K] | Promise<T[K]>;
+    getBindingPartialEntity(): Promise<Partial<T>>;
+    useBinding(value: any, bindngKey?: string): this;
+    _freezeBindings(): BindingSnapshot;
+    _restoreBindings(frozen: BindingSnapshot): this;
+    beforeSuper<R>(fn: () => Promise<R>): Promise<R>;
     _batchCreate(ents: T[], beforeCreate?: (repo: Repository<T>) => Promise<void>, skipErrors?: boolean): Promise<{
         results: T[];
         skipped: {
@@ -53,13 +68,14 @@ export declare class CrudBase<T extends ValidCrudEntity<T>> {
             entry: T;
         }[];
     }>;
-    create(_ent: T, beforeCreate?: (repo: Repository<T>) => Promise<void>): Promise<import("nesties").GenericReturnMessageDto<T>>;
+    create(_ent: T, beforeCreate?: (repo: Repository<T>) => Promise<void>): Promise<GenericReturnMessageDto<T>>;
     get entityAliasName(): string;
     _applyQueryRelation(qb: SelectQueryBuilder<T>, relation: RelationDef): void;
     _applyQueryRelations(qb: SelectQueryBuilder<T>): void;
     _applyQueryFilters(qb: SelectQueryBuilder<T>, ent: T): void;
     queryBuilder(): SelectQueryBuilder<T>;
-    findOne(id: EntityId<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<import("nesties").GenericReturnMessageDto<T>>;
+    _applyQueryFromBinding(bindingEnt: Partial<T>, qb: SelectQueryBuilder<T>): void;
+    findOne(id: EntityId<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<GenericReturnMessageDto<T>>;
     _preFindAll(ent?: Partial<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<{
         query: SelectQueryBuilder<T>;
         newEnt: T;
@@ -69,18 +85,22 @@ export declare class CrudBase<T extends ValidCrudEntity<T>> {
     findAllCursorPaginated(ent?: Partial<T & Partial<CursorPaginationDto>>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<import("./dto").GenericCursorPaginationReturnMessageDto<T>>;
     update(id: EntityId<T>, entPart: Partial<T>, cond?: FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
     delete(id: EntityId<T>, cond?: FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
-    importEntities(_ents: T[], extraChecking?: (ent: T) => string | Promise<string>): Promise<import("nesties").GenericReturnMessageDto<{
+    importEntities(_ents: T[], extraChecking?: (ent: T) => string | Promise<string>): Promise<GenericReturnMessageDto<{
         result: string;
         entry: T;
     }[]>>;
-    exists(id: EntityId<T>): Promise<boolean>;
+    exists(id: EntityId<T>, cond?: FindOptionsWhere<T>): Promise<boolean>;
+    operation<R>(id: EntityId<T>, cb: (ent: T, ctx: {
+        repo: Repository<T>;
+        flush: () => Promise<void>;
+    }) => Awaitable<R>, extraOptions?: FindOneOptions<T>): Promise<GenericReturnMessageDto<R>>;
     _loadFullTextIndex(): Promise<void>;
     onModuleInit(): Promise<void>;
 }
 export declare function CrudService<T extends ValidCrudEntity<T>>(entityClass: ClassType<T>, crudOptions?: CrudOptions<T>): {
     new (repo: Repository<T>): {
         readonly entityName: string;
-        readonly entityReturnMessageDto: new (statusCode: number, message: string, data: T) => import("nesties").GenericReturnMessageDto<T>;
+        readonly entityReturnMessageDto: new (statusCode: number, message: string, data: T) => GenericReturnMessageDto<T>;
         readonly importEntryDto: new () => {
             result: string;
             entry: T;
@@ -88,7 +108,7 @@ export declare function CrudService<T extends ValidCrudEntity<T>>(entityClass: C
         readonly importReturnMessageDto: new (statusCode: number, message: string, data: {
             result: string;
             entry: T;
-        }[]) => import("nesties").GenericReturnMessageDto<{
+        }[]) => GenericReturnMessageDto<{
             result: string;
             entry: T;
         }[]>;
@@ -103,6 +123,19 @@ export declare function CrudService<T extends ValidCrudEntity<T>>(entityClass: C
         crudOptions: CrudOptions<T>;
         _cleanEntityNotInResultFields(ent: T): T;
         cleanEntityNotInResultFields<E extends T | T[]>(ents: E): E;
+        readonly _tmpBindingMap: Map<string, any>;
+        readonly _bindingCache: Map<string, BindingValueMetadata & {
+            field: string;
+        }>;
+        _lookForBindingValueField(bindingKey: string): BindingValueMetadata & {
+            field: string;
+        };
+        _resolveBindingValue<K extends keyof T>(entityField: K): T[K] | Promise<T[K]>;
+        getBindingPartialEntity(): Promise<Partial<T>>;
+        useBinding(value: any, bindngKey?: string): /*elided*/ any;
+        _freezeBindings(): BindingSnapshot;
+        _restoreBindings(frozen: BindingSnapshot): /*elided*/ any;
+        beforeSuper<R>(fn: () => Promise<R>): Promise<R>;
         _batchCreate(ents: T[], beforeCreate?: (repo: Repository<T>) => Promise<void>, skipErrors?: boolean): Promise<{
             results: T[];
             skipped: {
@@ -110,13 +143,14 @@ export declare function CrudService<T extends ValidCrudEntity<T>>(entityClass: C
                 entry: T;
             }[];
         }>;
-        create(_ent: T, beforeCreate?: (repo: Repository<T>) => Promise<void>): Promise<import("nesties").GenericReturnMessageDto<T>>;
+        create(_ent: T, beforeCreate?: (repo: Repository<T>) => Promise<void>): Promise<GenericReturnMessageDto<T>>;
         readonly entityAliasName: string;
         _applyQueryRelation(qb: SelectQueryBuilder<T>, relation: RelationDef): void;
         _applyQueryRelations(qb: SelectQueryBuilder<T>): void;
         _applyQueryFilters(qb: SelectQueryBuilder<T>, ent: T): void;
         queryBuilder(): SelectQueryBuilder<T>;
-        findOne(id: EntityId<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<import("nesties").GenericReturnMessageDto<T>>;
+        _applyQueryFromBinding(bindingEnt: Partial<T>, qb: SelectQueryBuilder<T>): void;
+        findOne(id: EntityId<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<GenericReturnMessageDto<T>>;
         _preFindAll(ent?: Partial<T>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<{
             query: SelectQueryBuilder<T>;
             newEnt: T;
@@ -126,12 +160,17 @@ export declare function CrudService<T extends ValidCrudEntity<T>>(entityClass: C
         findAllCursorPaginated(ent?: Partial<T & Partial<CursorPaginationDto>>, extraQuery?: (qb: SelectQueryBuilder<T>) => void): Promise<import("./dto").GenericCursorPaginationReturnMessageDto<T>>;
         update(id: EntityId<T>, entPart: Partial<T>, cond?: FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
         delete(id: EntityId<T>, cond?: FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
-        importEntities(_ents: T[], extraChecking?: (ent: T) => string | Promise<string>): Promise<import("nesties").GenericReturnMessageDto<{
+        importEntities(_ents: T[], extraChecking?: (ent: T) => string | Promise<string>): Promise<GenericReturnMessageDto<{
             result: string;
             entry: T;
         }[]>>;
-        exists(id: EntityId<T>): Promise<boolean>;
+        exists(id: EntityId<T>, cond?: FindOptionsWhere<T>): Promise<boolean>;
+        operation<R>(id: EntityId<T>, cb: (ent: T, ctx: {
+            repo: Repository<T>;
+            flush: () => Promise<void>;
+        }) => Awaitable<R>, extraOptions?: FindOneOptions<T>): Promise<GenericReturnMessageDto<R>>;
         _loadFullTextIndex(): Promise<void>;
         onModuleInit(): Promise<void>;
     };
 };
+export {};

package/dist/src/decorators/binding.d.ts

@@ -0,0 +1,7 @@
+export interface BindingValueMetadata {
+    bindingKey: string;
+    isMethod: boolean;
+}
+export declare const DefaultBindingKey = "default";
+export declare const BindingColumn: (bindingKey?: string) => PropertyDecorator;
+export declare const BindingValue: (bindingKey?: string) => PropertyDecorator & MethodDecorator;

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

@@ -3,3 +3,4 @@ export * from './property';
 export * from './pipes';
 export * from './query';
 export * from './get-mutator';
+export * from './binding';

package/dist/src/restful.d.ts

@@ -1,4 +1,4 @@
-import { AnyClass, BlankReturnMessageDto, ClassType } from 'nesties';
+import { AnyClass, ClassType } from 'nesties';
 import { OperationObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
 import { CrudBase, CrudOptions } from './crud-base';
 import { PageSettingsDto } from './bases';
@@ -26,7 +26,18 @@ export declare class RestfulFactory<T extends {
     private options;
     private __resolveVisited;
     constructor(entityClass: ClassType<T>, options?: RestfulFactoryOptions<T, O, W, C, U, F, R>, __resolveVisited?: Map<AnyClass, [AnyClass]>);
-    private getEntityClassName;
+    omitInput<K extends keyof T>(...fields: K[]): RestfulFactory<T, O | K, W, C, U, F, R>;
+    omitWrite<K extends keyof T>(...fields: K[]): RestfulFactory<T, O, W | K, C, U, F, R>;
+    omitCreate<K extends keyof T>(...fields: K[]): RestfulFactory<T, O, W, C | K, U, F, R>;
+    omitUpdate<K extends keyof T>(...fields: K[]): RestfulFactory<T, O, W, C, U | K, F, R>;
+    omitFindAll<K extends keyof T>(...fields: K[]): RestfulFactory<T, O, W, C, U, F | K, R>;
+    omitOutput<K extends keyof T>(...fields: K[]): RestfulFactory<T, O, W, C, U, F, R | K>;
+    pathPrefix(prefix: string): RestfulFactory<T, O, W, C, U, F, R>;
+    keepEntityVersioningDates(enable?: boolean): RestfulFactory<T, O, W, C, U, F, R>;
+    skipNonQueryableFields(enable?: boolean): RestfulFactory<T, O, W, C, U, F, R>;
+    renameEntityClass(name: string): RestfulFactory<T, O, W, C, U, F, R>;
+    useRelations(...relations: (string | RelationDef)[]): RestfulFactory<T, O, W, C, U, F, R>;
+    get entityClassName(): string;
     get fieldsToOmit(): (keyof T)[];
     get fieldsInCreateToOmit(): (keyof T)[];
     get createDto(): ClassType<Omit<T, O | W | C>>;
@@ -66,6 +77,10 @@ export declare class RestfulFactory<T extends {
     updateParam(): ParameterDecorator;
     delete(extras?: Partial<OperationObject>): MethodDecorator;
     import(extras?: Partial<OperationObject>): MethodDecorator;
+    operation(operationName: string, options?: {
+        returnType?: AnyClass;
+        operationExtras?: Partial<OperationObject>;
+    }): MethodDecorator;
     baseController<Options extends Partial<{
         paginateType: RestfulPaginateType;
         globalMethodDecorators: MethodDecorator[];
@@ -108,6 +123,23 @@ export declare class RestfulFactory<T extends {
             crudOptions: CrudOptions<T>;
             _cleanEntityNotInResultFields(ent: T): T;
             cleanEntityNotInResultFields<E extends T | T[]>(ents: E): E;
+            readonly _tmpBindingMap: Map<string, any>;
+            readonly _bindingCache: Map<string, import("./decorators").BindingValueMetadata & {
+                field: string;
+            }>;
+            _lookForBindingValueField(bindingKey: string): import("./decorators").BindingValueMetadata & {
+                field: string;
+            };
+            _resolveBindingValue<K extends keyof T>(entityField: K): T[K] | Promise<T[K]>;
+            getBindingPartialEntity(): Promise<Partial<T>>;
+            useBinding(value: any, bindngKey?: string): /*elided*/ any;
+            _freezeBindings(): {
+                [x: string]: any;
+            };
+            _restoreBindings(frozen: {
+                [x: string]: any;
+            }): /*elided*/ any;
+            beforeSuper<R_1>(fn: () => Promise<R_1>): Promise<R_1>;
             _batchCreate(ents: T[], beforeCreate?: (repo: Repository<T>) => Promise<void>, skipErrors?: boolean): Promise<{
                 results: T[];
                 skipped: {
@@ -121,6 +153,7 @@ export declare class RestfulFactory<T extends {
             _applyQueryRelations(qb: import("typeorm").SelectQueryBuilder<T>): void;
             _applyQueryFilters(qb: import("typeorm").SelectQueryBuilder<T>, ent: T): void;
             queryBuilder(): import("typeorm").SelectQueryBuilder<T>;
+            _applyQueryFromBinding(bindingEnt: Partial<T>, qb: import("typeorm").SelectQueryBuilder<T>): void;
             findOne(id: import("./crud-base").EntityId<T>, extraQuery?: (qb: import("typeorm").SelectQueryBuilder<T>) => void): Promise<import("nesties").GenericReturnMessageDto<T>>;
             _preFindAll(ent?: Partial<T>, extraQuery?: (qb: import("typeorm").SelectQueryBuilder<T>) => void): Promise<{
                 query: import("typeorm").SelectQueryBuilder<T>;
@@ -129,13 +162,17 @@ export declare class RestfulFactory<T extends {
             }>;
             findAll(ent?: Partial<T>, extraQuery?: (qb: import("typeorm").SelectQueryBuilder<T>) => void): Promise<import("nesties").GenericPaginatedReturnMessageDto<T>>;
             findAllCursorPaginated(ent?: Partial<T & Partial<CursorPaginationDto>>, extraQuery?: (qb: import("typeorm").SelectQueryBuilder<T>) => void): Promise<import("./dto").GenericCursorPaginationReturnMessageDto<T>>;
-            update(id: import("./crud-base").EntityId<T>, entPart: Partial<T>, cond?: import("typeorm").FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
-            delete(id: import("./crud-base").EntityId<T>, cond?: import("typeorm").FindOptionsWhere<T>): Promise<BlankReturnMessageDto>;
+            update(id: import("./crud-base").EntityId<T>, entPart: Partial<T>, cond?: import("typeorm").FindOptionsWhere<T>): Promise<import("nesties").BlankReturnMessageDto>;
+            delete(id: import("./crud-base").EntityId<T>, cond?: import("typeorm").FindOptionsWhere<T>): Promise<import("nesties").BlankReturnMessageDto>;
             importEntities(_ents: T[], extraChecking?: (ent: T) => string | Promise<string>): Promise<import("nesties").GenericReturnMessageDto<{
                 result: string;
                 entry: T;
             }[]>>;
-            exists(id: import("./crud-base").EntityId<T>): Promise<boolean>;
+            exists(id: import("./crud-base").EntityId<T>, cond?: import("typeorm").FindOptionsWhere<T>): Promise<boolean>;
+            operation<R_1>(id: import("./crud-base").EntityId<T>, cb: (ent: T, ctx: {
+                repo: Repository<T>;
+                flush: () => Promise<void>;
+            }) => import("nesties").Awaitable<R_1>, extraOptions?: import("typeorm").FindOneOptions<T>): Promise<import("nesties").GenericReturnMessageDto<R_1>>;
             _loadFullTextIndex(): Promise<void>;
             onModuleInit(): Promise<void>;
         };

package/dist/src/utility/metadata.d.ts

@@ -3,6 +3,7 @@ import { QueryCond } from '../bases';
 import { AnyClass } from 'nesties';
 import { QueryFullTextColumnOptions } from './query-full-text-column-options.interface';
 import { GetMutatorOptions } from '../decorators/get-mutator';
+import { BindingValueMetadata } from '../decorators/binding';
 interface SpecificFields {
     notColumn: {
         keepInCreate?: boolean;
@@ -23,6 +24,8 @@ interface SpecificFields {
     queryCondition: QueryCond;
     requireGetMutator: boolean;
     getMutator: GetMutatorOptions;
+    bindingColumn: string;
+    bindingValue: BindingValueMetadata;
 }
 type MetadataMap = SpecificFields;
 type FieldsMap = {

package/dist/src/utility/observe-diff.d.ts

@@ -0,0 +1,6 @@
+export declare const observeDiff: <T>(obj: T, cb: <K extends keyof T>(change: {
+    type: "add" | "update" | "delete";
+    key: K;
+    oldValue: T[K] | undefined;
+    newValue: T[K] | undefined;
+}) => any) => T;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nicot",
   "description": "Nest.js interacting with class-validator + OpenAPI + TypeORM for Nest.js Restful API development.",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",