Feature/tippi 1198 tealium extension deployment

.github/workflows/tealium_deployment.yml

@@ -0,0 +1,29 @@
+name: Tealium Deployment
+
+on:
+  workflow_dispatch:
+
+jobs: 
+  tealium-deployment:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: '24'
+
+      - name: Install dependencies
+        run: yarn install
+
+      - name: Run tests
+        run: yarn test
+
+      - name: Deploy to Tealium
+        env:
+          TEALIUM_DEPLOY_ACCOUNT: ${{ secrets.TEALIUM_DEPLOY_ACCOUNT }}
+          TEALIUM_DEPLOY_USER: ${{ secrets.TEALIUM_DEPLOY_USER }}
+          TEALIUM_DEPLOY_API_KEY: ${{ secrets.TEALIUM_DEPLOY_API_KEY }}
+        run: yarn deploy -- "${{ github.sha }}: ${{ github.event.head_commit.message }}"

eslint.config.js

@@ -43,6 +43,10 @@ export default [
             '@typescript-eslint/no-unused-vars': ['warn'],
             // ersetzt "no-unused-vars": "off"
 
+            'no-redeclare': 'off',
+            '@typescript-eslint/no-redeclare': 'off',
+            // Erlaubt Enum + Namespace mit gleichem Namen (Declaration Merging)
+
             '@typescript-eslint/no-unused-expressions': 'error',
             // ersetzt "no-unused-expressions": 0
 
@@ -121,7 +125,7 @@ export default [
             'no-param-reassign': 'off',
             'no-process-env': 'error',
             'no-proto': 'error',
-            'no-redeclare': 'error',
+            // 'no-redeclare' ist oben deaktiviert, TypeScript übernimmt die Prüfung
             'no-return-assign': 'error',
             'no-script-url': 'error',
             'no-self-compare': 'error',

package.json

@@ -4,7 +4,6 @@
   "engines": {
     "node": "24"
   },
-  "type": "module",
   "scripts": {
     "prepare": "husky install",
     "test": "jest",
@@ -13,9 +12,13 @@
     "format:check": "prettier --check .",
     "test:mutation": "stryker run",
     "test:mutation:watch": "stryker run --watch",
-    "test:mutation:incremental": "stryker run --incremental"
+    "test:mutation:incremental": "stryker run --incremental",
+    "deploy": "ts-node src/tealiumdeployment/main.ts"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "terser": "^5.44.1"
   },
-  "dependencies": {},
   "devDependencies": {
     "@eslint/js": "^9.19.0",
     "@stryker-mutator/core": "^9.4.0",
@@ -32,6 +35,7 @@
     "jest-environment-jsdom": "^29.7.0",
     "prettier": "^3.7.4",
     "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.0"
   },

src/config.ts

@@ -0,0 +1,8 @@
+/* eslint-disable no-process-env */
+export const config = {
+    tealium: {
+        account: process.env.TEALIUM_DEPLOY_ACCOUNT || '',
+        user: process.env.TEALIUM_DEPLOY_USER || '',
+        apiKey: process.env.TEALIUM_DEPLOY_API_KEY || ''
+    }
+};

src/tealiumdeployment/Extension.test.ts

@@ -0,0 +1,93 @@
+import { Extension } from './Extension';
+import { ExtensionType, Occurrence, Scope, Status, TealiumExtension } from './TealiumAPI';
+
+describe('Extension', () => {
+    it('can be created from remote', () => {
+        const tealiumResponse: TealiumExtension = {
+            id: 7,
+            name: 'test-extension',
+            extensionId: '123',
+            extensionType: 'Javascript Code',
+            notes: 'A test note',
+            status: 'active',
+            scope: 'After Load Rules',
+            occurrence: 'Run Always',
+            configuration: {
+                code: 'console.log("Hello World");'
+            }
+        };
+        const extension = Extension.fromRemote(tealiumResponse);
+        expect(extension.name).toBe('test-extension');
+        expect(extension.type).toBe(ExtensionType.JavascriptCode);
+        expect(extension.id).toBe(7);
+        expect(extension.code).toBe('console.log("Hello World");');
+        expect(extension.getNotes()).toBe('A test note');
+        expect(extension.getFilepath()).toBe('');
+    });
+
+    it('can be created from local', () => {
+        const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+
+        expect(extension.name).toBe('test-extension');
+        expect(extension.id).toBe(123);
+        expect(extension.code).toBe('console.log("test");');
+        expect(extension.getNotes()).toBe('');
+    });
+
+    it('can have a filepath set', () => {
+        const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+        expect(extension.getFilepath()).toBe('');
+        extension.setFilePath('./extension/test.js');
+        expect(extension.getFilepath()).toBe('./extension/test.js');
+    });
+
+    it('can have notes set', () => {
+        const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+
+        expect(extension.getNotes()).toBe('');
+        extension.setNotes('An example note');
+        expect(extension.getNotes()).toBe('An example note');
+    });
+
+    describe('getHash', () => {
+        it('can create a hash', () => {
+            const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+            expect(extension.getHash()).toEqual('ef945f16c968dad131a99279f79c283e31816066bb48436de0265a4b3579a3b6');
+        });
+
+        it('changes if code is changed', () => {
+            const extensionA = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+            expect(extensionA.getHash()).toEqual('ef945f16c968dad131a99279f79c283e31816066bb48436de0265a4b3579a3b6');
+
+            const extensionB = Extension.fromLocal(123, 'test-extension', 'console.log("hello");');
+            expect(extensionB.getHash()).toEqual('bcc3426863eb61436eb611ee0e328140a5e66728ddb20da68b3386be84505fee');
+        });
+
+        it('changes if scope is changed', () => {
+            const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+            extension.setScope(Scope.AfterLoadRules);
+            expect(extension.getHash()).toEqual('ef945f16c968dad131a99279f79c283e31816066bb48436de0265a4b3579a3b6');
+
+            extension.setScope(Scope.BeforeLoadRules);
+            expect(extension.getHash()).toEqual('4e72dfe77437fb4fffbd287346c02fdcac1f24a8be398cfbd3af6bf17961a598');
+        });
+
+        it('changes if status is changed', () => {
+            const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+            extension.setStatus(Status.Active);
+            expect(extension.getHash()).toEqual('ef945f16c968dad131a99279f79c283e31816066bb48436de0265a4b3579a3b6');
+
+            extension.setStatus(Status.Inactive);
+            expect(extension.getHash()).toEqual('179acdade713e698c8eae9606574108f3d7a6552e002a6904fe2880a37cffbae');
+        });
+
+        it('changes if occurrence is changed', () => {
+            const extension = Extension.fromLocal(123, 'test-extension', 'console.log("test");');
+            extension.setOccurrence(Occurrence.RunAlways);
+            expect(extension.getHash()).toEqual('ef945f16c968dad131a99279f79c283e31816066bb48436de0265a4b3579a3b6');
+
+            extension.setOccurrence(Occurrence.RunOnce);
+            expect(extension.getHash()).toEqual('2d6aa9f8d52fa90d61833171b1d5a0adfb6300b2d9c5767eafaf451d5665eb16');
+        });
+    });
+});

src/tealiumdeployment/Extension.ts

@@ -0,0 +1,91 @@
+import { Occurrence, Status, TealiumExtension, Scope, ExtensionType } from './TealiumAPI';
+import crypto from 'node:crypto';
+
+export class Extension {
+
+    static fromRemote(data: TealiumExtension): Extension {
+        const code = data.configuration.code;
+        const extension = new Extension(data.name, ExtensionType.fromString(data.extensionType), code, data.id);
+        extension.setScope(Scope.fromString(data.scope));
+        extension.setOccurrence(Occurrence.fromString(data.occurrence));
+        extension.setStatus(Status.fromString(data.status));
+        extension.setNotes(data.notes);
+        return extension;
+    }
+
+    /**
+     * Creates Javascript Code extension
+     */
+    static fromLocal(id: number, name: string, code: string, type = ExtensionType.JavascriptCode) {
+        return new Extension(name, type, code, id);
+    }
+
+    private filepath: string;
+    private notes: string;
+    private scope: Scope;
+    private occurrence: Occurrence;
+    private status: Status;
+
+    private constructor(
+        public readonly name: string,
+        public readonly type: ExtensionType,
+        public readonly code: string,
+        public readonly id?: number
+    ) {
+        this.notes = '';
+        this.filepath = '';
+        this.scope = Scope.AfterLoadRules;
+        this.occurrence = Occurrence.RunAlways;
+        this.status = Status.Active;
+    }
+
+    setScope(scope: Scope) {
+        this.scope = scope;
+    }
+
+    getScope(): Scope {
+        return this.scope;
+    }
+
+    setNotes(notes: string) {
+        this.notes = notes;
+    }
+
+    getNotes(): string {
+        return this.notes;
+    }
+
+    getFilepath(): string {
+        return this.filepath;
+    }
+
+    setFilePath(filepath: string) {
+        this.filepath = filepath;
+    }
+
+    setOccurrence(occurrence: Occurrence) {
+        this.occurrence = occurrence;
+    }
+
+    getOccurrence() {
+        return this.occurrence;
+    }
+
+    setStatus(status: Status) {
+        this.status = status;
+    }
+
+    getStatus(): Status {
+        return this.status;
+    }
+
+    getHash() {
+        const content = {
+            code: this.code,
+            scope: this.scope,
+            status: this.status,
+            occurrence: this.occurrence
+        };
+        return crypto.createHash('sha256').update(JSON.stringify(content)).digest('hex');
+    }
+}