@hvedinich/utils 0.0.59 → 0.0.61

package/.eslintrc.js

@@ -13,4 +13,12 @@ module.exports = {
     'arrow-body-style': 'off',
     'prefer-arrow-callback': 'off',
   },
+  overrides: [
+    {
+      files: ['**/*.test.js', '**/*.spec.js'],
+      env: {
+        jest: true,
+      },
+    },
+  ],
 };

package/.github/workflows/test.yml

@@ -0,0 +1,28 @@
+name: run unit tests
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - main
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18]
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Run tests
+      run: npm test

package/.github/workflows/update_version_and_publish.yaml

@@ -0,0 +1,57 @@
+name: Publish utils
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  update-version-publish-and-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Update patch version
+        run: |
+          npm version patch --no-git-tag-version
+          git config --local user.email "rooolik@gmail.com"
+          git config --local user.name "hvedinich"
+          git commit -am "Update version to $(node -p "require('./package.json').version")"
+          git push
+
+      - name: Publish to npm
+        uses: JS-DevTools/npm-publish@v3
+        with:
+          token: ${{ secrets.NPM_TOKEN }}
+
+      - name: Read Changelog
+        id: changelog
+        run: echo "::set-output name=body::$(cat CHANGELOG.md)"
+
+      - name: Get package.json version
+        id: package_version
+        run: echo "::set-output name=version::$(node -p "require('./package.json').version")"
+        shell: bash
+
+      - name: Set the version in the env
+        run: echo "VERSION=${{ steps.package_version.outputs.version }}" >> $GITHUB_ENV
+
+      - name: Create release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "$VERSION" \
+              --repo="$GITHUB_REPOSITORY" \
+              --title="${GITHUB_REPOSITORY#*/} ${VERSION#v}" \
+              --generate-notes

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@hvedinich/utils",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "description": "utils module",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -32,7 +32,7 @@
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-prettier": "^4.0.0",
     "husky": "^8.0.1",
-    "jest": "^29.1.2",
+    "jest": "^29.7.0",
     "prettier": "^2.5.1"
   },
   "publishConfig": {

package/src/utils/buildDBModel/__tests/buildDBModel.test.js

@@ -0,0 +1,129 @@
+const { buildDBModel } = require('../index');
+
+// Mock Mongoose schema methods
+const mockSchema = {
+  findOneAndUpdate: jest.fn(),
+  findOne: jest.fn(),
+  find: jest.fn(),
+  create: jest.fn(),
+  deleteOne: jest.fn(),
+  countDocuments: jest.fn(),
+};
+
+// Create the model using the mocked schema
+const dbModel = buildDBModel(mockSchema);
+
+describe('buildDBModel', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create a new document', async () => {
+    const mockData = { name: 'Test' };
+    const createdDoc = { ...mockData, _id: '1' };
+    mockSchema.create.mockResolvedValue(createdDoc);
+
+    const result = await dbModel.create(mockData);
+    expect(result).toEqual(createdDoc);
+    expect(mockSchema.create).toHaveBeenCalledWith(mockData);
+  });
+
+  it('should read a single document', async () => {
+    const mockFilter = { _id: '1' };
+    const foundDoc = { _id: '1', name: 'Test' };
+    mockSchema.findOne.mockReturnValue({
+      lean: jest.fn().mockResolvedValue(foundDoc),
+    });
+
+    const result = await dbModel.read(mockFilter);
+    expect(result).toEqual(foundDoc);
+    expect(mockSchema.findOne).toHaveBeenCalledWith(mockFilter);
+  });
+
+  it('should read multiple documents', async () => {
+    const mockFilter = { name: 'Test' };
+    const foundDocs = [
+      { _id: '1', name: 'Test' },
+      { _id: '2', name: 'Test2' },
+    ];
+    mockSchema.find.mockReturnValue({
+      lean: jest.fn().mockReturnValue({
+        exec: jest.fn().mockResolvedValue(foundDocs),
+      }),
+    });
+
+    const result = await dbModel.readAll(mockFilter);
+    expect(result).toEqual(foundDocs);
+    expect(mockSchema.find).toHaveBeenCalledWith(mockFilter);
+  });
+
+  it('should find one and update a document', async () => {
+    const mockFilter = { _id: '1' };
+    const mockAction = { $set: { name: 'Updated' } };
+    const options = { new: true };
+    const updatedDoc = { _id: '1', name: 'Updated' };
+    mockSchema.findOneAndUpdate.mockReturnValue({
+      lean: jest.fn().mockResolvedValue(updatedDoc),
+    });
+
+    const result = await dbModel.findOneAndUpdate(mockFilter, mockAction, options);
+    expect(result).toEqual(updatedDoc);
+    expect(mockSchema.findOneAndUpdate).toHaveBeenCalledWith(mockFilter, mockAction, options);
+  });
+
+  it('should remove a document by id', async () => {
+    const mockId = '1';
+    const removeResult = { deletedCount: 1 };
+    mockSchema.deleteOne.mockResolvedValue(removeResult);
+
+    const result = await dbModel.remove(mockId);
+    expect(result).toEqual(removeResult);
+    expect(mockSchema.deleteOne).toHaveBeenCalledWith({ id: mockId });
+  });
+
+  it('should count documents', async () => {
+    const mockFilter = { name: 'Test' };
+    const countResult = 2;
+    mockSchema.countDocuments.mockReturnValue({
+      lean: jest.fn().mockReturnValue({
+        exec: jest.fn().mockResolvedValue(countResult),
+      }),
+    });
+
+    const result = await dbModel.count(mockFilter);
+    expect(result).toEqual(countResult);
+    expect(mockSchema.countDocuments).toHaveBeenCalledWith(mockFilter);
+  });
+
+  it('should list documents with pagination and sorting', async () => {
+    const mockOptions = {
+      filter: { name: 'Test' },
+      pagination: { page: 1, pageSize: 2 },
+      sortBy: { field: 'name', direction: 'asc' },
+    };
+    const foundDocs = [
+      { _id: '1', name: 'Test' },
+      { _id: '2', name: 'Test2' },
+    ];
+    const totalCount = 2;
+
+    mockSchema.find.mockReturnValue({
+      skip: jest.fn().mockReturnThis(),
+      limit: jest.fn().mockReturnThis(),
+      sort: jest.fn().mockReturnThis(),
+      lean: jest.fn().mockReturnThis(),
+      exec: jest.fn().mockResolvedValue(foundDocs),
+    });
+
+    mockSchema.countDocuments.mockReturnValue({
+      lean: jest.fn().mockReturnValue({
+        exec: jest.fn().mockResolvedValue(totalCount),
+      }),
+    });
+
+    const result = await dbModel.list(mockOptions);
+    expect(result).toEqual([foundDocs, totalCount]);
+    expect(mockSchema.find).toHaveBeenCalledWith(mockOptions.filter);
+    expect(mockSchema.countDocuments).toHaveBeenCalledWith(mockOptions.filter);
+  });
+});

package/src/utils/buildDBModel/index.js

@@ -0,0 +1,88 @@
+/**
+ * Creates basic CRUD methods for a Mongoose schema.
+ * @param {mongoose.Schema} schema - The Mongoose schema to build the model methods for.
+ * @returns {Object} - An object containing CRUD methods for the schema.
+ */
+const buildDBModel = schema => {
+  /**
+   * Finds one document and updates it.
+   * @param {Object} filter - The filter to find the document.
+   * @param {Object} action - The update action to perform.
+   * @param {Object} options - Options for the update operation.
+   * @returns {Promise<Object>} - The updated document.
+   */
+  const findOneAndUpdate = (filter, action, options) => schema.findOneAndUpdate(filter, action, options).lean();
+
+  /**
+   * Reads a single document.
+   * @param {Object} input - The filter to find the document.
+   * @returns {Promise<Object>} - The found document.
+   */
+  const read = input => schema.findOne(input).lean();
+
+  /**
+   * Reads multiple documents.
+   * @param {Object} filter - The filter to find the documents.
+   * @returns {Promise<Array>} - An array of found documents.
+   */
+  const readAll = filter => schema.find(filter).lean().exec();
+
+  /**
+   * Creates a new document.
+   * @param {Object} data - The data for the new document.
+   * @returns {Promise<Object>} - The created document.
+   */
+  const create = data => schema.create(data);
+
+  /**
+   * Removes a document by id.
+   * @param {String} id - The id of the document to remove.
+   * @returns {Promise<Object>} - The result of the remove operation.
+   */
+  const remove = id => schema.deleteOne({ id });
+
+  /**
+   * Counts the number of documents matching a filter.
+   * @param {Object} filter - The filter to count the documents.
+   * @returns {Promise<Number>} - The count of documents.
+   */
+  const count = filter => schema.countDocuments(filter).lean().exec();
+
+  /**
+   * Lists documents with optional pagination and sorting.
+   * @param {Object} options - The options for listing documents.
+   * @param {Object} options.filter - The filter to find the documents.
+   * @param {Object} [options.pagination] - The pagination options.
+   * @param {Number} [options.pagination.page] - The page number.
+   * @param {Number} [options.pagination.pageSize] - The number of documents per page.
+   * @param {Object} [options.sortBy] - The sorting options.
+   * @param {String} [options.sortBy.field] - The field to sort by.
+   * @param {String} [options.sortBy.direction] - The direction to sort ('asc' or 'desc').
+   * @returns {Promise<Array>} - An array containing the found documents and the total count.
+   */
+  const list = async ({ filter = {}, pagination, sortBy }) => {
+    let query = schema.find(filter);
+    const countQuery = schema.countDocuments(filter);
+    if (pagination) {
+      query = query.skip((pagination.page - 1) * pagination.pageSize).limit(pagination.pageSize);
+    }
+    if (sortBy && sortBy.field) {
+      query = query.sort([[sortBy.field, sortBy.direction || 'asc']]);
+    }
+    const [totalCount, results] = await Promise.all([countQuery.lean().exec(), query.lean().exec()]);
+    return [results, totalCount];
+  };
+  return {
+    create,
+    read,
+    readAll,
+    list,
+    findOneAndUpdate,
+    remove,
+    count,
+  };
+};
+
+module.exports = {
+  buildDBModel,
+};

package/src/utils/index.js

@@ -6,6 +6,7 @@ const common = require('./common');
 const permission = require('./permission');
 const config = require('./config');
 const healthCheck = require('./healthCheck');
+const db = require('./buildDBModel');
 
 module.exports = {
   context,
@@ -15,5 +16,6 @@ module.exports = {
   permission,
   config,
   common,
-  healthCheck
+  healthCheck,
+  db,
 };