@smartsoft001/models 2.76.0 → 2.80.0

package/index.cjs

@@ -0,0 +1,294 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/shared/models/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Field: () => Field,
+  FieldDecorator: () => FieldDecorator,
+  FieldType: () => FieldType,
+  FieldTypeDef: () => FieldTypeDef,
+  Model: () => Model,
+  ModelDecorator: () => ModelDecorator,
+  SYMBOL_FIELD: () => SYMBOL_FIELD,
+  SYMBOL_MODEL: () => SYMBOL_MODEL,
+  castModel: () => castModel,
+  getInvalidFields: () => getInvalidFields,
+  getModelFieldKeys: () => getModelFieldKeys,
+  getModelFieldOptions: () => getModelFieldOptions,
+  getModelFieldsWithOptions: () => getModelFieldsWithOptions,
+  getModelOptions: () => getModelOptions,
+  isModel: () => isModel
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/shared/models/src/lib/symbols.ts
+var SYMBOL_MODEL = Symbol.for("smartsoft:model");
+var SYMBOL_FIELD = Symbol.for("smartsoft:field");
+
+// packages/shared/models/src/lib/interfaces.ts
+var FieldTypeDef = /* @__PURE__ */ ((FieldTypeDef2) => {
+  FieldTypeDef2["address"] = "address";
+  FieldTypeDef2["currency"] = "currency";
+  FieldTypeDef2["date"] = "date";
+  FieldTypeDef2["dateTime"] = "dateTime";
+  FieldTypeDef2["dateWithEdit"] = "dateWithEdit";
+  FieldTypeDef2["email"] = "email";
+  FieldTypeDef2["enum"] = "enum";
+  FieldTypeDef2["file"] = "file";
+  FieldTypeDef2["flag"] = "flag";
+  FieldTypeDef2["int"] = "int";
+  FieldTypeDef2["nip"] = "nip";
+  FieldTypeDef2["object"] = "object";
+  FieldTypeDef2["array"] = "array";
+  FieldTypeDef2["password"] = "password";
+  FieldTypeDef2["radio"] = "radio";
+  FieldTypeDef2["text"] = "text";
+  FieldTypeDef2["strings"] = "strings";
+  FieldTypeDef2["ints"] = "ints";
+  FieldTypeDef2["longText"] = "longText";
+  FieldTypeDef2["color"] = "color";
+  FieldTypeDef2["logo"] = "logo";
+  FieldTypeDef2["check"] = "check";
+  FieldTypeDef2["phoneNumber"] = "phoneNumber";
+  FieldTypeDef2["phoneNumberPl"] = "phoneNumberPl";
+  FieldTypeDef2["pesel"] = "pesel";
+  FieldTypeDef2["pdf"] = "pdf";
+  FieldTypeDef2["video"] = "video";
+  FieldTypeDef2["attachment"] = "attachment";
+  FieldTypeDef2["dateRange"] = "dateRange";
+  FieldTypeDef2["image"] = "image";
+  FieldTypeDef2["float"] = "float";
+  return FieldTypeDef2;
+})(FieldTypeDef || {});
+var FieldType = FieldTypeDef;
+
+// packages/shared/models/src/lib/decorators/model/model.decorator.ts
+var import_reflect_metadata = require("reflect-metadata");
+var Model = ModelDecorator;
+function ModelDecorator(options) {
+  return function(target) {
+    options = options ? { ...options } : {};
+    Reflect.defineMetadata(SYMBOL_MODEL, options, target);
+    target.prototype.toJSON = function() {
+      const result = { ...this };
+      if (this.constructor["__properties"]) {
+        Object.keys(this.constructor["__properties"]).forEach((protoKey) => {
+          result[protoKey] = this["_" + protoKey];
+        });
+      }
+      return result;
+    };
+  };
+}
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+
+// packages/shared/utils/src/lib/services/password/password.service.ts
+var md5_ = __toESM(require("md5"));
+
+// packages/shared/utils/src/lib/services/object/object.service.ts
+var import_flatted = require("flatted");
+var ObjectService = class {
+  /***
+   * Create object with data
+   * @param data {object} - data to set
+   * @param type {type} - new type
+   * @return - new type object
+   */
+  static createByType(data, type) {
+    if (!data)
+      return data;
+    try {
+      if (data instanceof type)
+        return data;
+    } catch (e) {
+      console.warn(e);
+    }
+    const result = new type();
+    Object.keys(data).forEach((key) => {
+      result[key] = data[key];
+    });
+    return result;
+  }
+  /***
+   * Remove object type from data
+   * @param obj {object} - object
+   * @return - object without type
+   */
+  static removeTypes(obj) {
+    if (!obj)
+      return obj;
+    const result = {};
+    Object.keys(obj).forEach((key) => {
+      if (obj[key] && obj[key].constructor && !(obj[key] instanceof Date)) {
+        let stringValue = "";
+        try {
+          stringValue = JSON.stringify(obj[key]);
+        } catch (e) {
+          console.warn("can't stringify without circular package");
+          stringValue = (0, import_flatted.stringify)(obj[key]);
+        }
+        result[key] = JSON.parse(stringValue);
+      } else {
+        result[key] = obj[key];
+      }
+    });
+    return result;
+  }
+};
+
+// packages/shared/utils/src/lib/services/guid/guid.service.ts
+var import_guid_typescript = require("guid-typescript");
+
+// packages/shared/utils/src/lib/services/array/array.service.ts
+var _ = __toESM(require("lodash"));
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+var Field = FieldDecorator;
+function FieldDecorator(options) {
+  return (target, key) => {
+    options = options ? { ...options } : {};
+    if (!target.constructor["__fields"]) {
+      target.constructor["__fields"] = {};
+    }
+    target.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["_" + key] = target[key];
+      delete target[key];
+      Object.defineProperty(target, key, {
+        get: function() {
+          if (!this["_" + key] && options?.type === FieldType.array) {
+            this["_" + key] = [];
+          }
+          return this["_" + key];
+        },
+        set: function(v) {
+          this["_" + key] = options?.type === FieldType.array && v ? v.map(
+            (i) => ObjectService.createByType(i, options?.classType)
+          ) : ObjectService.createByType(v, options?.classType);
+        },
+        enumerable: true,
+        configurable: true
+      });
+      if (!target.constructor["__properties"]) {
+        target.constructor["__properties"] = {};
+      }
+      target.constructor["__properties"][key] = true;
+    }
+    Reflect.defineMetadata(SYMBOL_FIELD, options, target, key);
+  };
+}
+
+// packages/shared/models/src/lib/utils.ts
+function getModelFieldKeys(type) {
+  if (!type["__fields"])
+    return [];
+  return Object.keys(type["__fields"]);
+}
+function getModelFieldOptions(instance, fieldKey) {
+  return Reflect.getMetadata(SYMBOL_FIELD, instance, fieldKey);
+}
+function getModelFieldsWithOptions(instance) {
+  const keys = getModelFieldKeys(instance.constructor);
+  return keys.map((item) => {
+    return {
+      key: item,
+      options: getModelFieldOptions(instance, item)
+    };
+  });
+}
+function getModelOptions(type) {
+  return Reflect.getMetadata(SYMBOL_MODEL, type);
+}
+function isModel(instance) {
+  if (!instance || !instance.constructor)
+    return false;
+  return Reflect.hasMetadata(SYMBOL_MODEL, instance.constructor);
+}
+function getInvalidFields(instance, mode, permissions) {
+  const result = [];
+  getModelFieldsWithOptions(instance).forEach(({ key, options }) => {
+    let required = options.required;
+    if ((mode === "create" || mode === "update") && options[mode] && options[mode]?.constructor) {
+      required = options[mode].required;
+      if (required && permissions && options[mode].permissions) {
+        required = options[mode]?.permissions?.some(
+          (op) => permissions.some((p) => p === op)
+        );
+      }
+    }
+    if (required && (instance[key] === null || instance[key] === void 0 || instance[key] === ""))
+      result.push(key);
+  });
+  return result;
+}
+function castModel(instance, mode, permissions) {
+  if (!isModel(instance))
+    return;
+  const fieldsWithOptions = getModelFieldsWithOptions(instance);
+  Object.keys(instance).filter((key) => key !== "id").forEach((key) => {
+    const fieldWidthOptions = fieldsWithOptions.find((f) => f.key === key);
+    if (!fieldWidthOptions) {
+      delete instance[key];
+      return;
+    }
+    if ((mode === "create" || mode === "update") && (!fieldWidthOptions.options[mode] || permissions && fieldWidthOptions.options[mode].permissions && !fieldWidthOptions.options[mode]?.permissions?.some((op) => permissions.some((p) => op === p)))) {
+      delete instance[key];
+      return;
+    } else if (mode !== "create" && mode !== "update" && (!fieldWidthOptions.options.customs || !fieldWidthOptions.options.customs.some((c) => c.mode === mode))) {
+      delete instance[key];
+      return;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field,
+  FieldDecorator,
+  FieldType,
+  FieldTypeDef,
+  Model,
+  ModelDecorator,
+  SYMBOL_FIELD,
+  SYMBOL_MODEL,
+  castModel,
+  getInvalidFields,
+  getModelFieldKeys,
+  getModelFieldOptions,
+  getModelFieldsWithOptions,
+  getModelOptions,
+  isModel
+});

package/package.json

@@ -2,11 +2,20 @@
   "name": "@smartsoft001/models",
   "type": "commonjs",
   "dependencies": {
+    "@angular/core": "20.1.0",
+    "flatted": "3.3.3",
+    "guid-typescript": "^1.0.9",
+    "lodash": "4.17.21",
+    "md5": "^2.3.0",
     "reflect-metadata": "^0.2.1",
-    "rxjs": "^7.8.1",
-    "@smartsoft001/utils": "^2.76.0"
+    "tslib": "^2.3.0"
   },
-  "version": "2.76.0",
+  "version": "2.80.0",
   "main": "./src/index.js",
-  "typings": "./src/index.d.ts"
-}
+  "typings": "./src/index.d.ts",
+  "resolutions": {
+    "paypal-rest-sdk": "1.8.1",
+    "tslib": "^2.3.0",
+    "zone.js": "~0.15.0"
+  }
+}

package/src/{index.ts → index.d.ts}

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

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

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import { IFieldOptions } from '../../interfaces';
+export declare const Field: typeof FieldDecorator;
+export declare function FieldDecorator(options?: IFieldOptions): <T>(target: T, key: string) => void;

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

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import { IModelOptions } from '../../interfaces';
+export declare const Model: typeof ModelDecorator;
+export declare function ModelDecorator(options?: IModelOptions): <T>(target: any) => void;

package/src/lib/interfaces.d.ts

@@ -0,0 +1,141 @@
+import { Signal } from '@angular/core';
+export declare 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"
+}
+export declare const FieldType: typeof FieldTypeDef;
+export interface ISpecification {
+    readonly criteria: any;
+}
+export interface IModelFilter {
+    label?: string;
+    fieldType?: FieldTypeDef;
+    key: string;
+    type: '=' | '!=' | '>=' | '<=' | '<' | '>' | '~=';
+    possibilities?: Signal<{
+        id: any;
+        text: string;
+    }[]>;
+}
+export interface IModelStep {
+    number: number;
+    name: string;
+}
+export interface IModelMetadata {
+    titleKey?: string;
+    permissions?: Array<string>;
+    filters?: Array<IModelFilter>;
+}
+export interface IFieldMetadata extends IFieldModifyMetadata {
+    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;
+}
+export interface IFieldEditMetadata extends IFieldModifyMetadata {
+    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;
+    };
+}
+export interface IFieldDetailsMetadata {
+    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;
+}
+export interface IModelModeOptions {
+    permissions?: Array<string>;
+    enabled?: ISpecification;
+}
+export interface IModelModeOptionsCustom extends IModelModeOptions {
+    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;
+}
+export interface IModelMetadataCustom extends IModelMetadata {
+    mode: string;
+}
+export interface IFieldUniqueMetadata {
+    withFields?: Array<string>;
+}
+export interface IFieldCustomMetadata extends IFieldModifyMetadata, IFieldListMetadata {
+    mode: string;
+}

package/src/lib/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const SYMBOL_MODEL: unique symbol;
+export declare const SYMBOL_FIELD: unique symbol;

package/src/lib/utils.d.ts

@@ -0,0 +1,11 @@
+import { IFieldOptions, IModelOptions } from './interfaces';
+export declare function getModelFieldKeys<T>(type: T): Array<string>;
+export declare function getModelFieldOptions<T>(instance: T, fieldKey: string): IFieldOptions;
+export declare function getModelFieldsWithOptions<T>(instance: T): Array<{
+    key: string;
+    options: IFieldOptions;
+}>;
+export declare function getModelOptions(type: any): IModelOptions;
+export declare function isModel<T>(instance: T): boolean;
+export declare function getInvalidFields<T>(instance: T, mode: 'create' | 'update' | string, permissions: Array<string>): Array<string>;
+export declare function castModel<T>(instance: T, mode: 'create' | 'update' | string, permissions: Array<string>): void;

package/.eslintrc.json

@@ -1,24 +0,0 @@
-{
-  "extends": ["../../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "rules": {},
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": "package.json",
-      "parser": "jsonc-eslint-parser",
-      "rules": {}
-    }
-  ]
-}

package/jest.config.ts

@@ -1,11 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'models',
-  preset: '../../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../../coverage/packages/shared/models',
-};

package/project.json

@@ -1,39 +0,0 @@
-{
-  "name": "models",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/shared/models/src",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/shared/models",
-        "main": "packages/shared/models/src/index.ts",
-        "tsConfig": "packages/shared/models/tsconfig.lib.json",
-        "assets": ["packages/shared/models/*.md"],
-        "generatePackageJson": true,
-        "format": ["cjs"]
-      }
-    },
-    "deploy": {
-      "executor": "ngx-deploy-npm:deploy",
-      "options": {
-        "access": "public",
-        "distFolderPath": "dist/packages/shared/models"
-      },
-      "dependsOn": ["build"]
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "packages/shared/models/jest.config.ts"
-      }
-    }
-  }
-}

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

@@ -1,57 +0,0 @@
-import 'reflect-metadata';
-
-import { ObjectService } from '@smartsoft001/utils';
-
-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);
-  };
-}

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

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

package/src/lib/interfaces.ts

@@ -1,154 +0,0 @@
-import { Signal } from '@angular/core';
-
-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',
-}
-export const FieldType: typeof FieldTypeDef = FieldTypeDef;
-
-export interface ISpecification {
-  readonly criteria: any;
-}
-
-export interface IModelFilter {
-  label?: string;
-  fieldType?: FieldTypeDef;
-  key: string;
-  type: '=' | '!=' | '>=' | '<=' | '<' | '>' | '~=';
-  possibilities?: Signal<{ id: any; text: string }[]>;
-}
-
-export interface IModelStep {
-  number: number;
-  name: string;
-}
-
-export interface IModelMetadata {
-  titleKey?: string;
-  permissions?: Array<string>;
-  filters?: Array<IModelFilter>;
-}
-
-export interface IFieldMetadata extends IFieldModifyMetadata {
-  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;
-}
-
-export interface IFieldEditMetadata extends IFieldModifyMetadata {
-  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 };
-}
-
-export interface IFieldDetailsMetadata {
-  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;
-}
-
-export interface IModelModeOptions {
-  permissions?: Array<string>;
-  enabled?: ISpecification;
-}
-
-export interface IModelModeOptionsCustom extends IModelModeOptions {
-  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;
-}
-
-export interface IModelMetadataCustom extends IModelMetadata {
-  mode: string;
-}
-
-export interface IFieldUniqueMetadata {
-  withFields?: Array<string>;
-}
-
-export interface IFieldCustomMetadata
-  extends IFieldModifyMetadata,
-    IFieldListMetadata {
-  mode: string;
-}

package/src/lib/symbols.ts

@@ -1,2 +0,0 @@
-export const SYMBOL_MODEL = Symbol.for('smartsoft:model');
-export const SYMBOL_FIELD = Symbol.for('smartsoft:field');

package/src/lib/utils.spec.ts

@@ -1,151 +0,0 @@
-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 {}
-
-      const result = getModelFieldKeys(Test);
-
-      expect(result).toStrictEqual([]);
-    });
-
-    it('should return field keys array', () => {
-      @Model({})
-      class Test {
-        @Field({}) test1!: any;
-        @Field({}) test2!: any;
-        @Field({}) test3!: any;
-      }
-
-      const result = getModelFieldKeys(Test);
-
-      expect(result).toStrictEqual(['test1', 'test2', 'test3']);
-    });
-  });
-
-  describe('getModelFieldOptions', () => {
-    it('should return options', () => {
-      const options = { required: true, type: FieldType.password };
-
-      @Model({})
-      class Test {
-        @Field(options) test!: string;
-      }
-
-      expect(getModelFieldOptions(new Test(), 'test')).toStrictEqual(options);
-    });
-  });
-
-  describe('isModel', () => {
-    it('should return true when model type', () => {
-      @Model({})
-      class Test {
-        @Field({}) test!: string;
-      }
-
-      expect(isModel(new Test())).toBe(true);
-    });
-
-    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);
-    });
-
-    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,
-      );
-    });
-  });
-
-  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,118 +0,0 @@
-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']);
-}
-
-export function getModelFieldOptions<T>(
-  instance: T,
-  fieldKey: string,
-): IFieldOptions {
-  return Reflect.getMetadata(SYMBOL_FIELD, instance as any, fieldKey);
-}
-
-export function getModelFieldsWithOptions<T>(
-  instance: T,
-): Array<{ key: string; options: IFieldOptions }> {
-  const keys = getModelFieldKeys((instance as any).constructor);
-
-  return keys.map((item) => {
-    return {
-      key: item,
-      options: getModelFieldOptions(instance, item),
-    };
-  });
-}
-
-export function getModelOptions(type: any): IModelOptions {
-  return Reflect.getMetadata(SYMBOL_MODEL, type);
-}
-
-export function isModel<T>(instance: T): boolean {
-  if (!instance || !instance.constructor) return false;
-  return Reflect.hasMetadata(SYMBOL_MODEL, instance.constructor);
-}
-
-export function getInvalidFields<T>(
-  instance: T,
-  mode: 'create' | 'update' | string,
-  permissions: Array<string>,
-): Array<string> {
-  const result: any[] = [];
-
-  getModelFieldsWithOptions(instance).forEach(({ key, options }) => {
-    let required = options.required;
-
-    if (
-      (mode === 'create' || mode === 'update') &&
-      options[mode] &&
-      options[mode]?.constructor
-    ) {
-      required = (options[mode] as IFieldOptions).required;
-
-      if (
-        required &&
-        permissions &&
-        (options[mode] as IFieldOptions).permissions
-      ) {
-        required = (options[mode] as IFieldOptions)?.permissions?.some((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);
-  });
-
-  return result;
-}
-
-export function castModel<T>(
-  instance: T,
-  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')
-    .forEach((key) => {
-      const fieldWidthOptions = fieldsWithOptions.find((f) => f.key === key);
-
-      if (!fieldWidthOptions) {
-        delete (instance as any)[key];
-        return;
-      }
-
-      if (
-        (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))))
-      ) {
-        delete (instance as any)[key];
-        return;
-      } else if (
-        mode !== 'create' &&
-        mode !== 'update' &&
-        (!fieldWidthOptions.options.customs ||
-          !fieldWidthOptions.options.customs.some((c) => c.mode === mode))
-      ) {
-        delete (instance as any)[key];
-        return;
-      }
-    });
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

package/tsconfig.spec.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
-}