@vonaffenfels/contentful-teasermanager 1.2.30 → 1.2.31

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    testEnvironment: 'node',
+    testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
+    collectCoverageFrom: ['src/**/*.js', '!src/**/*.test.js', '!src/**/*.spec.js'],
+    transform: {
+        '^.+\\.js$': ['babel-jest', {presets: ['@babel/preset-env']}],
+    },
+};

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@vonaffenfels/contentful-teasermanager",
-    "version": "1.2.30",
+    "version": "1.2.31",
     "main": "dist/index.js",
     "scripts": {
         "prepublish": "yarn run build",
         "dev": "yarn run start",
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "jest",
         "build": "echo \"Don't build this module!\"",
         "link": "yarn link",
         "start": "webpack serve --config webpack.config.dev.js"
@@ -67,6 +67,7 @@
         "@dnd-kit/core": "^6.3.1",
         "@svgr/webpack": "^5.5.0",
         "@tanstack/react-query": "^4",
+        "babel-jest": "^30.2.0",
         "babel-loader": "^8.2.2",
         "classnames": "^2.3.2",
         "clean-webpack-plugin": "^3.0.0",
@@ -80,6 +81,7 @@
         "dotenv-webpack": "^7.0.2",
         "file-loader": "^6.2.0",
         "html-webpack-plugin": "^5.3.1",
+        "jest": "^30.2.0",
         "mini-css-extract-plugin": "^1.5.0",
         "postcss": "^8",
         "postcss-loader": "^7",
@@ -102,7 +104,7 @@
         "contentful-resolve-response": "^1.9.2",
         "webpack": "5.88.2"
     },
-    "gitHead": "78ae4b0bd976f82d941d7a47211504dd7dbcc46c",
+    "gitHead": "a7f6706ff699696493a6039fe2ac0ef500993453",
     "publishConfig": {
         "access": "public"
     }

package/src/queryFromLogic.js

@@ -1,9 +1,11 @@
+import {getGermanTimezoneOffset} from "./utils/germanTimezoneOffset";
+
 export const queryFromLogic = (logic) => {
     const orTags = logic.tags.filter(v => v.type === "or").map(v => v.id);
     const andTags = logic.tags.filter(v => v.type === "and").map(v => v.id);
     const excludeTags = logic.tags.filter(v => v.type === "exclude").map(v => v.id);
     const timeZoneOffsetInHours = new Date().getTimezoneOffset() / 60;
-    const differenceToGermanTime = timeZoneOffsetInHours + 2;
+    const differenceToGermanTime = timeZoneOffsetInHours + getGermanTimezoneOffset();
     const hours = [...(logic.timepoints || [])].map(v => parseInt(v)).sort((a, b) => a - b);
     let nearestPassedTime = hours.reverse().find(v => v <= new Date().getHours() + differenceToGermanTime);
     const logicQuery = {"fields.portal": logic.project};

package/src/queryFromLogic.test.js

@@ -0,0 +1,148 @@
+import {queryFromLogic} from './queryFromLogic';
+
+// Mock the germanTimezoneOffset utility
+jest.mock('./utils/germanTimezoneOffset', () => ({
+    getGermanTimezoneOffset: jest.fn(),
+}));
+
+const {getGermanTimezoneOffset} = require('./utils/germanTimezoneOffset');
+
+describe('queryFromLogic', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock Date to fixed value for consistent testing
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2025-07-15T14:30:00Z')); // 14:30 UTC
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it('should use dynamic timezone offset in summer (CEST = UTC+2)', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [],
+            timepoints: ['12', '14', '16'],
+        };
+
+        queryFromLogic(logic);
+
+        // Verify that getGermanTimezoneOffset was called
+        expect(getGermanTimezoneOffset).toHaveBeenCalled();
+    });
+
+    it('should use dynamic timezone offset in winter (CET = UTC+1)', () => {
+        jest.setSystemTime(new Date('2025-01-15T14:30:00Z')); // 14:30 UTC in winter
+        getGermanTimezoneOffset.mockReturnValue(1);
+
+        const logic = {
+            project: 'test-project',
+            tags: [],
+            timepoints: ['12', '14', '16'],
+        };
+
+        queryFromLogic(logic);
+
+        // Verify that getGermanTimezoneOffset was called
+        expect(getGermanTimezoneOffset).toHaveBeenCalled();
+    });
+
+    it('should handle OR tags correctly', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [
+                {type: 'or', id: 'tag1'},
+                {type: 'or', id: 'tag2'},
+            ],
+            timepoints: [],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.tags.sys.id[in]']).toBe('tag1,tag2');
+    });
+
+    it('should handle AND tags correctly', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [
+                {type: 'and', id: 'tag1'},
+                {type: 'and', id: 'tag2'},
+            ],
+            timepoints: [],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.tags.sys.id[all]']).toBe('tag1,tag2');
+    });
+
+    it('should handle exclude tags correctly', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [
+                {type: 'exclude', id: 'tag1'},
+                {type: 'exclude', id: 'tag2'},
+            ],
+            timepoints: [],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.tags.sys.id[nin]']).toBe('tag1,tag2');
+    });
+
+    it('should always include project in query', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'my-portal',
+            tags: [],
+            timepoints: [],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.portal']).toBe('my-portal');
+    });
+
+    it('should not add date filter when no timepoints provided', () => {
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [],
+            timepoints: [],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.date[lte]']).toBeUndefined();
+    });
+
+    it('should use first timepoint when current time is before all timepoints', () => {
+        jest.setSystemTime(new Date('2025-07-15T08:00:00Z')); // 08:00 UTC = 10:00 CEST
+        getGermanTimezoneOffset.mockReturnValue(2);
+
+        const logic = {
+            project: 'test-project',
+            tags: [],
+            timepoints: ['12', '14', '16'],
+        };
+
+        const result = queryFromLogic(logic);
+
+        expect(result['fields.date[lte]']).toBeDefined();
+        // Verify timezone function was called
+        expect(getGermanTimezoneOffset).toHaveBeenCalled();
+    });
+});

package/src/utils/germanTimezoneOffset.js

@@ -0,0 +1,35 @@
+/**
+ * Calculate the timezone offset in hours between UTC and Europe/Berlin timezone.
+ * Automatically handles Daylight Saving Time (DST) transitions:
+ * - CET (Central European Time): UTC+1 (Last Sunday October to Last Sunday March)
+ * - CEST (Central European Summer Time): UTC+2 (Last Sunday March to Last Sunday October)
+ *
+ * @param {Date} date - The date for which to calculate the offset (default: current date)
+ * @returns {number} The offset in hours (1 for CET, 2 for CEST)
+ */
+export const getGermanTimezoneOffset = (date = new Date()) => {
+    // Get timezone offset for Europe/Berlin using Intl API
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: 'Europe/Berlin',
+        timeZoneName: 'shortOffset',
+    });
+
+    const parts = formatter.formatToParts(date);
+    const offsetPart = parts.find(part => part.type === 'timeZoneName');
+
+    if (!offsetPart) {
+        // Fallback: should not happen with modern Node.js
+        throw new Error('Unable to determine timezone offset for Europe/Berlin');
+    }
+
+    // Parse offset string (format: "GMT+1" or "GMT+2")
+    const offsetMatch = offsetPart.value.match(/GMT([+-])(\d+)/);
+    if (!offsetMatch) {
+        throw new Error(`Unexpected offset format: ${offsetPart.value}`);
+    }
+
+    const sign = offsetMatch[1] === '+' ? 1 : -1;
+    const hours = parseInt(offsetMatch[2], 10);
+
+    return sign * hours;
+};

package/src/utils/germanTimezoneOffset.test.js

@@ -0,0 +1,51 @@
+import {getGermanTimezoneOffset} from './germanTimezoneOffset';
+
+describe('getGermanTimezoneOffset', () => {
+    it('should return UTC+1 for winter date (CET)', () => {
+        // January 15, 2025 - during Central European Time (winter)
+        const winterDate = new Date('2025-01-15T12:00:00Z');
+        const offset = getGermanTimezoneOffset(winterDate);
+        expect(offset).toBe(1);
+    });
+
+    it('should return UTC+2 for summer date (CEST)', () => {
+        // July 15, 2025 - during Central European Summer Time
+        const summerDate = new Date('2025-07-15T12:00:00Z');
+        const offset = getGermanTimezoneOffset(summerDate);
+        expect(offset).toBe(2);
+    });
+
+    it('should return UTC+1 for early spring date (before DST)', () => {
+        // March 1, 2025 - before DST transition
+        const earlySpringDate = new Date('2025-03-01T12:00:00Z');
+        const offset = getGermanTimezoneOffset(earlySpringDate);
+        expect(offset).toBe(1);
+    });
+
+    it('should return UTC+2 for late spring date (after DST)', () => {
+        // April 15, 2025 - after DST transition
+        const lateSpringDate = new Date('2025-04-15T12:00:00Z');
+        const offset = getGermanTimezoneOffset(lateSpringDate);
+        expect(offset).toBe(2);
+    });
+
+    it('should return UTC+2 for early autumn date (before DST ends)', () => {
+        // September 15, 2025 - still in summer time
+        const earlyAutumnDate = new Date('2025-09-15T12:00:00Z');
+        const offset = getGermanTimezoneOffset(earlyAutumnDate);
+        expect(offset).toBe(2);
+    });
+
+    it('should return UTC+1 for late autumn date (after DST ends)', () => {
+        // November 15, 2025 - back to winter time
+        const lateAutumnDate = new Date('2025-11-15T12:00:00Z');
+        const offset = getGermanTimezoneOffset(lateAutumnDate);
+        expect(offset).toBe(1);
+    });
+
+    it('should use current date when no argument provided', () => {
+        const offset = getGermanTimezoneOffset();
+        // Offset should be either 1 or 2 depending on current date
+        expect([1, 2]).toContain(offset);
+    });
+});