@socialgouv/matomo-postgres 2.3.2 → 2.3.11

package/README.md

@@ -28,7 +28,7 @@ npx @socialgouv/matomo-postgres
 ```bash
 npm install @socialgouv/matomo-postgres
 # or
-yarn add @socialgouv/matomo-postgres
+pnpm add @socialgouv/matomo-postgres
 ```
 
 ## ⚙️ Configuration
@@ -163,36 +163,36 @@ The tool creates a comprehensive table structure capturing:
 3. **Run the Application**:
 
    ```bash
-   yarn start
+   pnpm start
    ```
 
 ### Development Commands
 
 ```bash
 # Build TypeScript
-yarn build
+pnpm build
 
 # Run tests
-yarn test
+pnpm test
 
 # Update test snapshots
-yarn test -u
+pnpm test -u
 
 # Lint code
-yarn lint
+pnpm lint
 
 # Fix linting issues
-yarn lint:fix
+pnpm lint:fix
 
 # Run database migrations
-yarn migrate
+pnpm migrate
 ```
 
 ## 🗄️ Database Migrations
 
 Database schema is managed through Kysely migrations located in `./src/migrations/`:
 
-Migrations run automatically on each `yarn start` to ensure schema compatibility.
+Migrations run automatically on each `pnpm start` to ensure schema compatibility.
 
 ## 📊 Data Flow
 

package/bin/index.js

@@ -1,18 +1,9 @@
 #!/usr/bin/env node
 
-// DIAGNOSTIC: Log environment state at entry point
-console.log('🔍 [DIAGNOSTIC] bin/index.js starting...')
-console.log('🔍 [DIAGNOSTIC] PGDATABASE env var:', process.env.PGDATABASE ? `SET (length: ${process.env.PGDATABASE.length})` : 'NOT SET OR EMPTY')
-console.log('🔍 [DIAGNOSTIC] NODE_ENV:', process.env.NODE_ENV || 'NOT SET')
-console.log('🔍 [DIAGNOSTIC] Current working directory:', process.cwd())
-console.log('🔍 [DIAGNOSTIC] About to import db module...\n')
-
 import { db } from '../dist/db.js'
 import run from '../dist/index.js'
 import { startMigration } from '../dist/migrate-latest.js'
 
-console.log('🔍 [DIAGNOSTIC] Modules imported successfully\n')
-
 async function start(date) {
   console.log(`\nRunning migrations\n`)
   await startMigration()

package/package.json

@@ -1,24 +1,30 @@
 {
   "name": "@socialgouv/matomo-postgres",
   "description": "Extract visitor events from Matomo API and push to Postgres",
-  "version": "2.3.2",
+  "version": "2.3.11",
+  "packageManager": "pnpm@10.28.1",
   "types": "types/index.d.ts",
   "license": "Apache-2.0",
   "main": "dist/index.js",
+  "repository": {
+    "url": "https://github.com/SocialGouv/matomo-postgres"
+  },
   "preferGlobal": true,
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-  "bin": "./bin/index.js",
+  "bin": {
+    "matomo-postgres": "bin/index.js"
+  },
   "files": [
     "bin",
     "dist"
   ],
   "scripts": {
-    "start": "yarn migrate && node ./bin/index.js",
+    "start": "pnpm migrate && node ./bin/index.js",
     "build": "tsc",
-    "prepublish": "yarn build",
+    "prepublish": "pnpm build",
     "migrate": "node ./dist/migrate-latest.js",
     "test": "jest --verbose",
     "lint": "eslint .",

package/dist/PiwikClient.js

@@ -1,95 +0,0 @@
-import * as http from 'http';
-import * as https from 'https';
-import * as querystring from 'querystring';
-import * as url from 'url';
-export default class PiwikClient {
-    constructor(baseURL, token) {
-        const parsedUrl = url.parse(baseURL, true);
-        this.settings = {
-            apihost: parsedUrl.hostname || '',
-            apipath: parsedUrl.pathname || ''
-        };
-        // Determine protocol and set http module
-        switch (parsedUrl.protocol) {
-            case 'http:':
-                this.http = http;
-                this.settings.apiport = parsedUrl.port
-                    ? parseInt(parsedUrl.port, 10)
-                    : 80;
-                break;
-            case 'https:':
-                this.http = https;
-                this.settings.apiport = parsedUrl.port
-                    ? parseInt(parsedUrl.port, 10)
-                    : 443;
-                break;
-            default:
-                this.http = http;
-                this.settings.apiport = 80;
-        }
-        // Set token from URL query or constructor parameter
-        if (parsedUrl.query && parsedUrl.query.token_auth) {
-            this.settings.token = parsedUrl.query.token_auth;
-        }
-        if (token) {
-            this.settings.token = token;
-        }
-    }
-    api(vars, cb) {
-        if (typeof vars !== 'object') {
-            vars = {};
-        }
-        // Set default values
-        vars.module = 'API';
-        vars.format = 'JSON';
-        // Set token if not provided in vars
-        if (vars.token_auth == null) {
-            vars.token_auth = this.settings.token;
-        }
-        // Extract token_auth for POST body
-        const token_auth = vars.token_auth;
-        const postData = querystring.stringify({ token_auth });
-        // Remove token_auth from URL query params
-        const queryVars = Object.assign({}, vars);
-        delete queryVars.token_auth;
-        // Prepare request options
-        const options = {
-            host: this.settings.apihost,
-            port: this.settings.apiport,
-            path: this.settings.apipath + '?' + querystring.stringify(queryVars),
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded'
-            }
-        };
-        // Make HTTP POST request
-        const req = this.http.request(options, (response) => {
-            let data = '';
-            // Collect data chunks
-            response.on('data', (chunk) => {
-                data += chunk;
-            });
-            // Process complete response
-            response.on('end', () => {
-                try {
-                    const resObj = JSON.parse(data);
-                    if (resObj.result === 'error') {
-                        return cb(new Error(resObj.message), null);
-                    }
-                    return cb(null, resObj);
-                }
-                catch (error) {
-                    return cb(error instanceof Error ? error : new Error(String(error)), null);
-                }
-            });
-        });
-        // Handle request errors
-        req.on('error', (error) => {
-            cb(error, null);
-        });
-        // Write POST data and end request
-        req.write(postData);
-        req.end();
-        return req;
-    }
-}

package/dist/__tests__/importDate.test.js

@@ -1,123 +0,0 @@
-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());
-    });
-};
-// Set environment variables BEFORE any imports
-process.env.MATOMO_SITE = '42';
-process.env.PROJECT_NAME = 'some-project';
-process.env.RESULTPERPAGE = '10';
-process.env.DESTINATION_TABLE = 'matomo';
-import { Pool } from 'pg';
-import { importDate } from '../importDate';
-import matomoVisit from './visit.json';
-const TEST_DATE = new Date(2023, 3, 15);
-let queries = [];
-const result = {
-    command: 'string',
-    rowCount: 0
-};
-jest.mock('pg', () => {
-    const client = {
-        query: (query, values) => {
-            queries.push([query, values]);
-            return result;
-        },
-        release: jest.fn()
-    };
-    const methods = {
-        connect: () => client,
-        on: jest.fn(),
-        query: jest.fn()
-    };
-    return { Pool: jest.fn(() => methods) };
-});
-let pool;
-beforeEach(() => {
-    pool = new Pool();
-    queries = [];
-});
-afterEach(() => {
-    jest.clearAllMocks();
-});
-test('importDate: should import given date', () => __awaiter(void 0, void 0, void 0, function* () {
-    const piwikApi = jest.fn();
-    piwikApi.mockImplementation((options, cb) => {
-        cb(null, [
-            Object.assign(Object.assign({}, matomoVisit), { idVisit: 123 }),
-            Object.assign(Object.assign({}, matomoVisit), { idVisit: 124 })
-        ]);
-    });
-    pool.query.mockResolvedValueOnce({ rows: [], rowCount: 0 });
-    yield importDate(piwikApi, TEST_DATE);
-    expect(piwikApi.mock.calls.length).toEqual(1);
-    expect(piwikApi.mock.calls[0][0]).toMatchInlineSnapshot(`
-{
-  "date": "2023-04-15",
-  "filter_limit": 10,
-  "filter_offset": 0,
-  "filter_sort_order": "asc",
-  "idSite": "42",
-  "method": "Live.getLastVisitsDetails",
-  "period": "day",
-}
-`);
-    expect(queries[0]).toMatchInlineSnapshot(`
-[
-  "select count(distinct "idvisit") as "count" from "matomo" where date(timezone('UTC', action_timestamp)) = $1",
-  [
-    "2023-04-15",
-  ],
-]
-`);
-    expect(queries.length).toEqual(1 + matomoVisit.actionDetails.length * 2);
-}));
-test('importDate: should handle pagination across multiple pages', () => __awaiter(void 0, void 0, void 0, function* () {
-    const piwikApi = jest.fn();
-    // Mock first call to return exactly 10 visits (triggers pagination)
-    piwikApi
-        .mockImplementationOnce((options, cb) => {
-        const visits = Array.from({ length: 10 }, (_, i) => (Object.assign(Object.assign({}, matomoVisit), { idVisit: 200 + i })));
-        cb(null, visits);
-    })
-        // Mock second call to return 5 visits (stops pagination)
-        .mockImplementationOnce((options, cb) => {
-        const visits = Array.from({ length: 5 }, (_, i) => (Object.assign(Object.assign({}, matomoVisit), { idVisit: 300 + i })));
-        cb(null, visits);
-    });
-    // Mock database query for record count
-    pool.query.mockResolvedValue({ rows: [], rowCount: 0 });
-    const result = yield importDate(piwikApi, TEST_DATE);
-    // Should make exactly 2 API calls due to pagination
-    expect(piwikApi.mock.calls.length).toEqual(2);
-    // First call should have offset 0
-    expect(piwikApi.mock.calls[0][0]).toMatchObject({
-        date: '2023-04-15',
-        filter_limit: 10,
-        filter_offset: 0,
-        filter_sort_order: 'asc',
-        idSite: '42',
-        method: 'Live.getLastVisitsDetails',
-        period: 'day'
-    });
-    // Second call should have offset 10
-    expect(piwikApi.mock.calls[1][0]).toMatchObject({
-        date: '2023-04-15',
-        filter_limit: 10,
-        filter_offset: 10,
-        filter_sort_order: 'asc',
-        idSite: '42',
-        method: 'Live.getLastVisitsDetails',
-        period: 'day'
-    });
-    // Should process all events from both pages
-    // 15 visits total × 3 actionDetails each = 45 events
-    expect(result.length).toEqual(45);
-    // Verify database queries: 1 count query + (45 events × 1 query per event)
-    // Note: Each event generates 1 database query for insertion
-    expect(queries.length).toEqual(1 + 45);
-}));

package/dist/__tests__/importEvent.test.js

@@ -1,9 +0,0 @@
-import { getEventsFromMatomoVisit } from '../importEvent.js';
-import matomoVisit from './visit.json';
-process.env.MATOMO_SITE = '42';
-process.env.PROJECT_NAME = 'some-project';
-process.env.RESULTPERPAGE = '10';
-test('getEventsFromMatomoVisit: should merge action events', () => {
-    const visits = getEventsFromMatomoVisit(matomoVisit);
-    expect(visits).toMatchSnapshot();
-});

package/dist/__tests__/migration-imports.test.js

@@ -1,38 +0,0 @@
-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 { readdir, readFile } from 'fs/promises';
-import { join } from 'path';
-describe('Migration Import Validation', () => {
-    it('should not have src/ imports in migration files', () => __awaiter(void 0, void 0, void 0, function* () {
-        const migrationsDir = join(__dirname, '../migrations');
-        const migrationFiles = yield readdir(migrationsDir);
-        const tsFiles = migrationFiles.filter((file) => file.endsWith('.ts'));
-        const problematicFiles = [];
-        for (const file of tsFiles) {
-            const filePath = join(migrationsDir, file);
-            const content = yield readFile(filePath, 'utf-8');
-            // Check for imports from 'src/' paths
-            const srcImportRegex = /(?:import\s+[^;]+from\s+['"]src\/|require\s*\(\s*['"]src\/)/g;
-            const matches = content.match(srcImportRegex);
-            if (matches) {
-                problematicFiles.push(`${file}: ${matches.join(', ')}`);
-            }
-        }
-        if (problematicFiles.length > 0) {
-            fail(`Migration files contain problematic src/ imports that will fail in production:\n${problematicFiles.join('\n')}\n\nMigration files should use direct constants or relative imports instead.`);
-        }
-    }));
-    it('should have at least one migration file', () => __awaiter(void 0, void 0, void 0, function* () {
-        const migrationsDir = join(__dirname, '../migrations');
-        const migrationFiles = yield readdir(migrationsDir);
-        const tsFiles = migrationFiles.filter((file) => file.endsWith('.ts'));
-        expect(tsFiles.length).toBeGreaterThan(0);
-    }));
-});

package/dist/__tests__/run.test.js

@@ -1,91 +0,0 @@
-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());
-    });
-};
-process.env.MATOMO_SITE = '42';
-process.env.PROJECT_NAME = 'some-project';
-process.env.RESULTPERPAGE = '10';
-delete process.env.INITIAL_OFFSET;
-delete process.env.DESTINATION_TABLE;
-delete process.env.STARTDATE;
-// Clear STARTDATE to avoid conflicts with fake timers
-const TEST_DATE = new Date(2023, 3, 1);
-let queries = [];
-let piwikApiCalls = [];
-const result = {
-    command: 'string',
-    rowCount: 0
-};
-jest.mock('pg', () => {
-    const client = {
-        query: (query, values) => {
-            queries.push([query, values]);
-            return result;
-        },
-        release: jest.fn()
-    };
-    const methods = {
-        connect: () => client,
-        on: jest.fn(),
-        query: jest.fn()
-    };
-    return { Pool: jest.fn(() => methods) };
-});
-jest.mock('../PiwikClient', () => {
-    class PiwikMock {
-        constructor(options) {
-            this.options = options;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-        api(options, cb) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // Import the visit data dynamically to avoid circular dependency
-                const { default: matomoVisit } = yield import('./visit.json');
-                const matomoVisits = [
-                    Object.assign(Object.assign({}, matomoVisit), { idVisit: 123 }),
-                    Object.assign(Object.assign({}, matomoVisit), { idVisit: 124 })
-                ];
-                piwikApiCalls.push(options);
-                cb(null, matomoVisits);
-            });
-        }
-    }
-    return PiwikMock;
-});
-// Import after mocks are set up
-import run from '../index';
-beforeEach(() => {
-    queries = [];
-    piwikApiCalls = [];
-});
-afterEach(() => {
-    jest.clearAllMocks();
-});
-test('run: should fetch the latest 5 days on matomo', () => __awaiter(void 0, void 0, void 0, function* () {
-    jest.useFakeTimers().setSystemTime(TEST_DATE.getTime());
-    yield run();
-    expect(piwikApiCalls).toMatchSnapshot();
-}));
-test('run: should fetch the latest event date if no date provided', () => __awaiter(void 0, void 0, void 0, function* () {
-    jest.useFakeTimers().setSystemTime(TEST_DATE.getTime());
-    yield run();
-    expect(queries[0]).toMatchSnapshot();
-}));
-test('run: should run based on existing data if any', () => __awaiter(void 0, void 0, void 0, function* () {
-    // ensure we use the latest entry in DB
-    expect(1).toEqual(1);
-}));
-test('run: should run SQL queries', () => __awaiter(void 0, void 0, void 0, function* () {
-    jest.useFakeTimers().setSystemTime(TEST_DATE.getTime());
-    yield run();
-    expect(queries).toMatchSnapshot();
-    // Updated expectation based on actual behavior with INITIAL_OFFSET=3 (5 days total: 3 days before + today + 1 day after)
-    // 5 days * (6 events per day + 1 count query per day)
-    // Note: The initial findLastEventInMatomo query is not captured in the test mock environment
-    expect(queries.length).toEqual(5 * (6 + 1));
-}));

package/dist/__tests__/visit.json

@@ -1,104 +0,0 @@
-{
-    "idVisit": "124",
-    "idSite": "42",
-    "country": "Argentine",
-    "operatingSystemName": "Mac",
-    "deviceBrand": "Inconnu",
-    "deviceModel": "Générique Bureau",
-    "visitDuration": "300",
-    "daysSinceFirstVisit": "23",
-    "actions": "2",
-    "visitorType": "returningCustomer",
-    "visitorId": "visitorId",
-    "referrerType": "referrerType",
-    "referrerName": "referrerName",
-    "siteName": "tests",
-    "userId": "24",
-    "region": "Buenos Aires",
-    "city": "Buenos Aires",
-    "resolution": "1920x1080",
-    "dimension1": "guest",
-    "dimension3": "page",
-    "dimension6": "shop",
-    "dimension7": "v1.2.3",
-    "dimension8": "fr",
-    "dimension9": "light",
-    "dimension10": "36",
-    "firstActionTimestamp": 1629496512,
-    "actionDetails": [
-        {
-            "type": "event",
-            "url": "https://dive-shop.net/products/basic-wetsuit/",
-            "pageIdAction": "304",
-            "idpageview": "",
-            "serverTimePretty": "20 août 2021 21:35:18",
-            "pageId": "19696671",
-            "eventCategory": "Ecommerce",
-            "eventAction": "Cart change",
-            "timeSpent": 48,
-            "timeSpentPretty": "48s",
-            "pageviewPosition": "8",
-            "timestamp": 1629495318,
-            "icon": "plugins/Morpheus/images/event.png",
-            "iconSVG": "plugins/Morpheus/images/event.svg",
-            "title": "Evènement",
-            "subtitle": "Catégorie: \"Ecommerce', Action: \"Cart change\"",
-            "eventName": "added - Basic Wetsuit",
-            "eventValue": 1,
-            "dimension2": "julien",
-            "dimension4": "indonesia",
-            "dimension5": "diving",
-            "customVariables": {
-                "1": {
-                    "customVariableName1": "page-author",
-                    "customVariableValue1": "Julien"
-                },
-                "2": {
-                    "customVariableName2": "post-age",
-                    "customVariableValue2": "-430 days"
-                }
-            }
-        },
-        {
-            "type": "action",
-            "url": "https://dive-shop.net/products/diving-boots/",
-            "pageTitle": "Divezone Brand Diving Boots - Divezone Store",
-            "pageIdAction": "60",
-            "idpageview": "8CDIez",
-            "serverTimePretty": "20 août 2021 21:30:25",
-            "pageId": "19696664",
-            "timeSpent": "2",
-            "timeSpentPretty": "2s",
-            "pageviewPosition": "5",
-            "title": "Divezone Brand Diving Boots - Divezone Store",
-            "subtitle": "https://dive-shop.net/products/diving-boots/",
-            "icon": "",
-            "iconSVG": "plugins/Morpheus/images/action.svg",
-            "timestamp": 1629495025,
-            "dimension2": "julien",
-            "dimension4": "indonesia",
-            "dimension5": "diving"
-        },
-        {
-            "type": "search",
-            "url": "https://dive-shop.net/products/diving-boots/",
-            "pageTitle": "Divezone Brand Diving Boots - Divezone Store",
-            "pageIdAction": "60",
-            "idpageview": "8CDIez",
-            "serverTimePretty": "20 août 2021 21:30:25",
-            "pageId": "19696664",
-            "timeSpent": "2",
-            "timeSpentPretty": "2s",
-            "pageviewPosition": "5",
-            "title": "Divezone Brand Diving Boots - Divezone Store",
-            "subtitle": "https://dive-shop.net/products/diving-boots/",
-            "icon": "",
-            "iconSVG": "plugins/Morpheus/images/action.svg",
-            "timestamp": 1629495022,
-            "dimension2": "julien",
-            "dimension4": "indonesia",
-            "dimension5": "diving",
-            "siteSearchKeyword": "scuba"
-        }
-    ]
-}

package/dist/config.js

@@ -1,20 +0,0 @@
-// DIAGNOSTIC: Log when config is being loaded
-console.log('🔍 [DIAGNOSTIC] config.ts module loading...');
-console.log('🔍 [DIAGNOSTIC] Reading environment variables:');
-console.log('  - PGDATABASE:', process.env.PGDATABASE ? `SET (length: ${process.env.PGDATABASE.length})` : 'NOT SET OR EMPTY');
-console.log('  - MATOMO_URL:', process.env.MATOMO_URL ? 'SET' : 'NOT SET (will use default)');
-console.log('  - MATOMO_SITE:', process.env.MATOMO_SITE ? 'SET' : 'NOT SET (will use default)');
-console.log('  - MATOMO_KEY:', process.env.MATOMO_KEY ? 'SET' : 'NOT SET');
-export const MATOMO_KEY = process.env.MATOMO_KEY || '';
-export const MATOMO_URL = process.env.MATOMO_URL || 'https://matomo.fabrique.social.gouv.fr/';
-export const MATOMO_SITE = process.env.MATOMO_SITE || 0;
-export const PGDATABASE = process.env.PGDATABASE || '';
-export const INITIAL_OFFSET = process.env.INITIAL_OFFSET || '3';
-export const RESULTPERPAGE = process.env.RESULTPERPAGE || '500';
-export const FORCE_STARTDATE = process.env.FORCE_STARTDATE === 'true';
-console.log('🔍 [DIAGNOSTIC] config.ts module loaded\n');
-// We will create both a normal and a partitioned table (MATOMO_TABLE_NAME and PARTITIONED_MATOMO_TABLE_NAME)
-// and use DESTINATION_TABLE to determine which one to write to.
-export const DESTINATION_TABLE = process.env.DESTINATION_TABLE || 'matomo';
-export const MATOMO_TABLE_NAME = process.env.MATOMO_TABLE_NAME || 'matomo';
-export const PARTITIONED_MATOMO_TABLE_NAME = process.env.PARTITIONED_MATOMO_TABLE_NAME || 'matomo_partitioned';

package/dist/db.js

@@ -1,44 +0,0 @@
-import startDebug from 'debug';
-import { Kysely, PostgresDialect } from 'kysely';
-import pkg from 'pg';
-const { Pool } = pkg;
-import { PGDATABASE } from './config.js';
-startDebug('db');
-// DIAGNOSTIC: Log environment state at module load time
-console.log('🔍 [DIAGNOSTIC] db.ts module loading...');
-console.log('🔍 [DIAGNOSTIC] PGDATABASE value:', PGDATABASE ? `SET (length: ${PGDATABASE.length})` : 'NOT SET OR EMPTY');
-console.log('🔍 [DIAGNOSTIC] Pool constructor type:', typeof Pool);
-export const pool = new Pool({
-    connectionString: PGDATABASE,
-    ssl: {
-        rejectUnauthorized: false
-    }
-});
-// DIAGNOSTIC: Log pool creation details
-console.log('🔍 [DIAGNOSTIC] Pool created:', pool ? 'YES' : 'NO');
-console.log('🔍 [DIAGNOSTIC] Pool has connect method:', pool && typeof pool.connect === 'function' ? 'YES' : 'NO');
-console.log('🔍 [DIAGNOSTIC] Pool object keys:', pool ? Object.keys(pool).join(', ') : 'N/A');
-// Validate pool is properly initialized
-if (!pool || typeof pool.connect !== 'function') {
-    throw new Error('Failed to initialize PostgreSQL connection pool');
-}
-// DIAGNOSTIC: Log dialect creation
-console.log('🔍 [DIAGNOSTIC] Creating PostgresDialect with pool...');
-const dialect = new PostgresDialect({ pool: pool });
-console.log('🔍 [DIAGNOSTIC] PostgresDialect created:', dialect ? 'YES' : 'NO');
-export const db = new Kysely({
-    dialect: dialect,
-    log(event) {
-        if (event.level === 'query') {
-            // debug(event.query.sql)
-            // debug(event.query.parameters)
-        }
-    }
-});
-// DIAGNOSTIC: Log final db instance
-console.log('🔍 [DIAGNOSTIC] Kysely db instance created:', db ? 'YES' : 'NO');
-console.log('🔍 [DIAGNOSTIC] db.ts module loaded successfully\n');
-// Validate the Kysely instance
-if (!db) {
-    throw new Error('Failed to initialize Kysely database instance');
-}