@baasix/baasix 0.1.0

package/dist/utils/common.js

@@ -0,0 +1,162 @@
+/**
+ * Common utilities for routes
+ * Contains reusable functions that are duplicated across multiple route files
+ */
+import { schemaManager } from "./schemaManager.js";
+import { APIError } from "./errorHandler.js";
+import { getCache } from "./cache.js";
+import { getCacheService } from "./db.js";
+import settingsService from "../services/SettingsService.js";
+import env from "./env.js";
+/**
+ * Middleware to check if a model/collection exists
+ * Used in: items.route.ts, reports.route.ts
+ */
+export const modelExistsMiddleware = (req, res, next) => {
+    const modelName = req.params.collection;
+    if (!schemaManager.modelExists(modelName)) {
+        return next(new APIError(`Model ${modelName} not found`, 404));
+    }
+    next();
+};
+/**
+ * Throws APIError if user is not authenticated
+ * Used in: notification.route.ts (4 times)
+ */
+export function requireAuth(req) {
+    if (!req.accountability?.user?.id) {
+        throw new APIError("Authentication required", 401);
+    }
+}
+/**
+ * Check if a collection has a tenant_Id field (supports tenant isolation)
+ */
+export function collectionHasTenantField(collection) {
+    try {
+        const table = schemaManager.getTable(collection);
+        // Check if table has tenant_Id column
+        return 'tenant_Id' in table;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates and adjusts accountability for imports
+ *
+ * Rules:
+ * - User must be authenticated (not public)
+ * - In multi-tenant mode, for collections with tenant_Id field:
+ *   - Tenant-specific users: use their tenant from accountability (already set)
+ *   - Administrators/non-tenant-specific users: must provide tenant in body
+ * - In single-tenant mode or for collections without tenant_Id: no tenant handling needed
+ *
+ * Used in: items.route.ts (import-csv and import-json)
+ */
+export function getImportAccountability(req, collection) {
+    const accountability = req.accountability;
+    // Check if user is authenticated (not public)
+    if (!accountability?.user?.id) {
+        throw new APIError("Authentication required for import operations", 401);
+    }
+    const isMultiTenant = env.get('MULTI_TENANT') === 'true';
+    // If not multi-tenant mode, just return original accountability
+    if (!isMultiTenant) {
+        return accountability;
+    }
+    // Check if the collection supports tenant isolation
+    const hasTenantField = collection ? collectionHasTenantField(collection) : false;
+    // If collection doesn't have tenant field, no tenant handling needed
+    if (!hasTenantField) {
+        return accountability;
+    }
+    // Check if user has a tenant-specific role (accountability already has tenant set)
+    const isTenantSpecific = accountability?.role?.isTenantSpecific === true;
+    const userTenant = accountability?.tenant;
+    if (isTenantSpecific && userTenant) {
+        // Tenant-specific users: tenant is already in accountability, just return it
+        return accountability;
+    }
+    else {
+        // Administrators or non-tenant-specific users
+        // They must provide tenant in body for tenant-enabled tables
+        const tenant = req.body?.tenant;
+        if (tenant) {
+            return {
+                ...accountability,
+                tenant: tenant,
+            };
+        }
+        else {
+            throw new APIError("Tenant is required for importing into tenant-enabled collections. Provide 'tenant' in the request body.", 400);
+        }
+    }
+}
+/**
+ * Invalidate auth cache for a specific role or all roles
+ * Used in: permission.route.ts
+ */
+export async function invalidateAuthCache(roleId) {
+    try {
+        const cache = getCache();
+        if (roleId) {
+            const cacheKey = `auth:role:${roleId}:permissions`;
+            await cache.delete(cacheKey);
+        }
+        else {
+            await cache.invalidateModel("auth");
+        }
+    }
+    catch (error) {
+        console.error(`[Common] Failed to invalidate auth cache:`, error);
+    }
+}
+/**
+ * Invalidate cache for a collection
+ * Used in: permission.route.ts
+ */
+export async function invalidateCollectionCache(collection) {
+    try {
+        const cache = getCacheService();
+        if (cache) {
+            await cache.onMutate({ tables: [collection] });
+        }
+    }
+    catch (error) {
+        console.error(`[Common] Failed to invalidate cache for ${collection}:`, error);
+    }
+}
+/**
+ * Invalidate settings cache for a tenant or global
+ * Used in: items.route.ts
+ * @param corsInvalidator - Function to invalidate CORS cache (from app.ts)
+ */
+export async function invalidateSettingsCache(item, corsInvalidator) {
+    try {
+        const tenantId = item?.tenant_Id;
+        console.info(`Settings modified - invalidating cache for tenant: ${tenantId || "global"}`);
+        if (tenantId) {
+            await settingsService.invalidateTenantCache(tenantId);
+        }
+        else {
+            await settingsService.loadGlobalSettings();
+            await settingsService.invalidateAllCaches();
+        }
+        if (corsInvalidator) {
+            corsInvalidator();
+        }
+    }
+    catch (error) {
+        console.error("Error invalidating settings cache:", error);
+    }
+}
+/**
+ * Invalidate settings cache after import (always invalidates all)
+ * Used in: items.route.ts (import-csv and import-json)
+ */
+export async function invalidateSettingsCacheAfterImport() {
+    console.info(`Settings imported - invalidating all caches`);
+    await settingsService.loadGlobalSettings();
+    await settingsService.invalidateAllCaches();
+}
+//# sourceMappingURL=common.js.map

package/dist/utils/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../baasix/utils/common.ts"],"names":[],"mappings":"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"}

package/dist/utils/db.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Database Connection Layer for Drizzle ORM
+ * Provides PostgreSQL connection with pooling, SSL support, and read replicas
+ * Matches Sequelize database configuration for parity
+ */
+import { drizzle, PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import type { Transaction as TransactionType } from '../types/database.js';
+declare global {
+    var __baasix_db: ReturnType<typeof drizzle> | null;
+    var __baasix_sql: ReturnType<typeof postgres> | null;
+    var __baasix_readSql: ReturnType<typeof postgres> | null;
+}
+type DrizzleDb = ReturnType<typeof drizzle>;
+export type TransactionClient = Parameters<Parameters<DrizzleDb['transaction']>[0]>[0];
+export type Transaction = TransactionType;
+/**
+ * Initialize database connection
+ * Synchronous function that starts async cache initialization
+ */
+export declare function initializeDatabase(): PostgresJsDatabase<Record<string, unknown>>;
+/**
+ * Initialize database with cache service (async version)
+ * Use this when you need to ensure cache is ready before proceeding
+ */
+export declare function initializeDatabaseWithCache(): Promise<PostgresJsDatabase<Record<string, unknown>>>;
+/**
+ * Get database instance (synchronous - initializes if needed)
+ */
+export declare function getDatabase(): PostgresJsDatabase<Record<string, unknown>>;
+export declare const db: PostgresJsDatabase<Record<string, unknown>>;
+/**
+ * Get postgres SQL client (for raw queries)
+ */
+export declare function getSqlClient(): postgres.Sql<{}>;
+export declare const sqlClient: ReturnType<typeof postgres>;
+/**
+ * Get read replica SQL client (if configured)
+ */
+export declare function getReadSqlClient(): postgres.Sql<{}>;
+/**
+ * Close database connections
+ */
+export declare function closeDatabase(): Promise<void>;
+/**
+ * Create a new transaction with Sequelize-compatible API
+ * Returns a transaction that must be explicitly committed or rolled back
+ *
+ * Usage matching Sequelize:
+ *   const transaction = await createTransaction();
+ *   try {
+ *     await transaction.insert(table).values(data);
+ *     await transaction.commit();
+ *   } catch (error) {
+ *     await transaction.rollback();
+ *     throw error;
+ *   }
+ */
+export declare function createTransaction(): Promise<Transaction>;
+/**
+ * Test database connection
+ */
+export declare function testConnection(): Promise<boolean>;
+/**
+ * Get PostgreSQL server version
+ * Returns { major: number, minor: number, full: string }
+ * Caches the result after first call
+ */
+export declare function getPostgresVersion(): Promise<{
+    major: number;
+    minor: number;
+    full: string;
+}>;
+/**
+ * Check if PostgreSQL version supports a feature
+ * @param minMajor Minimum major version required
+ * @param minMinor Minimum minor version required (default: 0)
+ */
+export declare function isPgVersionAtLeast(minMajor: number, minMinor?: number): Promise<boolean>;
+/**
+ * Get helper to extract instance ID
+ */
+export declare function getInstanceId(instance: any): any;
+declare const _default: {
+    db: PostgresJsDatabase<Record<string, unknown>>;
+    sql: postgres.Sql<{}>;
+    initializeDatabase: typeof initializeDatabase;
+    initializeDatabaseWithCache: typeof initializeDatabaseWithCache;
+    getDatabase: typeof getDatabase;
+    getSqlClient: typeof getSqlClient;
+    getReadSqlClient: typeof getReadSqlClient;
+    closeDatabase: typeof closeDatabase;
+    createTransaction: typeof createTransaction;
+    testConnection: typeof testConnection;
+    getInstanceId: typeof getInstanceId;
+    getPostgresVersion: typeof getPostgresVersion;
+    isPgVersionAtLeast: typeof isPgVersionAtLeast;
+};
+export default _default;
+export { getCacheService, closeCacheService, initializeCacheService } from '../services/CacheService.js';
+//# sourceMappingURL=db.d.ts.map

package/dist/utils/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../baasix/utils/db.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,QAAQ,MAAM,UAAU,CAAC;AAKhC,OAAO,KAAK,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI3E,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,WAAW,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,GAAG,IAAI,CAAC;IACnD,IAAI,YAAY,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG,IAAI,CAAC;IACrD,IAAI,gBAAgB,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG,IAAI,CAAC;CAC1D;AAkBD,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAG5C,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAGvF,MAAM,MAAM,WAAW,GAAG,eAAe,CAAC;AA2B1C;;;GAGG;AACH,wBAAgB,kBAAkB,gDAqEjC;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,yDA0DhD;AAED;;GAEG;AACH,wBAAgB,WAAW,gDAK1B;AAKD,eAAO,MAAM,EAAE,6CAMb,CAAC;AAEH;;GAEG;AACH,wBAAgB,YAAY,qBAK3B;AAGD,eAAO,MAAM,SAAS,EAShB,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAElC;;GAEG;AACH,wBAAgB,gBAAgB,qBAK/B;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBnD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC,CAiG9D;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAUvD;AAKD;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA6BlG;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAGjG;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,GAAG,GAAG,CAMhD;;;;;;;;;;;;;;;;AAED,wBAcE;AAGF,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/utils/db.js

@@ -0,0 +1,413 @@
+/**
+ * Database Connection Layer for Drizzle ORM
+ * Provides PostgreSQL connection with pooling, SSL support, and read replicas
+ * Matches Sequelize database configuration for parity
+ */
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as fs from 'fs';
+import env from './env.js';
+import { initializeCacheService, closeCacheService } from '../services/CacheService.js';
+// Initialize globals if not already set
+globalThis.__baasix_db = globalThis.__baasix_db ?? null;
+globalThis.__baasix_sql = globalThis.__baasix_sql ?? null;
+globalThis.__baasix_readSql = globalThis.__baasix_readSql ?? null;
+// Use getters to access the global instances
+const getDbInstance = () => globalThis.__baasix_db;
+const setDbInstance = (val) => { globalThis.__baasix_db = val; };
+const getSql = () => globalThis.__baasix_sql;
+const setSql = (val) => { globalThis.__baasix_sql = val; };
+const getReadSql = () => globalThis.__baasix_readSql;
+const setReadSql = (val) => { globalThis.__baasix_readSql = val; };
+const excludeModels = ['baasix_AuditLog', 'baasix_Sessions'];
+/**
+ * Get database connection configuration
+ */
+function getConnectionConfig() {
+    const config = {
+        max: parseInt(env.get('DATABASE_POOL_MAX') || '20'),
+        idle_timeout: parseInt(env.get('DATABASE_POOL_IDLE') || '10000') / 1000, // Convert to seconds
+        connect_timeout: parseInt(env.get('DATABASE_POOL_ACQUIRE') || '30000') / 1000, // Convert to seconds
+        max_lifetime: parseInt(env.get('DATABASE_POOL_EVICT') || '1000') / 1000 * 60, // Convert to seconds
+        onnotice: env.get('DATABASE_LOGGING') === 'true' ? console.log : undefined,
+    };
+    // SSL configuration
+    if (env.get('DATABASE_SSL_CERTIFICATE') && env.get('DATABASE_SSL_CERTIFICATE') !== 'false') {
+        const caCert = fs.readFileSync(env.get('DATABASE_SSL_CERTIFICATE'));
+        config.ssl = {
+            ca: caCert.toString(),
+            rejectUnauthorized: env.get('DATABASE_SSL_REJECT_UNAUTHORIZED') === 'true',
+        };
+        console.info('Using SSL certificate for database connection');
+    }
+    return config;
+}
+/**
+ * Initialize database connection
+ * Synchronous function that starts async cache initialization
+ */
+export function initializeDatabase() {
+    if (getDbInstance()) {
+        return getDbInstance();
+    }
+    const config = getConnectionConfig();
+    // Start cache service initialization (async) but don't wait
+    // The cache will be available for subsequent queries
+    initializeCacheService().then(cacheService => {
+        if (cacheService && getDbInstance()) {
+            console.info('[Database] Cache service initialized and ready');
+            // Note: Drizzle cache is set during drizzle() initialization below
+            // We can't change it after creation, so cache is passed during init
+        }
+    }).catch(err => {
+        console.error('[Database] Cache service initialization failed:', err);
+    });
+    // Check if read replicas are enabled
+    if (env.get('DATABASE_READ_REPLICA_ENABLED') === 'true' && env.get('DATABASE_READ_REPLICA_URLS')) {
+        const readReplicaUrls = env.get('DATABASE_READ_REPLICA_URLS').split(',').map(url => url.trim());
+        // Write connection (primary)
+        setSql(postgres(env.get('DATABASE_URL'), {
+            ...config,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        }));
+        // Read connections (replicas) - use first replica for now
+        // In production, could implement load balancing across replicas
+        const replicaConfig = {
+            max: parseInt(env.get('DATABASE_READ_REPLICA_POOL_MAX') || '20'),
+            idle_timeout: parseInt(env.get('DATABASE_READ_REPLICA_POOL_IDLE') || '10000') / 1000,
+            connect_timeout: parseInt(env.get('DATABASE_READ_REPLICA_POOL_ACQUIRE') || '30000') / 1000,
+            max_lifetime: parseInt(env.get('DATABASE_READ_REPLICA_POOL_EVICT') || '1000') / 1000 * 60,
+            onnotice: env.get('DATABASE_LOGGING') === 'true' ? console.log : undefined,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        };
+        // Copy SSL config to replica if configured
+        if (config.ssl) {
+            replicaConfig.ssl = config.ssl;
+        }
+        setReadSql(postgres(readReplicaUrls[0], replicaConfig));
+        setDbInstance(drizzle(getSql(), {
+            logger: env.get('DATABASE_LOGGING') === 'true',
+            // Cache will be initialized asynchronously and used on subsequent queries
+        }));
+        console.info(`Database initialized with read replicas: ${readReplicaUrls.length} replica(s) configured`);
+    }
+    else {
+        // Single connection
+        setSql(postgres(env.get('DATABASE_URL'), {
+            ...config,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        }));
+        setDbInstance(drizzle(getSql(), {
+            logger: env.get('DATABASE_LOGGING') === 'true',
+            // Cache will be initialized asynchronously and used on subsequent queries
+        }));
+        console.info('Database initialized without read replicas');
+    }
+    return getDbInstance();
+}
+/**
+ * Initialize database with cache service (async version)
+ * Use this when you need to ensure cache is ready before proceeding
+ */
+export async function initializeDatabaseWithCache() {
+    if (getDbInstance()) {
+        return getDbInstance();
+    }
+    const config = getConnectionConfig();
+    // Initialize cache service first and wait for it
+    const cacheService = await initializeCacheService();
+    // Check if read replicas are enabled
+    if (env.get('DATABASE_READ_REPLICA_ENABLED') === 'true' && env.get('DATABASE_READ_REPLICA_URLS')) {
+        const readReplicaUrls = env.get('DATABASE_READ_REPLICA_URLS').split(',').map(url => url.trim());
+        // Write connection (primary)
+        setSql(postgres(env.get('DATABASE_URL'), {
+            ...config,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        }));
+        // Read connections (replicas)
+        const replicaConfig = {
+            max: parseInt(env.get('DATABASE_READ_REPLICA_POOL_MAX') || '20'),
+            idle_timeout: parseInt(env.get('DATABASE_READ_REPLICA_POOL_IDLE') || '10000') / 1000,
+            connect_timeout: parseInt(env.get('DATABASE_READ_REPLICA_POOL_ACQUIRE') || '30000') / 1000,
+            max_lifetime: parseInt(env.get('DATABASE_READ_REPLICA_POOL_EVICT') || '1000') / 1000 * 60,
+            onnotice: env.get('DATABASE_LOGGING') === 'true' ? console.log : undefined,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        };
+        if (config.ssl) {
+            replicaConfig.ssl = config.ssl;
+        }
+        setReadSql(postgres(readReplicaUrls[0], replicaConfig));
+        setDbInstance(drizzle(getSql(), {
+            logger: env.get('DATABASE_LOGGING') === 'true',
+            cache: cacheService || undefined,
+        }));
+        console.info(`Database initialized with read replicas and cache: ${readReplicaUrls.length} replica(s) configured`);
+    }
+    else {
+        // Single connection
+        setSql(postgres(env.get('DATABASE_URL'), {
+            ...config,
+            debug: env.get('DATABASE_LOGGING') === 'true',
+        }));
+        setDbInstance(drizzle(getSql(), {
+            logger: env.get('DATABASE_LOGGING') === 'true',
+            cache: cacheService || undefined,
+        }));
+        console.info('Database initialized with cache (no read replicas)');
+    }
+    return getDbInstance();
+}
+/**
+ * Get database instance (synchronous - initializes if needed)
+ */
+export function getDatabase() {
+    if (!getDbInstance()) {
+        return initializeDatabase();
+    }
+    return getDbInstance();
+}
+// Export db as a getter to always return the current instance
+// This ensures that even if the module is loaded from different paths,
+// we always get the same database instance
+export const db = new Proxy({}, {
+    get(_, prop) {
+        const instance = getDatabase();
+        const value = instance[prop];
+        return typeof value === 'function' ? value.bind(instance) : value;
+    },
+});
+/**
+ * Get postgres SQL client (for raw queries)
+ */
+export function getSqlClient() {
+    if (!getSql()) {
+        initializeDatabase();
+    }
+    return getSql();
+}
+// Export sql for backward compatibility
+export const sqlClient = new Proxy({}, {
+    get(_, prop) {
+        const instance = getSqlClient();
+        const value = instance[prop];
+        return typeof value === 'function' ? value.bind(instance) : value;
+    },
+    apply(_, thisArg, args) {
+        return getSqlClient().apply(thisArg, args);
+    },
+});
+/**
+ * Get read replica SQL client (if configured)
+ */
+export function getReadSqlClient() {
+    if (!getSql()) {
+        initializeDatabase();
+    }
+    return getReadSql() || getSql();
+}
+/**
+ * Close database connections
+ */
+export async function closeDatabase() {
+    // Close cache service first
+    await closeCacheService();
+    const sql = getSql();
+    const readSql = getReadSql();
+    if (sql) {
+        await sql.end();
+        setSql(null);
+    }
+    if (readSql) {
+        await readSql.end();
+        setReadSql(null);
+    }
+    setDbInstance(null);
+    console.info('Database connections closed');
+}
+/**
+ * Create a new transaction with Sequelize-compatible API
+ * Returns a transaction that must be explicitly committed or rolled back
+ *
+ * Usage matching Sequelize:
+ *   const transaction = await createTransaction();
+ *   try {
+ *     await transaction.insert(table).values(data);
+ *     await transaction.commit();
+ *   } catch (error) {
+ *     await transaction.rollback();
+ *     throw error;
+ *   }
+ */
+export async function createTransaction() {
+    let resolveTransaction;
+    let rejectTransaction;
+    let resolveTxComplete;
+    let rejectTxComplete;
+    // Transaction timeout (default 30 seconds, configurable via env)
+    const TRANSACTION_TIMEOUT_MS = parseInt(env.get('TRANSACTION_TIMEOUT_MS') || '60000');
+    const transactionPromise = new Promise((resolve, reject) => {
+        resolveTransaction = resolve;
+        rejectTransaction = reject;
+    });
+    // Promise that resolves when Drizzle's transaction completes
+    const txCompletePromise = new Promise((resolve, reject) => {
+        resolveTxComplete = resolve;
+        rejectTxComplete = reject;
+    });
+    // Start the Drizzle transaction
+    const txPromise = db.transaction(async (tx) => {
+        // Create wrapper with commit/rollback methods
+        const transaction = tx;
+        transaction._committed = false;
+        transaction._rolledBack = false;
+        // Store the completion resolver
+        transaction._resolveTxComplete = resolveTxComplete;
+        transaction._rejectTxComplete = rejectTxComplete;
+        transaction.commit = async () => {
+            if (transaction._rolledBack) {
+                throw new Error('Transaction already rolled back');
+            }
+            transaction._committed = true;
+            // Wait for Drizzle transaction to complete before returning
+            await txCompletePromise;
+        };
+        transaction.rollback = async () => {
+            if (transaction._committed) {
+                throw new Error('Transaction already committed');
+            }
+            transaction._rolledBack = true;
+            throw new Error('__ROLLBACK__');
+        };
+        // Resolve with the transaction wrapper
+        resolveTransaction(transaction);
+        // Wait for explicit commit or rollback with timeout
+        await new Promise((resolve, reject) => {
+            let resolved = false;
+            // Timeout to prevent transaction from hanging forever
+            const timeoutId = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    console.error(`[Transaction] Transaction timeout after ${TRANSACTION_TIMEOUT_MS}ms - forcing rollback`);
+                    transaction._rolledBack = true;
+                    resolve();
+                }
+            }, TRANSACTION_TIMEOUT_MS);
+            const checkInterval = setInterval(() => {
+                if (transaction._committed || transaction._rolledBack) {
+                    if (!resolved) {
+                        resolved = true;
+                        clearTimeout(timeoutId);
+                        clearInterval(checkInterval);
+                        resolve();
+                    }
+                }
+            }, 10);
+        });
+        // If rolled back, throw to trigger Drizzle's rollback
+        if (transaction._rolledBack) {
+            throw new Error('__ROLLBACK__');
+        }
+        // If committed, transaction will complete successfully here
+    }).then(() => {
+        // Transaction completed successfully
+        resolveTxComplete();
+    }).catch((error) => {
+        // Swallow intentional rollback errors
+        if (error.message === '__ROLLBACK__') {
+            resolveTxComplete(); // Rollback is also a valid completion
+        }
+        else {
+            rejectTxComplete(error);
+            throw error;
+        }
+    });
+    return transactionPromise;
+}
+/**
+ * Test database connection
+ */
+export async function testConnection() {
+    try {
+        const sqlClient = getSqlClient();
+        await sqlClient `SELECT 1 as test`;
+        console.info('Database connection test successful');
+        return true;
+    }
+    catch (error) {
+        console.error('Database connection test failed:', error);
+        return false;
+    }
+}
+// Cache for PostgreSQL version
+let pgVersionCache = null;
+/**
+ * Get PostgreSQL server version
+ * Returns { major: number, minor: number, full: string }
+ * Caches the result after first call
+ */
+export async function getPostgresVersion() {
+    if (pgVersionCache) {
+        return pgVersionCache;
+    }
+    try {
+        const sqlClient = getSqlClient();
+        const result = await sqlClient `SHOW server_version`;
+        const versionString = result[0].server_version;
+        // Parse version like "15.4" or "14.9 (Ubuntu 14.9-0ubuntu0.22.04.1)"
+        const match = versionString.match(/^(\d+)\.(\d+)/);
+        if (match) {
+            pgVersionCache = {
+                major: parseInt(match[1], 10),
+                minor: parseInt(match[2], 10),
+                full: versionString,
+            };
+        }
+        else {
+            // Fallback if parsing fails
+            pgVersionCache = { major: 14, minor: 0, full: versionString };
+        }
+        return pgVersionCache;
+    }
+    catch (error) {
+        console.warn('Failed to get PostgreSQL version, defaulting to 14:', error);
+        pgVersionCache = { major: 14, minor: 0, full: 'unknown' };
+        return pgVersionCache;
+    }
+}
+/**
+ * Check if PostgreSQL version supports a feature
+ * @param minMajor Minimum major version required
+ * @param minMinor Minimum minor version required (default: 0)
+ */
+export async function isPgVersionAtLeast(minMajor, minMinor = 0) {
+    const version = await getPostgresVersion();
+    return version.major > minMajor || (version.major === minMajor && version.minor >= minMinor);
+}
+/**
+ * Get helper to extract instance ID
+ */
+export function getInstanceId(instance) {
+    let id = instance.id || instance?._previousData?.id;
+    if (instance.constructor?.name === 'baasix_SchemaDefinition') {
+        return instance.collectionName;
+    }
+    return id;
+}
+export default {
+    db,
+    sql: sqlClient,
+    initializeDatabase,
+    initializeDatabaseWithCache,
+    getDatabase,
+    getSqlClient,
+    getReadSqlClient,
+    closeDatabase,
+    createTransaction,
+    testConnection,
+    getInstanceId,
+    getPostgresVersion,
+    isPgVersionAtLeast,
+};
+// Export cache service for use in other modules
+export { getCacheService, closeCacheService, initializeCacheService } from '../services/CacheService.js';
+//# sourceMappingURL=db.js.map