@loomcore/api 0.1.135 → 0.1.136

package/dist/__tests__/postgres.test-database.d.ts

@@ -3,7 +3,7 @@ import { IDatabase } from '../databases/models/index.js';
 export declare class TestPostgresDatabase implements ITestDatabase {
     private database;
     private postgresClient;
-    private postgresPool;
+    private migrationPool;
     private initPromise;
     init(): Promise<IDatabase>;
     getRandomId(): string;

package/dist/__tests__/postgres.test-database.js

@@ -1,6 +1,6 @@
 import testUtils from './common-test.utils.js';
 import { newDb } from "pg-mem";
-import { Client, Pool } from 'pg';
+import { Pool } from 'pg';
 import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
 import { config } from '../config/base-api-config.js';
 import { runInitialSchemaMigrations, runTestSchemaMigrations } from '../databases/postgres/migrations/__tests__/test-migration-helper.js';
@@ -8,7 +8,7 @@ const USE_REAL_POSTGRES = process.env.USE_REAL_POSTGRES === 'true';
 export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
-    postgresPool = null;
+    migrationPool = null;
     initPromise = null;
     async init() {
         if (this.initPromise) {
@@ -22,18 +22,21 @@ export class TestPostgresDatabase {
     }
     async _performInit() {
         if (!this.database) {
-            let postgresClient;
+            let connection;
             let pool;
             if (USE_REAL_POSTGRES) {
                 const connectionString = `postgresql://test-user:test-password@localhost:5444/test-db`;
-                postgresClient = new Client({
+                pool = new Pool({
                     connectionString,
                     connectionTimeoutMillis: 5000,
                 });
+                this.migrationPool = pool;
                 try {
-                    await postgresClient.connect();
+                    await pool.query('SELECT now(), current_database()');
                 }
                 catch (error) {
+                    await pool.end();
+                    this.migrationPool = null;
                     const errorMessage = error.message || String(error);
                     const isPermissionError = errorMessage.includes('permission denied') || errorMessage.includes('operation not permitted');
                     if (isPermissionError) {
@@ -49,20 +52,18 @@ export class TestPostgresDatabase {
                         `View container logs: npm run test:db:logs\n` +
                         `Connection error: ${errorMessage}`);
                 }
-                pool = new Pool({
-                    connectionString,
-                    connectionTimeoutMillis: 5000,
-                });
+                connection = pool;
             }
             else {
                 const { Client } = newDb().adapters.createPg();
-                postgresClient = new Client();
-                await postgresClient.connect();
-                pool = postgresClient;
+                const pgMemClient = new Client();
+                await pgMemClient.connect();
+                pool = pgMemClient;
+                connection = pgMemClient;
+                this.migrationPool = pool;
             }
-            this.postgresPool = pool;
-            this.database = new PostgresDatabase(postgresClient);
-            this.postgresClient = postgresClient;
+            this.database = new PostgresDatabase(connection);
+            this.postgresClient = connection;
             const { initializeSystemUserContext, isSystemUserContextInitialized } = await import('@loomcore/common/models');
             if (!isSystemUserContextInitialized()) {
                 initializeSystemUserContext(config.email?.systemEmailAddress || 'system@test.com', undefined);
@@ -70,14 +71,14 @@ export class TestPostgresDatabase {
             await runInitialSchemaMigrations(pool, config);
             await runTestSchemaMigrations(pool, config);
             testUtils.initialize(this.database);
-            await this.createIndexes(postgresClient);
+            await this.createIndexes(connection);
             await testUtils.createMetaOrg();
         }
         return this.database;
     }
-    async createIndexes(client) {
+    async createIndexes(connection) {
         try {
-            await client.query(`
+            await connection.query(`
         CREATE INDEX IF NOT EXISTS email_index ON users (LOWER(email));
         CREATE UNIQUE INDEX IF NOT EXISTS email_unique_index ON users (LOWER(email));
       `);
@@ -97,7 +98,7 @@ export class TestPostgresDatabase {
       AND "table_type" = 'BASE TABLE'
     `);
         if (USE_REAL_POSTGRES) {
-            await this.postgresClient?.query(`TRUNCATE TABLE ${result.rows.map(row => `"${row.table_name}"`).join(', ')} RESTART IDENTITY CASCADE`);
+            await this.postgresClient.query(`TRUNCATE TABLE ${result.rows.map(row => `"${row.table_name}"`).join(', ')} RESTART IDENTITY CASCADE`);
         }
         else {
             result.rows.forEach(async (row) => {
@@ -111,21 +112,18 @@ export class TestPostgresDatabase {
         }
         if (this.postgresClient) {
             try {
-                await this.postgresClient.end();
-            }
-            catch (error) {
-                console.warn('Error closing PostgreSQL client:', error);
-            }
-        }
-        if (this.postgresPool) {
-            try {
-                await this.postgresPool.end();
+                if (this.postgresClient instanceof Pool) {
+                    await this.postgresClient.end();
+                }
+                else {
+                    await this.postgresClient.end();
+                }
             }
             catch (error) {
-                console.warn('Error closing PostgreSQL pool:', error);
+                console.warn('Error closing PostgreSQL connection:', error);
             }
-            this.postgresPool = null;
         }
+        this.migrationPool = null;
         this.initPromise = null;
         this.database = null;
         this.postgresClient = null;

package/dist/databases/models/database.d.ts

@@ -1,3 +1,3 @@
 import { Db } from 'mongodb';
-import { Client } from 'pg';
-export type Database = Db | Client;
+import type { Client, Pool } from 'pg';
+export type Database = Db | Client | Pool;

package/dist/databases/postgres/commands/postgres-batch-update.command.d.ts

@@ -1,4 +1,4 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from "../../operations/operation.js";
 import { IEntity, IQueryOptions } from '@loomcore/common/models';
-export declare function batchUpdate<T extends IEntity>(client: Client, entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+export declare function batchUpdate<T extends IEntity>(connection: PostgresConnection, entities: Partial<T>[], operations: Operation[], queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/commands/postgres-batch-update.command.js

@@ -1,3 +1,4 @@
+import { Pool } from 'pg';
 import { LeftJoin } from "../../operations/left-join.operation.js";
 import { InnerJoin } from "../../operations/inner-join.operation.js";
 import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
@@ -7,7 +8,7 @@ import { buildSelectClause } from '../utils/build-select-clause.js';
 import { transformJoinResults } from '../utils/transform-join-results.js';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 import { buildWhereClause } from '../utils/build-where-clause.js';
-export async function batchUpdate(client, entities, operations, queryObject, pluralResourceName) {
+export async function batchUpdate(connection, entities, operations, queryObject, pluralResourceName) {
     if (!entities || entities.length === 0) {
         return [];
     }
@@ -19,8 +20,17 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
         entityIds.push(entity._id);
     }
     queryObject.filters = queryObject.filters || {};
+    let session;
+    let releaseSession = false;
+    if (connection instanceof Pool) {
+        session = await connection.connect();
+        releaseSession = true;
+    }
+    else {
+        session = connection;
+    }
     try {
-        await client.query('BEGIN');
+        await session.query('BEGIN');
         for (const entity of entities) {
             const { _id, ...updateData } = entity;
             if (Object.keys(updateData).length === 0) {
@@ -35,31 +45,36 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
                 SET ${setClause}
                 ${whereClause}
             `;
-            await client.query(query, values);
+            await session.query(query, values);
         }
-        await client.query('COMMIT');
+        await session.query('COMMIT');
         const joinClauses = buildJoinClauses(operations, pluralResourceName);
         const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
         const tablePrefix = hasJoins ? pluralResourceName : undefined;
         queryObject.filters._id = { in: entityIds };
         const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
         const selectClause = hasJoins
-            ? await buildSelectClause(client, pluralResourceName, operations)
+            ? await buildSelectClause(session, pluralResourceName, operations)
             : '*';
         const selectQuery = `
             SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}
             ${whereClause}
         `;
-        const result = await client.query(selectQuery, values);
+        const result = await session.query(selectQuery, values);
         return hasJoins
             ? transformJoinResults(result.rows, operations)
             : result.rows;
     }
     catch (err) {
-        await client.query('ROLLBACK');
+        await session.query('ROLLBACK');
         if (err.code === '23505') {
             throw new BadRequestError(`One or more ${pluralResourceName} have duplicate key violations`);
         }
         throw new BadRequestError(`Error updating ${pluralResourceName}: ${err.message}`);
     }
+    finally {
+        if (releaseSession) {
+            session.release();
+        }
+    }
 }

package/dist/databases/postgres/commands/postgres-create-many.command.d.ts

@@ -1,7 +1,7 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IEntity } from '@loomcore/common/models';
 import type { AppIdType } from '@loomcore/common/types';
-export declare function createMany<T extends IEntity>(client: Client, pluralResourceName: string, entities: Partial<T>[]): Promise<{
+export declare function createMany<T extends IEntity>(client: PostgresConnection, pluralResourceName: string, entities: Partial<T>[]): Promise<{
     insertedIds: AppIdType[];
     entities: T[];
 }>;

package/dist/databases/postgres/commands/postgres-create.command.d.ts

@@ -1,7 +1,7 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IEntity } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
-export declare function create<T extends IEntity>(client: Client, pluralResourceName: string, entity: Partial<T>): Promise<{
+export declare function create<T extends IEntity>(client: PostgresConnection, pluralResourceName: string, entity: Partial<T>): Promise<{
     insertedId: AppIdType;
     entity: T;
 }>;

package/dist/databases/postgres/commands/postgres-delete-by-id.command.d.ts

@@ -1,4 +1,4 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { DeleteResult } from "../../models/delete-result.js";
 import type { AppIdType } from '@loomcore/common/types';
-export declare function deleteById(client: Client, id: AppIdType, pluralResourceName: string): Promise<DeleteResult>;
+export declare function deleteById(client: PostgresConnection, id: AppIdType, pluralResourceName: string): Promise<DeleteResult>;

package/dist/databases/postgres/commands/postgres-delete-many.command.d.ts

@@ -1,4 +1,4 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from "@loomcore/common/models";
 import { DeleteResult } from "../../models/delete-result.js";
-export declare function deleteMany(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
+export declare function deleteMany(client: PostgresConnection, queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.d.ts

@@ -1,5 +1,5 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from "../../operations/operation.js";
 import { IEntity } from '@loomcore/common/models';
 import type { AppIdType } from '@loomcore/common/types';
-export declare function fullUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+export declare function fullUpdateById<T extends IEntity>(client: PostgresConnection, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.d.ts

@@ -1,5 +1,5 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from "../../operations/operation.js";
 import { IEntity } from '@loomcore/common/models';
 import type { AppIdType } from '@loomcore/common/types';
-export declare function partialUpdateById<T extends IEntity>(client: Client, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;
+export declare function partialUpdateById<T extends IEntity>(client: PostgresConnection, operations: Operation[], id: AppIdType, entity: Partial<T>, pluralResourceName: string): Promise<T>;

package/dist/databases/postgres/commands/postgres-update.command.d.ts

@@ -1,5 +1,5 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from "@loomcore/common/models";
 import { Operation } from "../../operations/operation.js";
 import { IEntity } from '@loomcore/common/models';
-export declare function update<T extends IEntity>(client: Client, queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+export declare function update<T extends IEntity>(client: PostgresConnection, queryObject: IQueryOptions, entity: Partial<T>, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/index.d.ts

@@ -1,3 +1,4 @@
+export * from './postgres-connection.js';
 export * from './postgres.database.js';
 export * from './migrations/index.js';
 export * from './utils/index.js';

package/dist/databases/postgres/index.js

@@ -1,3 +1,4 @@
+export * from './postgres-connection.js';
 export * from './postgres.database.js';
 export * from './migrations/index.js';
 export * from './utils/index.js';

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -9,9 +9,25 @@ export const getPostgresInitialSchema = (dbConfig) => {
         throw new Error('Multi-tenant configuration is enabled but multi-tenant configuration is not provided');
     }
     const isAuthEnabled = dbConfig.app.isAuthEnabled;
+    const dbName = dbConfig.database.name.replace(/"/g, '""');
+    migrations.push({
+        name: '00000000000001_system-configurations',
+        up: async ({ context: pool }) => {
+            if (dbConfig.env === 'test') {
+                return;
+            }
+            await pool.query(`ALTER DATABASE "${dbName}" SET statement_timeout = '60s'`);
+        },
+        down: async ({ context: pool }) => {
+            if (dbConfig.env === 'test') {
+                return;
+            }
+            await pool.query(`ALTER DATABASE "${dbName}" RESET statement_timeout`);
+        }
+    });
     if (isMultiTenant) {
         migrations.push({
-            name: '00000000000001_schema-organizations',
+            name: '00000000000002_schema-organizations',
             up: async ({ context: pool }) => {
                 await pool.query(`
           CREATE TABLE IF NOT EXISTS "organizations" (
@@ -38,7 +54,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000002_schema-persons',
+            name: '00000000000003_schema-persons',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const personsUniqueConstraints = isMultiTenant
@@ -76,7 +92,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000003_schema-users',
+            name: '00000000000004_schema-users',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 let uniqueConstraint = isMultiTenant
@@ -111,7 +127,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000004_schema-refresh-tokens',
+            name: '00000000000005_schema-refresh-tokens',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 await pool.query(`
@@ -134,7 +150,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000005_schema-password-reset-tokens',
+            name: '00000000000006_schema-password-reset-tokens',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -163,7 +179,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000006_schema-roles',
+            name: '00000000000007_schema-roles',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -185,7 +201,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000007_schema-user-roles',
+            name: '00000000000008_schema-user-roles',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -215,7 +231,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000008_schema-features',
+            name: '00000000000009_schema-features',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -237,7 +253,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000009_schema-authorizations',
+            name: '00000000000010_schema-authorizations',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -270,7 +286,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: '00000000000010_data-meta-org',
+            name: '00000000000011_data-meta-org',
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
           INSERT INTO "organizations" ("name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy")
@@ -289,11 +305,11 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000011_data-admin-user',
+            name: '00000000000012_data-admin-user',
             up: async ({ context: pool }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. ' +
+                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000011_data-meta-org) should have run before this migration. ' +
                             'Please ensure metaOrgName and metaOrgCode are provided in your dbConfig.'
                         : 'BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.';
                     console.error('❌ Migration Error:', errorMessage);
@@ -335,7 +351,7 @@ export const getPostgresInitialSchema = (dbConfig) => {
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000012_data-admin-authorizations',
+            name: '00000000000013_data-admin-authorizations',
             up: async ({ context: pool }) => {
                 const client = await pool.connect();
                 try {

package/dist/databases/postgres/postgres-connection.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Pool, PoolClient } from 'pg';
+export type PostgresConnection = Client | Pool | PoolClient;

package/dist/databases/postgres/postgres-connection.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/postgres/postgres.database.d.ts

@@ -3,10 +3,10 @@ import type { AppIdType } from "@loomcore/common/types";
 import { TSchema } from "@sinclair/typebox";
 import { DeleteResult, IDatabase } from "../models/index.js";
 import { Operation } from "../operations/operation.js";
-import { Client } from 'pg';
+import type { PostgresConnection } from './postgres-connection.js';
 export declare class PostgresDatabase implements IDatabase {
-    private client;
-    constructor(client: Client);
+    private connection;
+    constructor(connection: PostgresConnection);
     preProcessEntity<T extends IEntity>(entity: Partial<T>, modelSpec: TSchema): Partial<T>;
     postProcessEntity<T extends IEntity>(entity: T, modelSpec: TSchema): T;
     getAll<T extends IEntity>(operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/postgres.database.js

@@ -15,9 +15,9 @@ import { getCount as getCountQuery } from "./queries/postgres-get-count.query.js
 import { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
 import { convertKeysToSnakeCase, convertKeysToCamelCase } from "./utils/convert-keys.util.js";
 export class PostgresDatabase {
-    client;
-    constructor(client) {
-        this.client = client;
+    connection;
+    constructor(connection) {
+        this.connection = connection;
     }
     preProcessEntity(entity, modelSpec) {
         return convertKeysToSnakeCase(entity);
@@ -27,46 +27,46 @@ export class PostgresDatabase {
         return convertKeysToCamelCase(withNullsConverted);
     }
     async getAll(operations, pluralResourceName) {
-        return getAllQuery(this.client, operations, pluralResourceName);
+        return getAllQuery(this.connection, operations, pluralResourceName);
     }
     async get(operations, queryOptions, modelSpec, pluralResourceName) {
-        return getQuery(this.client, operations, queryOptions, pluralResourceName);
+        return getQuery(this.connection, operations, queryOptions, pluralResourceName);
     }
     async getById(operations, queryObject, id, pluralResourceName) {
-        return getByIdQuery(this.client, operations, queryObject, id, pluralResourceName);
+        return getByIdQuery(this.connection, operations, queryObject, id, pluralResourceName);
     }
     async getCount(pluralResourceName) {
-        return getCountQuery(this.client, pluralResourceName);
+        return getCountQuery(this.connection, pluralResourceName);
     }
     async create(entity, pluralResourceName) {
-        return createCommand(this.client, pluralResourceName, entity);
+        return createCommand(this.connection, pluralResourceName, entity);
     }
     async createMany(entities, pluralResourceName) {
-        return createManyCommand(this.client, pluralResourceName, entities);
+        return createManyCommand(this.connection, pluralResourceName, entities);
     }
     async batchUpdate(entities, operations, queryObject, pluralResourceName) {
-        return batchUpdateCommand(this.client, entities, operations, queryObject, pluralResourceName);
+        return batchUpdateCommand(this.connection, entities, operations, queryObject, pluralResourceName);
     }
     async fullUpdateById(operations, id, entity, pluralResourceName) {
-        return fullUpdateByIdCommand(this.client, operations, id, entity, pluralResourceName);
+        return fullUpdateByIdCommand(this.connection, operations, id, entity, pluralResourceName);
     }
     async partialUpdateById(operations, id, entity, pluralResourceName) {
-        return partialUpdateByIdCommand(this.client, operations, id, entity, pluralResourceName);
+        return partialUpdateByIdCommand(this.connection, operations, id, entity, pluralResourceName);
     }
     async update(queryObject, entity, operations, pluralResourceName) {
-        return updateCommand(this.client, queryObject, entity, operations, pluralResourceName);
+        return updateCommand(this.connection, queryObject, entity, operations, pluralResourceName);
     }
     async deleteById(id, pluralResourceName) {
-        return deleteByIdCommand(this.client, id, pluralResourceName);
+        return deleteByIdCommand(this.connection, id, pluralResourceName);
     }
     async deleteMany(queryObject, pluralResourceName) {
-        return deleteManyCommand(this.client, queryObject, pluralResourceName);
+        return deleteManyCommand(this.connection, queryObject, pluralResourceName);
     }
     async find(queryObject, pluralResourceName) {
-        return findQuery(this.client, queryObject, pluralResourceName);
+        return findQuery(this.connection, queryObject, pluralResourceName);
     }
     async findOne(queryObject, pluralResourceName) {
-        return findOneQuery(this.client, queryObject, pluralResourceName);
+        return findOneQuery(this.connection, queryObject, pluralResourceName);
     }
     async getUserAuthorizations(userId, orgId) {
         const now = new Date();
@@ -93,7 +93,7 @@ export class PostgresDatabase {
             query += ` AND ur."_orgId" = $3 AND r."_orgId" = $3 AND a."_orgId" = $3 AND f."_orgId" = $3`;
             values.push(orgId);
         }
-        const result = await this.client.query(query, values);
+        const result = await this.connection.query(query, values);
         const authorizations = [];
         for (const row of result.rows) {
             const userId = row.userId;

package/dist/databases/postgres/queries/postgres-find-one.query.d.ts

@@ -1,3 +1,3 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from "@loomcore/common/models";
-export declare function findOne<T>(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
+export declare function findOne<T>(client: PostgresConnection, queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;

package/dist/databases/postgres/queries/postgres-find.query.d.ts

@@ -1,3 +1,3 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from "@loomcore/common/models";
-export declare function find<T>(client: Client, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
+export declare function find<T>(client: PostgresConnection, queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/queries/postgres-get-all.query.d.ts

@@ -1,3 +1,3 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from "../../operations/operation.js";
-export declare function getAll<T>(client: Client, operations: Operation[], pluralResourceName: string): Promise<T[]>;
+export declare function getAll<T>(client: PostgresConnection, operations: Operation[], pluralResourceName: string): Promise<T[]>;

package/dist/databases/postgres/queries/postgres-get-by-id.query.d.ts

@@ -1,5 +1,5 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from "../../operations/operation.js";
 import { IQueryOptions } from '@loomcore/common/models';
 import type { AppIdType } from '@loomcore/common/types';
-export declare function getById<T>(client: Client, operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;
+export declare function getById<T>(client: PostgresConnection, operations: Operation[], queryObject: IQueryOptions, id: AppIdType, pluralResourceName: string): Promise<T | null>;

package/dist/databases/postgres/queries/postgres-get-count.query.d.ts

@@ -1,2 +1,2 @@
-import { Client } from 'pg';
-export declare function getCount(client: Client, pluralResourceName: string): Promise<number>;
+import type { PostgresConnection } from '../postgres-connection.js';
+export declare function getCount(client: PostgresConnection, pluralResourceName: string): Promise<number>;

package/dist/databases/postgres/queries/postgres-get.query.d.ts

@@ -1,4 +1,4 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions, IPagedResult } from "@loomcore/common/models";
 import { Operation } from "../../operations/operation.js";
-export declare function get<T>(client: Client, operations: Operation[], queryOptions: IQueryOptions, pluralResourceName: string): Promise<IPagedResult<T>>;
+export declare function get<T>(client: PostgresConnection, operations: Operation[], queryOptions: IQueryOptions, pluralResourceName: string): Promise<IPagedResult<T>>;

package/dist/databases/postgres/utils/build-count-query.d.ts

@@ -1,3 +1,3 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from "@loomcore/common/models";
-export declare function executeCountQuery(client: Client, pluralResourceName: string, queryOptions?: IQueryOptions): Promise<number>;
+export declare function executeCountQuery(client: PostgresConnection, pluralResourceName: string, queryOptions?: IQueryOptions): Promise<number>;

package/dist/databases/postgres/utils/build-select-clause.d.ts

@@ -1,4 +1,4 @@
-import { Client } from 'pg';
+import type { PostgresConnection } from '../postgres-connection.js';
 import { Operation } from '../../operations/operation.js';
-export declare function getTableColumns(client: Client, tableName: string): Promise<string[]>;
-export declare function buildSelectClause(client: Client, mainTableName: string, operations: Operation[]): Promise<string>;
+export declare function getTableColumns(client: PostgresConnection, tableName: string): Promise<string[]>;
+export declare function buildSelectClause(client: PostgresConnection, mainTableName: string, operations: Operation[]): Promise<string>;

package/dist/databases/postgres/utils/does-table-exist.util.d.ts

@@ -1,2 +1,2 @@
-import { Client } from "pg";
-export declare function doesTableExist(client: Client, tableName: string): Promise<boolean>;
+import type { PostgresConnection } from "../postgres-connection.js";
+export declare function doesTableExist(client: PostgresConnection, tableName: string): Promise<boolean>;

package/dist/utils/express.utils.d.ts

@@ -1,11 +1,12 @@
 import { Application } from 'express';
 import { MongoClient } from "mongodb";
+import type { Client, Pool } from "pg";
 import { Server } from "http";
 import { IBaseApiConfig } from "../models/index.js";
 import { IDatabase } from '../databases/models/index.js';
 type RouteSetupFunction = (app: Application, database: IDatabase, config: IBaseApiConfig) => void;
 declare function setupExpressApp(database: IDatabase, config: IBaseApiConfig, setupRoutes: RouteSetupFunction): Application;
-declare function performGracefulShutdown(event: any, mongoClient: MongoClient | null, externalServer: Server | null, internalServer: Server | null): void;
+declare function performGracefulShutdown(event: any, mongoClient: MongoClient | null, externalServer: Server | null, internalServer: Server | null, postgres?: Pool | Client | null): void;
 export declare const expressUtils: {
     setupExpressApp: typeof setupExpressApp;
     performGracefulShutdown: typeof performGracefulShutdown;

package/dist/utils/express.utils.js

@@ -31,7 +31,7 @@ function setupExpressApp(database, config, setupRoutes) {
     app.use(errorHandler);
     return app;
 }
-function performGracefulShutdown(event, mongoClient, externalServer, internalServer) {
+function performGracefulShutdown(event, mongoClient, externalServer, internalServer, postgres = null) {
     const closeMongoConnection = async () => {
         if (mongoClient) {
             console.log('closing mongodb connection');
@@ -44,6 +44,19 @@ function performGracefulShutdown(event, mongoClient, externalServer, internalSer
             }
         }
     };
+    const closePostgres = async () => {
+        if (!postgres) {
+            return;
+        }
+        console.log('closing PostgreSQL pool');
+        try {
+            await postgres.end();
+            console.log('PostgreSQL pool closed successfully');
+        }
+        catch (err) {
+            console.error('Error closing PostgreSQL pool:', err);
+        }
+    };
     const shutdownServers = new Promise((resolve) => {
         let serversClosedCount = 0;
         const totalServers = (externalServer ? 1 : 0) + (internalServer ? 1 : 0);
@@ -76,16 +89,19 @@ function performGracefulShutdown(event, mongoClient, externalServer, internalSer
             });
         }
         setTimeout(() => {
-            console.log('Server shutdown timeout reached, proceeding with MongoDB cleanup');
+            console.log('Server shutdown timeout reached, proceeding with database cleanup');
             resolve();
         }, 5000);
     });
+    const closeAllDatabases = async () => {
+        await Promise.all([closeMongoConnection(), closePostgres()]);
+    };
     Promise.race([
-        shutdownServers.then(() => closeMongoConnection()),
+        shutdownServers.then(() => closeAllDatabases()),
         new Promise(resolve => {
             setTimeout(async () => {
-                console.log('Ensuring MongoDB connection is closed before exit');
-                await closeMongoConnection();
+                console.log('Ensuring database connections are closed before exit');
+                await closeAllDatabases();
                 resolve();
             }, 6000);
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.135",
+  "version": "0.1.136",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {