@loomcore/api 0.1.66 → 0.1.68

package/README.md

@@ -37,6 +37,34 @@ The framework is built around a few core components:
 
 By extending these base classes, you can quickly stand up a new, fully-featured API endpoint with minimal boilerplate code.
 
+## Testing
+
+### PostgreSQL Testing
+
+The test suite supports two modes for PostgreSQL testing:
+
+1. **pg-mem (default)**: Fast, in-memory PostgreSQL simulation. Use for most tests.
+   ```bash
+   npm run test:postgres
+   ```
+
+2. **Real PostgreSQL Container**: Full PostgreSQL compatibility for tests that require advanced features (e.g., LATERAL joins). Requires Docker.
+   ```bash
+   # Start the test database container
+   npm run test:db:start
+   
+   # Wait for it to be ready (optional, tests will retry)
+   ./scripts/wait-for-postgres.sh
+   
+   # Run tests with real PostgreSQL
+   npm run test:postgres:real
+   
+   # Stop the container when done
+   npm run test:db:stop
+   ```
+
+The container uses port `5433` to avoid conflicts with local PostgreSQL instances. Set `USE_REAL_POSTGRES=true` to use the container instead of pg-mem.
+
 ## Example Usage
 
 ### Host Application

package/dist/__tests__/common-test.utils.js

@@ -15,7 +15,7 @@ import * as testObjectsModule from './test-objects.js';
 const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId } = testObjectsModule;
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
-import { setBaseApiConfig } from '../config/index.js';
+import { setBaseApiConfig, config } from '../config/index.js';
 import { entityUtils } from '@loomcore/common/utils';
 import { getTestOrgUser } from './test-objects.js';
 import { TestEmailClient } from './test-email-client.js';
@@ -44,6 +44,9 @@ function getExpectedIdType(database) {
     return isPostgresDatabase(database) ? 'number' : 'string';
 }
 async function createMetaOrg() {
+    if (!config.app.isMultiTenant) {
+        return;
+    }
     if (!organizationService) {
         throw new Error('OrganizationService not initialized. Call initialize() first.');
     }

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -93,5 +93,191 @@ export const getPostgresTestSchema = (config) => {
             await pool.query('DROP TABLE IF EXISTS "testItems"');
         }
     });
+    migrations.push({
+        name: '00000000000105_schema-persons',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "persons" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "external_id" VARCHAR UNIQUE,
+          "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
+          "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
+          "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
+          "first_name" VARCHAR NOT NULL,
+          "middle_name" VARCHAR,
+          "date_of_birth" DATE,
+          "last_name" VARCHAR NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER
+)
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "persons"');
+        }
+    });
+    migrations.push({
+        name: '00000000000104_schema-clients',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "clients" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "external_id" VARCHAR UNIQUE,
+          "person_id" INTEGER NOT NULL UNIQUE,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_clients_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "clients"');
+        }
+    });
+    migrations.push({
+        name: '00000000000106_schema-email-addresses',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS email_addresses (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "person_id" INTEGER NOT NULL,
+          "external_id" VARCHAR UNIQUE,
+          "email_address" VARCHAR NOT NULL UNIQUE,
+          "email_address_type" VARCHAR,
+          "is_default" BOOLEAN NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_email_addresses_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "email_addresses"');
+        }
+    });
+    migrations.push({
+        name: '00000000000107_schema-phone-numbers',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS phone_numbers (
+            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            "_orgId" INTEGER,
+            "external_id" VARCHAR UNIQUE,
+            "phone_number" VARCHAR NOT NULL UNIQUE,
+            "phone_number_type" VARCHAR,
+            "is_default" BOOLEAN NOT NULL DEFAULT FALSE,
+            "_created" TIMESTAMPTZ NOT NULL,
+            "_createdBy" INTEGER NOT NULL,
+            "_updated" TIMESTAMPTZ NOT NULL,
+            "_updatedBy" INTEGER NOT NULL,
+            "_deleted" TIMESTAMPTZ,
+            "_deletedBy" INTEGER
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "phone_numbers"');
+        }
+    });
+    migrations.push({
+        name: '00000000000108_schema-addresses',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS addresses (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "external_id" VARCHAR UNIQUE,
+          "address_type" VARCHAR NOT NULL,
+          "address_line_1" VARCHAR NOT NULL,
+          "address_line_2" VARCHAR,
+          "city" VARCHAR NOT NULL,
+          "state" VARCHAR NOT NULL,
+          "zip_code" VARCHAR NOT NULL,
+          "country" VARCHAR NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "addresses"');
+        }
+    });
+    migrations.push({
+        name: '00000000000109_schema-person-addresses',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS persons_addresses (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "address_id" INTEGER NOT NULL,
+          "person_id" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_persons_addresses_address_id FOREIGN KEY ("address_id") REFERENCES addresses("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_persons_addresses_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE,
+          CONSTRAINT uk_persons_addresses_address_person UNIQUE ("address_id", "person_id")
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "persons_addresses"');
+        }
+    });
+    migrations.push({
+        name: '00000000000110_schema-person-phone-numbers',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS persons_phone_numbers (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "phone_number_id" INTEGER NOT NULL,
+          "person_id" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_persons_phone_numbers_phone_number_id FOREIGN KEY ("phone_number_id") REFERENCES phone_numbers("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_persons_phone_numbers_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE,
+          CONSTRAINT uk_persons_phone_numbers_phone_number_person UNIQUE ("phone_number_id", "person_id")
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "persons_phone_numbers"');
+        }
+    });
     return migrations;
 };

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

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

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

@@ -1,11 +1,14 @@
 import testUtils from './common-test.utils.js';
 import { newDb } from "pg-mem";
+import { Client, 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';
+const USE_REAL_POSTGRES = process.env.USE_REAL_POSTGRES === 'true';
 export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
+    postgresPool = null;
     initPromise = null;
     async init(adminUsername, adminPassword) {
         if (this.initPromise) {
@@ -19,9 +22,45 @@ export class TestPostgresDatabase {
     }
     async _performInit(adminUsername, adminPassword) {
         if (!this.database) {
-            const { Client } = newDb().adapters.createPg();
-            const postgresClient = new Client();
-            await postgresClient.connect();
+            let postgresClient;
+            let pool;
+            if (USE_REAL_POSTGRES) {
+                const connectionString = `postgresql://test-user:test-password@localhost:5433/test-db`;
+                postgresClient = new Client({
+                    connectionString,
+                    connectionTimeoutMillis: 5000,
+                });
+                try {
+                    await postgresClient.connect();
+                }
+                catch (error) {
+                    const errorMessage = error.message || String(error);
+                    const isPermissionError = errorMessage.includes('permission denied') || errorMessage.includes('operation not permitted');
+                    if (isPermissionError) {
+                        throw new Error(`Docker permission error. Please ensure:\n` +
+                            `1. Docker Desktop is running\n` +
+                            `2. You have permission to access Docker (may need to restart Docker Desktop)\n` +
+                            `3. Try: docker ps (to verify Docker access)\n` +
+                            `Original error: ${errorMessage}`);
+                    }
+                    throw new Error(`Failed to connect to PostgreSQL test container at localhost:5433.\n` +
+                        `Make sure the container is running: npm run test:db:start\n` +
+                        `Check container status: docker ps | grep postgres-test\n` +
+                        `View container logs: npm run test:db:logs\n` +
+                        `Connection error: ${errorMessage}`);
+                }
+                pool = new Pool({
+                    connectionString,
+                    connectionTimeoutMillis: 5000,
+                });
+                this.postgresPool = pool;
+            }
+            else {
+                const { Client } = newDb().adapters.createPg();
+                postgresClient = new Client();
+                await postgresClient.connect();
+                pool = postgresClient;
+            }
             const testDatabase = new PostgresDatabase(postgresClient);
             this.database = testDatabase;
             this.postgresClient = postgresClient;
@@ -29,7 +68,6 @@ export class TestPostgresDatabase {
             if (!isSystemUserContextInitialized()) {
                 initializeSystemUserContext(config.email?.systemEmailAddress || 'system@test.com', undefined);
             }
-            const pool = postgresClient;
             await runInitialSchemaMigrations(pool, config);
             await runTestSchemaMigrations(pool, config);
             testUtils.initialize(testDatabase);
@@ -64,12 +102,28 @@ export class TestPostgresDatabase {
         });
     }
     async cleanup() {
-        await testUtils.cleanup();
-        if (!this.postgresClient) {
-            throw new Error('Database not initialized');
+        if (this.database) {
+            await testUtils.cleanup();
+        }
+        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();
+            }
+            catch (error) {
+                console.warn('Error closing PostgreSQL pool:', error);
+            }
+            this.postgresPool = null;
         }
-        await this.postgresClient.end();
         this.initPromise = null;
         this.database = null;
+        this.postgresClient = null;
     }
 }

package/dist/databases/migrations/migration-runner.js

@@ -56,7 +56,13 @@ export class MigrationRunner {
             throw new Error(`❌ Migrations directory not found at: ${this.migrationsDir}`);
         }
         if (this.dbType === 'postgres') {
-            const pool = new Pool({ connectionString: this.dbUrl });
+            const pool = new Pool({
+                host: this.config.database.host,
+                user: this.config.database.username,
+                password: this.config.database.password,
+                port: this.config.database.port,
+                database: this.config.database.name
+            });
             this.dbConnection = pool;
             return new Umzug({
                 migrations: async () => {
@@ -158,7 +164,13 @@ export class MigrationRunner {
     async wipeDatabase() {
         console.log(`⚠️  Wiping ${this.dbType} database...`);
         if (this.dbType === 'postgres') {
-            const pool = new Pool({ connectionString: this.dbUrl });
+            const pool = new Pool({
+                host: this.config.database.host,
+                user: this.config.database.username,
+                password: this.config.database.password,
+                port: this.config.database.port,
+                database: this.config.database.name
+            });
             try {
                 await pool.query('DROP SCHEMA public CASCADE; CREATE SCHEMA public;');
             }

package/dist/databases/mongo-db/utils/convert-operations-to-pipeline.util.js

@@ -1,6 +1,9 @@
 import { Join } from '../../operations/join.operation.js';
+import { JoinMany } from '../../operations/join-many.operation.js';
+import { JoinThrough } from '../../operations/join-through.operation.js';
 export function convertOperationsToPipeline(operations) {
     let pipeline = [];
+    const processedOperations = [];
     operations.forEach(operation => {
         if (operation instanceof Join) {
             const needsObjectIdConversion = operation.foreignField === '_id';
@@ -63,6 +66,255 @@ export function convertOperationsToPipeline(operations) {
                 });
             }
         }
+        else if (operation instanceof JoinMany) {
+            const needsObjectIdConversion = operation.foreignField === '_id';
+            const isNestedField = operation.localField.includes('.');
+            if (needsObjectIdConversion || isNestedField) {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        let: { localId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.localField}` },
+                                    `$${operation.localField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [`$${operation.foreignField}`, '$$localId']
+                                    }
+                                }
+                            }
+                        ],
+                        as: operation.as
+                    }
+                });
+                if (isNestedField) {
+                    const [parentAlias] = operation.localField.split('.');
+                    const parentJoin = processedOperations.find(op => op instanceof Join && op.as === parentAlias);
+                    if (parentJoin) {
+                        pipeline.push({
+                            $addFields: {
+                                [parentAlias]: {
+                                    $mergeObjects: [
+                                        `$${parentAlias}`,
+                                        { [operation.as]: `$${operation.as}` }
+                                    ]
+                                }
+                            }
+                        });
+                        pipeline.push({
+                            $project: {
+                                [operation.as]: 0
+                            }
+                        });
+                    }
+                }
+            }
+            else {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        localField: operation.localField,
+                        foreignField: operation.foreignField,
+                        as: operation.as
+                    }
+                });
+            }
+        }
+        else if (operation instanceof JoinThrough) {
+            const needsObjectIdConversion = operation.foreignField === '_id';
+            const isNestedField = operation.localField.includes('.');
+            if (needsObjectIdConversion || isNestedField) {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.through,
+                        let: { localId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.localField}` },
+                                    `$${operation.localField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [
+                                            {
+                                                $cond: [
+                                                    { $eq: [{ $type: `$${operation.throughLocalField}` }, 'string'] },
+                                                    { $toObjectId: `$${operation.throughLocalField}` },
+                                                    `$${operation.throughLocalField}`
+                                                ]
+                                            },
+                                            '$$localId'
+                                        ]
+                                    }
+                                }
+                            }
+                        ],
+                        as: `${operation.as}_through`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}_through`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $lookup: {
+                        from: operation.from,
+                        let: { foreignId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.as}_through.${operation.throughForeignField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.as}_through.${operation.throughForeignField}` },
+                                    `$${operation.as}_through.${operation.throughForeignField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [
+                                            {
+                                                $cond: [
+                                                    { $eq: [{ $type: `$${operation.foreignField}` }, 'string'] },
+                                                    { $toObjectId: `$${operation.foreignField}` },
+                                                    `$${operation.foreignField}`
+                                                ]
+                                            },
+                                            '$$foreignId'
+                                        ]
+                                    }
+                                }
+                            }
+                        ],
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $group: {
+                        _id: '$_id',
+                        root: { $first: '$$ROOT' },
+                        [operation.as]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
+                    }
+                }, {
+                    $replaceRoot: {
+                        newRoot: {
+                            $mergeObjects: ['$root', { [operation.as]: `$${operation.as}` }]
+                        }
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_through`]: 0,
+                        [`${operation.as}_temp`]: 0
+                    }
+                });
+                if (isNestedField) {
+                    const [parentAlias] = operation.localField.split('.');
+                    const parentJoin = processedOperations.find(op => op instanceof Join && op.as === parentAlias);
+                    if (parentJoin) {
+                        pipeline.push({
+                            $set: {
+                                [parentAlias]: {
+                                    $mergeObjects: [
+                                        { $ifNull: [`$${parentAlias}`, {}] },
+                                        { [operation.as]: `$${operation.as}` }
+                                    ]
+                                }
+                            }
+                        });
+                        pipeline.push({
+                            $unset: operation.as
+                        });
+                    }
+                }
+            }
+            else {
+                const isNestedFieldElse = operation.localField.includes('.');
+                if (isNestedFieldElse) {
+                    pipeline.push({
+                        $lookup: {
+                            from: operation.through,
+                            let: { localId: `$${operation.localField}` },
+                            pipeline: [
+                                {
+                                    $match: {
+                                        $expr: {
+                                            $eq: [`$${operation.throughLocalField}`, '$$localId']
+                                        }
+                                    }
+                                }
+                            ],
+                            as: `${operation.as}_through`
+                        }
+                    }, {
+                        $unwind: {
+                            path: `$${operation.as}_through`,
+                            preserveNullAndEmptyArrays: true
+                        }
+                    });
+                }
+                else {
+                    pipeline.push({
+                        $lookup: {
+                            from: operation.through,
+                            localField: operation.localField,
+                            foreignField: operation.throughLocalField,
+                            as: `${operation.as}_through`
+                        }
+                    }, {
+                        $unwind: {
+                            path: `$${operation.as}_through`,
+                            preserveNullAndEmptyArrays: true
+                        }
+                    });
+                }
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        localField: `${operation.as}_through.${operation.throughForeignField}`,
+                        foreignField: operation.foreignField,
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $group: {
+                        _id: '$_id',
+                        root: { $first: '$$ROOT' },
+                        [operation.as]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
+                    }
+                }, {
+                    $replaceRoot: {
+                        newRoot: {
+                            $mergeObjects: ['$root', { [operation.as]: `$${operation.as}` }]
+                        }
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_through`]: 0,
+                        [`${operation.as}_temp`]: 0
+                    }
+                });
+                if (isNestedFieldElse) {
+                    const [parentAlias] = operation.localField.split('.');
+                    const parentJoin = processedOperations.find(op => op instanceof Join && op.as === parentAlias);
+                    if (parentJoin) {
+                        pipeline.push({
+                            $addFields: {
+                                [parentAlias]: {
+                                    $mergeObjects: [
+                                        `$${parentAlias}`,
+                                        { [operation.as]: `$${operation.as}` }
+                                    ]
+                                }
+                            }
+                        });
+                        pipeline.push({
+                            $project: {
+                                [operation.as]: 0
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        processedOperations.push(operation);
     });
     return pipeline;
 }

package/dist/databases/operations/__tests__/models/client-report.model.d.ts

@@ -0,0 +1,23 @@
+import { IPersonModel } from "./person.model.js";
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IClientReportsModel extends IEntity, IAuditable {
+    person: IPersonModel;
+}
+export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
+    person: import("@sinclair/typebox").TObject<{
+        first_name: import("@sinclair/typebox").TString;
+        middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        last_name: import("@sinclair/typebox").TString;
+        phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            phone_number: import("@sinclair/typebox").TString;
+            phone_number_type: import("@sinclair/typebox").TString;
+            is_default: import("@sinclair/typebox").TBoolean;
+        }>>;
+        email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            person_id: import("@sinclair/typebox").TNumber;
+            email_address: import("@sinclair/typebox").TString;
+            is_default: import("@sinclair/typebox").TBoolean;
+        }>>;
+    }>;
+}>;
+export declare const clientReportsModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/client-report.model.js

@@ -0,0 +1,7 @@
+import { personSchema } from "./person.model.js";
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const clientReportsSchema = Type.Object({
+    person: personSchema
+});
+export const clientReportsModelSpec = entityUtils.getModelSpec(clientReportsSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/email-address.model.d.ts

@@ -0,0 +1,12 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IEmailAddressModel extends IEntity, IAuditable {
+    person_id: number;
+    email_address: string;
+    is_default: boolean;
+}
+export declare const emailAddressSchema: import("@sinclair/typebox").TObject<{
+    person_id: import("@sinclair/typebox").TNumber;
+    email_address: import("@sinclair/typebox").TString;
+    is_default: import("@sinclair/typebox").TBoolean;
+}>;
+export declare const emailAddressModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/email-address.model.js

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const emailAddressSchema = Type.Object({
+    person_id: Type.Number(),
+    email_address: Type.String(),
+    is_default: Type.Boolean(),
+});
+export const emailAddressModelSpec = entityUtils.getModelSpec(emailAddressSchema);

package/dist/databases/operations/__tests__/models/person.model.d.ts

@@ -0,0 +1,26 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { IEmailAddressModel } from "./email-address.model.js";
+import { IPhoneNumberModel } from "./phone-number.model.js";
+export interface IPersonModel extends IEntity, IAuditable {
+    first_name: string;
+    middle_name: string | null;
+    last_name: string;
+    email_addresses: IEmailAddressModel[];
+    phone_numbers: IPhoneNumberModel[];
+}
+export declare const personSchema: import("@sinclair/typebox").TObject<{
+    first_name: import("@sinclair/typebox").TString;
+    middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    last_name: import("@sinclair/typebox").TString;
+    phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        phone_number: import("@sinclair/typebox").TString;
+        phone_number_type: import("@sinclair/typebox").TString;
+        is_default: import("@sinclair/typebox").TBoolean;
+    }>>;
+    email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        person_id: import("@sinclair/typebox").TNumber;
+        email_address: import("@sinclair/typebox").TString;
+        is_default: import("@sinclair/typebox").TBoolean;
+    }>>;
+}>;
+export declare const personModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/person.model.js

@@ -0,0 +1,12 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { emailAddressSchema } from "./email-address.model.js";
+import { phoneNumberSchema } from "./phone-number.model.js";
+export const personSchema = Type.Object({
+    first_name: Type.String(),
+    middle_name: Type.Optional(Type.String()),
+    last_name: Type.String(),
+    phone_numbers: Type.Array(phoneNumberSchema),
+    email_addresses: Type.Array(emailAddressSchema),
+});
+export const personModelSpec = entityUtils.getModelSpec(personSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/phone-number.model.d.ts

@@ -0,0 +1,12 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IPhoneNumberModel extends IEntity, IAuditable {
+    phone_number: string;
+    phone_number_type: string;
+    is_default: boolean;
+}
+export declare const phoneNumberSchema: import("@sinclair/typebox").TObject<{
+    phone_number: import("@sinclair/typebox").TString;
+    phone_number_type: import("@sinclair/typebox").TString;
+    is_default: import("@sinclair/typebox").TBoolean;
+}>;
+export declare const phoneNumberModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/phone-number.model.js

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const phoneNumberSchema = Type.Object({
+    phone_number: Type.String(),
+    phone_number_type: Type.String(),
+    is_default: Type.Boolean(),
+});
+export const phoneNumberModelSpec = entityUtils.getModelSpec(phoneNumberSchema, { isAuditable: true });

package/dist/databases/operations/join-many.operation.d.ts

@@ -0,0 +1,7 @@
+export declare class JoinMany {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as: string;
+    constructor(from: string, localField: string, foreignField: string, as: string);
+}

package/dist/databases/operations/join-many.operation.js

@@ -0,0 +1,12 @@
+export class JoinMany {
+    from;
+    localField;
+    foreignField;
+    as;
+    constructor(from, localField, foreignField, as) {
+        this.from = from;
+        this.localField = localField;
+        this.foreignField = foreignField;
+        this.as = as;
+    }
+}

package/dist/databases/operations/join-through.operation.d.ts

@@ -0,0 +1,10 @@
+export declare class JoinThrough {
+    from: string;
+    through: string;
+    localField: string;
+    throughLocalField: string;
+    throughForeignField: string;
+    foreignField: string;
+    as: string;
+    constructor(from: string, through: string, localField: string, throughLocalField: string, throughForeignField: string, foreignField: string, as: string);
+}

package/dist/databases/operations/join-through.operation.js

@@ -0,0 +1,18 @@
+export class JoinThrough {
+    from;
+    through;
+    localField;
+    throughLocalField;
+    throughForeignField;
+    foreignField;
+    as;
+    constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
+        this.from = from;
+        this.through = through;
+        this.localField = localField;
+        this.throughLocalField = throughLocalField;
+        this.throughForeignField = throughForeignField;
+        this.foreignField = foreignField;
+        this.as = as;
+    }
+}

package/dist/databases/operations/operation.d.ts

@@ -1,2 +1,4 @@
 import { Join } from "./join.operation.js";
-export type Operation = Join;
+import { JoinMany } from "./join-many.operation.js";
+import { JoinThrough } from "./join-through.operation.js";
+export type Operation = Join | JoinMany | JoinThrough;

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

@@ -1,6 +1,10 @@
 import { Join } from "../../operations/join.operation.js";
+import { JoinMany } from "../../operations/join-many.operation.js";
+import { JoinThrough } from "../../operations/join-through.operation.js";
 import { BadRequestError } from "../../../errors/index.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
+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) {
@@ -35,16 +39,21 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
         }
         await client.query('COMMIT');
         const joinClauses = buildJoinClauses(operations, pluralResourceName);
-        const hasJoins = operations.some(op => op instanceof Join);
+        const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
         const tablePrefix = hasJoins ? pluralResourceName : undefined;
         queryObject.filters._id = { in: entityIds };
         const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
+        const selectClause = hasJoins
+            ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+            : '*';
         const selectQuery = `
-            SELECT * FROM "${pluralResourceName}" ${joinClauses}
+            SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}
             ${whereClause}
         `;
         const result = await client.query(selectQuery, values);
-        return result.rows;
+        return hasJoins
+            ? transformJoinResults(result.rows, operations)
+            : result.rows;
     }
     catch (err) {
         await client.query('ROLLBACK');

package/dist/databases/postgres/queries/postgres-get-all.query.js

@@ -1,10 +1,12 @@
 import { Join } from "../../operations/join.operation.js";
+import { JoinMany } from "../../operations/join-many.operation.js";
+import { JoinThrough } from "../../operations/join-through.operation.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
 import { transformJoinResults } from '../utils/transform-join-results.js';
 export async function getAll(client, operations, pluralResourceName) {
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
-    const hasJoins = operations.some(op => op instanceof Join);
+    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

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

@@ -1,4 +1,6 @@
 import { Join } from "../../operations/join.operation.js";
+import { JoinMany } from "../../operations/join-many.operation.js";
+import { JoinThrough } from "../../operations/join-through.operation.js";
 import { buildJoinClauses } from "../utils/build-join-clauses.js";
 import { buildSelectClause } from "../utils/build-select-clause.js";
 import { transformJoinResults } from "../utils/transform-join-results.js";
@@ -8,7 +10,7 @@ export async function getById(client, operations, queryObject, id, pluralResourc
     if (!id)
         throw new BadRequestError('id is required');
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
-    const hasJoins = operations.some(op => op instanceof Join);
+    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

package/dist/databases/postgres/queries/postgres-get.query.js

@@ -1,4 +1,6 @@
 import { Join } from "../../operations/join.operation.js";
+import { JoinMany } from "../../operations/join-many.operation.js";
+import { JoinThrough } from "../../operations/join-through.operation.js";
 import { buildWhereClause } from "../utils/build-where-clause.js";
 import { buildOrderByClause } from "../utils/build-order-by-clause.js";
 import { buildJoinClauses } from "../utils/build-join-clauses.js";
@@ -11,7 +13,7 @@ export async function get(client, operations, queryOptions, pluralResourceName)
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const orderByClause = buildOrderByClause(queryOptions);
     const paginationClause = buildPaginationClause(queryOptions);
-    const hasJoins = operations.some(op => op instanceof Join);
+    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

package/dist/databases/postgres/utils/build-join-clauses.js

@@ -1,12 +1,55 @@
 import { Join } from "../../operations/join.operation.js";
+import { JoinMany } from "../../operations/join-many.operation.js";
+import { JoinThrough } from "../../operations/join-through.operation.js";
 export function buildJoinClauses(operations, mainTableName) {
     let joinClauses = '';
     const joinOperations = operations.filter(op => op instanceof Join);
+    const joinManyOperations = operations.filter(op => op instanceof JoinMany);
+    const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
     for (const operation of joinOperations) {
         const localFieldRef = mainTableName
             ? `"${mainTableName}"."${operation.localField}"`
             : `"${operation.localField}"`;
         joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
     }
+    for (const joinMany of joinManyOperations) {
+        let localFieldRef;
+        if (joinMany.localField.includes('.')) {
+            const [tableAlias, columnName] = joinMany.localField.split('.');
+            localFieldRef = `${tableAlias}."${columnName}"`;
+        }
+        else {
+            localFieldRef = mainTableName
+                ? `"${mainTableName}"."${joinMany.localField}"`
+                : `"${joinMany.localField}"`;
+        }
+        joinClauses += ` LEFT JOIN LATERAL (
+            SELECT COALESCE(JSON_AGG(row_to_json("${joinMany.from}")), '[]'::json) AS aggregated
+            FROM "${joinMany.from}"
+            WHERE "${joinMany.from}"."${joinMany.foreignField}" = ${localFieldRef}
+            AND "${joinMany.from}"."_deleted" IS NULL
+        ) AS ${joinMany.as} ON true`;
+    }
+    for (const joinThrough of joinThroughOperations) {
+        let localFieldRef;
+        if (joinThrough.localField.includes('.')) {
+            const [tableAlias, columnName] = joinThrough.localField.split('.');
+            localFieldRef = `${tableAlias}."${columnName}"`;
+        }
+        else {
+            localFieldRef = mainTableName
+                ? `"${mainTableName}"."${joinThrough.localField}"`
+                : `"${joinThrough.localField}"`;
+        }
+        joinClauses += ` LEFT JOIN LATERAL (
+            SELECT COALESCE(JSON_AGG(row_to_json(${joinThrough.as})), '[]'::json) AS aggregated
+            FROM "${joinThrough.through}"
+            INNER JOIN "${joinThrough.from}" AS ${joinThrough.as} 
+                ON ${joinThrough.as}."${joinThrough.foreignField}" = "${joinThrough.through}"."${joinThrough.throughForeignField}"
+            WHERE "${joinThrough.through}"."${joinThrough.throughLocalField}" = ${localFieldRef}
+            AND "${joinThrough.through}"."_deleted" IS NULL
+            AND ${joinThrough.as}."_deleted" IS NULL
+        ) AS ${joinThrough.as} ON true`;
+    }
     return joinClauses;
 }

package/dist/databases/postgres/utils/build-select-clause.js

@@ -1,4 +1,6 @@
 import { Join } from '../../operations/join.operation.js';
+import { JoinMany } from '../../operations/join-many.operation.js';
+import { JoinThrough } from '../../operations/join-through.operation.js';
 async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
@@ -11,6 +13,8 @@ async function getTableColumns(client, tableName) {
 }
 export async function buildSelectClause(client, mainTableName, mainTableAlias, operations) {
     const joinOperations = operations.filter(op => op instanceof Join);
+    const joinManyOperations = operations.filter(op => op instanceof JoinMany);
+    const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
     const mainTableColumns = await getTableColumns(client, mainTableName);
     const mainSelects = mainTableColumns.map(col => `"${mainTableName}"."${col}" AS "${col}"`);
     const joinSelects = [];
@@ -23,6 +27,12 @@ export async function buildSelectClause(client, mainTableName, mainTableAlias, o
             joinSelects.push(`${join.as}."${col}" AS "${join.as}__${col}"`);
         }
     }
+    for (const joinMany of joinManyOperations) {
+        joinSelects.push(`${joinMany.as}.aggregated AS "${joinMany.as}"`);
+    }
+    for (const joinThrough of joinThroughOperations) {
+        joinSelects.push(`${joinThrough.as}.aggregated AS "${joinThrough.as}"`);
+    }
     const allSelects = [...mainSelects, ...joinSelects];
     return allSelects.join(', ');
 }

package/dist/databases/postgres/utils/transform-join-results.js

@@ -1,14 +1,24 @@
 import { Join } from '../../operations/join.operation.js';
+import { JoinMany } from '../../operations/join-many.operation.js';
+import { JoinThrough } from '../../operations/join-through.operation.js';
 export function transformJoinResults(rows, operations) {
     const joinOperations = operations.filter(op => op instanceof Join);
-    if (joinOperations.length === 0) {
+    const joinManyOperations = operations.filter(op => op instanceof JoinMany);
+    const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
+    if (joinOperations.length === 0 && joinManyOperations.length === 0 && joinThroughOperations.length === 0) {
         return rows;
     }
     return rows.map(row => {
         const transformed = {};
+        const allJoinAliases = [
+            ...joinOperations.map(j => j.as),
+            ...joinManyOperations.map(j => j.as),
+            ...joinThroughOperations.map(j => j.as)
+        ];
         for (const key of Object.keys(row)) {
             const hasJoinPrefix = joinOperations.some(join => key.startsWith(`${join.as}__`));
-            if (!hasJoinPrefix) {
+            const isJoinAlias = allJoinAliases.includes(key);
+            if (!hasJoinPrefix && !isJoinAlias) {
                 transformed[key] = row[key];
             }
         }
@@ -28,6 +38,56 @@ export function transformJoinResults(rows, operations) {
             }
             transformed[join.as] = hasAnyData ? joinedData : null;
         }
+        for (const joinMany of joinManyOperations) {
+            const jsonValue = row[joinMany.as];
+            let parsedValue;
+            if (jsonValue !== null && jsonValue !== undefined) {
+                parsedValue = typeof jsonValue === 'string'
+                    ? JSON.parse(jsonValue)
+                    : jsonValue;
+            }
+            else {
+                parsedValue = [];
+            }
+            if (joinMany.localField.includes('.')) {
+                const [tableAlias] = joinMany.localField.split('.');
+                const relatedJoin = joinOperations.find(j => j.as === tableAlias);
+                if (relatedJoin && transformed[relatedJoin.as]) {
+                    transformed[relatedJoin.as][joinMany.as] = parsedValue;
+                }
+                else {
+                    transformed[joinMany.as] = parsedValue;
+                }
+            }
+            else {
+                transformed[joinMany.as] = parsedValue;
+            }
+        }
+        for (const joinThrough of joinThroughOperations) {
+            const jsonValue = row[joinThrough.as];
+            let parsedValue;
+            if (jsonValue !== null && jsonValue !== undefined) {
+                parsedValue = typeof jsonValue === 'string'
+                    ? JSON.parse(jsonValue)
+                    : jsonValue;
+            }
+            else {
+                parsedValue = [];
+            }
+            if (joinThrough.localField.includes('.')) {
+                const [tableAlias] = joinThrough.localField.split('.');
+                const relatedJoin = joinOperations.find(j => j.as === tableAlias);
+                if (relatedJoin && transformed[relatedJoin.as]) {
+                    transformed[relatedJoin.as][joinThrough.as] = parsedValue;
+                }
+                else {
+                    transformed[joinThrough.as] = parsedValue;
+                }
+            }
+            else {
+                transformed[joinThrough.as] = parsedValue;
+            }
+        }
         return transformed;
     });
 }

package/dist/services/generic-query-service/generic-query-service.interface.d.ts

@@ -0,0 +1,14 @@
+import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
+import { Operation } from '../../databases/operations/operation.js';
+export interface IGenericQueryService<T extends IEntity> {
+    prepareQuery(userContext: IUserContext | undefined, queryOptions: IQueryOptions, operations: Operation[]): {
+        queryOptions: IQueryOptions;
+        operations: Operation[];
+    };
+    prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
+    postProcessEntity(userContext: IUserContext, entity: T): T;
+    getAll(userContext: IUserContext): Promise<T[]>;
+    get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
+    getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+}

package/dist/services/generic-query-service/generic-query-service.interface.js

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

package/dist/services/generic-query-service/generic-query.service.d.ts

@@ -0,0 +1,21 @@
+import { IUserContext, IEntity, IQueryOptions, IPagedResult, IModelSpec } from '@loomcore/common/models';
+import type { AppIdType } from '@loomcore/common/types';
+import { IGenericQueryService } from './generic-query-service.interface.js';
+import { Operation } from '../../databases/operations/operation.js';
+import { IDatabase } from '../../databases/models/index.js';
+export declare class GenericQueryService<T extends IEntity> implements IGenericQueryService<T> {
+    protected database: IDatabase;
+    protected rootTableName: string;
+    protected modelSpec: IModelSpec;
+    protected defaultOperations: Operation[];
+    constructor(database: IDatabase, rootTableName: string, modelSpec: IModelSpec, defaultOperations?: Operation[]);
+    prepareQuery(userContext: IUserContext | undefined, queryOptions: IQueryOptions, operations: Operation[]): {
+        queryOptions: IQueryOptions;
+        operations: Operation[];
+    };
+    prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
+    postProcessEntity(userContext: IUserContext, entity: T): T;
+    getAll(userContext: IUserContext): Promise<T[]>;
+    get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
+    getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+}

package/dist/services/generic-query-service/generic-query.service.js

@@ -0,0 +1,47 @@
+import { DefaultQueryOptions } from '@loomcore/common/models';
+import { IdNotFoundError } from '../../errors/index.js';
+export class GenericQueryService {
+    database;
+    rootTableName;
+    modelSpec;
+    defaultOperations;
+    constructor(database, rootTableName, modelSpec, defaultOperations = []) {
+        this.database = database;
+        this.rootTableName = rootTableName;
+        this.modelSpec = modelSpec;
+        this.defaultOperations = defaultOperations;
+    }
+    prepareQuery(userContext, queryOptions, operations) {
+        const mergedOperations = [...this.defaultOperations, ...operations];
+        return { queryOptions, operations: mergedOperations };
+    }
+    prepareQueryOptions(userContext, queryOptions) {
+        return queryOptions;
+    }
+    postProcessEntity(userContext, entity) {
+        return this.database.postProcessEntity(entity, this.modelSpec.fullSchema);
+    }
+    async getAll(userContext) {
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const entities = await this.database.getAll(operations, this.rootTableName);
+        return entities.map(entity => this.postProcessEntity(userContext, entity));
+    }
+    async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
+        const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const pagedResult = await this.database.get(operations, preparedOptions, this.modelSpec, this.rootTableName);
+        const transformedEntities = (pagedResult.entities || []).map(entity => this.postProcessEntity(userContext, entity));
+        return {
+            ...pagedResult,
+            entities: transformedEntities
+        };
+    }
+    async getById(userContext, id) {
+        const { operations, queryOptions } = this.prepareQuery(userContext, {}, []);
+        const entity = await this.database.getById(operations, queryOptions, id, this.rootTableName);
+        if (!entity) {
+            throw new IdNotFoundError();
+        }
+        return this.postProcessEntity(userContext, entity);
+    }
+}

package/dist/services/index.d.ts

@@ -2,6 +2,8 @@ export * from './auth.service.js';
 export * from './email.service.js';
 export * from './generic-api-service/generic-api.service.js';
 export * from './generic-api-service/generic-api-service.interface.js';
+export * from './generic-query-service/generic-query.service.js';
+export * from './generic-query-service/generic-query-service.interface.js';
 export * from './jwt.service.js';
 export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';

package/dist/services/index.js

@@ -2,6 +2,8 @@ export * from './auth.service.js';
 export * from './email.service.js';
 export * from './generic-api-service/generic-api.service.js';
 export * from './generic-api-service/generic-api-service.interface.js';
+export * from './generic-query-service/generic-query.service.js';
+export * from './generic-query-service/generic-query-service.interface.js';
 export * from './jwt.service.js';
 export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -19,6 +19,7 @@
     "typecheck": "tsc",
     "test": "npm-run-all -s test:postgres test:mongodb",
     "test:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run",
+    "test:postgres:real": "cross-env NODE_ENV=test TEST_DATABASE=postgres USE_REAL_POSTGRES=true vitest run",
     "test:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run",
     "test:ci": "npm-run-all -s test:ci:postgres test:ci:mongodb",
     "test:ci:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --reporter=json --outputFile=test-results-postgres.json",
@@ -26,7 +27,10 @@
     "test:watch": "cross-env NODE_ENV=test vitest",
     "coverage": "npm-run-all -s coverage:postgres coverage:mongodb",
     "coverage:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --coverage",
-    "coverage:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --coverage"
+    "coverage:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --coverage",
+    "test:db:start": "docker-compose -f docker-compose.test.yml up -d",
+    "test:db:stop": "docker-compose -f docker-compose.test.yml down",
+    "test:db:logs": "docker-compose -f docker-compose.test.yml logs -f"
   },
   "author": "Tim Hardy",
   "license": "Apache 2.0",
@@ -78,7 +82,7 @@
     "cross-env": "^7.0.3",
     "mongodb-memory-server": "^9.3.0",
     "npm-run-all": "^4.1.5",
-    "pg-mem": "^3.0.5",
+    "pg-mem": "^3.0.8",
     "rxjs": "^7.8.0",
     "supertest": "^7.1.0",
     "typescript": "^5.8.3",