@smartsoft001/mongo 2.76.0 → 2.80.0

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

@@ -1,259 +0,0 @@
-import { MongoClient, GridFSBucket } from 'mongodb';
-
-import { IEntity } from '@smartsoft001/domain-core';
-
-import { Readable } from 'stream';
-
-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 call MongoClient.connect with correct URL', async () => {
-    const mockUrl = 'mock-url';
-    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
-    const mockStream = new Readable();
-    mockStream._read = jest.fn();
-    data.stream = mockStream;
-    model.upload(data);
-    expect(MongoClient.connect).toHaveBeenCalledWith(mockUrl);
-  });
-
-  it('upload() should resolve the upload promise', async () => {
-    const mockUrl = 'mock-url';
-    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
-    const mockStream = new Readable();
-    mockStream._read = jest.fn();
-    data.stream = mockStream;
-    const result = model.upload(data);
-    await expect(result).resolves.toBeUndefined();
-  });
-
-  it('upload() should call GridFSBucket and openUploadStreamWithId', async () => {
-    const mockUrl = 'mock-url';
-    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
-    const mockStream = new Readable();
-    mockStream._read = jest.fn();
-    data.stream = mockStream;
-    await model.upload(data);
-    expect(GridFSBucket).toHaveBeenCalledWith(expect.anything(), {
-      bucketName: mockConfig.collection,
-    });
-    expect(mockOpenUploadStreamWithId).toHaveBeenCalledWith(
-      data.id,
-      data.fileName,
-      {
-        contentType: data.mimeType,
-      },
-    );
-  });
-
-  it('upload() should call streamCallback if provided', async () => {
-    const mockUrl = 'mock-url';
-    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
-    const mockStream = new Readable();
-    mockStream._read = jest.fn();
-    data.stream = mockStream;
-    await model.upload(data, options);
-    expect(options.streamCallback).toHaveBeenCalled();
-  });
-
-  it('upload() should call pipe of the provided data stream', async () => {
-    const mockUrl = 'mock-url';
-    jest.spyOn(model as any, 'getUrl').mockImplementation(() => mockUrl);
-    const mockStream = new Readable();
-    mockStream._read = jest.fn();
-    mockStream.pipe = jest.fn();
-    data.stream = mockStream;
-    await model.upload(data);
-    expect(mockStream.pipe).toHaveBeenCalled();
-  });
-});

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

@@ -1,115 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { MongoClient } from 'mongodb';
-import * as mongo from 'mongodb';
-
-import { IEntity, IAttachmentRepository } from '@smartsoft001/domain-core';
-
-import { Readable, Stream } from 'stream';
-
-import { MongoConfig } from '../mongo.module';
-import { getMongoUrl } from '../mongo.utils';
-
-@Injectable()
-export class MongoAttachmentRepository<
-  T extends IEntity<string>,
-> extends IAttachmentRepository<T> {
-  constructor(private config: MongoConfig) {
-    super();
-  }
-
-  async upload(
-    data: {
-      id: string;
-      fileName: string;
-      stream: Stream;
-      mimeType: string;
-      encoding: string;
-    },
-    options?: { streamCallback?: (r) => void },
-  ): Promise<void> {
-    const client = await MongoClient.connect(this.getUrl());
-
-    return await new Promise<void>((res, rej) => {
-      const db = client.db(this.config.database);
-      const bucket = new mongo.GridFSBucket(db, {
-        bucketName: this.config.collection,
-      });
-
-      const writeStream = bucket.openUploadStreamWithId(
-        data.id as any,
-        data.fileName,
-        {
-          contentType: data.mimeType,
-        },
-      );
-
-      if (options?.streamCallback) options.streamCallback(writeStream);
-
-      data.stream.pipe(writeStream as any);
-
-      writeStream.on('error', (error) => {
-        rej(error);
-      });
-
-      writeStream.on('finish', () => {
-        res();
-      });
-    });
-  }
-
-  async getInfo(
-    id: string,
-  ): Promise<{ fileName: string; contentType: string; length: number }> {
-    const client = await MongoClient.connect(this.getUrl());
-
-    const db = client.db(this.config.database);
-
-    const bucket = new mongo.GridFSBucket(db, {
-      bucketName: this.config.collection,
-    });
-
-    const items = await bucket
-      .find({
-        _id: id as any,
-      })
-      .toArray();
-
-    if (!items || items.length === 0) return null;
-
-    return {
-      fileName: items[0].filename,
-      contentType: items[0].contentType,
-      length: items[0].length,
-    };
-  }
-
-  async getStream(
-    id: string,
-    options: { start: number; end: number } | undefined,
-  ): Promise<Readable> {
-    const client = await MongoClient.connect(this.getUrl());
-
-    const db = client.db(this.config.database);
-    const bucket = new mongo.GridFSBucket(db, {
-      bucketName: this.config.collection,
-    });
-
-    return bucket.openDownloadStream(id as any, options);
-  }
-
-  async delete(id: string): Promise<void> {
-    const client = await MongoClient.connect(this.getUrl());
-
-    const db = client.db(this.config.database);
-    const bucket = new mongo.GridFSBucket(db, {
-      bucketName: this.config.collection,
-    });
-
-    await bucket.delete(id as any);
-    await client.close();
-  }
-
-  private getUrl(): string {
-    return getMongoUrl(this.config);
-  }
-}

package/src/lib/repositories/interfaces.ts

@@ -1,28 +0,0 @@
-export interface IItemCreateData {
-  id: string;
-  type: 'create';
-  data: any;
-}
-
-export interface IItemUpdateData {
-  id: string;
-  type: 'update';
-  data: {
-    removedFields: Array<string>;
-    updatedFields: {
-      [key: string]: any;
-    };
-  };
-}
-
-export interface IItemDeleteData {
-  id: string;
-  type: 'delete';
-}
-
-export type ItemChangedData =
-  | IItemCreateData
-  | IItemUpdateData
-  | IItemDeleteData;
-
-export type ItemChangedDataType = 'create' | 'update' | 'delete';