@loomcore/api 0.1.13 → 0.1.15

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

@@ -6,7 +6,7 @@ export declare class TestMongoDatabase implements ITestDatabase {
     private mongoDb;
     private database;
     private initPromise;
-    init(databaseName: string): Promise<IDatabase>;
+    init(): Promise<IDatabase>;
     getRandomId(): string;
     private _performInit;
     private createIndexes;

package/dist/__tests__/mongo-db.test-database.js

@@ -9,17 +9,17 @@ export class TestMongoDatabase {
     mongoDb = null;
     database = null;
     initPromise = null;
-    async init(databaseName) {
+    async init() {
         if (this.initPromise) {
             return this.initPromise;
         }
-        this.initPromise = this._performInit(databaseName);
+        this.initPromise = this._performInit();
         return this.initPromise;
     }
     getRandomId() {
         return new ObjectId().toString();
     }
-    async _performInit(databaseName) {
+    async _performInit() {
         if (!this.database) {
             this.mongoServer = await MongoMemoryServer.create({
                 instance: {

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

@@ -4,7 +4,7 @@ export declare class TestPostgresDatabase implements ITestDatabase {
     private database;
     private postgresClient;
     private initPromise;
-    init(databaseName: string): Promise<IDatabase>;
+    init(adminUsername?: string, adminPassword?: string): Promise<IDatabase>;
     getRandomId(): string;
     private _performInit;
     private createIndexes;

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

@@ -11,17 +11,17 @@ export class TestPostgresDatabase {
     database = null;
     postgresClient = null;
     initPromise = null;
-    async init(databaseName) {
+    async init(adminUsername, adminPassword) {
         if (this.initPromise) {
             return this.initPromise;
         }
-        this.initPromise = this._performInit(databaseName);
+        this.initPromise = this._performInit(adminUsername, adminPassword);
         return this.initPromise;
     }
     getRandomId() {
         return randomUUID();
     }
-    async _performInit(databaseName) {
+    async _performInit(adminUsername, adminPassword) {
         if (!this.database) {
             const { Client } = newDb().adapters.createPg();
             const postgresClient = new Client();
@@ -33,7 +33,7 @@ export class TestPostgresDatabase {
             if (!success) {
                 throw new Error('Failed to setup for multitenant');
             }
-            success = (await setupDatabaseForAuth(postgresClient, testOrg._id)).success;
+            success = (await setupDatabaseForAuth(postgresClient, adminUsername || 'admin', adminPassword || 'password', testOrg._id)).success;
             if (!success) {
                 throw new Error('Failed to setup for auth');
             }

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

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

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

@@ -61,12 +61,12 @@ export class TestExpressApp {
             if (useMongoDb) {
                 const testMongoDb = new TestMongoDatabase();
                 this.testDatabase = testMongoDb;
-                this.database = await testMongoDb.init(this.databaseName);
+                this.database = await testMongoDb.init();
             }
             else {
                 const testPostgresDb = new TestPostgresDatabase();
                 this.testDatabase = testPostgresDb;
-                this.database = await testPostgresDb.init(this.databaseName);
+                this.database = await testPostgresDb.init('admin', 'password');
             }
         }
         if (!this.app) {

package/dist/databases/postgres/migrations/001-create-migrations-table.migration.js

@@ -19,10 +19,7 @@ export class CreateMigrationTableMigration {
             `);
         }
         catch (error) {
-            if (error.code === '42P07' || error.data?.error?.includes('already exists')) {
-                console.log(`Migrations table already exists`);
-            }
-            else {
+            if (error.code !== '42P07' && !error.data?.error?.includes('already exists')) {
                 return { success: false, error: new Error(`Error creating migrations table: ${error.message}`) };
             }
         }

package/dist/databases/postgres/migrations/006-create-admin-user.migration.d.ts

@@ -0,0 +1,20 @@
+import { Client } from "pg";
+import { IMigration } from "../index.js";
+export declare class CreateAdminUserMigration implements IMigration {
+    private readonly client;
+    private readonly adminEmail;
+    private readonly adminPassword;
+    constructor(client: Client, adminEmail: string, adminPassword: string);
+    index: number;
+    execute(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(_orgId?: string): Promise<{
+        success: boolean;
+        error: Error | null;
+    }>;
+}

package/dist/databases/postgres/migrations/006-create-admin-user.migration.js

@@ -0,0 +1,53 @@
+import { PostgresDatabase } from "../index.js";
+import { randomUUID } from "crypto";
+import { UserService } from "../../../services/user.service.js";
+import { getSystemUserContext, initializeSystemUserContext } from "@loomcore/common/models";
+export class CreateAdminUserMigration {
+    client;
+    adminEmail;
+    adminPassword;
+    constructor(client, adminEmail, adminPassword) {
+        this.client = client;
+        this.adminEmail = adminEmail;
+        this.adminPassword = adminPassword;
+    }
+    index = 6;
+    async execute(_orgId) {
+        const _id = randomUUID().toString();
+        try {
+            const database = new PostgresDatabase(this.client);
+            const userService = new UserService(database);
+            initializeSystemUserContext(this.adminEmail, _orgId);
+            const systemUserContext = getSystemUserContext();
+            const adminUser = await userService.create(systemUserContext, {
+                _id: _id,
+                _orgId: _orgId,
+                email: this.adminEmail,
+                password: this.adminPassword,
+                firstName: 'Admin',
+                lastName: 'User',
+                displayName: 'Admin User',
+                roles: ['admin'],
+            });
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error creating admin user: ${error.message}`) };
+        }
+        try {
+            const result = await this.client.query(`
+                INSERT INTO "migrations" ("_id", "_orgId", "index", "hasRun", "reverted")
+                VALUES ('${_id}', '${_orgId}', ${this.index}, TRUE, FALSE);
+            `);
+            if (result.rowCount === 0) {
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+        }
+        catch (error) {
+            return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
+        }
+        return { success: true, error: null };
+    }
+    async revert(_orgId) {
+        throw new Error('Not implemented');
+    }
+}

package/dist/databases/postgres/migrations/setup-for-auth.migration.d.ts

@@ -1,5 +1,5 @@
 import { Client } from "pg";
-export declare function setupDatabaseForAuth(client: Client, _orgId?: string): Promise<{
+export declare function setupDatabaseForAuth(client: Client, adminUsername: string, adminPassword: string, _orgId?: string): Promise<{
     success: boolean;
     error: Error | null;
 }>;

package/dist/databases/postgres/migrations/setup-for-auth.migration.js

@@ -2,7 +2,8 @@ import { CreateRefreshTokenTableMigration } from "./004-create-refresh-tokens-ta
 import { CreateMigrationTableMigration } from "./001-create-migrations-table.migration.js";
 import { CreateUsersTableMigration } from "./003-create-users-table.migration.js";
 import { doesTableExist } from "../utils/does-table-exist.util.js";
-export async function setupDatabaseForAuth(client, _orgId) {
+import { CreateAdminUserMigration } from "./006-create-admin-user.migration.js";
+export async function setupDatabaseForAuth(client, adminUsername, adminPassword, _orgId) {
     let runMigrations = [];
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
@@ -21,6 +22,8 @@ export async function setupDatabaseForAuth(client, _orgId) {
         migrationsToRun.push(new CreateUsersTableMigration(client));
     if (!runMigrations.includes(4))
         migrationsToRun.push(new CreateRefreshTokenTableMigration(client));
+    if (!runMigrations.includes(6))
+        migrationsToRun.push(new CreateAdminUserMigration(client, adminUsername, adminPassword));
     for (const migration of migrationsToRun) {
         await migration.execute(_orgId);
     }

package/package.json

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