@smartsoft001/domain-core 2.75.0 → 2.80.0

package/index.cjs

@@ -0,0 +1,152 @@
+"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/domain-core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AndSpecification: () => AndSpecification,
+  BasicSpecification: () => BasicSpecification,
+  DomainForbiddenError: () => DomainForbiddenError,
+  DomainValidationError: () => DomainValidationError,
+  IAttachmentRepository: () => IAttachmentRepository,
+  IItemRepository: () => IItemRepository,
+  IUnitOfWork: () => IUnitOfWork,
+  MergeSpecification: () => MergeSpecification,
+  OrSpecification: () => OrSpecification
+});
+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/decorators/model/model.decorator.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// 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");
+
+// 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/domain-core/src/lib/errors.ts
+var DomainValidationError = class _DomainValidationError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainValidationError;
+  }
+};
+var DomainForbiddenError = class _DomainForbiddenError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainForbiddenError;
+  }
+};
+
+// packages/shared/domain-core/src/lib/repositories.ts
+var IUnitOfWork = class {
+};
+var IItemRepository = class {
+};
+var IAttachmentRepository = class {
+};
+
+// packages/shared/domain-core/src/lib/specifications.ts
+var BasicSpecification = class {
+  /**
+   * Creates an instance of BasicSpecification.
+   *
+   * @param {any} criteria - The criteria used to filter entities.
+   */
+  constructor(criteria) {
+    this.criteria = criteria;
+  }
+};
+var MergeSpecification = class extends BasicSpecification {
+  /**
+   * Creates an instance of MergeSpecification.
+   *
+   * @param {...ISpecification[]} specs - An array of specifications to be merged.
+   */
+  constructor(...specs) {
+    let criteria = {};
+    specs.forEach((spec) => {
+      criteria = {
+        ...criteria,
+        ...spec.criteria
+      };
+    });
+    super(criteria);
+  }
+};
+var OrSpecification = class extends BasicSpecification {
+  /**
+   * Creates an instance of OrSpecification.
+   *
+   * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical OR.
+   */
+  constructor(...spec) {
+    super({
+      $or: spec.map((c) => c.criteria)
+    });
+  }
+};
+var AndSpecification = class extends BasicSpecification {
+  /**
+   * Creates an instance of AndSpecification.
+   *
+   * @param {...ISpecification[]} spec - An array of specifications to be combined using a logical AND.
+   */
+  constructor(...spec) {
+    super({
+      $and: spec.map((c) => c.criteria)
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AndSpecification,
+  BasicSpecification,
+  DomainForbiddenError,
+  DomainValidationError,
+  IAttachmentRepository,
+  IItemRepository,
+  IUnitOfWork,
+  MergeSpecification,
+  OrSpecification
+});

package/package.json

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

package/src/lib/errors.d.ts

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

@@ -0,0 +1,18 @@
+export interface IEntity<T> {
+    id: T;
+}
+export interface IAddress {
+    city: string;
+    street: string;
+    buildingNumber: string;
+    flatNumber?: string;
+    zipCode: string;
+}
+export interface IDateRange {
+    start: `${string}-${string}-${string}`;
+    end: `${string}-${string}-${string}`;
+}
+export interface IFactory<T, TConfig> {
+    create(config: NonNullable<TConfig>): Promise<T>;
+}
+export { ISpecification } from '@smartsoft001/models';

package/src/lib/repositories.d.ts

@@ -0,0 +1,320 @@
+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 | null, 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 | null, 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 | null, 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/{specifications.ts → specifications.d.ts}

@@ -1,5 +1,4 @@
 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
@@ -11,15 +10,15 @@ import { ISpecification } from './interfaces';
  * @class BasicSpecification
  * @implements {ISpecification}
  */
-export class BasicSpecification implements ISpecification {
-  /**
-   * Creates an instance of BasicSpecification.
-   *
-   * @param {any} criteria - The criteria used to filter entities.
-   */
-  constructor(public readonly criteria: any) {}
+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
@@ -30,26 +29,14 @@ export class BasicSpecification implements ISpecification {
  * @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: Array<ISpecification>) {
-    let criteria = {};
-
-    specs.forEach((spec) => {
-      criteria = {
-        ...criteria,
-        ...spec.criteria,
-      };
-    });
-
-    super(criteria);
-  }
+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
@@ -61,19 +48,14 @@ export class MergeSpecification 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: Array<ISpecification>) {
-    super({
-      $or: spec.map((c) => c.criteria),
-    });
-  }
+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
@@ -85,15 +67,11 @@ export class OrSpecification 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: Array<ISpecification>) {
-    super({
-      $and: spec.map((c) => c.criteria),
-    });
-  }
+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/.eslintrc.json

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

package/jest.config.ts

@@ -1,11 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: '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/project.json

@@ -1,46 +0,0 @@
-{
-  "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",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/shared/domain-core/**/*.{ts,tsx,js,jsx}",
-          "packages/shared/domain-core/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "packages/shared/domain-core/jest.config.ts"
-      }
-    }
-  }
-}

package/src/lib/errors.ts

@@ -1,15 +0,0 @@
-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.ts

@@ -1,40 +0,0 @@
-/*
- * Interface for entities
- */
-export interface IEntity<T> {
-  id: T;
-}
-
-/*
- * Address interface
- */
-export interface IAddress {
-  city: string;
-  street: string;
-  buildingNumber: string;
-  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

@@ -1,373 +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 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 | null,
-    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 | null,
-    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 | null,
-    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

@@ -1,68 +0,0 @@
-import { ISpecification } from './interfaces';
-import {
-  BasicSpecification,
-  MergeSpecification,
-  OrSpecification,
-  AndSpecification,
-} from './specifications';
-
-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/tsconfig.json

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

package/tsconfig.lib.json

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

package/tsconfig.spec.json

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