@smartsoft001/models 2.27.0 → 2.30.0

package/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "extends": ["../../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": [
+          "error",
+          {
+            "ignoredFiles": ["{projectRoot}/esbuild.config.{js,ts,mjs,mts}"]
+          }
+        ]
+      }
+    }
+  ]
+}

package/jest.config.ts

@@ -0,0 +1,11 @@
+/* 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/package.json

@@ -2,16 +2,11 @@
   "name": "@smartsoft001/models",
   "type": "commonjs",
   "dependencies": {
-    "@smartsoft001/utils": "^2.27.0",
-    "flatted": "3.2.9",
-    "guid-typescript": "^1.0.9",
-    "lodash": "4.17.21",
-    "md5": "^2.3.0",
     "reflect-metadata": "^0.2.1",
     "rxjs": "^7.8.1",
-    "tslib": "^2.3.0"
+    "@smartsoft001/utils": "^2.30.0"
   },
-  "version": "2.27.0",
+  "version": "2.30.0",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts"
-}
+}

package/project.json

@@ -0,0 +1,39 @@
+{
+  "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/{index.d.ts → index.ts}

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

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

@@ -0,0 +1,55 @@
+import 'reflect-metadata';
+
+import {ObjectService} from "@smartsoft001/utils";
+
+import * as symbols from "../../symbols";
+import {FieldType, IFieldOptions} from "../../interfaces";
+
+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

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+
+import * as symbols from "../../symbols";
+import {IModelOptions} from "../../interfaces";
+
+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.d.ts → interfaces.ts}

@@ -1,5 +1,6 @@
-import { Observable } from "rxjs";
-export declare enum FieldTypeDef {
+import {Observable} from "rxjs";
+
+export enum FieldTypeDef {
     address = "address",
     currency = "currency",
     date = "date",
@@ -32,34 +33,37 @@ export declare enum FieldTypeDef {
     image = "image",
     float = "float"
 }
-export declare const FieldType: typeof FieldTypeDef;
+export const FieldType: typeof FieldTypeDef = FieldTypeDef;
+
 export interface ISpecification {
     readonly criteria: any;
 }
+
 export interface IModelFilter {
     label?: string;
     fieldType?: FieldTypeDef;
     key: string;
     type: '=' | '!=' | '>=' | '<=' | '<' | '>' | '~=';
-    possibilities$?: Observable<{
-        id: any;
-        text: string;
-    }[]>;
+    possibilities$?: Observable<{ 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;
@@ -74,9 +78,11 @@ export interface IFieldModifyMetadata {
      */
     step?: IModelStep;
 }
+
 export interface IFieldEditMetadata extends IFieldModifyMetadata {
     multi?: boolean;
 }
+
 export interface IFieldListMetadata {
     order?: number;
     filter?: boolean;
@@ -86,16 +92,15 @@ export interface IFieldListMetadata {
      * @param {string} dynamic.headerKey - column header object key
      * @param {string} dynamic.rowKey - column row value object key
      */
-    dynamic?: {
-        headerKey: string;
-        rowKey: string;
-    };
+    dynamic?: { headerKey: string, rowKey: string }
 }
+
 export interface IFieldDetailsMetadata {
     order?: number;
     permissions?: Array<string>;
     enabled?: ISpecification;
 }
+
 export interface IModelOptions {
     titleKey?: string;
     filters?: Array<IModelFilter>;
@@ -114,13 +119,16 @@ export interface IModelOptions {
      */
     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;
@@ -130,12 +138,15 @@ export interface IFieldOptions extends IFieldMetadata {
     search?: boolean;
     info?: string;
 }
+
 export interface IModelMetadataCustom extends IModelMetadata {
-    mode: string;
+    mode: string
 }
+
 export interface IFieldUniqueMetadata {
     withFields?: Array<string>;
 }
+
 export interface IFieldCustomMetadata extends IFieldModifyMetadata, IFieldListMetadata {
     mode: string;
 }

package/src/lib/symbols.ts

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

package/src/lib/utils.spec.ts

@@ -0,0 +1,137 @@
+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";
+
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,22 @@
+{
+  "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

@@ -0,0 +1,10 @@
+{
+  "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

@@ -0,0 +1,14 @@
+{
+  "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"
+  ]
+}

package/index.cjs

@@ -1,294 +0,0 @@
-"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/src/lib/decorators/field/field.decorator.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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/symbols.d.ts

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

package/src/lib/utils.d.ts

@@ -1,11 +0,0 @@
-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;