@socialgouv/matomo-postgres 2.3.12 → 2.3.13

package/dist/importEvent.js

@@ -0,0 +1,214 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sql } from 'kysely';
+import { db, pool } from './db.js';
+/**
+ *
+ * @param {Client} client
+ * @param {import("types").Event} event
+ *
+ * @return {Promise<void>}
+ */
+export const importEvent = (event) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14;
+    // Build a sanitized, typed data object to reduce drift and ensure defaults in one place
+    const eventData = {
+        action_id: (_a = event.action_id) !== null && _a !== void 0 ? _a : '',
+        action_timestamp: event.action_timestamp
+            ? new Date(event.action_timestamp)
+            : new Date(),
+        idsite: (_b = event.idsite) !== null && _b !== void 0 ? _b : '',
+        idvisit: (_c = event.idvisit) !== null && _c !== void 0 ? _c : '',
+        actions: (_d = event.actions) !== null && _d !== void 0 ? _d : null,
+        country: (_e = event.country) !== null && _e !== void 0 ? _e : null,
+        region: (_f = event.region) !== null && _f !== void 0 ? _f : null,
+        city: (_g = event.city) !== null && _g !== void 0 ? _g : null,
+        operatingsystemname: (_h = event.operatingsystemname) !== null && _h !== void 0 ? _h : null,
+        devicemodel: (_j = event.devicemodel) !== null && _j !== void 0 ? _j : null,
+        devicebrand: (_k = event.devicebrand) !== null && _k !== void 0 ? _k : null,
+        visitduration: (_l = event.visitduration) !== null && _l !== void 0 ? _l : null,
+        dayssincefirstvisit: (_m = event.dayssincefirstvisit) !== null && _m !== void 0 ? _m : null,
+        visitortype: (_o = event.visitortype) !== null && _o !== void 0 ? _o : null,
+        sitename: (_p = event.sitename) !== null && _p !== void 0 ? _p : null,
+        userid: (_q = event.userid) !== null && _q !== void 0 ? _q : null,
+        serverdateprettyfirstaction: event.serverdateprettyfirstaction
+            ? new Date(event.serverdateprettyfirstaction)
+            : null,
+        action_type: (_r = event.action_type) !== null && _r !== void 0 ? _r : '',
+        action_eventcategory: (_s = event.action_eventcategory) !== null && _s !== void 0 ? _s : '',
+        action_eventaction: (_t = event.action_eventaction) !== null && _t !== void 0 ? _t : '',
+        action_eventname: (_u = event.action_eventname) !== null && _u !== void 0 ? _u : '',
+        action_eventvalue: event.action_eventvalue
+            ? Number(event.action_eventvalue)
+            : 0,
+        action_timespent: (_v = event.action_timespent) !== null && _v !== void 0 ? _v : '0',
+        usercustomproperties: (_w = event.usercustomproperties) !== null && _w !== void 0 ? _w : null,
+        usercustomdimensions: (_x = event.usercustomdimensions) !== null && _x !== void 0 ? _x : null,
+        dimension1: (_y = event.dimension1) !== null && _y !== void 0 ? _y : null,
+        dimension2: (_z = event.dimension2) !== null && _z !== void 0 ? _z : null,
+        dimension3: (_0 = event.dimension3) !== null && _0 !== void 0 ? _0 : null,
+        dimension4: (_1 = event.dimension4) !== null && _1 !== void 0 ? _1 : null,
+        dimension5: (_2 = event.dimension5) !== null && _2 !== void 0 ? _2 : null,
+        dimension6: (_3 = event.dimension6) !== null && _3 !== void 0 ? _3 : null,
+        dimension7: (_4 = event.dimension7) !== null && _4 !== void 0 ? _4 : null,
+        dimension8: (_5 = event.dimension8) !== null && _5 !== void 0 ? _5 : null,
+        dimension9: (_6 = event.dimension9) !== null && _6 !== void 0 ? _6 : null,
+        dimension10: (_7 = event.dimension10) !== null && _7 !== void 0 ? _7 : null,
+        action_url: (_8 = event.action_url) !== null && _8 !== void 0 ? _8 : null,
+        sitesearchkeyword: (_9 = event.sitesearchkeyword) !== null && _9 !== void 0 ? _9 : null,
+        action_title: (_10 = event.action_title) !== null && _10 !== void 0 ? _10 : null,
+        visitorid: (_11 = event.visitorid) !== null && _11 !== void 0 ? _11 : null,
+        referrertype: (_12 = event.referrertype) !== null && _12 !== void 0 ? _12 : null,
+        referrername: (_13 = event.referrername) !== null && _13 !== void 0 ? _13 : null,
+        resolution: (_14 = event.resolution) !== null && _14 !== void 0 ? _14 : null
+    };
+    // Minimal runtime validation for required fields
+    if (!eventData.action_id || eventData.action_id.trim().length === 0) {
+        throw new Error('importEvent(): action_id is required and cannot be empty');
+    }
+    if (!(eventData.action_timestamp instanceof Date) ||
+        isNaN(eventData.action_timestamp.getTime())) {
+        throw new Error('importEvent(): action_timestamp is invalid');
+    }
+    try {
+        if (!pool || typeof pool.connect !== 'function') {
+            throw new Error('Database connection pool is invalid or undefined');
+        }
+        // Keep the stored procedure but centralize mapping to avoid parameter mis-ordering
+        yield sql `
+      SELECT insert_into_matomo_partitioned(
+        ${eventData.action_id},
+        ${eventData.action_timestamp},
+        ${eventData.idsite},
+        ${eventData.idvisit},
+        ${eventData.actions},
+        ${eventData.country},
+        ${eventData.region},
+        ${eventData.city},
+        ${eventData.operatingsystemname},
+        ${eventData.devicemodel},
+        ${eventData.devicebrand},
+        ${eventData.visitduration},
+        ${eventData.dayssincefirstvisit},
+        ${eventData.visitortype},
+        ${eventData.sitename},
+        ${eventData.userid},
+        ${eventData.serverdateprettyfirstaction},
+        ${eventData.action_type},
+        ${eventData.action_eventcategory},
+        ${eventData.action_eventaction},
+        ${eventData.action_eventname},
+        ${eventData.action_eventvalue},
+        ${eventData.action_timespent},
+        ${eventData.usercustomproperties},
+        ${eventData.usercustomdimensions},
+        ${eventData.dimension1},
+        ${eventData.dimension2},
+        ${eventData.dimension3},
+        ${eventData.dimension4},
+        ${eventData.dimension5},
+        ${eventData.dimension6},
+        ${eventData.dimension7},
+        ${eventData.dimension8},
+        ${eventData.dimension9},
+        ${eventData.dimension10},
+        ${eventData.action_url},
+        ${eventData.sitesearchkeyword},
+        ${eventData.action_title},
+        ${eventData.visitorid},
+        ${eventData.referrertype},
+        ${eventData.referrername},
+        ${eventData.resolution}
+      )
+    `.execute(db);
+    }
+    catch (err) {
+        // Add context for troubleshooting
+        const minimalContext = {
+            action_id: eventData.action_id,
+            action_timestamp: eventData.action_timestamp,
+            idsite: eventData.idsite,
+            idvisit: eventData.idvisit
+        };
+        console.error('importEvent(): failed to insert event', minimalContext);
+        // Log error details but avoid exposing sensitive information
+        console.error('importEvent(): error', err instanceof Error ? err.message : 'Unknown error');
+        throw err;
+    }
+});
+const matomoProps = [
+    'idSite',
+    'idVisit',
+    'actions',
+    'country',
+    'region',
+    'city',
+    'operatingSystemName',
+    'deviceModel',
+    'deviceBrand',
+    'visitDuration',
+    'daysSinceFirstVisit',
+    'visitorType',
+    'visitorId',
+    'referrerType',
+    'referrerName',
+    'siteName',
+    'userId',
+    'resolution'
+];
+/** @type Record<string, (a: import("types/matomo-api").ActionDetail) => string | number> */
+const actionProps = {
+    action_type: (action) => action.type,
+    action_title: (action) => action.title,
+    action_eventcategory: (action) => action.eventCategory,
+    action_eventaction: (action) => action.eventAction,
+    action_eventname: (action) => action.eventName,
+    action_eventvalue: (action) => action.eventValue,
+    action_timespent: (action) => action.timeSpent,
+    action_timestamp: (action) => new Date(action.timestamp * 1000).toISOString(),
+    action_url: (action) => action.url,
+    sitesearchkeyword: (action) => action.siteSearchKeyword
+};
+export const getEventsFromMatomoVisit = (matomoVisit) => {
+    return matomoVisit.actionDetails.map((actionDetail, actionIndex) => {
+        var _a;
+        const usercustomproperties = {};
+        for (let k = 1; k < 10; k++) {
+            const property = (_a = actionDetail.customVariables) === null || _a === void 0 ? void 0 : _a[k];
+            if (!property)
+                continue; // max 10 custom variables
+            //@ts-expect-error implicit any type
+            usercustomproperties[property[`customVariableName${k}`]] =
+                //@ts-expect-error implicit any type
+                property[`customVariableValue${k}`];
+        }
+        /** @type {Record<string, string>} */
+        const usercustomdimensions = {};
+        for (let k = 1; k < 11; k++) {
+            const dimension = `dimension${k}`;
+            //@ts-expect-error implicit any type
+            const value = actionDetail[dimension] || matomoVisit[dimension];
+            if (!value)
+                continue; // max 10 custom variables
+            //@ts-expect-error implicit any type
+            usercustomdimensions[dimension] = value;
+        }
+        const event = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, matomoProps.reduce((a, prop) => (Object.assign(Object.assign({}, a), { [prop.toLowerCase()]: matomoVisit[prop] })), {})), { serverdateprettyfirstaction: new Date((matomoVisit.firstActionTimestamp || 0) * 1000).toISOString() }), Object.keys(actionProps).reduce((a, prop) => (Object.assign(Object.assign({}, a), { [prop.toLowerCase()]: actionProps[prop](actionDetail) })), {
+            action_id: `${matomoVisit.idVisit}_${actionIndex}`
+        })), { 
+            // custom variables
+            usercustomproperties,
+            // custom dimensions
+            // We keep both for backwards compatibility.
+            // Current implementation is flat with one column for each dimension.
+            usercustomdimensions }), usercustomdimensions);
+        return event;
+    });
+};

package/dist/index.js

@@ -0,0 +1,107 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { addDays } from 'date-fns';
+import startDebug from 'debug';
+import { sql } from 'kysely';
+import { DESTINATION_TABLE, INITIAL_OFFSET, MATOMO_KEY, MATOMO_SITE, MATOMO_URL } from './config.js';
+import { db } from './db.js';
+import { importDate } from './importDate.js';
+import PiwikClient from './PiwikClient.js';
+const debug = startDebug('index');
+function run(date) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`🚀 Starting data import process`);
+        debug('run, date=' + date);
+        console.log(`🔗 Initializing Matomo client`);
+        console.log(`  - Matomo URL: ${MATOMO_URL}`);
+        console.log(`  - Matomo Site ID: ${MATOMO_SITE}`);
+        const piwik = new PiwikClient(MATOMO_URL, MATOMO_KEY);
+        console.log(`📅 Determining reference date for import...`);
+        // priority:
+        //  - optional parameter date
+        //  - STARTDATE (if FORCE_STARTDATE is true)
+        //  - last event in the table
+        //  - STARTDATE (if FORCE_STARTDATE is false)
+        //  - today
+        let referenceDate;
+        if (!referenceDate && date) {
+            referenceDate = new Date(date);
+            console.log(`✅ Using provided date parameter: ${referenceDate.toISOString()}`);
+        }
+        // Check FORCE_STARTDATE mode first
+        const forceStartDate = process.env.FORCE_STARTDATE === 'true';
+        if (!referenceDate && forceStartDate && process.env.STARTDATE) {
+            referenceDate = new Date(process.env.STARTDATE);
+            console.log(`✅ FORCE_STARTDATE enabled - Using STARTDATE environment variable: ${referenceDate.toISOString()}`);
+        }
+        // Only query database if not forcing STARTDATE
+        if (!referenceDate && !forceStartDate) {
+            console.log(`🔍 Looking for last event in database...`);
+            referenceDate = yield findLastEventInMatomo(db);
+            if (referenceDate) {
+                console.log(`✅ Found last event, starting from: ${referenceDate.toISOString()}`);
+            }
+            else {
+                console.log(`ℹ️ No previous events found in database`);
+            }
+        }
+        // Fallback to STARTDATE if database had no results
+        if (!referenceDate && process.env.STARTDATE) {
+            referenceDate = new Date(process.env.STARTDATE);
+            console.log(`✅ Using STARTDATE environment variable: ${referenceDate.toISOString()}`);
+        }
+        if (!referenceDate) {
+            referenceDate = new Date(new Date().getTime() - +INITIAL_OFFSET * 24 * 60 * 60 * 1000);
+            console.log(`✅ Using default offset (${INITIAL_OFFSET} days ago): ${referenceDate.toISOString()}`);
+        }
+        const endDate = new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
+        console.log(`📊 Import date range determined:`);
+        console.log(`  - Start date: ${referenceDate.toISOString()}`);
+        console.log(`  - End date: ${endDate.toISOString()}`);
+        debug(`import starting at : ${referenceDate.toISOString()}`);
+        console.log(`🔄 Starting sequential import for each date...`);
+        let daysProcessed = 0;
+        let totalEventsImported = 0;
+        for (let current = new Date(referenceDate); current <= endDate; current = addDays(current, 1)) {
+            daysProcessed += 1;
+            const dayIso = current.toISOString().split('T')[0];
+            console.log(`📅 Processing day ${daysProcessed}: ${dayIso}`);
+            const result = yield importDate(piwik.api.bind(piwik), current);
+            totalEventsImported += result.eventsImported;
+            console.log(`✅ Finished ${dayIso}: pages=${result.pages} visits=${result.visitsFetched} events=${result.eventsImported}`);
+        }
+        console.log(`✅ Import process completed`);
+        console.log(`📈 Summary:`);
+        console.log(`  - Days processed: ${daysProcessed}`);
+        console.log(`  - Total events imported: ${totalEventsImported}`);
+        debug('close');
+        return {
+            daysProcessed,
+            eventsImportedTotal: totalEventsImported
+        };
+    });
+}
+function findLastEventInMatomo(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const latest = yield db
+            .selectFrom(DESTINATION_TABLE)
+            .select(sql `action_timestamp at time zone 'UTC'`.as('action_timestamp'))
+            .orderBy('action_timestamp', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (latest) {
+            // check from the day before just to be sure we have all events
+            const date = new Date(new Date(latest.action_timestamp).getTime() - 2 * 24 * 60 * 60 * 1000);
+            return date;
+        }
+        return null;
+    });
+}
+export default run;

package/dist/migrate-down.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { promises as fs } from 'fs';
+import { FileMigrationProvider, Migrator } from 'kysely';
+import * as path from 'path';
+import { db } from './db.js';
+function migrateDown() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const migrator = new Migrator({
+            db,
+            provider: new FileMigrationProvider({
+                fs,
+                path,
+                migrationFolder: path.join(path.dirname(new URL(import.meta.url).pathname), 'migrations')
+            })
+        });
+        const { error, results } = yield migrator.migrateDown();
+        results === null || results === void 0 ? void 0 : results.forEach((it) => {
+            if (it.status === 'Success') {
+                console.log(`down migration "${it.migrationName}" was executed successfully`);
+            }
+            else if (it.status === 'Error') {
+                console.error(`failed to execute down migration "${it.migrationName}"`);
+            }
+        });
+        if (error) {
+            console.error('failed to down migrate');
+            console.error(error);
+            process.exit(1);
+        }
+        yield db.destroy();
+    });
+}
+migrateDown();

package/dist/migrate-latest.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { promises as fs } from 'fs';
+import { FileMigrationProvider, Migrator } from 'kysely';
+import * as path from 'path';
+import { MATOMO_TABLE_NAME } from './config.js';
+import { db } from './db.js';
+function migrateToLatest() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`Starting migrate to latest`);
+        try {
+            const migrator = new Migrator({
+                db,
+                provider: new FileMigrationProvider({
+                    fs,
+                    path,
+                    migrationFolder: path.join(path.dirname(new URL(import.meta.url).pathname), 'migrations')
+                }),
+                // allow to have mutliple migratable instances in a single schema
+                migrationTableName: `${MATOMO_TABLE_NAME}_migration`,
+                migrationLockTableName: `${MATOMO_TABLE_NAME}_migration_lock`
+            });
+            const { error, results } = yield migrator.migrateToLatest();
+            results === null || results === void 0 ? void 0 : results.forEach((it) => {
+                if (it.status === 'Success') {
+                    console.log(`migration "${it.migrationName}" was executed successfully`);
+                }
+                else if (it.status === 'Error') {
+                    console.error(`failed to execute migration "${it.migrationName}"`);
+                }
+            });
+            if (error) {
+                console.error('failed to migrate');
+                console.error(error);
+                process.exit(1);
+            }
+            else if (!(results === null || results === void 0 ? void 0 : results.length)) {
+                console.log('No migration to run');
+            }
+        }
+        catch (uncaughtError) {
+            console.error('UNCAUGHT ERROR during migration:');
+            console.error('Error message:', uncaughtError instanceof Error
+                ? uncaughtError.message
+                : String(uncaughtError));
+            console.error('Error stack:', uncaughtError instanceof Error
+                ? uncaughtError.stack
+                : 'No stack trace available');
+            console.error('Full error object:', uncaughtError);
+            process.exit(1);
+        }
+    });
+}
+export default migrateToLatest;
+export function startMigration() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield migrateToLatest();
+        // Don't destroy the db connection here since the main application will need it
+    });
+}

package/dist/migrations/20230301-01-initial.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sql } from 'kysely';
+const MATOMO_TABLE_NAME = process.env.MATOMO_TABLE_NAME || 'matomo';
+export function up(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield db.schema
+            .createTable(MATOMO_TABLE_NAME)
+            .ifNotExists()
+            .addColumn('action_id', 'text', (col) => col.unique().notNull())
+            .addColumn('idsite', 'text')
+            .addColumn('idvisit', 'text')
+            .addColumn('actions', 'text')
+            .addColumn('country', 'text')
+            .addColumn('region', 'text')
+            .addColumn('city', 'text')
+            .addColumn('operatingsystemname', 'text')
+            .addColumn('devicemodel', 'text')
+            .addColumn('devicebrand', 'text')
+            .addColumn('visitduration', 'text')
+            .addColumn('dayssincefirstvisit', 'text')
+            .addColumn('visitortype', 'text')
+            .addColumn('sitename', 'text')
+            .addColumn('userid', 'text')
+            .addColumn('serverdateprettyfirstaction', 'date')
+            .addColumn('action_type', 'text')
+            .addColumn('action_eventcategory', 'text')
+            .addColumn('action_eventaction', 'text')
+            .addColumn('action_eventname', 'text')
+            .addColumn('action_eventvalue', 'numeric')
+            .addColumn('action_timespent', 'text')
+            .addColumn('action_timestamp', 'timestamptz', (col) => col.defaultTo(sql `now()`))
+            .addColumn('usercustomproperties', 'json')
+            .addColumn('usercustomdimensions', 'json')
+            .addColumn('dimension1', 'text')
+            .addColumn('dimension2', 'text')
+            .addColumn('dimension3', 'text')
+            .addColumn('dimension4', 'text')
+            .addColumn('dimension5', 'text')
+            .addColumn('dimension6', 'text')
+            .addColumn('dimension7', 'text')
+            .addColumn('dimension8', 'text')
+            .addColumn('dimension9', 'text')
+            .addColumn('dimension10', 'text')
+            .addColumn('action_url', 'text')
+            .addColumn('sitesearchkeyword', 'text')
+            .addColumn('action_title', 'text')
+            .addColumn('visitorid', 'text')
+            .addColumn('referrertype', 'text')
+            .addColumn('referrername', 'text')
+            .execute();
+    });
+}
+export function down(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield db.schema.dropTable(MATOMO_TABLE_NAME).execute();
+    });
+}

package/dist/migrations/20230301-02-indexes.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sql } from 'kysely';
+const MATOMO_TABLE_NAME = process.env.MATOMO_TABLE_NAME || 'matomo';
+const indexes = [
+    {
+        name: 'idx_action_eventaction_matomo',
+        columns: ['action_eventaction']
+    },
+    {
+        name: 'idx_action_eventcategory_matomo',
+        columns: ['action_eventcategory']
+    },
+    {
+        name: 'idx_action_id',
+        columns: ['action_id']
+    },
+    {
+        name: 'idx_action_timestamp_matomo',
+        columns: ['action_timestamp']
+    },
+    {
+        name: 'idx_action_type_matomo',
+        columns: ['action_type']
+    },
+    {
+        name: 'idx_actionurl',
+        columns: ['action_url']
+    },
+    {
+        name: 'idx_dimension1',
+        columns: ['dimension1']
+    },
+    {
+        name: 'idx_dimension2',
+        columns: ['dimension2']
+    },
+    {
+        name: 'idx_dimension3',
+        columns: ['dimension3']
+    },
+    {
+        name: 'idx_dimension4',
+        columns: ['dimension4']
+    },
+    {
+        name: 'idx_dimension5',
+        columns: ['dimension5']
+    },
+    {
+        name: 'idx_idvisit_matomo',
+        columns: ['idvisit']
+    },
+    {
+        name: 'idx_region',
+        columns: ['region']
+    },
+    {
+        name: 'idx_userid',
+        columns: ['userid']
+    },
+    {
+        name: 'idx_visitorid',
+        columns: ['visitorid']
+    }
+];
+export function up(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        indexes.forEach((index) => __awaiter(this, void 0, void 0, function* () {
+            yield db.schema
+                .createIndex(index.name)
+                .ifNotExists()
+                .on(MATOMO_TABLE_NAME)
+                .using('btree')
+                .columns(index.columns)
+                .execute();
+        }));
+        yield db.schema
+            .createIndex('actions_day')
+            .ifNotExists()
+            .on(MATOMO_TABLE_NAME)
+            .expression(sql `date(timezone('UTC', action_timestamp))`)
+            .execute();
+    });
+}
+export function down(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        indexes.forEach((index) => __awaiter(this, void 0, void 0, function* () {
+            yield db.schema.dropIndex(index.name).execute();
+        }));
+        db.schema.dropIndex('actions_day').execute();
+    });
+}

package/dist/migrations/20250425-01-add-resolution.js

@@ -0,0 +1,38 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sql } from 'kysely';
+const MATOMO_TABLE_NAME = process.env.MATOMO_TABLE_NAME || 'matomo';
+export function up(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Check if the column already exists before trying to add it
+        const columnExists = yield sql `
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.columns
+      WHERE table_name = ${MATOMO_TABLE_NAME}
+      AND column_name = 'resolution'
+    ) as exists
+  `.execute(db);
+        if (!columnExists.rows[0].exists) {
+            yield db.schema
+                .alterTable(MATOMO_TABLE_NAME)
+                .addColumn('resolution', 'text')
+                .execute();
+        }
+    });
+}
+export function down(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield db.schema
+            .alterTable(MATOMO_TABLE_NAME)
+            .dropColumn('resolution')
+            .execute();
+    });
+}