@smartsoft001/crud-shell-app-services 2.75.0 → 2.80.0

package/index.js

@@ -0,0 +1,333 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// packages/crud/shell/app-services/src/lib/services/crud/crud.service.ts
+import { Injectable, Logger } from "@nestjs/common";
+import * as CombinedStream from "combined-stream";
+import { Guid as Guid2 } from "guid-typescript";
+import { Memoize } from "lodash-decorators";
+
+// 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/decorators/model/model.decorator.ts
+import "reflect-metadata";
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+import "reflect-metadata";
+
+// packages/shared/utils/src/lib/services/password/password.service.ts
+import * as md5_ from "md5";
+var md5 = md5_;
+var PasswordService = class _PasswordService {
+  /**
+   * Hash password text
+   * @param p {string} - text
+   * @return - hashed text
+   */
+  static hash(p) {
+    return Promise.resolve(md5(p));
+  }
+  /**
+   * Compare password text with hashed text
+   * @param p {string} - password text
+   * @param h {string} - hashed text
+   */
+  static async compare(p, h) {
+    const hp = await _PasswordService.hash(p);
+    return hp === h;
+  }
+};
+
+// packages/shared/utils/src/lib/services/object/object.service.ts
+import { stringify } from "flatted";
+
+// packages/shared/utils/src/lib/services/guid/guid.service.ts
+import { Guid } from "guid-typescript";
+var GuidService = class {
+  /***
+   * Create guid as string
+   */
+  static create() {
+    return Guid.raw();
+  }
+};
+
+// packages/shared/utils/src/lib/services/array/array.service.ts
+import * as _ from "lodash";
+
+// 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 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;
+    }
+  });
+}
+
+// packages/shared/domain-core/src/lib/errors.ts
+var DomainValidationError = class _DomainValidationError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainValidationError;
+  }
+};
+
+// packages/crud/shell/app-services/src/lib/services/crud/crud.service.ts
+var CrudService = class {
+  constructor(permissionService, repository, attachmentRepository) {
+    this.permissionService = permissionService;
+    this.repository = repository;
+    this.attachmentRepository = attachmentRepository;
+    this._logger = new Logger(CrudService.name, { timestamp: true });
+  }
+  async create(data, user) {
+    data.id = Guid2.raw();
+    try {
+      this.permissionService.valid("create", user);
+      castModel(data, "create", user.permissions);
+      this.checkValidCreate(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.create(data, user);
+      return data.id;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async createMany(data, user, options) {
+    data.forEach((item) => {
+      item.id = Guid2.raw();
+    });
+    try {
+      this.permissionService.valid("create", user);
+      data.forEach((item) => {
+        castModel(item, "create", user.permissions);
+        this.checkValidCreate(item, user.permissions);
+      });
+      if (options && options.mode === "replace") {
+        await this.repository.clear(user);
+      }
+      for (let index = 0; index < data.length; index++) {
+        const item = data[index];
+        if (item["password"]) {
+          item["password"] = await PasswordService.hash(item["password"]);
+        }
+        if (item["passwordConfirm"]) {
+          delete item["passwordConfirm"];
+        }
+      }
+      await this.repository.createMany(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+    return data;
+  }
+  async readById(id, user) {
+    try {
+      this.permissionService.valid("read", user);
+      const result = await this.repository.getById(id);
+      delete result["password"];
+      return result;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async read(criteria, options, user) {
+    try {
+      this.permissionService.valid("read", user);
+      const result = await this.repository.getByCriteria(criteria, options);
+      result.data.forEach((item) => delete item["password"]);
+      return result;
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  readBySpec(spec, options, user) {
+    return this.read(spec.criteria, options, user);
+  }
+  async update(id, data, user) {
+    try {
+      data.id = id;
+      this.permissionService.valid("update", user);
+      castModel(data, "update", user.permissions);
+      this.checkValidUpdate(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.update(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async updatePartial(id, data, user) {
+    try {
+      data.id = id;
+      this.permissionService.valid("update", user);
+      castModel(data, "update", user.permissions);
+      this.checkValidUpdatePartial(data, user.permissions);
+      if (data["password"]) {
+        data["password"] = await PasswordService.hash(data["password"]);
+      }
+      if (data["passwordConfirm"]) {
+        delete data["passwordConfirm"];
+      }
+      await this.repository.updatePartial(data, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async delete(id, user) {
+    try {
+      this.permissionService.valid("delete", user);
+      await this.repository.delete(id, user);
+    } catch (e) {
+      this._logger.error(e);
+      throw e;
+    }
+  }
+  async uploadAttachment(data, options) {
+    if (!data.id) {
+      data.id = GuidService.create();
+    }
+    let oldId = null;
+    if (options?.start) {
+      oldId = data.id;
+      const stream = await this.attachmentRepository.getStream(data.id, {
+        start: 0,
+        end: options.start - 1
+      });
+      const combinedStream = CombinedStream.create();
+      combinedStream.append(stream);
+      combinedStream.append(data.stream);
+      data.stream = combinedStream;
+      data.id = GuidService.create();
+    }
+    this.attachmentRepository.upload(data, options);
+    if (oldId)
+      await this.attachmentRepository.delete(data.id);
+    return data.id;
+  }
+  getAttachmentInfo(id) {
+    return this.attachmentRepository.getInfo(id);
+  }
+  getAttachmentStream(id, options) {
+    return this.attachmentRepository.getStream(id, options);
+  }
+  async deleteAttachment(id) {
+    return this.attachmentRepository.delete(id);
+  }
+  changes(criteria) {
+    return this.repository.changesByCriteria(criteria);
+  }
+  checkValidCreate(item, permissions) {
+    const array = getInvalidFields(item, "create", permissions);
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+  checkValidUpdate(item, permissions) {
+    const array = getInvalidFields(item, "update", permissions);
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+  checkValidUpdatePartial(item, permissions) {
+    if (!isModel(item))
+      return;
+    const keys = Object.keys(item);
+    const array = getInvalidFields(item, "update", permissions).filter(
+      (invalidField) => keys.some((key) => key === invalidField)
+    );
+    if (array.length) {
+      throw new DomainValidationError("Required fields: " + array.join(", "));
+    }
+  }
+};
+__decorateClass([
+  Memoize()
+], CrudService.prototype, "getAttachmentInfo", 1);
+CrudService = __decorateClass([
+  Injectable()
+], CrudService);
+
+// packages/crud/shell/app-services/src/lib/services/index.ts
+var SERVICES = [CrudService];
+export {
+  CrudService,
+  SERVICES
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/crud-shell-app-services",
-  "version": "2.75.0",
+  "version": "2.80.0",
   "description": "Utils to crud",
   "repository": {
     "type": "git",

package/src/lib/services/crud/crud.service.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { ICreateManyOptions } from '@smartsoft001/crud-domain';
+import { ItemChangedData } from '@smartsoft001/crud-shell-dtos';
+import { IAttachmentRepository, IEntity, IItemRepository, ISpecification } from '@smartsoft001/domain-core';
+import { PermissionService } from '@smartsoft001/nestjs';
+import { IUser } from '@smartsoft001/users';
+import { Readable, Stream } from 'stream';
+export declare class CrudService<T extends IEntity<string>> {
+    protected readonly permissionService: PermissionService;
+    protected readonly repository: IItemRepository<T>;
+    protected readonly attachmentRepository: IAttachmentRepository<T>;
+    private _logger;
+    constructor(permissionService: PermissionService, repository: IItemRepository<T>, attachmentRepository: IAttachmentRepository<T>);
+    create(data: T, user: IUser): Promise<string>;
+    createMany(data: T[], user: IUser, options: ICreateManyOptions): Promise<T[]>;
+    readById(id: string, user: IUser): Promise<T>;
+    read(criteria: any, options: any, user: IUser): Promise<{
+        data: T[];
+        totalCount: number;
+    }>;
+    readBySpec(spec: ISpecification, options: any, user: IUser): Promise<{
+        data: T[];
+        totalCount: number;
+    }>;
+    update(id: string, data: T, user: IUser): Promise<void>;
+    updatePartial(id: string, data: Partial<T>, user: IUser): Promise<void>;
+    delete(id: string, user: IUser): Promise<void>;
+    uploadAttachment(data: {
+        id: string;
+        fileName: string;
+        stream: Stream;
+        mimeType: string;
+        encoding: string;
+    }, options?: {
+        streamCallback?: (r: any) => void;
+        start?: number;
+    }): Promise<string>;
+    getAttachmentInfo(id: string): Promise<{
+        fileName: string;
+        contentType: string;
+        length: number;
+    }>;
+    getAttachmentStream(id: string, options?: {
+        start: number;
+        end: number;
+    }): Promise<Readable>;
+    deleteAttachment(id: string): Promise<void>;
+    changes(criteria: {
+        id?: string;
+    }): Observable<ItemChangedData>;
+    private checkValidCreate;
+    private checkValidUpdate;
+    private checkValidUpdatePartial;
+}

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

@@ -1,5 +1,3 @@
 import { CrudService } from './crud/crud.service';
-
 export * from './crud/crud.service';
-
-export const SERVICES = [CrudService];
+export declare const SERVICES: (typeof CrudService)[];

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../../.eslintrc",
-  "rules": {
-
-  },
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser"
-    }
-  ]
-}

package/jest.config.ts

@@ -1,27 +0,0 @@
-/* eslint-disable */
-export default {
-  globals: {},
-  transform: {
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        tsConfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../../../coverage/packages/crud/shell/app-services',
-  displayName: 'crud-shell-app-services',
-  testEnvironment: 'node',
-  preset: '../../../../jest.preset.js',
-  /* TODO: Update to latest Jest snapshotFormat
-   * By default Nx has kept the older style of Jest Snapshot formats
-   * to prevent breaking of any existing tests with snapshots.
-   * It's recommend you update to the latest format.
-   * You can do this by removing snapshotFormat property
-   * and running tests with --update-snapshot flag.
-   * Example: From within the project directory, run "nx test --update-snapshot"
-   * More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format
-   */
-  snapshotFormat: { escapeString: true, printBasicPrototype: true },
-};

package/project.json

@@ -1,43 +0,0 @@
-{
-  "name": "crud-shell-app-services",
-  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/crud/shell/app-services/src",
-  "projectType": "library",
-  "tags": ["scope:crud", "type:shell"],
-  "generators": {},
-  "targets": {
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/crud/shell/app-services/**/*.{ts,tsx,js,jsx}",
-          "packages/crud/shell/app-services/package.json"
-        ],
-        "tsConfig": [
-          "packages/crud/shell/app-services/tsconfig.lib.json",
-          "packages/crud/shell/app-services/tsconfig.spec.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "options": {
-        "jestConfig": "packages/crud/shell/app-services/jest.config.ts",
-        "passWithNoTests": true
-      },
-      "outputs": ["{workspaceRoot}/coverage/packages/crud/shell/app-services"]
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "options": {
-        "outputPath": "dist/packages/crud/shell/app-services",
-        "tsConfig": "packages/crud/shell/app-services/tsconfig.lib.json",
-        "packageJson": "packages/crud/shell/app-services/package.json",
-        "main": "packages/crud/shell/app-services/src/index.ts",
-        "assets": ["packages/crud/shell/app-services/*.md"]
-      },
-      "outputs": ["{options.outputPath}"]
-    }
-  }
-}

package/src/lib/services/crud/crud.service.spec.ts

@@ -1,228 +0,0 @@
-import { of, Observable } from 'rxjs';
-
-import { CrudService } from './crud.service';
-
-jest.mock('@smartsoft001/utils', () => ({
-  PasswordService: { hash: jest.fn(async (v) => 'hashed-' + v) },
-  GuidService: { create: jest.fn(() => 'guid') },
-}));
-
-const mockUser = { id: 'u', username: 'test', permissions: ['p'] };
-const mockData = { id: 'id', password: 'pw', passwordConfirm: 'pw' };
-const mockRepo = () => ({
-  create: jest.fn(),
-  createMany: jest.fn(),
-  getById: jest.fn().mockResolvedValue({ id: 'id', password: 'pw' }),
-  getByCriteria: jest
-    .fn()
-    .mockResolvedValue({ data: [{ id: 'id', password: 'pw' }], totalCount: 1 }),
-  update: jest.fn(),
-  updatePartial: jest.fn(),
-  delete: jest.fn(),
-  clear: jest.fn(),
-  changesByCriteria: jest.fn(() => of({})),
-});
-const mockAttachRepo = () => ({
-  upload: jest.fn(),
-  getInfo: jest
-    .fn()
-    .mockResolvedValue({ fileName: 'f', contentType: 'c', length: 1 }),
-  getStream: jest.fn().mockResolvedValue({}),
-  delete: jest.fn(),
-});
-const mockPerm = () => ({ valid: jest.fn() });
-
-describe('crud-app-services: CrudService', () => {
-  let service: CrudService<any>;
-  let repository: any;
-  let attachmentRepository: any;
-  let permissionService: any;
-
-  beforeEach(() => {
-    repository = mockRepo();
-    attachmentRepository = mockAttachRepo();
-    permissionService = mockPerm();
-    service = new CrudService(
-      permissionService,
-      repository,
-      attachmentRepository,
-    );
-  });
-
-  describe('create', () => {
-    it('should create and return id', async () => {
-      const id = await service.create({ ...mockData }, mockUser);
-      expect(typeof id).toBe('string');
-    });
-    it('should log and throw on error', async () => {
-      permissionService.valid.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(service.create({ ...mockData }, mockUser)).rejects.toThrow(
-        'fail',
-      );
-    });
-  });
-
-  describe('createMany', () => {
-    it('should create many and return data', async () => {
-      const data = await service.createMany([{ ...mockData }], mockUser, {
-        mode: undefined,
-      });
-      expect(Array.isArray(data)).toBe(true);
-    });
-    it('should clear repo if mode is replace', async () => {
-      await service.createMany([{ ...mockData }], mockUser, {
-        mode: 'replace',
-      });
-      expect(repository.clear).toHaveBeenCalled();
-    });
-    it('should log and throw on error', async () => {
-      permissionService.valid.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(
-        service.createMany([{ ...mockData }], mockUser, { mode: undefined }),
-      ).rejects.toThrow('fail');
-    });
-  });
-
-  describe('readById', () => {
-    it('should return result without password', async () => {
-      const res = await service.readById('id', mockUser);
-      expect(res.password).toBeUndefined();
-    });
-    it('should log and throw on error', async () => {
-      repository.getById.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(service.readById('id', mockUser)).rejects.toThrow('fail');
-    });
-  });
-
-  describe('read', () => {
-    it('should return data and totalCount', async () => {
-      const res = await service.read({}, {}, mockUser);
-      expect(res).toHaveProperty('data');
-    });
-    it('should log and throw on error', async () => {
-      repository.getByCriteria.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(service.read({}, {}, mockUser)).rejects.toThrow('fail');
-    });
-  });
-
-  describe('readBySpec', () => {
-    it('should call read with spec', async () => {
-      const spy = jest
-        .spyOn(service, 'read')
-        .mockResolvedValue({ data: [], totalCount: 0 });
-      await service.readBySpec({ criteria: {} }, {}, mockUser);
-      expect(spy).toHaveBeenCalled();
-    });
-  });
-
-  describe('update', () => {
-    it('should update', async () => {
-      await service.update('id', { ...mockData }, mockUser);
-      expect(repository.update).toHaveBeenCalled();
-    });
-    it('should log and throw on error', async () => {
-      repository.update.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(
-        service.update('id', { ...mockData }, mockUser),
-      ).rejects.toThrow('fail');
-    });
-  });
-
-  describe('updatePartial', () => {
-    it('should updatePartial', async () => {
-      await service.updatePartial('id', { ...mockData }, mockUser);
-      expect(repository.updatePartial).toHaveBeenCalled();
-    });
-    it('should log and throw on error', async () => {
-      repository.updatePartial.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(
-        service.updatePartial('id', { ...mockData }, mockUser),
-      ).rejects.toThrow('fail');
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete', async () => {
-      await service.delete('id', mockUser);
-      expect(repository.delete).toHaveBeenCalled();
-    });
-    it('should log and throw on error', async () => {
-      repository.delete.mockImplementation(() => {
-        throw new Error('fail');
-      });
-      await expect(service.delete('id', mockUser)).rejects.toThrow('fail');
-    });
-  });
-
-  describe('uploadAttachment', () => {
-    it('should upload and return id', async () => {
-      const fakeStream = {
-        pipe: jest.fn(),
-        addListener: jest.fn(),
-        on: jest.fn(),
-        once: jest.fn(),
-        emit: jest.fn(),
-        removeListener: jest.fn(),
-        destroy: jest.fn(),
-        off: jest.fn(),
-        removeAllListeners: jest.fn(),
-        setMaxListeners: jest.fn(),
-        getMaxListeners: jest.fn(),
-        listeners: jest.fn(),
-        rawListeners: jest.fn(),
-        prependListener: jest.fn(),
-        prependOnceListener: jest.fn(),
-        eventNames: jest.fn(),
-        listenerCount: jest.fn(),
-      };
-      const id = await service.uploadAttachment({
-        id: '',
-        fileName: '',
-        stream: fakeStream,
-        mimeType: '',
-        encoding: '',
-      });
-      expect(typeof id).toBe('string');
-    });
-  });
-
-  describe('getAttachmentInfo', () => {
-    it('should get info', async () => {
-      const info = await service.getAttachmentInfo('id');
-      expect(info).toHaveProperty('fileName');
-    });
-  });
-
-  describe('getAttachmentStream', () => {
-    it('should get stream', async () => {
-      const stream = await service.getAttachmentStream('id');
-      expect(stream).toBeDefined();
-    });
-  });
-
-  describe('deleteAttachment', () => {
-    it('should delete attachment', async () => {
-      await service.deleteAttachment('id');
-      expect(attachmentRepository.delete).toHaveBeenCalled();
-    });
-  });
-
-  describe('changes', () => {
-    it('should return observable', () => {
-      const obs = service.changes({});
-      expect(obs instanceof Observable).toBe(true);
-    });
-  });
-});

package/src/lib/services/crud/crud.service.ts

@@ -1,285 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import * as CombinedStream from 'combined-stream';
-import { Guid } from 'guid-typescript';
-import { Memoize } from 'lodash-decorators';
-import { Observable } from 'rxjs';
-
-import { ICreateManyOptions } from '@smartsoft001/crud-domain';
-import { ItemChangedData } from '@smartsoft001/crud-shell-dtos';
-import {
-  DomainValidationError,
-  IAttachmentRepository,
-  IEntity,
-  IItemRepository,
-  ISpecification,
-} from '@smartsoft001/domain-core';
-import { castModel, getInvalidFields, isModel } from '@smartsoft001/models';
-import { PermissionService } from '@smartsoft001/nestjs';
-import { IUser } from '@smartsoft001/users';
-import { GuidService, PasswordService } from '@smartsoft001/utils';
-
-import { Readable, Stream } from 'stream';
-
-@Injectable()
-export class CrudService<T extends IEntity<string>> {
-  private _logger = new Logger(CrudService.name, { timestamp: true });
-
-  constructor(
-    protected readonly permissionService: PermissionService,
-    protected readonly repository: IItemRepository<T>,
-    protected readonly attachmentRepository: IAttachmentRepository<T>,
-  ) {}
-
-  async create(data: T, user: IUser): Promise<string> {
-    data.id = Guid.raw();
-
-    try {
-      this.permissionService.valid('create', user);
-
-      castModel(data, 'create', user.permissions);
-      this.checkValidCreate(data, user.permissions);
-
-      if (data['password']) {
-        data['password'] = await PasswordService.hash(data['password']);
-      }
-      if (data['passwordConfirm']) {
-        delete data['passwordConfirm'];
-      }
-      await this.repository.create(data, user);
-
-      return data.id;
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  async createMany(
-    data: T[],
-    user: IUser,
-    options: ICreateManyOptions,
-  ): Promise<T[]> {
-    data.forEach((item) => {
-      item.id = Guid.raw();
-    });
-
-    try {
-      this.permissionService.valid('create', user);
-
-      data.forEach((item) => {
-        castModel(item, 'create', user.permissions);
-        this.checkValidCreate(item, user.permissions);
-      });
-
-      if (options && options.mode === 'replace') {
-        await this.repository.clear(user);
-      }
-
-      for (let index = 0; index < data.length; index++) {
-        const item = data[index];
-
-        if (item['password']) {
-          item['password'] = await PasswordService.hash(item['password']);
-        }
-
-        if (item['passwordConfirm']) {
-          delete item['passwordConfirm'];
-        }
-      }
-
-      await this.repository.createMany(data, user);
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-
-    return data;
-  }
-
-  async readById(id: string, user: IUser): Promise<T> {
-    try {
-      this.permissionService.valid('read', user);
-      const result = await this.repository.getById(id);
-      delete result['password'];
-
-      return result;
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  async read(
-    criteria: any,
-    options: any,
-    user: IUser,
-  ): Promise<{ data: T[]; totalCount: number }> {
-    try {
-      this.permissionService.valid('read', user);
-      const result = await this.repository.getByCriteria(criteria, options);
-      result.data.forEach((item) => delete item['password']);
-
-      return result;
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  readBySpec(
-    spec: ISpecification,
-    options: any,
-    user: IUser,
-  ): Promise<{ data: T[]; totalCount: number }> {
-    return this.read(spec.criteria, options, user);
-  }
-
-  async update(id: string, data: T, user: IUser): Promise<void> {
-    try {
-      data.id = id;
-      this.permissionService.valid('update', user);
-
-      castModel(data, 'update', user.permissions);
-      this.checkValidUpdate(data, user.permissions);
-
-      if (data['password']) {
-        data['password'] = await PasswordService.hash(data['password']);
-      }
-      if (data['passwordConfirm']) {
-        delete data['passwordConfirm'];
-      }
-      await this.repository.update(data, user);
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  async updatePartial(
-    id: string,
-    data: Partial<T>,
-    user: IUser,
-  ): Promise<void> {
-    try {
-      data.id = id;
-
-      this.permissionService.valid('update', user);
-
-      castModel(data, 'update', user.permissions);
-      this.checkValidUpdatePartial(data, user.permissions);
-
-      if (data['password']) {
-        data['password'] = await PasswordService.hash(data['password']);
-      }
-      if (data['passwordConfirm']) {
-        delete data['passwordConfirm'];
-      }
-      await this.repository.updatePartial(data as Partial<T> & { id }, user);
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  async delete(id: string, user: IUser): Promise<void> {
-    try {
-      this.permissionService.valid('delete', user);
-
-      await this.repository.delete(id, user);
-    } catch (e) {
-      this._logger.error(e);
-      throw e;
-    }
-  }
-
-  async uploadAttachment(
-    data: {
-      id: string;
-      fileName: string;
-      stream: Stream;
-      mimeType: string;
-      encoding: string;
-    },
-    options?: { streamCallback?: (r) => void; start?: number },
-  ): Promise<string> {
-    if (!data.id) {
-      data.id = GuidService.create();
-    }
-    let oldId = null;
-
-    if (options?.start) {
-      oldId = data.id;
-      const stream = await this.attachmentRepository.getStream(data.id, {
-        start: 0,
-        end: options.start - 1,
-      });
-
-      const combinedStream = CombinedStream.create();
-      combinedStream.append(stream);
-      combinedStream.append(data.stream);
-
-      data.stream = combinedStream;
-      data.id = GuidService.create();
-    }
-
-    this.attachmentRepository.upload(data, options);
-
-    if (oldId) await this.attachmentRepository.delete(data.id);
-
-    return data.id;
-  }
-
-  @Memoize()
-  getAttachmentInfo(
-    id: string,
-  ): Promise<{ fileName: string; contentType: string; length: number }> {
-    return this.attachmentRepository.getInfo(id);
-  }
-
-  getAttachmentStream(
-    id: string,
-    options?: { start: number; end: number },
-  ): Promise<Readable> {
-    return this.attachmentRepository.getStream(id, options);
-  }
-
-  async deleteAttachment(id: string): Promise<void> {
-    return this.attachmentRepository.delete(id);
-  }
-
-  changes(criteria: { id?: string }): Observable<ItemChangedData> {
-    return this.repository.changesByCriteria(criteria);
-  }
-
-  private checkValidCreate(item: T, permissions: Array<string>): void {
-    const array = getInvalidFields(item, 'create', permissions);
-
-    if (array.length) {
-      throw new DomainValidationError('Required fields: ' + array.join(', '));
-    }
-  }
-
-  private checkValidUpdate(item: T, permissions: Array<string>): void {
-    const array = getInvalidFields(item, 'update', permissions);
-
-    if (array.length) {
-      throw new DomainValidationError('Required fields: ' + array.join(', '));
-    }
-  }
-
-  private checkValidUpdatePartial(
-    item: Partial<T>,
-    permissions: Array<string>,
-  ): void {
-    if (!isModel(item)) return;
-
-    const keys = Object.keys(item);
-    const array = getInvalidFields(item, 'update', permissions).filter(
-      (invalidField) => keys.some((key) => key === invalidField),
-    );
-
-    if (array.length) {
-      throw new DomainValidationError('Required fields: ' + array.join(', '));
-    }
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

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

package/tsconfig.spec.json

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