@loomcore/api 0.0.59 → 0.1.0

package/dist/__tests__/postgres-test-migrations/001-create-test-entities-table.migration.js

@@ -0,0 +1,59 @@
+import { randomUUID } from "crypto";
+export class CreateTestEntitiesTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 1;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "testEntities" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "name" VARCHAR(255) NOT NULL,
+                    "description" TEXT,
+                    "isActive" BOOLEAN,
+                    "tags" TEXT[],
+                    "count" INTEGER,
+                    "_created" TIMESTAMP NOT NULL,
+                    "_createdBy" VARCHAR(255) NOT NULL,
+                    "_updated" TIMESTAMP NOT NULL,
+                    "_updatedBy" VARCHAR(255) NOT NULL,
+                    "_deleted" TIMESTAMP,
+                    "_deletedBy" VARCHAR(255)
+                )
+            `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating test entities table:', error);
+            return false;
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE test_entities;
+            `);
+        }
+        catch (error) {
+            console.error('Error reverting test entities table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/__tests__/postgres-test-migrations/002-create-categories-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { IMigration } from "../../databases/postgres/migrations/index.js";
+import { Client } from "pg";
+export declare class CreateCategoriesTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/__tests__/postgres-test-migrations/002-create-categories-table.migration.js

@@ -0,0 +1,52 @@
+import { randomUUID } from "crypto";
+export class CreateCategoriesTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 2;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "categories" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "name" VARCHAR(255) NOT NULL
+                )
+            `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating categories table:', error);
+            return false;
+        }
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "categories";
+            `);
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+        }
+        catch (error) {
+            console.error('Error reverting categories table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/__tests__/postgres-test-migrations/003-create-products-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "../../databases/postgres/migrations/index.js";
+export declare class CreateProductsTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/__tests__/postgres-test-migrations/003-create-products-table.migration.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "crypto";
+export class CreateProductsTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 3;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "products" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "name" VARCHAR(255) NOT NULL,
+                    "description" TEXT,
+                    "internalNumber" VARCHAR(255),
+                    "categoryId" VARCHAR(255) NOT NULL REFERENCES "categories"("_id"),
+                    "_created" TIMESTAMP NOT NULL,
+                    "_createdBy" VARCHAR(255) NOT NULL,
+                    "_updated" TIMESTAMP NOT NULL,
+                    "_updatedBy" VARCHAR(255) NOT NULL,
+                    "_deleted" TIMESTAMP,
+                    "_deletedBy" VARCHAR(255)
+                )
+            `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating products table:', error);
+            return false;
+        }
+        return true;
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "products";
+            `);
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+        }
+        catch (error) {
+            console.error('Error reverting products table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "../../databases/postgres/migrations/index.js";
+export declare class CreateTestUsersTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/__tests__/postgres-test-migrations/004-create-test-users-table.migration.js

@@ -0,0 +1,66 @@
+import { randomUUID } from "crypto";
+export class CreateTestUsersTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 4;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "testUsers" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "email" VARCHAR(255) NOT NULL,
+                    "password" VARCHAR(255) NOT NULL,
+                    "firstName" VARCHAR(255),
+                    "lastName" VARCHAR(255),
+                    "displayName" VARCHAR(255),
+                    "roles" TEXT[],
+                    "_lastLoggedIn" TIMESTAMP,
+                    "_lastPasswordChange" TIMESTAMP,
+                    "_created" TIMESTAMP NOT NULL,
+                    "_createdBy" VARCHAR(255) NOT NULL,
+                    "_updated" TIMESTAMP NOT NULL,
+                    "_updatedBy" VARCHAR(255) NOT NULL,
+                    "_deleted" TIMESTAMP,
+                    "_deletedBy" VARCHAR(255)
+                )
+            `);
+            if (this.orgId) {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "_orgId", "index", "hasRun", "reverted") values ('${this._id}', '${this.orgId}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            else {
+                await this.client.query(`
+                    Insert into "migrations" ("_id", "index", "hasRun", "reverted") values ('${this._id}', ${this.index}, TRUE, FALSE);
+                `);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating test users table:', error);
+            return false;
+        }
+        return true;
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "testUsers";
+            `);
+        }
+        catch (error) {
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+            console.error('Error reverting test users table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/__tests__/postgres-test-migrations/005-create-test-items-table.migration.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "pg";
+import { IMigration } from "../../databases/postgres/migrations/index.js";
+export declare class CreateTestItemsTableMigration implements IMigration {
+    private readonly client;
+    private readonly orgId?;
+    constructor(client: Client, orgId?: string | undefined);
+    index: number;
+    _id: string;
+    execute(): Promise<boolean>;
+    revert(): Promise<boolean>;
+}

package/dist/__tests__/postgres-test-migrations/005-create-test-items-table.migration.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "crypto";
+export class CreateTestItemsTableMigration {
+    client;
+    orgId;
+    constructor(client, orgId) {
+        this.client = client;
+        this.orgId = orgId;
+    }
+    index = 5;
+    _id = randomUUID().toString();
+    async execute() {
+        try {
+            await this.client.query(`
+                CREATE TABLE "testItems" (
+                    "_id" VARCHAR(255) PRIMARY KEY,
+                    "_orgId" VARCHAR(255),
+                    "name" VARCHAR(255) NOT NULL,
+                    "value" INTEGER,
+                    "eventDate" TIMESTAMP,
+                    "_created" TIMESTAMP NOT NULL,
+                    "_createdBy" VARCHAR(255) NOT NULL,
+                    "_updated" TIMESTAMP NOT NULL,
+                    "_updatedBy" VARCHAR(255) NOT NULL,
+                    "_deleted" TIMESTAMP,
+                    "_deletedBy" VARCHAR(255)
+                )
+            `);
+        }
+        catch (error) {
+            console.error('Error creating test items table:', error);
+            return false;
+        }
+        return true;
+    }
+    async revert() {
+        try {
+            await this.client.query(`
+                DROP TABLE "testItems";
+            `);
+        }
+        catch (error) {
+            await this.client.query(`
+                Update "migrations" SET "reverted" = TRUE WHERE "_id" = '${this._id}';
+            `);
+            console.error('Error reverting test items table:', error);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/__tests__/postgres-test-migrations/run-test-migrations.d.ts

@@ -0,0 +1,2 @@
+import { Client } from "pg";
+export declare function runTestMigrations(client: Client, orgId?: string): Promise<boolean>;

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

@@ -0,0 +1,22 @@
+import { CreateTestEntitiesTableMigration } from "./001-create-test-entities-table.migration.js";
+import { CreateCategoriesTableMigration } from "./002-create-categories-table.migration.js";
+import { CreateProductsTableMigration } from "./003-create-products-table.migration.js";
+import { CreateTestUsersTableMigration } from "./004-create-test-users-table.migration.js";
+import { CreateTestItemsTableMigration } from "./005-create-test-items-table.migration.js";
+export async function runTestMigrations(client, orgId) {
+    const migrations = [
+        new CreateTestEntitiesTableMigration(client, orgId),
+        new CreateCategoriesTableMigration(client, orgId),
+        new CreateProductsTableMigration(client, orgId),
+        new CreateTestUsersTableMigration(client, orgId),
+        new CreateTestItemsTableMigration(client, orgId),
+    ];
+    let success = true;
+    for (const migration of migrations) {
+        success = await migration.execute();
+        if (!success) {
+            return false;
+        }
+    }
+    return success;
+}

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

@@ -0,0 +1,13 @@
+import { ITestDatabase } from './test-database.interface.js';
+import { IDatabase } from '../databases/models/index.js';
+export declare class TestPostgresDatabase implements ITestDatabase {
+    private database;
+    private postgresClient;
+    private initPromise;
+    init(databaseName: string): Promise<IDatabase>;
+    getRandomId(): string;
+    private _performInit;
+    private createIndexes;
+    clearCollections(): Promise<void>;
+    cleanup(): Promise<void>;
+}

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

@@ -0,0 +1,85 @@
+import { randomUUID } from 'crypto';
+import testUtils from './common-test.utils.js';
+import { initSystemUserContext } from '../config/base-api-config.js';
+import { newDb } from "pg-mem";
+import { setupDatabaseForMultitenant } from '../databases/postgres/migrations/setup-for-multitenant.migration.js';
+import { setupDatabaseForAuth } from '../databases/postgres/migrations/setup-for-auth.migration.js';
+import { runTestMigrations } from './postgres-test-migrations/run-test-migrations.js';
+import { PostgresDatabase } from '../databases/postgres/postgres.database.js';
+import { testOrg } from './test-objects.js';
+export class TestPostgresDatabase {
+    database = null;
+    postgresClient = null;
+    initPromise = null;
+    async init(databaseName) {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performInit(databaseName);
+        return this.initPromise;
+    }
+    getRandomId() {
+        return randomUUID();
+    }
+    async _performInit(databaseName) {
+        if (!this.database) {
+            const { Client } = newDb().adapters.createPg();
+            const postgresClient = new Client();
+            await postgresClient.connect();
+            const testDatabase = new PostgresDatabase(postgresClient);
+            this.database = testDatabase;
+            this.postgresClient = postgresClient;
+            let success = await setupDatabaseForMultitenant(postgresClient, testOrg._id);
+            if (!success) {
+                throw new Error('Failed to setup for multitenant');
+            }
+            success = await setupDatabaseForAuth(postgresClient, testOrg._id);
+            if (!success) {
+                throw new Error('Failed to setup for auth');
+            }
+            success = await runTestMigrations(postgresClient, testOrg._id);
+            if (!success) {
+                throw new Error('Failed to run test migrations');
+            }
+            testUtils.initialize(testDatabase);
+            await this.createIndexes(postgresClient);
+            await testUtils.createMetaOrg();
+        }
+        await initSystemUserContext(this.database);
+        return this.database;
+    }
+    async createIndexes(client) {
+        try {
+            await client.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));
+      `);
+        }
+        catch (error) {
+            console.log('Note: Indexes may be created later when tables are initialized:', error.message);
+        }
+    }
+    async clearCollections() {
+        if (!this.postgresClient) {
+            throw new Error('Database not initialized');
+        }
+        const result = await this.postgresClient.query(`
+      SELECT "table_name" 
+      FROM information_schema.tables 
+      WHERE "table_schema" = 'public'
+      AND "table_type" = 'BASE TABLE'
+    `);
+        result.rows.forEach(async (row) => {
+            await this.postgresClient?.query(`TRUNCATE TABLE "${row.table_name}" RESTART IDENTITY CASCADE`);
+        });
+    }
+    async cleanup() {
+        await testUtils.cleanup();
+        if (!this.postgresClient) {
+            throw new Error('Database not initialized');
+        }
+        await this.postgresClient.end();
+        this.initPromise = null;
+        this.database = null;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { IDatabase } from "../databases/models/index.js";
+export type ITestDatabase = {
+    init(databaseName: string): Promise<IDatabase>;
+    getRandomId(): string;
+    clearCollections(): Promise<void>;
+    cleanup(): Promise<void>;
+};

package/dist/__tests__/test-express-app.d.ts

@@ -1,18 +1,20 @@
 import { Application } from 'express';
-import { Db } from 'mongodb';
+import { ITestDatabase } from './test-database.interface.js';
+import { IDatabase } from '../databases/models/database.interface.js';
 export declare class TestExpressApp {
     private static app;
-    private static mongoServer;
-    private static client;
-    private static db;
+    private static database;
+    private static testDatabase;
     private static initPromise;
-    static init(): Promise<{
+    private static databaseName;
+    static init(useMongoDb?: boolean): Promise<{
         app: Application;
-        db: Db;
+        database: IDatabase;
+        testDatabase: ITestDatabase;
         agent: any;
     }>;
     private static _performInit;
     static setupErrorHandling(): Promise<void>;
-    static cleanup(): Promise<void>;
     static clearCollections(): Promise<void>;
+    static cleanup(): Promise<void>;
 }

package/dist/__tests__/test-express-app.js

@@ -2,34 +2,38 @@ import express from 'express';
 import bodyParser from 'body-parser';
 import cookieParser from 'cookie-parser';
 import supertest from 'supertest';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import { MongoClient } from 'mongodb';
 import { initializeTypeBox } from '@loomcore/common/validation';
-import testUtils from './common-test.utils.js';
-import { setBaseApiConfig, initSystemUserContext } from '../config/base-api-config.js';
+import { setBaseApiConfig } from '../config/base-api-config.js';
 import { errorHandler } from '../middleware/error-handler.js';
 import { ensureUserContext } from '../middleware/ensure-user-context.js';
+import { TestMongoDatabase } from './mongo-db.test-database.js';
+import { TestPostgresDatabase } from './postgres.test-database.js';
 export class TestExpressApp {
     static app;
-    static mongoServer;
-    static client;
-    static db;
+    static database;
+    static testDatabase;
     static initPromise = null;
-    static async init() {
+    static databaseName = 'test-db';
+    static async init(useMongoDb) {
+        if (useMongoDb === undefined) {
+            const testDb = process.env.TEST_DATABASE;
+            useMongoDb = testDb === 'mongodb';
+        }
         if (this.initPromise) {
             return this.initPromise;
         }
-        this.initPromise = this._performInit();
+        this.initPromise = this._performInit(useMongoDb);
         return this.initPromise;
     }
-    static async _performInit() {
+    static async _performInit(useMongoDb) {
         setBaseApiConfig({
             env: 'test',
             hostName: 'localhost',
             appName: 'test-app',
             clientSecret: 'test-secret',
-            mongoDbUrl: '',
-            databaseName: '',
+            database: {
+                name: this.databaseName,
+            },
             externalPort: 4000,
             internalPort: 8083,
             corsAllowedOrigins: ['*'],
@@ -53,24 +57,18 @@ export class TestExpressApp {
             }
         });
         initializeTypeBox();
-        if (!this.db) {
-            this.mongoServer = await MongoMemoryServer.create({
-                instance: {
-                    ip: '127.0.0.1',
-                    port: 0,
-                },
-                binary: {
-                    downloadDir: process.env.HOME ? `${process.env.HOME}/.cache/mongodb-binaries` : undefined,
-                }
-            });
-            const uri = this.mongoServer.getUri();
-            this.client = await MongoClient.connect(uri);
-            this.db = this.client.db();
-            testUtils.initialize(this.db);
-            await testUtils.createIndexes(this.db);
-            await testUtils.createMetaOrg();
+        if (!this.database) {
+            if (useMongoDb) {
+                const testMongoDb = new TestMongoDatabase();
+                this.testDatabase = testMongoDb;
+                this.database = await testMongoDb.init(this.databaseName);
+            }
+            else {
+                const testPostgresDb = new TestPostgresDatabase();
+                this.testDatabase = testPostgresDb;
+                this.database = await testPostgresDb.init(this.databaseName);
+            }
         }
-        await initSystemUserContext(this.db);
         if (!this.app) {
             this.app = express();
             this.app.use(bodyParser.json());
@@ -83,34 +81,26 @@ export class TestExpressApp {
         const agent = supertest.agent(this.app);
         return {
             app: this.app,
-            db: this.db,
+            database: this.database,
+            testDatabase: this.testDatabase,
             agent
         };
     }
     static async setupErrorHandling() {
         this.app.use(errorHandler);
     }
-    static async cleanup() {
-        await testUtils.cleanup();
-        if (this.client) {
-            await this.client.close();
+    static async clearCollections() {
+        if (this.testDatabase) {
+            await this.testDatabase.clearCollections();
         }
-        if (this.mongoServer) {
-            await this.mongoServer.stop();
+    }
+    static async cleanup() {
+        if (this.testDatabase) {
+            await this.testDatabase.cleanup();
         }
         this.initPromise = null;
         this.app = undefined;
-        this.db = undefined;
-        this.client = undefined;
-        this.mongoServer = undefined;
-    }
-    static async clearCollections() {
-        if (!this.db) {
-            throw new Error('Database not initialized');
-        }
-        const collections = await this.db.collections();
-        for (const collection of collections) {
-            await collection.deleteMany({});
-        }
+        this.database = undefined;
+        this.testDatabase = undefined;
     }
 }

package/dist/__tests__/test-mongo-db.d.ts

@@ -0,0 +1,14 @@
+import { Db } from 'mongodb';
+export declare class TestMongoDb {
+    private static mongoServer;
+    private static client;
+    private static db;
+    private static initPromise;
+    static init(): Promise<Db>;
+    static getRandomId(): string;
+    private static _performInit;
+    private static createIndexes;
+    static getDb(): Db;
+    static clearCollections(): Promise<void>;
+    static cleanup(): Promise<void>;
+}