@smartsoft001/models 2.45.0 → 2.47.0

package/.eslintrc.json

@@ -15,16 +15,9 @@
       "rules": {}
     },
     {
-      "files": ["*.json"],
+      "files": "package.json",
       "parser": "jsonc-eslint-parser",
-      "rules": {
-        "@nx/dependency-checks": [
-          "error",
-          {
-            "ignoredFiles": ["{projectRoot}/esbuild.config.{js,ts,mjs,mts}"]
-          }
-        ]
-      }
+      "rules": {}
     }
   ]
 }

package/README.md

@@ -1,11 +1,28 @@
-# models
+## Decorators
+### @Model Decorator
+Used to annotate a class as a "model," adding metadata and a custom toJSON method. This method serializes the instance 
+into JSON format, including fields marked with specific metadata. Associates the model with metadata (IModelOptions) 
+using reflection, allowing for dynamic handling of models at runtime.
 
-This library was generated with [Nx](https://nx.dev).
+### @Field Decorator
+Used to annotate properties of a model class, providing additional metadata (IFieldOptions) such as field type, 
+requirements, and custom behavior for serialization or validation. Defines how properties should be accessed, mutated, 
+and serialized, including special handling for arrays and specific types.
 
-## Building
+## Utility Functions
+### Metadata Retrieval
+Functions like **getModelFieldKeys**, **getModelFieldOptions**, **getModelFieldsWithOptions**, and **getModelOptions**
+are used to retrieve metadata about models and their fields. This enables dynamic inspection and manipulation of models.
 
-Run `nx build models` to build the library.
+### Model Validation
+**getInvalidFields** - Checks for fields that have invalid values based on specified rules 
+(such as being required during "create" or "update" operations) and permissions. This is useful for form validation or 
+API input validation.
 
-## Running unit tests
+### Model Casting
+**castModel** - Adjusts an instance of a model by removing fields that do not conform to the specified mode 
+("create", "update") or the provided permissions. This ensures the instance is valid and adheres to the constraints
+defined by the model's metadata.
 
-Run `nx test models` to execute the unit tests via [Jest](https://jestjs.io).
+### Model Check
+**isModel** - Determines if an object is a model decorated with the @Model decorator.

package/package.json

@@ -4,9 +4,9 @@
   "dependencies": {
     "reflect-metadata": "^0.2.1",
     "rxjs": "^7.8.1",
-    "@smartsoft001/utils": "^2.45.0"
+    "@smartsoft001/utils": "^2.47.0"
   },
-  "version": "2.45.0",
+  "version": "2.47.0",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts"
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from "./lib/symbols";
+export * from './lib/symbols';
 export * from './lib/interfaces';
 export * from './lib/decorators';
 

package/src/lib/decorators/field/field.decorator.ts

@@ -1,55 +1,57 @@
 import 'reflect-metadata';
 
-import {ObjectService} from "@smartsoft001/utils";
+import { ObjectService } from '@smartsoft001/utils';
 
-import * as symbols from "../../symbols";
-import {FieldType, IFieldOptions} from "../../interfaces";
+import { FieldType, IFieldOptions } from '../../interfaces';
+import * as symbols from '../../symbols';
 
 export const Field = FieldDecorator;
 export function FieldDecorator(options?: IFieldOptions) {
-    return <T>(target: T, key: string) => {
-
-        options = options ? { ...options } : {};
-
-        if (!(target as any).constructor['__fields']) {
-            (target as any).constructor['__fields'] = {};
-        }
-
-        (target as any).constructor['__fields'][key] = true;
-
-        if (!options.type && key === 'password') {
-            options.type = FieldType.password;
-        } else if (!options.type) {
-            options.type = FieldType.text;
-        }
-
-        if (options.classType) {
-            (target as any)['_' + key] = (target as any)[key];
-            delete (target as any)[key];
-
-            Object.defineProperty(target, key, {
-               get: function () {
-                   if (!this['_' + key] && options?.type === FieldType.array) {
-                       this['_' + key] = [];
-                   }
-                   return this['_' + key];
-               },
-                set: function (v: any) {
-                    this['_' + key] = options?.type === FieldType.array && v ?
-                        v.map((i: any) => ObjectService.createByType(i, options?.classType))
-                        : ObjectService.createByType(v, options?.classType);
-                },
-                enumerable: true,
-                configurable: true
-            });
-
-            if (!(target as any).constructor['__properties']) {
-                (target as any).constructor['__properties'] = {};
-            }
-
-            (target as any).constructor['__properties'][key] = true;
-        }
-
-        Reflect.defineMetadata(symbols.SYMBOL_FIELD, options, target as any, key);
+  return <T>(target: T, key: string) => {
+    options = options ? { ...options } : {};
+
+    if (!(target as any).constructor['__fields']) {
+      (target as any).constructor['__fields'] = {};
+    }
+
+    (target as any).constructor['__fields'][key] = true;
+
+    if (!options.type && key === 'password') {
+      options.type = FieldType.password;
+    } else if (!options.type) {
+      options.type = FieldType.text;
     }
+
+    if (options.classType) {
+      (target as any)['_' + key] = (target as any)[key];
+      delete (target as any)[key];
+
+      Object.defineProperty(target, key, {
+        get: function () {
+          if (!this['_' + key] && options?.type === FieldType.array) {
+            this['_' + key] = [];
+          }
+          return this['_' + key];
+        },
+        set: function (v: any) {
+          this['_' + key] =
+            options?.type === FieldType.array && v
+              ? v.map((i: any) =>
+                  ObjectService.createByType(i, options?.classType),
+                )
+              : ObjectService.createByType(v, options?.classType);
+        },
+        enumerable: true,
+        configurable: true,
+      });
+
+      if (!(target as any).constructor['__properties']) {
+        (target as any).constructor['__properties'] = {};
+      }
+
+      (target as any).constructor['__properties'][key] = true;
+    }
+
+    Reflect.defineMetadata(symbols.SYMBOL_FIELD, options, target as any, key);
+  };
 }

package/src/lib/decorators/model/model.decorator.ts

@@ -1,11 +1,11 @@
 import 'reflect-metadata';
 
-import * as symbols from "../../symbols";
-import {IModelOptions} from "../../interfaces";
+import { IModelOptions } from '../../interfaces';
+import * as symbols from '../../symbols';
 
 export const Model = ModelDecorator;
 export function ModelDecorator(options?: IModelOptions) {
-  return function<T>(target: any) {
+  return function <T>(target: any) {
     options = options ? { ...options } : {};
 
     Reflect.defineMetadata(symbols.SYMBOL_MODEL, options, target);
@@ -14,12 +14,12 @@ export function ModelDecorator(options?: IModelOptions) {
       const result = { ...this };
 
       if (this.constructor['__properties']) {
-        Object.keys(this.constructor['__properties']).forEach(protoKey => {
+        Object.keys(this.constructor['__properties']).forEach((protoKey) => {
           result[protoKey] = this['_' + protoKey];
         });
       }
 
       return result;
     };
-  }
+  };
 }

package/src/lib/interfaces.ts

@@ -1,152 +1,154 @@
-import {Observable} from "rxjs";
+import { Observable } from 'rxjs';
 
 export enum FieldTypeDef {
-    address = "address",
-    currency = "currency",
-    date = "date",
-    dateTime = "dateTime",
-    dateWithEdit = "dateWithEdit",
-    email = "email",
-    enum = "enum",
-    file = "file",
-    flag = "flag",
-    int = "int",
-    nip = "nip",
-    object = "object",
-    array = "array",
-    password = "password",
-    radio = "radio",
-    text = "text",
-    strings = "strings",
-    ints = "ints",
-    longText = "longText",
-    color = "color",
-    logo = "logo",
-    check = "check",
-    phoneNumber = "phoneNumber",
-    phoneNumberPl = "phoneNumberPl",
-    pesel = "pesel",
-    pdf = "pdf",
-    video = "video",
-    attachment = "attachment",
-    dateRange = "dateRange",
-    image = "image",
-    float = "float"
+  address = 'address',
+  currency = 'currency',
+  date = 'date',
+  dateTime = 'dateTime',
+  dateWithEdit = 'dateWithEdit',
+  email = 'email',
+  enum = 'enum',
+  file = 'file',
+  flag = 'flag',
+  int = 'int',
+  nip = 'nip',
+  object = 'object',
+  array = 'array',
+  password = 'password',
+  radio = 'radio',
+  text = 'text',
+  strings = 'strings',
+  ints = 'ints',
+  longText = 'longText',
+  color = 'color',
+  logo = 'logo',
+  check = 'check',
+  phoneNumber = 'phoneNumber',
+  phoneNumberPl = 'phoneNumberPl',
+  pesel = 'pesel',
+  pdf = 'pdf',
+  video = 'video',
+  attachment = 'attachment',
+  dateRange = 'dateRange',
+  image = 'image',
+  float = 'float',
 }
 export const FieldType: typeof FieldTypeDef = FieldTypeDef;
 
 export interface ISpecification {
-    readonly criteria: any;
+  readonly criteria: any;
 }
 
 export interface IModelFilter {
-    label?: string;
-    fieldType?: FieldTypeDef;
-    key: string;
-    type: '=' | '!=' | '>=' | '<=' | '<' | '>' | '~=';
-    possibilities$?: Observable<{ id: any, text: string }[]>;
+  label?: string;
+  fieldType?: FieldTypeDef;
+  key: string;
+  type: '=' | '!=' | '>=' | '<=' | '<' | '>' | '~=';
+  possibilities$?: Observable<{ id: any; text: string }[]>;
 }
 
 export interface IModelStep {
-    number: number;
-    name: string;
+  number: number;
+  name: string;
 }
 
 export interface IModelMetadata {
-    titleKey?: string;
-    permissions?: Array<string>;
-    filters?: Array<IModelFilter>;
+  titleKey?: string;
+  permissions?: Array<string>;
+  filters?: Array<IModelFilter>;
 }
 
 export interface IFieldMetadata extends IFieldModifyMetadata {
-    type?: FieldTypeDef;
-    classType?: any;
-    possibilities?: Array<any> | any;
+  type?: FieldTypeDef;
+  classType?: any;
+  possibilities?: Array<any> | any;
 }
 
 export interface IFieldModifyMetadata {
-    required?: boolean;
-    focused?: boolean;
-    confirm?: boolean;
-    permissions?: Array<string>;
-    unique?: boolean | IFieldUniqueMetadata;
-    defaltValue?: () => any;
-    enabled?: ISpecification;
-    hide?: boolean;
-    /**
-     * @desc - Model step configuration
-     */
-    step?: IModelStep;
+  required?: boolean;
+  focused?: boolean;
+  confirm?: boolean;
+  permissions?: Array<string>;
+  unique?: boolean | IFieldUniqueMetadata;
+  defaltValue?: () => any;
+  enabled?: ISpecification;
+  hide?: boolean;
+  /**
+   * @desc - Model step configuration
+   */
+  step?: IModelStep;
 }
 
 export interface IFieldEditMetadata extends IFieldModifyMetadata {
-    multi?: boolean;
+  multi?: boolean;
 }
 
 export interface IFieldListMetadata {
-    order?: number;
-    filter?: boolean;
-    permissions?: Array<string>;
-    /**
-     * Configuration for dynamic list table data
-     * @param {string} dynamic.headerKey - column header object key
-     * @param {string} dynamic.rowKey - column row value object key
-     */
-    dynamic?: { headerKey: string, rowKey: string }
+  order?: number;
+  filter?: boolean;
+  permissions?: Array<string>;
+  /**
+   * Configuration for dynamic list table data
+   * @param {string} dynamic.headerKey - column header object key
+   * @param {string} dynamic.rowKey - column row value object key
+   */
+  dynamic?: { headerKey: string; rowKey: string };
 }
 
 export interface IFieldDetailsMetadata {
-    order?: number;
-    permissions?: Array<string>;
-    enabled?: ISpecification;
+  order?: number;
+  permissions?: Array<string>;
+  enabled?: ISpecification;
 }
 
 export interface IModelOptions {
-    titleKey?: string;
-    filters?: Array<IModelFilter>;
-    create?: IModelModeOptions;
-    update?: IModelModeOptions;
-    list?: IModelModeOptions;
-    details?: IModelModeOptions;
-    remove?: IModelModeOptions;
-    customs?: Array<IModelModeOptionsCustom>;
-    /**
-     * @desc - Allow export field data
-     */
-    export?: boolean;
-    /**
-     * @desc - Allow import field data
-     */
-    import?: boolean;
+  titleKey?: string;
+  filters?: Array<IModelFilter>;
+  create?: IModelModeOptions;
+  update?: IModelModeOptions;
+  list?: IModelModeOptions;
+  details?: IModelModeOptions;
+  remove?: IModelModeOptions;
+  customs?: Array<IModelModeOptionsCustom>;
+  /**
+   * @desc - Allow export field data
+   */
+  export?: boolean;
+  /**
+   * @desc - Allow import field data
+   */
+  import?: boolean;
 }
 
 export interface IModelModeOptions {
-    permissions?: Array<string>;
-    enabled?: ISpecification;
+  permissions?: Array<string>;
+  enabled?: ISpecification;
 }
 
 export interface IModelModeOptionsCustom extends IModelModeOptions {
-    mode: string;
+  mode: string;
 }
 
 export interface IFieldOptions extends IFieldMetadata {
-    create?: IFieldModifyMetadata | boolean;
-    update?: IFieldEditMetadata | boolean;
-    list?: IFieldListMetadata | boolean;
-    details?: IFieldDetailsMetadata | boolean;
-    customs?: Array<IModelMetadataCustom>;
-    search?: boolean;
-    info?: string;
+  create?: IFieldModifyMetadata | boolean;
+  update?: IFieldEditMetadata | boolean;
+  list?: IFieldListMetadata | boolean;
+  details?: IFieldDetailsMetadata | boolean;
+  customs?: Array<IModelMetadataCustom>;
+  search?: boolean;
+  info?: string;
 }
 
 export interface IModelMetadataCustom extends IModelMetadata {
-    mode: string
+  mode: string;
 }
 
 export interface IFieldUniqueMetadata {
-    withFields?: Array<string>;
+  withFields?: Array<string>;
 }
 
-export interface IFieldCustomMetadata extends IFieldModifyMetadata, IFieldListMetadata {
-    mode: string;
+export interface IFieldCustomMetadata
+  extends IFieldModifyMetadata,
+    IFieldListMetadata {
+  mode: string;
 }

package/src/lib/utils.spec.ts

@@ -1,137 +1,151 @@
-import {Model} from "./decorators/model/model.decorator";
-import {Field} from "./decorators/field/field.decorator";
-import {castModel, getInvalidFields, getModelFieldKeys, getModelFieldOptions, isModel} from "./utils";
-import {FieldType} from "./interfaces";
+import { Field } from './decorators/field/field.decorator';
+import { Model } from './decorators/model/model.decorator';
+import { FieldType } from './interfaces';
+import {
+  castModel,
+  getInvalidFields,
+  getModelFieldKeys,
+  getModelFieldOptions,
+  isModel,
+} from './utils';
 
 describe('shared-models: utils', () => {
-    describe('getModelFieldKeys()', () => {
-        it('should return empty array when fields is not defined', () => {
-            @Model({})
-            class Test {
-            }
+  describe('getModelFieldKeys()', () => {
+    it('should return empty array when fields is not defined', () => {
+      @Model({})
+      class Test {}
 
-            const result = getModelFieldKeys(Test);
+      const result = getModelFieldKeys(Test);
 
-            expect(result).toStrictEqual([ ]);
-        });
+      expect(result).toStrictEqual([]);
+    });
 
-        it('should return field keys array', () => {
-            @Model({})
-            class Test {
-                @Field({}) test1!: any;
-                @Field({}) test2!: any;
-                @Field({}) test3!: any;
-            }
+    it('should return field keys array', () => {
+      @Model({})
+      class Test {
+        @Field({}) test1!: any;
+        @Field({}) test2!: any;
+        @Field({}) test3!: any;
+      }
 
-            const result = getModelFieldKeys(Test);
+      const result = getModelFieldKeys(Test);
 
-            expect(result).toStrictEqual([ 'test1', 'test2', 'test3' ]);
-        });
+      expect(result).toStrictEqual(['test1', 'test2', 'test3']);
     });
+  });
 
-    describe('getModelFieldOptions', () => {
-       it('should return options', () => {
-           const options = { required: true, type: FieldType.password };
+  describe('getModelFieldOptions', () => {
+    it('should return options', () => {
+      const options = { required: true, type: FieldType.password };
 
-           @Model({})
-           class Test {
-               @Field(options) test!: string;
-           }
+      @Model({})
+      class Test {
+        @Field(options) test!: string;
+      }
 
-           expect(getModelFieldOptions(new Test(), 'test')).toStrictEqual(options);
-       });
+      expect(getModelFieldOptions(new Test(), 'test')).toStrictEqual(options);
     });
+  });
 
-    describe('isModel', () => {
-        it('should return true when model type', () => {
-            @Model({})
-            class Test {
-                @Field({}) test!: string;
-            }
+  describe('isModel', () => {
+    it('should return true when model type', () => {
+      @Model({})
+      class Test {
+        @Field({}) test!: string;
+      }
 
-            expect(isModel(new Test())).toBe(true);
-        });
+      expect(isModel(new Test())).toBe(true);
+    });
 
-        it('should return false when other type', () => {
-            expect(isModel(new Date())).toBe(false);
-        });
+    it('should return false when other type', () => {
+      expect(isModel(new Date())).toBe(false);
+    });
+  });
+
+  describe('getInvalidFields', () => {
+    it('should return empty array when correct', () => {
+      @Model({})
+      class Test {
+        @Field({}) test!: string;
+        @Field({
+          required: true,
+        })
+        test2!: string;
+        @Field({
+          create: {
+            required: true,
+          },
+        })
+        test3!: string;
+        @Field({
+          create: {
+            required: false,
+          },
+        })
+        test4!: string;
+      }
+
+      const instance = new Test();
+      instance.test2 = '12';
+      instance.test3 = '21';
+
+      expect(getInvalidFields(instance, 'create', null as any).length).toBe(0);
     });
 
-    describe('getInvalidFields', () => {
-        it('should return empty array when correct', () => {
-            @Model({})
-            class Test {
-                @Field({}) test!: string;
-                @Field({
-                    required: true
-                }) test2!: string;
-                @Field({
-                    create: {
-                        required: true
-                    }
-                }) test3!: string;
-                @Field({
-                    create: {
-                        required: false
-                    }
-                }) test4!: string;
-            }
-
-            const instance = new Test();
-            instance.test2 = "12";
-            instance.test3 = "21";
-
-            expect(getInvalidFields(instance, 'create', null as any).length).toBe(0);
-        });
-
-        it('should return array when incorrect', () => {
-            @Model({})
-            class Test {
-                @Field({}) test!: string;
-                @Field({
-                    required: true
-                }) test2!: string;
-                @Field({
-                    create: {
-                        required: true
-                    }
-                }) test3!: string;
-                @Field({
-                    create: {
-                        required: false
-                    }
-                }) test4!: string;
-            }
-
-            const instance = new Test();
-            instance.test2 = "12";
-
-            expect(getInvalidFields(instance, 'create', null as any).length).toBe(1);
-        });
-
-        it('should return empty array when not model', () => {
-            expect(getInvalidFields(new Date(), 'create', null as any).length).toBe(0);
-        });
+    it('should return array when incorrect', () => {
+      @Model({})
+      class Test {
+        @Field({}) test!: string;
+        @Field({
+          required: true,
+        })
+        test2!: string;
+        @Field({
+          create: {
+            required: true,
+          },
+        })
+        test3!: string;
+        @Field({
+          create: {
+            required: false,
+          },
+        })
+        test4!: string;
+      }
+
+      const instance = new Test();
+      instance.test2 = '12';
+
+      expect(getInvalidFields(instance, 'create', null as any).length).toBe(1);
     });
 
-    describe('castModel', () => {
-        it('should remove unused fields', () => {
-            @Model({})
-            class Test {
-                @Field({}) test!: string;
-                @Field({
-                    create: true
-                }) test2!: string;
-            }
-
-            const instance = new Test();
-            instance.test = "asd";
-            instance.test2 = "aaa";
-
-            castModel(instance, 'create', null as any);
-
-            expect(instance.test).not.toBeDefined();
-            expect(instance.test2).toBeDefined();
-        });
+    it('should return empty array when not model', () => {
+      expect(getInvalidFields(new Date(), 'create', null as any).length).toBe(
+        0,
+      );
+    });
+  });
+
+  describe('castModel', () => {
+    it('should remove unused fields', () => {
+      @Model({})
+      class Test {
+        @Field({}) test!: string;
+        @Field({
+          create: true,
+        })
+        test2!: string;
+      }
+
+      const instance = new Test();
+      instance.test = 'asd';
+      instance.test2 = 'aaa';
+
+      castModel(instance, 'create', null as any);
+
+      expect(instance.test).not.toBeDefined();
+      expect(instance.test2).toBeDefined();
     });
+  });
 });

package/src/lib/utils.ts

@@ -1,20 +1,20 @@
-import { IFieldOptions, IModelOptions } from "./interfaces";
-import { SYMBOL_FIELD, SYMBOL_MODEL } from "./symbols";
+import { IFieldOptions, IModelOptions } from './interfaces';
+import { SYMBOL_FIELD, SYMBOL_MODEL } from './symbols';
 
 export function getModelFieldKeys<T>(type: T): Array<string> {
-  if (!(type as any)["__fields"]) return [];
-  return Object.keys((type as any)["__fields"]);
+  if (!(type as any)['__fields']) return [];
+  return Object.keys((type as any)['__fields']);
 }
 
 export function getModelFieldOptions<T>(
   instance: T,
-  fieldKey: string
+  fieldKey: string,
 ): IFieldOptions {
   return Reflect.getMetadata(SYMBOL_FIELD, instance as any, fieldKey);
 }
 
 export function getModelFieldsWithOptions<T>(
-  instance: T
+  instance: T,
 ): Array<{ key: string; options: IFieldOptions }> {
   const keys = getModelFieldKeys((instance as any).constructor);
 
@@ -37,8 +37,8 @@ export function isModel<T>(instance: T): boolean {
 
 export function getInvalidFields<T>(
   instance: T,
-  mode: "create" | "update" | string,
-  permissions: Array<string>
+  mode: 'create' | 'update' | string,
+  permissions: Array<string>,
 ): Array<string> {
   const result: any[] = [];
 
@@ -46,7 +46,7 @@ export function getInvalidFields<T>(
     let required = options.required;
 
     if (
-      (mode === "create" || mode === "update") &&
+      (mode === 'create' || mode === 'update') &&
       options[mode] &&
       options[mode]?.constructor
     ) {
@@ -58,15 +58,18 @@ export function getInvalidFields<T>(
         (options[mode] as IFieldOptions).permissions
       ) {
         required = (options[mode] as IFieldOptions)?.permissions?.some((op) =>
-          permissions.some((p) => p === op)
+          permissions.some((p) => p === op),
         );
       }
     }
 
     if (
-        required
-        && ((instance as any)[key] === null || (instance as any)[key] === undefined || (instance as any)[key] === '')
-    ) result.push(key);
+      required &&
+      ((instance as any)[key] === null ||
+        (instance as any)[key] === undefined ||
+        (instance as any)[key] === '')
+    )
+      result.push(key);
   });
 
   return result;
@@ -74,18 +77,17 @@ export function getInvalidFields<T>(
 
 export function castModel<T>(
   instance: T,
-  mode: "create" | "update" | string,
-  permissions: Array<string>
+  mode: 'create' | 'update' | string,
+  permissions: Array<string>,
 ): void {
   if (!isModel(instance)) return;
 
   const fieldsWithOptions = getModelFieldsWithOptions(instance);
 
   Object.keys(instance as any)
-    .filter((key) => key !== "id")
+    .filter((key) => key !== 'id')
     .forEach((key) => {
-      const fieldWidthOptions =
-          fieldsWithOptions.find((f) => f.key === key);
+      const fieldWidthOptions = fieldsWithOptions.find((f) => f.key === key);
 
       if (!fieldWidthOptions) {
         delete (instance as any)[key];
@@ -93,21 +95,19 @@ export function castModel<T>(
       }
 
       if (
-        (mode === "create" || mode === "update") &&
+        (mode === 'create' || mode === 'update') &&
         (!fieldWidthOptions.options[mode] ||
           (permissions &&
             (fieldWidthOptions.options[mode] as IFieldOptions).permissions &&
-            !(fieldWidthOptions.options[
-              mode
-            ] as IFieldOptions)?.permissions?.some((op) =>
-              permissions.some((p) => op === p)
-            )))
+            !(
+              fieldWidthOptions.options[mode] as IFieldOptions
+            )?.permissions?.some((op) => permissions.some((p) => op === p))))
       ) {
         delete (instance as any)[key];
         return;
       } else if (
-        mode !== "create" &&
-        mode !== "update" &&
+        mode !== 'create' &&
+        mode !== 'update' &&
         (!fieldWidthOptions.options.customs ||
           !fieldWidthOptions.options.customs.some((c) => c.mode === mode))
       ) {