@smartsoft001/domain-core 2.30.0 → 2.39.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: 'domain-core',
+  preset: '../../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../../coverage/packages/shared/domain-core',
+};

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@smartsoft001/domain-core",
-  "version": "2.30.0",
+  "type": "commonjs",
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@smartsoft001/models": "2.30.0",
     "rxjs": "^7.8.1",
-    "@smartsoft001/users": "2.30.0"
+    "@smartsoft001/models": "^2.39.0",
+    "@smartsoft001/users": "^2.39.0"
   },
-  "type": "commonjs",
+  "version": "2.39.0",
   "main": "./src/index.js",
-  "typings": "./src/index.d.ts",
-  "types": "./src/index.d.ts"
-}
+  "typings": "./src/index.d.ts"
+}

package/project.json

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

package/src/lib/errors.ts

@@ -0,0 +1,15 @@
+export class DomainValidationError extends Error {
+    type = DomainValidationError;
+
+    constructor(msg: string) {
+        super(msg);
+    }
+}
+
+export class DomainForbiddenError extends Error {
+    type = DomainForbiddenError;
+
+    constructor(msg: string) {
+        super(msg);
+    }
+}

package/src/lib/{interfaces.d.ts → interfaces.ts}

@@ -1,6 +1,13 @@
+/*
+ * Interface for entities
+ */
 export interface IEntity<T> {
     id: T;
 }
+
+/*
+ * Address interface
+ */
 export interface IAddress {
     city: string;
     street: string;
@@ -8,11 +15,26 @@ export interface IAddress {
     flatNumber?: string;
     zipCode: string;
 }
+
+/*
+ * Date range interface
+ */
 export interface IDateRange {
+    /*
+     * YYYY-MM-DD
+     */
     start: `${string}-${string}-${string}`;
+    /*
+     * YYYY-MM-DD
+     */
     end: `${string}-${string}-${string}`;
 }
+
+/*
+ * Factory interface
+ */
 export interface IFactory<T, TConfig> {
     create(config: NonNullable<TConfig>): Promise<T>;
 }
+
 export { ISpecification } from "@smartsoft001/models";

package/src/lib/repositories.ts

@@ -0,0 +1,339 @@
+import { Observable } from "rxjs";
+
+import { IUser } from "@smartsoft001/users";
+
+import { IEntity, ISpecification } from "./interfaces";
+
+/**
+ * ITransaction defines the structure of a transaction context that can be used to
+ * perform a series of database operations as a single atomic unit of work.
+ *
+ * @interface ITransaction
+ */
+export interface ITransaction {
+  /**
+   * The connection object that provides access to the database.
+   *
+   * This property typically represents the active database connection that is used
+   * to execute operations within the transaction. The exact type of the connection
+   * may vary depending on the database being used (e.g., MongoDB, SQL, etc.).
+   *
+   * @type {any}
+   */
+  connection: any;
+}
+
+/**
+ * IUnitOfWork is an abstract class that defines the contract for managing transactional operations
+ * across multiple repositories or services. This pattern ensures that a set of operations either
+ * all succeed or all fail, maintaining data consistency.
+ *
+ * @interface IUnitOfWork
+ */
+export abstract class IUnitOfWork {
+  /**
+   * Executes a set of operations within a transactional scope.
+   *
+   * @param {function(ITransaction): Promise<void>} definition - A function that contains the operations to be executed within the transaction.
+   * The function receives an `ITransaction` object that provides the necessary context for the transaction.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the transactional operations are completed successfully.
+   *
+   * @throws {Error} - Throws an error if the transaction fails, in which case all operations are rolled back.
+   *
+   * @example
+   * await this.unitOfWork.scope(async (tx) => {
+   *       await this.itemRepository.updatePartial(
+   *         {
+   *           id: id1,
+   *           status: "finished",
+   *         },
+   *         user,
+   *         { transaction: tx }
+   *       );
+   *
+   *       await this.itemRepository.updatePartial(
+   *           {
+   *             id: id2,
+   *             status: "finished",
+   *           },
+   *           user,
+   *           { transaction: tx }
+   *       );
+   * });
+   */
+  abstract scope(definition: (transaction: ITransaction) => Promise<void>): Promise<void>;
+}
+
+/**
+ *
+ * @interface IItemRepositoryOptions
+ */
+export interface IItemRepositoryOptions {
+  transaction: ITransaction;
+}
+
+/**
+ * IItemRepository is an abstract class that defines the contract for a repository
+ * responsible for managing entities of type `T` in a storage system. This repository
+ * interface provides a set of methods for creating, updating, deleting, and querying
+ * entities, with support for transactional operations and various query criteria.
+ *
+ * @template T - The type of entity that this repository will manage. The entity should extend `IEntity<string>`.
+ *
+ * @interface IItemRepository
+ */
+export abstract class IItemRepository<T extends IEntity<string>> {
+  /**
+   * Creates a new entity in the storage system.
+   *
+   * @param {T} item - The entity to be created.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entity is successfully created.
+   */
+  abstract create(item: T, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
+
+  /**
+   * Creates multiple entities in the storage system.
+   *
+   * @param {T[]} list - The list of entities to be created.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when all entities are successfully created.
+   */
+  abstract createMany(list: T[], user: IUser, options?: IItemRepositoryOptions): Promise<void>;
+
+  /**
+   * Updates an existing entity in the storage system.
+   *
+   * @param {T} item - The entity to be updated.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entity is successfully updated.
+   */
+  abstract update(item: T, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
+
+  /**
+   * Partially updates an existing entity in the storage system.
+   *
+   * @param {Partial<T> & { id: string }} item - The partial entity data to be updated along with the entity's ID.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entity is successfully updated.
+   */
+  abstract updatePartial(
+    item: Partial<T> & { id: string },
+    user: IUser
+      , options?: IItemRepositoryOptions
+  ): Promise<void>;
+
+  /**
+   * Partially updates multiple entities that match the specified criteria.
+   *
+   * @param {any} criteria - The criteria used to select the entities to be updated.
+   * @param {Partial<T>} set - The partial data to be set on the matching entities.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entities are successfully updated.
+   */
+  abstract updatePartialManyByCriteria(
+    criteria: any,
+    set: Partial<T>,
+    user: IUser, options?: IItemRepositoryOptions
+  ): Promise<void>;
+
+  /**
+   * Partially updates multiple entities that match the specified specification.
+   *
+   * @param {ISpecification} spec - The specification used to select the entities to be updated.
+   * @param {Partial<T>} set - The partial data to be set on the matching entities.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entities are successfully updated.
+   */
+  abstract updatePartialManyBySpecification(
+    spec: ISpecification,
+    set: Partial<T>,
+    user: IUser, options?: IItemRepositoryOptions
+  ): Promise<void>;
+
+  /**
+   * Deletes an entity from the storage system by its ID.
+   *
+   * @param {string} id - The ID of the entity to be deleted.
+   * @param {IUser} user - The user performing the operation.
+   * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the entity is successfully deleted.
+   */
+  abstract delete(id: string, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
+
+  /**
+   * Retrieves an entity from the storage system by its ID.
+   *
+   * @param {string} id - The ID of the entity to be retrieved.
+   * @param {IItemRepositoryOptions} [repoOptions] - Optional parameters for the operation, including transaction context.
+   *
+   * @returns {Promise<T>} - A promise that resolves to the retrieved entity.
+   */
+  abstract getById(id: string, repoOptions?: IItemRepositoryOptions): Promise<T>;
+
+  /**
+   * Retrieves entities from the storage system that match the specified criteria.
+   *
+   * @param {any} criteria - The criteria used to select the entities.
+   * @param {any} [options] - Optional parameters for the operation, such as pagination or sorting.
+   *
+   * @returns {Promise<{ data: T[]; totalCount: number }>} - A promise that resolves to an object containing the matching entities and the total count.
+   */
+  abstract getByCriteria(
+    criteria: any,
+    options?: any
+  ): Promise<{ data: T[]; totalCount: number }>;
+
+  /**
+   * Retrieves entities from the storage system that match the specified specification.
+   *
+   * @param {ISpecification} spec - The specification used to select the entities.
+   * @param {any} [options] - Optional parameters for the operation, such as pagination or sorting.
+   *
+   * @returns {Promise<{ data: T[]; totalCount: number }>} - A promise that resolves to an object containing the matching entities and the total count.
+   */
+  abstract getBySpecification(
+    spec: ISpecification,
+    options?: any
+  ): Promise<{ data: T[]; totalCount: number }>;
+
+  /**
+   * Counts the number of entities in the storage system that match the specified criteria.
+   *
+   * @param {any} criteria - The criteria used to count the entities.
+   *
+   * @returns {Promise<number>} - A promise that resolves to the count of matching entities.
+   */
+  abstract countByCriteria(criteria: any): Promise<number>;
+
+  /**
+   * Counts the number of entities in the storage system that match the specified specification.
+   *
+   * @param {ISpecification} spec - The specification used to count the entities.
+   *
+   * @returns {Promise<number>} - A promise that resolves to the count of matching entities.
+   */
+  abstract countBySpecification(spec: ISpecification): Promise<number>;
+
+  /**
+   * Clears all entities from the storage system.
+   *
+   * @param user
+   *
+   * @returns {Promise<void>} - A promise that resolves when the storage system is cleared.
+   */
+  abstract clear(user: IUser | IItemRepositoryOptions): Promise<void>;
+
+  /**
+   * Returns an observable that emits changes to entities that match the specified criteria.
+   *
+   * @param {any} criteria - The criteria used to select the entities to observe.
+   *
+   * @returns {Observable<any>} - An observable that emits changes to the matching entities.
+   */
+  abstract changesByCriteria(criteria: { id?: string }): Observable<any>;
+}
+
+/**
+ * IAttachmentRepository is an abstract class that defines the contract for managing file attachments
+ * in a storage system. This interface can be implemented to work with various storage backends, such as
+ * MongoDB GridFS, Amazon S3, Google Cloud Storage, or any other file storage solution.
+ *
+ * @template T - The type of the entity that this repository will manage. The entity should extend `IEntity<string>`.
+ *
+ * @interface IAttachmentRepository
+ */
+export abstract class IAttachmentRepository<T extends IEntity<string>> {
+  /**
+   * Uploads a file to the storage system.
+   *
+   * @param {Object} data - The data required to upload the file.
+   * @param {string} data.id - A unique identifier for the file.
+   * @param {string} data.fileName - The name of the file to be uploaded.
+   * @param {Stream} data.stream - The stream of the file to be uploaded.
+   * @param {string} data.mimeType - The MIME type of the file.
+   * @param {string} data.encoding - The encoding of the file.
+   *
+   * @param {Object} [options] - Optional parameters for the upload.
+   * @param {Function} [options.streamCallback] - A callback function that gets invoked with the upload stream.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the upload is complete.
+   *
+   * @throws {Error} - Throws an error if the upload fails.
+   *
+   * @example
+   * // Example usage with MongoDB implementation:
+   * const repository = new MongoAttachmentRepository(config);
+   *
+   * const fileStream = fs.createReadStream('/path/to/file');
+   *
+   * await repository.upload({
+   *   id: 'unique-file-id',
+   *   fileName: 'example.txt',
+   *   stream: fileStream,
+   *   mimeType: 'text/plain',
+   *   encoding: 'utf-8'
+   * }, {
+   *   streamCallback: (writeStream) => {
+   *     console.log('Upload started');
+   *   }
+   * });
+   *
+   * console.log('File uploaded successfully');
+   */
+  abstract upload(
+      data: { id: string, fileName: string; stream: any; mimeType: string; encoding: string },
+      options?: { streamCallback?: (r: any) => void }
+  ): Promise<void>;
+
+  /**
+   * Retrieves metadata information about a file stored in the storage system.
+   *
+   * @param {string} id - The unique identifier of the file.
+   *
+   * @returns {Promise<{ fileName: string, contentType: string, length: number } | null>}
+   * - A promise that resolves to an object containing file metadata, or `null` if the file is not found.
+   *
+   * @throws {Error} - Throws an error if retrieving the file information fails.
+   */
+  abstract getInfo(id: string): Promise<{ fileName: string, contentType: string, length: number }>;
+
+  /**
+   * Retrieves a stream for downloading a file from the storage system.
+   *
+   * @param {string} id - The unique identifier of the file.
+   * @param {Object} [options] - Optional parameters for retrieving a specific range of the file.
+   * @param {number} [options.start] - The starting byte position for the stream.
+   * @param {number} [options.end] - The ending byte position for the stream.
+   *
+   * @returns {Promise<any>} - A promise that resolves to a readable stream of the file.
+   *
+   * @throws {Error} - Throws an error if retrieving the file stream fails.
+   */
+  abstract getStream(id: string, options?: { start: number; end: number }): Promise<any>;
+
+  /**
+   * Deletes a file from the storage system.
+   *
+   * @param {string} id - The unique identifier of the file to be deleted.
+   *
+   * @returns {Promise<void>} - A promise that resolves when the file has been successfully deleted.
+   *
+   * @throws {Error} - Throws an error if the deletion fails.
+   */
+  abstract delete(id: string): Promise<void>;
+}

package/src/lib/specifications.spec.ts

@@ -0,0 +1,69 @@
+import { BasicSpecification, MergeSpecification, OrSpecification, AndSpecification } from './specifications';
+import { ISpecification } from './interfaces';
+
+describe('shared-domain-core: BasicSpecification', () => {
+    it('should create a BasicSpecification with the given criteria', () => {
+        const criteria = { key: 'value' };
+
+        const spec = new BasicSpecification(criteria);
+
+        expect(spec.criteria).toEqual(criteria);
+    });
+});
+
+describe('shared-domain-core: MergeSpecification', () => {
+    it('should merge multiple specifications into one', () => {
+        const spec1: ISpecification = { criteria: { key1: 'value1' } };
+        const spec2: ISpecification = { criteria: { key2: 'value2' } };
+
+        const spec = new MergeSpecification(spec1, spec2);
+
+        expect(spec.criteria).toEqual({
+            key1: 'value1',
+            key2: 'value2'
+        });
+    });
+
+    it('should override criteria with the same key', () => {
+        const spec1: ISpecification = { criteria: { key: 'value1' } };
+        const spec2: ISpecification = { criteria: { key: 'value2' } };
+
+        const spec = new MergeSpecification(spec1, spec2);
+
+        expect(spec.criteria).toEqual({
+            key: 'value2'
+        });
+    });
+});
+
+describe('shared-domain-core: OrSpecification', () => {
+    it('should combine multiple specifications using logical OR', () => {
+        const spec1: ISpecification = { criteria: { key1: 'value1' } };
+        const spec2: ISpecification = { criteria: { key2: 'value2' } };
+
+        const spec = new OrSpecification(spec1, spec2);
+
+        expect(spec.criteria).toEqual({
+            $or: [
+                { key1: 'value1' },
+                { key2: 'value2' }
+            ]
+        });
+    });
+});
+
+describe('shared-domain-core: AndSpecification', () => {
+    it('should combine multiple specifications using logical AND', () => {
+        const spec1: ISpecification = { criteria: { key1: 'value1' } };
+        const spec2: ISpecification = { criteria: { key2: 'value2' } };
+        
+        const spec = new AndSpecification(spec1, spec2);
+
+        expect(spec.criteria).toEqual({
+            $and: [
+                { key1: 'value1' },
+                { key2: 'value2' }
+            ]
+        });
+    });
+});

package/src/lib/{specifications.js → specifications.ts}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndSpecification = exports.OrSpecification = exports.MergeSpecification = exports.BasicSpecification = void 0;
+import {ISpecification} from "./interfaces";
+
 /**
  * BasicSpecification is a class that implements the `ISpecification` interface and serves as a base
  * class for defining basic query criteria. It holds a single set of criteria that can be used to
@@ -12,17 +11,16 @@ exports.AndSpecification = exports.OrSpecification = exports.MergeSpecification
  * @class BasicSpecification
  * @implements {ISpecification}
  */
-class BasicSpecification {
+export class BasicSpecification implements ISpecification {
+
     /**
      * Creates an instance of BasicSpecification.
      *
      * @param {any} criteria - The criteria used to filter entities.
      */
-    constructor(criteria) {
-        this.criteria = criteria;
-    }
+    constructor(public readonly criteria: any) { }
 }
-exports.BasicSpecification = BasicSpecification;
+
 /**
  * MergeSpecification is a class that extends `BasicSpecification` and allows for the merging of multiple
  * specifications into a single specification. The resulting specification combines the criteria of all provided
@@ -33,21 +31,27 @@ exports.BasicSpecification = BasicSpecification;
  * @class MergeSpecification
  * @extends {BasicSpecification}
  */
-class MergeSpecification extends BasicSpecification {
+export class MergeSpecification extends BasicSpecification {
+
     /**
      * Creates an instance of MergeSpecification.
      *
      * @param {...ISpecification[]} specs - An array of specifications to be merged.
      */
-    constructor(...specs) {
+    constructor(...specs: Array<ISpecification>) {
         let criteria = {};
+
         specs.forEach(spec => {
-            criteria = Object.assign(Object.assign({}, criteria), spec.criteria);
+           criteria = {
+               ...criteria,
+               ...spec.criteria
+           }
         });
+
         super(criteria);
     }
 }
-exports.MergeSpecification = MergeSpecification;
+
 /**
  * OrSpecification is a class that extends `BasicSpecification` and allows for the combination of
  * multiple specifications using a logical OR operation. The resulting specification matches entities that satisfy
@@ -59,19 +63,20 @@ exports.MergeSpecification = MergeSpecification;
  * @class OrSpecification
  * @extends {BasicSpecification}
  */
-class OrSpecification extends BasicSpecification {
+export class OrSpecification extends BasicSpecification {
+
     /**
      * Creates an instance of OrSpecification.
      *
      * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical OR.
      */
-    constructor(...spec) {
+    constructor(...spec: Array<ISpecification>) {
         super({
             $or: spec.map(c => c.criteria)
         });
     }
 }
-exports.OrSpecification = OrSpecification;
+
 /**
  * AndSpecification is a class that extends `BasicSpecification` and allows for the combination of
  * multiple specifications using a logical AND operation. The resulting specification matches entities that satisfy
@@ -83,17 +88,16 @@ exports.OrSpecification = OrSpecification;
  * @class AndSpecification
  * @extends {BasicSpecification}
  */
-class AndSpecification extends BasicSpecification {
+export class AndSpecification extends BasicSpecification {
+
     /**
      * Creates an instance of AndSpecification.
      *
      * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical AND.
      */
-    constructor(...spec) {
+    constructor(...spec: Array<ISpecification>) {
         super({
             $and: spec.map(c => c.criteria)
         });
     }
 }
-exports.AndSpecification = AndSpecification;
-//# sourceMappingURL=specifications.js.map

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/src/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/interfaces"), exports);
-tslib_1.__exportStar(require("./lib/errors"), exports);
-tslib_1.__exportStar(require("./lib/repositories"), exports);
-tslib_1.__exportStar(require("./lib/specifications"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/shared/domain-core/src/index.ts"],"names":[],"mappings":";;;AAAA,2DAAiC;AACjC,uDAA6B;AAC7B,6DAAmC;AACnC,+DAAqC"}

package/src/lib/errors.d.ts

@@ -1,8 +0,0 @@
-export declare class DomainValidationError extends Error {
-    type: typeof DomainValidationError;
-    constructor(msg: string);
-}
-export declare class DomainForbiddenError extends Error {
-    type: typeof DomainForbiddenError;
-    constructor(msg: string);
-}

package/src/lib/errors.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DomainForbiddenError = exports.DomainValidationError = void 0;
-class DomainValidationError extends Error {
-    constructor(msg) {
-        super(msg);
-        this.type = DomainValidationError;
-    }
-}
-exports.DomainValidationError = DomainValidationError;
-class DomainForbiddenError extends Error {
-    constructor(msg) {
-        super(msg);
-        this.type = DomainForbiddenError;
-    }
-}
-exports.DomainForbiddenError = DomainForbiddenError;
-//# sourceMappingURL=errors.js.map

package/src/lib/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../../../packages/shared/domain-core/src/lib/errors.ts"],"names":[],"mappings":";;;AAAA,MAAa,qBAAsB,SAAQ,KAAK;IAG5C,YAAY,GAAW;QACnB,KAAK,CAAC,GAAG,CAAC,CAAC;QAHf,SAAI,GAAG,qBAAqB,CAAC;IAI7B,CAAC;CACJ;AAND,sDAMC;AAED,MAAa,oBAAqB,SAAQ,KAAK;IAG3C,YAAY,GAAW;QACnB,KAAK,CAAC,GAAG,CAAC,CAAC;QAHf,SAAI,GAAG,oBAAoB,CAAC;IAI5B,CAAC;CACJ;AAND,oDAMC"}

package/src/lib/interfaces.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interfaces.js.map

package/src/lib/interfaces.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../packages/shared/domain-core/src/lib/interfaces.ts"],"names":[],"mappings":""}

package/src/lib/repositories.d.ts

@@ -1,320 +0,0 @@
-import { Observable } from "rxjs";
-import { IUser } from "@smartsoft001/users";
-import { IEntity, ISpecification } from "./interfaces";
-/**
- * ITransaction defines the structure of a transaction context that can be used to
- * perform a series of database operations as a single atomic unit of work.
- *
- * @interface ITransaction
- */
-export interface ITransaction {
-    /**
-     * The connection object that provides access to the database.
-     *
-     * This property typically represents the active database connection that is used
-     * to execute operations within the transaction. The exact type of the connection
-     * may vary depending on the database being used (e.g., MongoDB, SQL, etc.).
-     *
-     * @type {any}
-     */
-    connection: any;
-}
-/**
- * IUnitOfWork is an abstract class that defines the contract for managing transactional operations
- * across multiple repositories or services. This pattern ensures that a set of operations either
- * all succeed or all fail, maintaining data consistency.
- *
- * @interface IUnitOfWork
- */
-export declare abstract class IUnitOfWork {
-    /**
-     * Executes a set of operations within a transactional scope.
-     *
-     * @param {function(ITransaction): Promise<void>} definition - A function that contains the operations to be executed within the transaction.
-     * The function receives an `ITransaction` object that provides the necessary context for the transaction.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the transactional operations are completed successfully.
-     *
-     * @throws {Error} - Throws an error if the transaction fails, in which case all operations are rolled back.
-     *
-     * @example
-     * await this.unitOfWork.scope(async (tx) => {
-     *       await this.itemRepository.updatePartial(
-     *         {
-     *           id: id1,
-     *           status: "finished",
-     *         },
-     *         user,
-     *         { transaction: tx }
-     *       );
-     *
-     *       await this.itemRepository.updatePartial(
-     *           {
-     *             id: id2,
-     *             status: "finished",
-     *           },
-     *           user,
-     *           { transaction: tx }
-     *       );
-     * });
-     */
-    abstract scope(definition: (transaction: ITransaction) => Promise<void>): Promise<void>;
-}
-/**
- *
- * @interface IItemRepositoryOptions
- */
-export interface IItemRepositoryOptions {
-    transaction: ITransaction;
-}
-/**
- * IItemRepository is an abstract class that defines the contract for a repository
- * responsible for managing entities of type `T` in a storage system. This repository
- * interface provides a set of methods for creating, updating, deleting, and querying
- * entities, with support for transactional operations and various query criteria.
- *
- * @template T - The type of entity that this repository will manage. The entity should extend `IEntity<string>`.
- *
- * @interface IItemRepository
- */
-export declare abstract class IItemRepository<T extends IEntity<string>> {
-    /**
-     * Creates a new entity in the storage system.
-     *
-     * @param {T} item - The entity to be created.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entity is successfully created.
-     */
-    abstract create(item: T, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Creates multiple entities in the storage system.
-     *
-     * @param {T[]} list - The list of entities to be created.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when all entities are successfully created.
-     */
-    abstract createMany(list: T[], user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Updates an existing entity in the storage system.
-     *
-     * @param {T} item - The entity to be updated.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entity is successfully updated.
-     */
-    abstract update(item: T, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Partially updates an existing entity in the storage system.
-     *
-     * @param {Partial<T> & { id: string }} item - The partial entity data to be updated along with the entity's ID.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entity is successfully updated.
-     */
-    abstract updatePartial(item: Partial<T> & {
-        id: string;
-    }, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Partially updates multiple entities that match the specified criteria.
-     *
-     * @param {any} criteria - The criteria used to select the entities to be updated.
-     * @param {Partial<T>} set - The partial data to be set on the matching entities.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entities are successfully updated.
-     */
-    abstract updatePartialManyByCriteria(criteria: any, set: Partial<T>, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Partially updates multiple entities that match the specified specification.
-     *
-     * @param {ISpecification} spec - The specification used to select the entities to be updated.
-     * @param {Partial<T>} set - The partial data to be set on the matching entities.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entities are successfully updated.
-     */
-    abstract updatePartialManyBySpecification(spec: ISpecification, set: Partial<T>, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Deletes an entity from the storage system by its ID.
-     *
-     * @param {string} id - The ID of the entity to be deleted.
-     * @param {IUser} user - The user performing the operation.
-     * @param {IItemRepositoryOptions} [options] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the entity is successfully deleted.
-     */
-    abstract delete(id: string, user: IUser, options?: IItemRepositoryOptions): Promise<void>;
-    /**
-     * Retrieves an entity from the storage system by its ID.
-     *
-     * @param {string} id - The ID of the entity to be retrieved.
-     * @param {IItemRepositoryOptions} [repoOptions] - Optional parameters for the operation, including transaction context.
-     *
-     * @returns {Promise<T>} - A promise that resolves to the retrieved entity.
-     */
-    abstract getById(id: string, repoOptions?: IItemRepositoryOptions): Promise<T>;
-    /**
-     * Retrieves entities from the storage system that match the specified criteria.
-     *
-     * @param {any} criteria - The criteria used to select the entities.
-     * @param {any} [options] - Optional parameters for the operation, such as pagination or sorting.
-     *
-     * @returns {Promise<{ data: T[]; totalCount: number }>} - A promise that resolves to an object containing the matching entities and the total count.
-     */
-    abstract getByCriteria(criteria: any, options?: any): Promise<{
-        data: T[];
-        totalCount: number;
-    }>;
-    /**
-     * Retrieves entities from the storage system that match the specified specification.
-     *
-     * @param {ISpecification} spec - The specification used to select the entities.
-     * @param {any} [options] - Optional parameters for the operation, such as pagination or sorting.
-     *
-     * @returns {Promise<{ data: T[]; totalCount: number }>} - A promise that resolves to an object containing the matching entities and the total count.
-     */
-    abstract getBySpecification(spec: ISpecification, options?: any): Promise<{
-        data: T[];
-        totalCount: number;
-    }>;
-    /**
-     * Counts the number of entities in the storage system that match the specified criteria.
-     *
-     * @param {any} criteria - The criteria used to count the entities.
-     *
-     * @returns {Promise<number>} - A promise that resolves to the count of matching entities.
-     */
-    abstract countByCriteria(criteria: any): Promise<number>;
-    /**
-     * Counts the number of entities in the storage system that match the specified specification.
-     *
-     * @param {ISpecification} spec - The specification used to count the entities.
-     *
-     * @returns {Promise<number>} - A promise that resolves to the count of matching entities.
-     */
-    abstract countBySpecification(spec: ISpecification): Promise<number>;
-    /**
-     * Clears all entities from the storage system.
-     *
-     * @param user
-     *
-     * @returns {Promise<void>} - A promise that resolves when the storage system is cleared.
-     */
-    abstract clear(user: IUser | IItemRepositoryOptions): Promise<void>;
-    /**
-     * Returns an observable that emits changes to entities that match the specified criteria.
-     *
-     * @param {any} criteria - The criteria used to select the entities to observe.
-     *
-     * @returns {Observable<any>} - An observable that emits changes to the matching entities.
-     */
-    abstract changesByCriteria(criteria: {
-        id?: string;
-    }): Observable<any>;
-}
-/**
- * IAttachmentRepository is an abstract class that defines the contract for managing file attachments
- * in a storage system. This interface can be implemented to work with various storage backends, such as
- * MongoDB GridFS, Amazon S3, Google Cloud Storage, or any other file storage solution.
- *
- * @template T - The type of the entity that this repository will manage. The entity should extend `IEntity<string>`.
- *
- * @interface IAttachmentRepository
- */
-export declare abstract class IAttachmentRepository<T extends IEntity<string>> {
-    /**
-     * Uploads a file to the storage system.
-     *
-     * @param {Object} data - The data required to upload the file.
-     * @param {string} data.id - A unique identifier for the file.
-     * @param {string} data.fileName - The name of the file to be uploaded.
-     * @param {Stream} data.stream - The stream of the file to be uploaded.
-     * @param {string} data.mimeType - The MIME type of the file.
-     * @param {string} data.encoding - The encoding of the file.
-     *
-     * @param {Object} [options] - Optional parameters for the upload.
-     * @param {Function} [options.streamCallback] - A callback function that gets invoked with the upload stream.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the upload is complete.
-     *
-     * @throws {Error} - Throws an error if the upload fails.
-     *
-     * @example
-     * // Example usage with MongoDB implementation:
-     * const repository = new MongoAttachmentRepository(config);
-     *
-     * const fileStream = fs.createReadStream('/path/to/file');
-     *
-     * await repository.upload({
-     *   id: 'unique-file-id',
-     *   fileName: 'example.txt',
-     *   stream: fileStream,
-     *   mimeType: 'text/plain',
-     *   encoding: 'utf-8'
-     * }, {
-     *   streamCallback: (writeStream) => {
-     *     console.log('Upload started');
-     *   }
-     * });
-     *
-     * console.log('File uploaded successfully');
-     */
-    abstract upload(data: {
-        id: string;
-        fileName: string;
-        stream: any;
-        mimeType: string;
-        encoding: string;
-    }, options?: {
-        streamCallback?: (r: any) => void;
-    }): Promise<void>;
-    /**
-     * Retrieves metadata information about a file stored in the storage system.
-     *
-     * @param {string} id - The unique identifier of the file.
-     *
-     * @returns {Promise<{ fileName: string, contentType: string, length: number } | null>}
-     * - A promise that resolves to an object containing file metadata, or `null` if the file is not found.
-     *
-     * @throws {Error} - Throws an error if retrieving the file information fails.
-     */
-    abstract getInfo(id: string): Promise<{
-        fileName: string;
-        contentType: string;
-        length: number;
-    }>;
-    /**
-     * Retrieves a stream for downloading a file from the storage system.
-     *
-     * @param {string} id - The unique identifier of the file.
-     * @param {Object} [options] - Optional parameters for retrieving a specific range of the file.
-     * @param {number} [options.start] - The starting byte position for the stream.
-     * @param {number} [options.end] - The ending byte position for the stream.
-     *
-     * @returns {Promise<any>} - A promise that resolves to a readable stream of the file.
-     *
-     * @throws {Error} - Throws an error if retrieving the file stream fails.
-     */
-    abstract getStream(id: string, options?: {
-        start: number;
-        end: number;
-    }): Promise<any>;
-    /**
-     * Deletes a file from the storage system.
-     *
-     * @param {string} id - The unique identifier of the file to be deleted.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the file has been successfully deleted.
-     *
-     * @throws {Error} - Throws an error if the deletion fails.
-     */
-    abstract delete(id: string): Promise<void>;
-}

package/src/lib/repositories.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IAttachmentRepository = exports.IItemRepository = exports.IUnitOfWork = void 0;
-/**
- * IUnitOfWork is an abstract class that defines the contract for managing transactional operations
- * across multiple repositories or services. This pattern ensures that a set of operations either
- * all succeed or all fail, maintaining data consistency.
- *
- * @interface IUnitOfWork
- */
-class IUnitOfWork {
-}
-exports.IUnitOfWork = IUnitOfWork;
-/**
- * IItemRepository is an abstract class that defines the contract for a repository
- * responsible for managing entities of type `T` in a storage system. This repository
- * interface provides a set of methods for creating, updating, deleting, and querying
- * entities, with support for transactional operations and various query criteria.
- *
- * @template T - The type of entity that this repository will manage. The entity should extend `IEntity<string>`.
- *
- * @interface IItemRepository
- */
-class IItemRepository {
-}
-exports.IItemRepository = IItemRepository;
-/**
- * IAttachmentRepository is an abstract class that defines the contract for managing file attachments
- * in a storage system. This interface can be implemented to work with various storage backends, such as
- * MongoDB GridFS, Amazon S3, Google Cloud Storage, or any other file storage solution.
- *
- * @template T - The type of the entity that this repository will manage. The entity should extend `IEntity<string>`.
- *
- * @interface IAttachmentRepository
- */
-class IAttachmentRepository {
-}
-exports.IAttachmentRepository = IAttachmentRepository;
-//# sourceMappingURL=repositories.js.map

package/src/lib/repositories.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"repositories.js","sourceRoot":"","sources":["../../../../../../packages/shared/domain-core/src/lib/repositories.ts"],"names":[],"mappings":";;;AAyBA;;;;;;GAMG;AACH,MAAsB,WAAW;CAiChC;AAjCD,kCAiCC;AAUD;;;;;;;;;GASG;AACH,MAAsB,eAAe;CAmKpC;AAnKD,0CAmKC;AAED;;;;;;;;GAQG;AACH,MAAsB,qBAAqB;CA+E1C;AA/ED,sDA+EC"}

package/src/lib/specifications.d.ts

@@ -1,77 +0,0 @@
-import { ISpecification } from "./interfaces";
-/**
- * BasicSpecification is a class that implements the `ISpecification` interface and serves as a base
- * class for defining basic query criteria. It holds a single set of criteria that can be used to
- * filter entities in a repository or database.
- *
- * This class can be extended to create more complex specifications by combining or modifying the
- * base criteria.
- *
- * @class BasicSpecification
- * @implements {ISpecification}
- */
-export declare class BasicSpecification implements ISpecification {
-    readonly criteria: any;
-    /**
-     * Creates an instance of BasicSpecification.
-     *
-     * @param {any} criteria - The criteria used to filter entities.
-     */
-    constructor(criteria: any);
-}
-/**
- * MergeSpecification is a class that extends `BasicSpecification` and allows for the merging of multiple
- * specifications into a single specification. The resulting specification combines the criteria of all provided
- * specifications using a shallow merge.
- *
- * This class is useful when you need to apply multiple specifications to a query in a way that combines their criteria.
- *
- * @class MergeSpecification
- * @extends {BasicSpecification}
- */
-export declare class MergeSpecification extends BasicSpecification {
-    /**
-     * Creates an instance of MergeSpecification.
-     *
-     * @param {...ISpecification[]} specs - An array of specifications to be merged.
-     */
-    constructor(...specs: Array<ISpecification>);
-}
-/**
- * OrSpecification is a class that extends `BasicSpecification` and allows for the combination of
- * multiple specifications using a logical OR operation. The resulting specification matches entities that satisfy
- * at least one of the provided specifications.
- *
- * This class is useful when you need to apply multiple specifications to a query in a way that matches entities
- * that meet any of the specified criteria.
- *
- * @class OrSpecification
- * @extends {BasicSpecification}
- */
-export declare class OrSpecification extends BasicSpecification {
-    /**
-     * Creates an instance of OrSpecification.
-     *
-     * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical OR.
-     */
-    constructor(...spec: Array<ISpecification>);
-}
-/**
- * AndSpecification is a class that extends `BasicSpecification` and allows for the combination of
- * multiple specifications using a logical AND operation. The resulting specification matches entities that satisfy
- * all the provided specifications.
- *
- * This class is useful when you need to apply multiple specifications to a query in a way that matches entities
- * that meet all the specified criteria.
- *
- * @class AndSpecification
- * @extends {BasicSpecification}
- */
-export declare class AndSpecification extends BasicSpecification {
-    /**
-     * Creates an instance of AndSpecification.
-     *
-     * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical AND.
-     */
-    constructor(...spec: Array<ISpecification>);
-}

package/src/lib/specifications.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"specifications.js","sourceRoot":"","sources":["../../../../../../packages/shared/domain-core/src/lib/specifications.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;GAUG;AACH,MAAa,kBAAkB;IAE3B;;;;OAIG;IACH,YAA4B,QAAa;QAAb,aAAQ,GAAR,QAAQ,CAAK;IAAI,CAAC;CACjD;AARD,gDAQC;AAED;;;;;;;;;GASG;AACH,MAAa,kBAAmB,SAAQ,kBAAkB;IAEtD;;;;OAIG;IACH,YAAY,GAAG,KAA4B;QACvC,IAAI,QAAQ,GAAG,EAAE,CAAC;QAElB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YAClB,QAAQ,mCACD,QAAQ,GACR,IAAI,CAAC,QAAQ,CACnB,CAAA;QACJ,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,QAAQ,CAAC,CAAC;IACpB,CAAC;CACJ;AAnBD,gDAmBC;AAED;;;;;;;;;;GAUG;AACH,MAAa,eAAgB,SAAQ,kBAAkB;IAEnD;;;;OAIG;IACH,YAAY,GAAG,IAA2B;QACtC,KAAK,CAAC;YACF,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;SACjC,CAAC,CAAC;IACP,CAAC;CACJ;AAZD,0CAYC;AAED;;;;;;;;;;GAUG;AACH,MAAa,gBAAiB,SAAQ,kBAAkB;IAEpD;;;;OAIG;IACH,YAAY,GAAG,IAA2B;QACtC,KAAK,CAAC;YACF,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;SAClC,CAAC,CAAC;IACP,CAAC;CACJ;AAZD,4CAYC"}