@smartsoft001/mongo 1.1.91 → 1.3.0

package/.eslintrc

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

package/jest.config.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/mongo",
-  "version": "1.1.91",
+  "version": "1.3.0",
   "description": "Utils to mongo",
   "repository": {
     "type": "git",
@@ -16,29 +16,5 @@
   "bugs": {
     "url": "https://github.com/emiljuchnikowski/smartsoft/issues"
   },
-  "homepage": "https://github.com/emiljuchnikowski/smartsoft#readme",
-  "dependencies": {
-    "@angular/common": "16.1.3",
-    "@angular/core": "16.1.3",
-    "@angular/platform-browser-dynamic": "16.1.3",
-    "@nestjs/common": "^10.0.5",
-    "flatted": "^3.2.4",
-    "guid-typescript": "1.0.9",
-    "lodash": "^4.17.20",
-    "md5": "2.3.0",
-    "mongodb": "5.6.0",
-    "reflect-metadata": "0.1.13",
-    "rxjs": "7.8.1"
-  },
-  "peerDependencies": {
-    "@smartsoft001/crud-shell-dtos": "1.1.91",
-    "@smartsoft001/domain-core": "1.1.91",
-    "@smartsoft001/models": "1.1.91",
-    "@smartsoft001/users": "1.1.91",
-    "@smartsoft001/utils": "1.1.91",
-    "util": "0.12.5",
-    "tslib": "2.5.3"
-  },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts"
+  "homepage": "https://github.com/emiljuchnikowski/smartsoft#readme"
 }

package/project.json

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

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/mongo.module';
+export * from './lib/repositories/item.repository';
+export * from './lib/mongo.config';

package/src/lib/mongo.config.ts

@@ -0,0 +1,10 @@
+export class MongoConfig {
+  host?: string;
+  port?: number;
+  database: string;
+  username?: string;
+  password?: string;
+  collection?: string;
+  url?: string;
+  type?: any;
+}

package/src/lib/mongo.module.ts

@@ -0,0 +1,28 @@
+import { DynamicModule } from '@nestjs/common';
+import {
+  IAttachmentRepository,
+  IItemRepository,
+  IUnitOfWork,
+} from '@smartsoft001/domain-core';
+
+import { MongoConfig } from './mongo.config';
+import { MongoUnitOfWork } from './mongo.unitofwork';
+import { MongoAttachmentRepository } from './repositories/attachment.repository';
+import { MongoItemRepository } from './repositories/item.repository';
+
+export class MongoModule {
+  static forRoot(config: MongoConfig): DynamicModule {
+    const providers = [
+      { provide: MongoConfig, useValue: config },
+      { provide: IItemRepository, useClass: MongoItemRepository },
+      { provide: IAttachmentRepository, useClass: MongoAttachmentRepository },
+      { provide: IUnitOfWork, useClass: MongoUnitOfWork },
+    ];
+
+    return {
+      module: MongoModule,
+      providers: providers,
+      exports: providers,
+    };
+  }
+}

package/src/lib/mongo.unitofwork.spec.ts

@@ -0,0 +1,84 @@
+import { jest } from '@jest/globals';
+import { MongoConfig } from '@smartsoft001/mongo';
+import { MongoClient, ClientSession, TransactionOptions } from 'mongodb';
+
+import { IMongoTransaction, MongoUnitOfWork } from './mongo.unitofwork';
+
+const mockData: {
+  config: MongoConfig;
+  url: string;
+} = {
+  config: {
+    host: 'host',
+    port: 4200,
+    database: 'db-string',
+  },
+  url: 'mongodb://host:4200?authSource=db-string',
+};
+
+describe('shared-mongo: MongoUnitOfWork scope function', () => {
+  let mockClient: Partial<MongoClient>;
+  let mockSession: Partial<ClientSession>;
+  let model: MongoUnitOfWork;
+
+  beforeEach(() => {
+    model = new MongoUnitOfWork(mockData.config);
+
+    mockSession = {
+      withTransaction: jest.fn(
+        async <T>(
+          callback: (session: ClientSession) => Promise<T>,
+          options: TransactionOptions,
+        ): Promise<T> => {
+          return callback(mockSession as ClientSession); // Pass the mocked session
+        },
+      ) as ClientSession['withTransaction'],
+      endSession: jest.fn(() => Promise.resolve()),
+    };
+
+    mockClient = {
+      startSession: jest.fn(() => mockSession as ClientSession),
+      close: jest.fn(() => Promise.resolve()),
+    };
+
+    jest
+      .spyOn(MongoClient, 'connect')
+      .mockResolvedValue(mockClient as MongoClient);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should execute the definition within a transaction', async () => {
+    const mockDefinition = jest.fn(async (transaction: IMongoTransaction) => {
+      expect(transaction.session).toBe(mockSession);
+      expect(transaction.connection).toBe(mockClient);
+    });
+
+    await expect(model.scope(mockDefinition)).resolves.not.toThrow();
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(mockData.url);
+    expect(mockClient.startSession).toHaveBeenCalled();
+    expect(mockSession.withTransaction).toHaveBeenCalled();
+    expect(mockDefinition).toHaveBeenCalled();
+    expect(mockSession.endSession).toHaveBeenCalled();
+    expect(mockClient.close).toHaveBeenCalled();
+  });
+
+  it('should throw an error if the definition throws an error', async () => {
+    const mockError = new Error('Test error');
+    const mockDefinition = jest.fn(async () => {
+      throw mockError;
+    });
+
+    await expect(model.scope(mockDefinition)).rejects.toThrow(mockError);
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(mockData.url);
+    expect(mockClient.startSession).toHaveBeenCalled();
+    expect(mockSession.withTransaction).toHaveBeenCalled();
+    expect(mockDefinition).toHaveBeenCalled();
+    expect(mockSession.endSession).toHaveBeenCalled();
+    expect(mockClient.close).toHaveBeenCalled();
+  });
+});

package/src/lib/mongo.unitofwork.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@nestjs/common';
+import { ClientSession, MongoClient, TransactionOptions } from 'mongodb';
+
+import { ITransaction, IUnitOfWork } from '@smartsoft001/domain-core';
+import { MongoConfig } from '@smartsoft001/mongo';
+
+import { getMongoUrl } from './mongo.utils';
+
+export interface IMongoTransaction extends ITransaction {
+  session: ClientSession;
+}
+
+@Injectable()
+export class MongoUnitOfWork extends IUnitOfWork {
+  constructor(private config: MongoConfig) {
+    super();
+  }
+
+  async scope(
+    definition: (transaction: ITransaction) => Promise<void>,
+  ): Promise<void> {
+    const client = await MongoClient.connect(this.getUrl());
+
+    // Step 1: Start a Client Session
+    const session = client.startSession();
+
+    // Step 2: Optional. Define options to use for the transaction
+    const transactionOptions: TransactionOptions = {
+      readPreference: 'primary',
+      readConcern: { level: 'local' },
+      writeConcern: { w: 'majority' },
+    };
+
+    // Step 3: Use withTransaction to start a transaction, execute the callback, and commit (or abort on error)
+    // Note: The callback for withTransaction MUST be async and/or return a Promise.
+
+    let error = null;
+    try {
+      await session.withTransaction(async () => {
+        await definition({
+          session,
+          connection: client,
+        } as IMongoTransaction);
+      }, transactionOptions);
+    } catch (e) {
+      error = e;
+    } finally {
+      await session.endSession();
+      await client.close();
+    }
+
+    if (error) throw error;
+  }
+
+  private getUrl(): string {
+    return getMongoUrl(this.config);
+  }
+}

package/src/lib/mongo.utils.spec.ts

@@ -0,0 +1,54 @@
+import { MongoConfig } from '@smartsoft001/mongo';
+
+import { getMongoUrl } from './mongo.utils';
+
+const mockData: (MongoConfig & { result: string; testName: string })[] = [
+  {
+    host: 'host',
+    port: 4200,
+    database: 'db-string',
+    result: 'mongodb://host:4200?authSource=db-string',
+    testName: 'Basic',
+  },
+  {
+    host: 'ondigitalocean.com',
+    port: 4200,
+    database: 'db-string',
+    result:
+      'mongodb+srv://ondigitalocean.com:4200?authSource=db-string&tls=true',
+    testName: 'Specific host',
+  },
+  {
+    host: 'host',
+    port: 4200,
+    database: 'db-string',
+    result: 'mongodb://host:4200?authSource=db-string',
+    testName: 'Only username',
+    username: 'username',
+  },
+  {
+    host: 'host',
+    port: 4200,
+    database: 'db-string',
+    result: 'mongodb://host:4200?authSource=db-string',
+    testName: 'Only password',
+    password: 'password',
+  },
+  {
+    host: 'host',
+    port: 4200,
+    database: 'db-string',
+    result: 'mongodb://username:password@host:4200?authSource=db-string',
+    testName: 'Username and Password',
+    username: 'username',
+    password: 'password',
+  },
+];
+
+describe('shared-mongo: utils getMongoUrl function', () => {
+  for (const data of mockData) {
+    it(data.testName, () => {
+      expect(getMongoUrl(data)).toBe(data.result);
+    });
+  }
+});

package/src/lib/mongo.utils.ts

@@ -0,0 +1,17 @@
+import { MongoConfig } from '@smartsoft001/mongo';
+
+export function getMongoUrl(config: MongoConfig): string {
+  let url;
+  if (config.username && config.password)
+    url = `mongodb://${config.username}:${config.password}@${config.host}:${config.port}`;
+  else url = `mongodb://${config.host}:${config.port}`;
+
+  url = url + '?authSource=' + config.database;
+
+  if (config.host.indexOf('ondigitalocean.com') > -1) {
+    url = url.replace('mongodb://', 'mongodb+srv://');
+    url = url + '&tls=true';
+  }
+
+  return url;
+}

package/src/lib/repositories/attachment.repository.spec.ts

@@ -0,0 +1,249 @@
+import { MongoClient, GridFSBucket } from 'mongodb';
+import { Readable } from 'stream';
+
+import { IEntity } from '@smartsoft001/domain-core';
+
+import { MongoAttachmentRepository } from './attachment.repository';
+
+jest.mock('mongodb', () => {
+  const mockOpenDownloadStream = jest.fn();
+  const mockDelete = jest.fn();
+  const mockClose = jest.fn();
+  const mockToArray = jest.fn();
+  const mockFind = jest.fn().mockReturnValue({
+    toArray: mockToArray, // Return a mock cursor with toArray method
+  });
+
+  const mockWriteStream = {
+    on: jest.fn((event, callback) => {
+      if (event === 'finish') {
+        setTimeout(callback, 0); // Simulate the 'finish' event after a timeout
+      } else if (event === 'error') {
+        // You can use this to simulate an error event in your test
+        mockWriteStream._errorCallback = callback;
+      }
+      return mockWriteStream; // Return this for chaining
+    }),
+    pipe: jest.fn(function () {
+      return this; // Make sure pipe is chainable
+    }),
+    once: jest.fn((event, callback) => {
+      // Handle 'once' event similarly to 'on'
+      if (event === 'finish') {
+        setTimeout(callback, 0); // Simulate the 'finish' event after a timeout
+      }
+      return mockWriteStream; // Chainable
+    }),
+    emit: jest.fn((event, ...args) => {
+      if (event === 'finish') {
+        setTimeout(() => {
+          // eslint-disable-next-line @typescript-eslint/no-empty-function
+          mockWriteStream.on('finish', () => {
+            // Simulate the finish event
+          });
+        }, 0);
+      }
+      return true; // Return true for emit as a valid event
+    }),
+    removeListener: jest.fn((event, callback) => {
+      // Just return the mock itself for chaining
+      return mockWriteStream;
+    }),
+    _errorCallback: null, // Used to simulate an error when you trigger it manually
+  };
+  const mockOpenUploadStreamWithId = jest.fn().mockReturnValue(mockWriteStream);
+  const mockGridFSBucket = jest.fn().mockImplementation(() => ({
+    delete: mockDelete,
+    openDownloadStream: mockOpenDownloadStream,
+    find: mockFind,
+    openUploadStreamWithId: mockOpenUploadStreamWithId,
+  }));
+
+  const mockDb = jest.fn().mockReturnValue({
+    GridFSBucket: mockGridFSBucket,
+  });
+
+  const mockConnect = jest.fn().mockResolvedValue({
+    db: jest.fn(() => mockDb()),
+    close: mockClose,
+  });
+
+  return {
+    MongoClient: {
+      connect: mockConnect,
+    },
+    GridFSBucket: mockGridFSBucket,
+    __mockDelete: mockDelete, // Expose the mockDelete for assertions
+    __mockClose: mockClose, // Expose the mockClose for assertions
+    __mockOpenDownloadStream: mockOpenDownloadStream, // Expose the mockOpenDownloadStream for assertions
+    __mockToArray: mockToArray, // Expose the mockToArray for assertions
+    __mockWriteStream: mockWriteStream, // Expose the mockWriteStream for assertions
+    __mockOpenUploadStreamWithId: mockOpenUploadStreamWithId, // Expose the mockOpenUploadStreamWithId for assertions
+  };
+});
+
+describe('shared-mongo: MongoAttachmentRepository', () => {
+  let model: MongoAttachmentRepository<IEntity<string>>;
+  const mockConfig = {
+    database: 'testDB',
+    host: 'host',
+    port: 4200,
+    collection: 'testCollection',
+  };
+
+  const data = {
+    id: 'test-id',
+    fileName: 'test-file.txt',
+    stream: new Readable(),
+    mimeType: 'text/plain',
+    encoding: 'utf8',
+  };
+
+  const options = {
+    streamCallback: jest.fn(),
+  };
+
+  // Declare mockDelete here to access in the test scope
+  const mongodbMock = jest.requireMock('mongodb');
+  const mockDelete = mongodbMock.__mockDelete;
+  const mockClose = mongodbMock.__mockClose;
+  const mockOpenDownloadStream = mongodbMock.__mockOpenDownloadStream;
+  const mockToArray = mongodbMock.__mockToArray;
+  const mockWriteStream = mongodbMock.__mockWriteStream;
+  const mockOpenUploadStreamWithId = mongodbMock.__mockOpenUploadStreamWithId;
+  const mockStream = new Readable();
+  mockStream._read = jest.fn();
+
+  beforeEach(() => {
+    model = new MongoAttachmentRepository<IEntity<string>>(mockConfig); // Pass required config
+  });
+
+  it('delete() should delete a file from GridFSBucket and close the client', async () => {
+    const id = 'test-id';
+    const mockUrl = 'mock-url';
+    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
+
+    await model.delete(id);
+
+    // Assertions
+    expect(MongoClient.connect).toHaveBeenCalledWith(mockUrl);
+    expect(GridFSBucket).toHaveBeenCalledWith(expect.anything(), {
+      bucketName: mockConfig.collection,
+    });
+    expect(mockDelete).toHaveBeenCalledWith(id);
+    expect(mockClose).toHaveBeenCalled();
+  });
+
+  it('getStream() should return a readable stream when getStream is called', async () => {
+    const id = 'test-id';
+    const options = { start: 0, end: 100 };
+    const mockUrl = 'mock-url';
+    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
+
+    // Mock the return value of openDownloadStream to return a mock Readable stream
+    const mockStream = new Readable();
+    mockStream._read = jest.fn(); // Implement the _read method to make it a valid Readable stream
+    mockOpenDownloadStream.mockReturnValue(mockStream);
+
+    const stream = await model.getStream(id, options);
+
+    // Assertions
+    expect(MongoClient.connect).toHaveBeenCalledWith(mockUrl); // Ensure MongoClient.connect is called with the correct URL
+    expect(mockOpenDownloadStream).toHaveBeenCalledWith(id, options); // Check if openDownloadStream was called with the right parameters
+    expect(stream).toBe(mockStream); // Ensure the returned stream is the one we mocked
+  });
+
+  it('getInfo() should return file info if the file exists', async () => {
+    const id = 'test-id';
+    const mockFileData = [
+      {
+        filename: 'test-file.txt',
+        contentType: 'text/plain',
+        length: 1024,
+      },
+    ];
+    const mockUrl = 'mock-url';
+
+    mockToArray.mockResolvedValueOnce(mockFileData); // Mock toArray to return mock file data
+
+    const result = await model.getInfo(id);
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(mockUrl); // Ensure MongoClient.connect is called with the correct URL
+    expect(result).toEqual({
+      fileName: 'test-file.txt',
+      contentType: 'text/plain',
+      length: 1024,
+    }); // Check if the correct file info is returned
+  });
+
+  it('getInfo() should return null if no file is found', async () => {
+    const id = 'non-existent-id';
+
+    // Mock the return value of toArray to return an empty array
+    (MongoClient.connect as jest.Mock).mockResolvedValueOnce({
+      db: jest.fn(() => ({
+        GridFSBucket: jest.fn().mockImplementation(() => ({
+          find: jest.fn().mockReturnValue({
+            toArray: jest.fn().mockResolvedValue([]), // Return mock file data
+          }),
+        })),
+      })),
+      close: jest.fn(),
+    });
+
+    const result = await model.getInfo(id);
+
+    expect(result).toBeNull(); // Expect null if no file is found
+  });
+
+  // it("upload() should upload file successfully", async () => {
+  //   const mockUrl = "mock-url";
+  //   jest.spyOn(model as any, "getUrl").mockImplementation(() => mockUrl);
+  //
+  //   const mockStream = new Readable();
+  //   mockStream._read = jest.fn();
+  //
+  //   // Set up the stream to simulate data being piped
+  //   data.stream = mockStream;
+  //
+  //   const result = model.upload(data);
+  //
+  //   // Ensure the MongoClient.connect method is called with the correct URL
+  //   expect(MongoClient.connect).toHaveBeenCalledWith(mockUrl);
+  //
+  //   // Wait for the upload promise to resolve
+  //   await expect(result).resolves.toBeUndefined();
+  //
+  //   // Ensure GridFSBucket and openUploadStreamWithId are called
+  //   expect(GridFSBucket).toHaveBeenCalledWith(expect.anything(), {
+  //     bucketName: mockConfig.collection,
+  //   });
+  //   expect(mockOpenUploadStreamWithId).toHaveBeenCalledWith(data.id, data.fileName, {
+  //     contentType: data.mimeType,
+  //   });
+  //
+  //   // Ensure the stream callback is called if provided
+  //   expect(options.streamCallback).toHaveBeenCalledWith(mockWriteStream);
+  //
+  //   // Ensure data is piped into the write stream
+  //   expect(mockStream.pipe).toHaveBeenCalledWith(mockWriteStream);
+  // });
+
+  // it("upload() should reject with error if upload fails", async () => {
+  //   const mockUrl = "mock-url";
+  //   jest.spyOn(model as any, "getUrl").mockImplementation(() => mockUrl);
+  //
+  //   const result = model.upload({
+  //     ...data,
+  //     stream: mockStream
+  //   });
+  //
+  //   if (mockWriteStream._errorCallback) {
+  //     mockWriteStream._errorCallback(new Error("Upload failed"));
+  //   }
+  //   // Ensure the upload rejects with the error
+  //   // await expect(result.catch(e => e)).rejects.toThrowError("Upload failed");
+  //
+  //   await expect(result).rejects.toThrowError("Upload failed");
+  // });
+});