@happychef/algorithm 1.2.9 → 1.2.10

package/.github/workflows/ci-cd.yml

@@ -0,0 +1,103 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Run tests with coverage
+        run: npm run test:coverage
+
+      - name: Upload coverage reports
+        uses: codecov/codecov-action@v4
+        if: matrix.node-version == '20.x'
+        with:
+          files: ./coverage/lcov.info
+          flags: unittests
+          name: codecov-umbrella
+          fail_ci_if_error: false
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  publish:
+    name: Publish to NPM
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Check if version changed
+        id: version-check
+        run: |
+          PACKAGE_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view @happychef/algorithm version 2>/dev/null || echo "0.0.0")
+          echo "Package version: $PACKAGE_VERSION"
+          echo "NPM version: $NPM_VERSION"
+          if [ "$PACKAGE_VERSION" != "$NPM_VERSION" ]; then
+            echo "version_changed=true" >> $GITHUB_OUTPUT
+            echo "Version changed from $NPM_VERSION to $PACKAGE_VERSION"
+          else
+            echo "version_changed=false" >> $GITHUB_OUTPUT
+            echo "Version unchanged: $PACKAGE_VERSION"
+          fi
+
+      - name: Publish to NPM
+        if: steps.version-check.outputs.version_changed == 'true'
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: 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
+
+      - name: Create Git Tag
+        if: steps.version-check.outputs.version_changed == 'true'
+        run: |
+          PACKAGE_VERSION=$(node -p "require('./package.json').version")
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "v$PACKAGE_VERSION" -m "Release v$PACKAGE_VERSION"
+          git push origin "v$PACKAGE_VERSION"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/README.md

@@ -0,0 +1,144 @@
+# @happychef/algorithm
+
+Restaurant and reservation algorithm utilities for Happy Chef.
+
+[![CI/CD Pipeline](https://github.com/YOUR_USERNAME/YOUR_REPO/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/YOUR_USERNAME/YOUR_REPO/actions/workflows/ci-cd.yml)
+[![codecov](https://codecov.io/gh/YOUR_USERNAME/YOUR_REPO/branch/main/graph/badge.svg)](https://codecov.io/gh/YOUR_USERNAME/YOUR_REPO)
+[![npm version](https://badge.fury.io/js/%40happychef%2Falgorithm.svg)](https://www.npmjs.com/package/@happychef/algorithm)
+
+## Installation
+
+```bash
+npm install @happychef/algorithm
+```
+
+## Features
+
+- **Date & Time Availability**: Check if specific dates and times are available for reservations
+- **Timeblock Management**: Get available timeblocks based on restaurant settings
+- **Table Assignment**: Automatically assign tables to reservations
+- **Smart Filtering**: Filter timeblocks based on max arrivals, max groups, and other constraints
+- **Exception Handling**: Support for restaurant opening hours exceptions and closures
+- **Comprehensive Testing**: 70+ unit tests ensuring reliability
+
+## Usage
+
+```javascript
+const {
+  isDateAvailable,
+  isTimeAvailable,
+  getAvailableTimeblocks,
+  assignTablesIfPossible
+} = require('@happychef/algorithm');
+
+// Check if a date is available
+const available = isDateAvailable(
+  restaurantData,
+  '2025-06-15',
+  reservations,
+  guests
+);
+
+// Get available timeblocks
+const timeblocks = getAvailableTimeblocks(
+  restaurantData,
+  '2025-06-15',
+  reservations,
+  guests
+);
+
+// Check if specific time is available
+const timeAvailable = isTimeAvailable(
+  restaurantData,
+  '2025-06-15',
+  '12:00',
+  reservations,
+  guests
+);
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+```
+
+### Test Coverage
+
+The package includes comprehensive unit tests covering:
+- Helper functions (parseTime, getMealTypeByTime, etc.)
+- Date and time availability checks
+- Timeblock filtering
+- Restaurant data and exceptions handling
+- Table assignment logic
+- Filter functions (max arrivals, max groups)
+
+All tests are automatically run on every push to the main branch via GitHub Actions.
+
+## CI/CD Pipeline
+
+This package uses GitHub Actions for continuous integration and deployment:
+
+1. **Automated Testing**: Tests run on Node.js 18.x and 20.x
+2. **Coverage Reports**: Automatically uploaded to Codecov
+3. **Automatic Publishing**: When tests pass on main branch and version changes, package is automatically published to npm
+4. **Git Tagging**: Successful releases are automatically tagged
+
+### Setup Instructions
+
+To enable automatic publishing:
+
+1. **Create an NPM Token**:
+   - Go to [npmjs.com](https://www.npmjs.com/)
+   - Navigate to Access Tokens
+   - Generate a new "Automation" token
+   - Copy the token
+
+2. **Add NPM Token to GitHub Secrets**:
+   - Go to your GitHub repository
+   - Navigate to Settings > Secrets and variables > Actions
+   - Click "New repository secret"
+   - Name: `NPM_TOKEN`
+   - Value: Paste your NPM token
+   - Click "Add secret"
+
+3. **Optional: Add Codecov Token** (for coverage reports):
+   - Go to [codecov.io](https://codecov.io/)
+   - Add your repository
+   - Copy the token
+   - Add as `CODECOV_TOKEN` secret in GitHub
+
+4. **Publish New Version**:
+   - Update version in `package.json`
+   - Commit and push to main branch
+   - GitHub Actions will automatically:
+     - Run all tests
+     - Publish to npm if tests pass
+     - Create a git tag for the release
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Write tests for your changes
+4. Ensure all tests pass (`npm test`)
+5. Commit your changes (`git commit -m 'Add some amazing feature'`)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+## License
+
+MIT
+
+## Author
+
+Happy Chef

package/__tests__/filters.test.js

@@ -0,0 +1,276 @@
+const { filterTimeblocksByMaxArrivals } = require('../filters/maxArrivalsFilter');
+const { filterTimeblocksByMaxGroups } = require('../filters/maxGroupsFilter');
+
+describe('maxArrivalsFilter', () => {
+  test('should keep timeblocks when no max arrivals config exists', () => {
+    const restaurantData = {};
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, [], 4);
+    expect(result).toEqual(timeblocks);
+  });
+
+  test('should filter out timeblocks that exceed max arrivals', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 10,
+        '12:30': 8
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 8 }
+    ];
+
+    // Adding 4 guests to 12:00 (8 + 4 = 12 > 10) should filter it out
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 4);
+    expect(result['12:00']).toBeUndefined();
+    expect(result['12:30']).toBeDefined();
+  });
+
+  test('should keep timeblocks when within max arrivals limit', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 20
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 10 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle MongoDB NumberInt format', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': { $numberInt: '20' }
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 15 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle breakfast times correctly', () => {
+    const restaurantData = {
+      'max-arrivals-breakfast': {
+        '09:00': 15
+      }
+    };
+    const timeblocks = {
+      '09:00': { name: '09:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '09:00', guests: 12 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 2);
+    expect(result['09:00']).toBeDefined();
+  });
+
+  test('should handle dinner times correctly', () => {
+    const restaurantData = {
+      'max-arrivals-dinner': {
+        '18:00': 30
+      }
+    };
+    const timeblocks = {
+      '18:00': { name: '18:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '18:00', guests: 20 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['18:00']).toBeDefined();
+  });
+
+  test('should only count arrivals on the specific date', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 10
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-14', time: '12:00', guests: 8 }, // Different date
+      { date: '2025-06-15', time: '12:00', guests: 2 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined(); // 2 + 5 = 7 <= 10
+  });
+});
+
+describe('maxGroupsFilter', () => {
+  test('should keep timeblocks when no max groups config exists', () => {
+    const restaurantData = {};
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, [], 4);
+    expect(result).toEqual(timeblocks);
+  });
+
+  test('should filter out timeblocks that exceed max groups for a size threshold', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2 // Max 2 groups of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '13:00': { name: '13:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 },
+      { date: '2025-06-15', time: '12:30', guests: 8 }
+    ];
+
+    // Already have 2 groups of 6+, so adding another should be blocked
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  test('should keep timeblocks when within max groups limit', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 3 // Max 3 groups of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['12:00']).toBeDefined(); // 1 + 1 = 2 <= 3
+  });
+
+  test('should not apply filter if new booking is smaller than threshold', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 1 // Max 1 group of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 8 }
+    ];
+
+    // Booking for 4 people - doesn't meet the 6+ threshold
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 4);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle MongoDB NumberInt format', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': { $numberInt: '2' }
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle multiple thresholds correctly', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2,
+        '10': 1
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 12 } // Already have 1 group of 10+
+    ];
+
+    // Trying to add another 10+ group should be blocked
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 10);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  test('should only count reservations for the same meal type', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 1
+      },
+      'max-groups-dinner': {
+        '6': 1
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' } // lunch
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '18:00', guests: 8 } // dinner - different meal type
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 7);
+    expect(result['12:00']).toBeDefined(); // Dinner reservation doesn't count for lunch
+  });
+
+  test('should handle breakfast times correctly', () => {
+    const restaurantData = {
+      'max-groups-breakfast': {
+        '4': 3
+      }
+    };
+    const timeblocks = {
+      '09:00': { name: '09:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '08:00', guests: 5 },
+      { date: '2025-06-15', time: '09:30', guests: 4 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['09:00']).toBeDefined();
+  });
+
+  test('should handle invalid guest counts gracefully', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, [], 'invalid');
+    expect(result).toEqual(timeblocks); // Should return unfiltered
+  });
+});

package/__tests__/isDateAvailable.test.js

@@ -0,0 +1,175 @@
+const { isDateAvailable } = require('../isDateAvailable');
+
+// Mock the getAvailableTimeblocks function
+jest.mock('../getAvailableTimeblocks', () => ({
+  getAvailableTimeblocks: jest.fn()
+}));
+
+const { getAvailableTimeblocks } = require('../getAvailableTimeblocks');
+
+describe('isDateAvailable', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return true when timeblocks are available', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-06-15', [], 4, [], null, false);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      [],
+      null,
+      false
+    );
+  });
+
+  test('should return false when no timeblocks are available', () => {
+    getAvailableTimeblocks.mockReturnValue({});
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-06-15', [], 4);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when date is outside allowed range (non-admin)', () => {
+    getAvailableTimeblocks.mockReturnValue({});
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 1 // Only 1 day in future
+      }
+    };
+
+    // Use a date far in the future - the function will calculate if it's out of range
+    const result = isDateAvailable(data, '2099-12-31', [], 4, [], null, false);
+    expect(result).toBe(false);
+  });
+
+  test('should allow dates outside range when isAdmin is true', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 1
+      }
+    };
+
+    const result = isDateAvailable(data, '2099-12-31', [], 4, [], null, true);
+    expect(result).toBe(true);
+  });
+
+  test('should use default dagenInToekomst of 90 when not specified', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {}
+    };
+
+    // Use a reasonable date within 90 days
+    const result = isDateAvailable(data, '2025-02-01', [], 4);
+    expect(result).toBe(true);
+  });
+
+  test('should handle giftcard parameter', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-02-01', [], 4, [], 'LUNCH50');
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      [],
+      4,
+      [],
+      'LUNCH50',
+      false
+    );
+  });
+
+  test('should handle blockedSlots parameter', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const blockedSlots = [
+      { date: '2025-02-01', time: '13:00' }
+    ];
+
+    const result = isDateAvailable(data, '2025-02-01', [], 4, blockedSlots);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      [],
+      4,
+      blockedSlots,
+      null,
+      false
+    );
+  });
+
+  test('should handle reservations array', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const reservations = [
+      { date: '2025-02-01', time: '12:00', guests: 2 }
+    ];
+
+    const result = isDateAvailable(data, '2025-02-01', reservations, 4);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      reservations,
+      4,
+      [],
+      null,
+      false
+    );
+  });
+});