@loomcore/api 0.2.4 → 0.2.6

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -1,169 +1,205 @@
-import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
-import { MongoDBDatabase } from '../mongo-db.database.js';
-import { OrganizationService } from '../../../services/index.js';
-import { passwordUtils } from '../../../utils/index.js';
+import { EmptyUserContext, getSystemUserContext, initializeSystemUserContext, isSystemUserContextInitialized, } from "@loomcore/common/models";
+import { OrganizationService } from "../../../services/index.js";
+import { passwordUtils } from "../../../utils/index.js";
+import { MongoDBDatabase } from "../mongo-db.database.js";
 export const getMongoInitialSchema = (dbConfig) => {
     const migrations = [];
     const isMultiTenant = dbConfig.app.isMultiTenant;
     if (isMultiTenant && !dbConfig.multiTenant) {
-        throw new Error('Multi-tenant configuration is enabled but multi-tenant configuration is not provided');
+        throw new Error("Multi-tenant configuration is enabled but multi-tenant configuration is not provided");
     }
     const isAuthEnabled = dbConfig.app.isAuthEnabled;
     if (isMultiTenant)
         migrations.push({
-            name: '00000000000001_schema-organizations',
+            name: "00000000000001_schema-organizations",
             up: async ({ context: db }) => {
-                await db.createCollection('organizations');
-                await db.collection('organizations').createIndex({ name: 1 }, { unique: true });
-                await db.collection('organizations').createIndex({ code: 1 }, { unique: true });
-                await db.collection('organizations').createIndex({ isMetaOrg: 1 });
+                await db.createCollection("organizations");
+                await db
+                    .collection("organizations")
+                    .createIndex({ name: 1 }, { unique: true });
+                await db
+                    .collection("organizations")
+                    .createIndex({ code: 1 }, { unique: true });
+                await db.collection("organizations").createIndex({ isMetaOrg: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection('organizations').drop();
-            }
+                await db.collection("organizations").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000002_schema-persons',
+            name: "00000000000002_schema-persons",
             up: async ({ context: db }) => {
-                await db.createCollection('persons');
+                await db.createCollection("persons");
                 if (isMultiTenant) {
-                    await db.collection('persons').createIndex({ _orgId: 1 });
-                    await db.collection('persons').createIndex({ _orgId: 1, externalId: 1 }, { unique: true, sparse: true });
+                    await db.collection("persons").createIndex({ _orgId: 1 });
+                    await db
+                        .collection("persons")
+                        .createIndex({ _orgId: 1, externalId: 1 }, { unique: true, sparse: true });
                 }
                 else {
-                    await db.collection('persons').createIndex({ externalId: 1 }, { unique: true, sparse: true });
+                    await db
+                        .collection("persons")
+                        .createIndex({ externalId: 1 }, { unique: true, sparse: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('persons').drop();
-            }
+                await db.collection("persons").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000003_schema-users',
+            name: "00000000000003_schema-users",
             up: async ({ context: db }) => {
-                await db.createCollection('users');
+                await db.createCollection("users");
                 if (dbConfig.app.isMultiTenant) {
-                    await db.collection('users').createIndex({ _orgId: 1, email: 1 }, { unique: true });
-                    await db.collection('users').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("users")
+                        .createIndex({ _orgId: 1, email: 1 }, { unique: true });
+                    await db.collection("users").createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('users').createIndex({ email: 1 }, { unique: true });
+                    await db
+                        .collection("users")
+                        .createIndex({ email: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('users').drop();
-            }
+                await db.collection("users").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000004_schema-refresh-tokens',
+            name: "00000000000004_schema-refresh-tokens",
             up: async ({ context: db }) => {
-                await db.createCollection('refresh_tokens');
-                await db.collection('refresh_tokens').createIndex({ token: 1 }, { unique: true });
-                await db.collection('refresh_tokens').createIndex({ userId: 1 });
-                await db.collection('refresh_tokens').createIndex({ deviceId: 1 });
+                await db.createCollection("refresh_tokens");
+                await db
+                    .collection("refresh_tokens")
+                    .createIndex({ token: 1 }, { unique: true });
+                await db.collection("refresh_tokens").createIndex({ userId: 1 });
+                await db.collection("refresh_tokens").createIndex({ deviceId: 1 });
                 if (isMultiTenant) {
-                    await db.collection('refresh_tokens').createIndex({ _orgId: 1 });
+                    await db.collection("refresh_tokens").createIndex({ _orgId: 1 });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('refresh_tokens').drop();
-            }
+                await db.collection("refresh_tokens").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000005_schema-password-reset-tokens',
+            name: "00000000000005_schema-password-reset-tokens",
             up: async ({ context: db }) => {
-                await db.createCollection('password_reset_tokens');
+                await db.createCollection("password_reset_tokens");
                 if (isMultiTenant) {
-                    await db.collection('password_reset_tokens').createIndex({ _orgId: 1, email: 1 }, { unique: true });
-                    await db.collection('password_reset_tokens').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("password_reset_tokens")
+                        .createIndex({ _orgId: 1, email: 1 }, { unique: true });
+                    await db
+                        .collection("password_reset_tokens")
+                        .createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('password_reset_tokens').createIndex({ email: 1 }, { unique: true });
+                    await db
+                        .collection("password_reset_tokens")
+                        .createIndex({ email: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('password_reset_tokens').drop();
-            }
+                await db.collection("password_reset_tokens").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000006_schema-roles',
+            name: "00000000000006_schema-roles",
             up: async ({ context: db }) => {
-                await db.createCollection('roles');
+                await db.createCollection("roles");
                 if (isMultiTenant) {
-                    await db.collection('roles').createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                    await db.collection('roles').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("roles")
+                        .createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                    await db.collection("roles").createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('roles').createIndex({ name: 1 }, { unique: true });
+                    await db
+                        .collection("roles")
+                        .createIndex({ name: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('roles').drop();
-            }
+                await db.collection("roles").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000007_schema-user-roles',
+            name: "00000000000007_schema-user-roles",
             up: async ({ context: db }) => {
-                await db.createCollection('user_roles');
+                await db.createCollection("user_roles");
                 if (isMultiTenant) {
-                    await db.collection('user_roles').createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
-                    await db.collection('user_roles').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("user_roles")
+                        .createIndex({ _orgId: 1, userId: 1, roleId: 1 }, { unique: true });
+                    await db.collection("user_roles").createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('user_roles').createIndex({ userId: 1, roleId: 1 }, { unique: true });
+                    await db
+                        .collection("user_roles")
+                        .createIndex({ userId: 1, roleId: 1 }, { unique: true });
                 }
-                await db.collection('user_roles').createIndex({ userId: 1 });
-                await db.collection('user_roles').createIndex({ roleId: 1 });
+                await db.collection("user_roles").createIndex({ userId: 1 });
+                await db.collection("user_roles").createIndex({ roleId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection('user_roles').drop();
-            }
+                await db.collection("user_roles").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000008_schema-features',
+            name: "00000000000008_schema-features",
             up: async ({ context: db }) => {
-                await db.createCollection('features');
+                await db.createCollection("features");
                 if (isMultiTenant) {
-                    await db.collection('features').createIndex({ _orgId: 1, name: 1 }, { unique: true });
-                    await db.collection('features').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("features")
+                        .createIndex({ _orgId: 1, name: 1 }, { unique: true });
+                    await db.collection("features").createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('features').createIndex({ name: 1 }, { unique: true });
+                    await db
+                        .collection("features")
+                        .createIndex({ name: 1 }, { unique: true });
                 }
             },
             down: async ({ context: db }) => {
-                await db.collection('features').drop();
-            }
+                await db.collection("features").drop();
+            },
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000009_schema-authorizations',
+            name: "00000000000009_schema-authorizations",
             up: async ({ context: db }) => {
-                await db.createCollection('authorizations');
+                await db.createCollection("authorizations");
                 if (isMultiTenant) {
-                    await db.collection('authorizations').createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
-                    await db.collection('authorizations').createIndex({ _orgId: 1 });
+                    await db
+                        .collection("authorizations")
+                        .createIndex({ _orgId: 1, roleId: 1, featureId: 1 }, { unique: true });
+                    await db.collection("authorizations").createIndex({ _orgId: 1 });
                 }
                 else {
-                    await db.collection('authorizations').createIndex({ roleId: 1, featureId: 1 }, { unique: true });
+                    await db
+                        .collection("authorizations")
+                        .createIndex({ roleId: 1, featureId: 1 }, { unique: true });
                 }
-                await db.collection('authorizations').createIndex({ roleId: 1 });
-                await db.collection('authorizations').createIndex({ featureId: 1 });
+                await db.collection("authorizations").createIndex({ roleId: 1 });
+                await db.collection("authorizations").createIndex({ featureId: 1 });
             },
             down: async ({ context: db }) => {
-                await db.collection('authorizations').drop();
-            }
+                await db.collection("authorizations").drop();
+            },
         });
     if (isMultiTenant) {
         migrations.push({
-            name: '00000000000010_data-meta-org',
+            name: "00000000000010_data-meta-org",
             up: async ({ context: db }) => {
                 const metaOrgDoc = {
                     name: dbConfig.multiTenant.metaOrgName,
@@ -173,106 +209,117 @@ export const getMongoInitialSchema = (dbConfig) => {
                     isMetaOrg: true,
                     authToken: undefined,
                     _created: new Date(),
-                    _createdBy: 'system',
+                    _createdBy: "system",
                     _updated: new Date(),
-                    _updatedBy: 'system',
+                    _updatedBy: "system",
                     _deleted: undefined,
-                    _deletedBy: undefined
+                    _deletedBy: undefined,
                 };
-                const result = await db.collection('organizations').insertOne(metaOrgDoc);
-                const metaOrg = { ...metaOrgDoc, _id: result.insertedId };
-                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || 'system@example.com', metaOrg);
+                const result = await db
+                    .collection("organizations")
+                    .insertOne(metaOrgDoc);
+                const metaOrg = {
+                    ...metaOrgDoc,
+                    _id: result.insertedId,
+                };
+                initializeSystemUserContext(dbConfig.email?.systemEmailAddress || "system@example.com", metaOrg);
             },
             down: async ({ context: db }) => {
-                await db.collection('organizations').deleteMany({ isMetaOrg: true });
-            }
+                await db.collection("organizations").deleteMany({ isMetaOrg: true });
+            },
         });
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000011_data-admin-user',
+            name: "00000000000011_data-admin-user",
             up: async ({ context: db }) => {
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
-                        ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. ' +
-                            'Please ensure metaOrgName and metaOrgCode are provided in your dbConfig.'
-                        : 'BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.';
-                    console.error('❌ Migration Error:', errorMessage);
+                        ? "SystemUserContext has not been initialized. The meta-org migration (00000000000010_data-meta-org) should have run before this migration. " +
+                            "Please ensure metaOrgName and metaOrgCode are provided in your dbConfig."
+                        : "BUG: SystemUserContext has not been initialized. For non-multi-tenant setups, SystemUserContext should be initialized before migrations run.";
+                    console.error("❌ Migration Error:", errorMessage);
                     throw new Error(errorMessage);
                 }
                 const systemUserContext = getSystemUserContext();
-                const orgDoc = isMultiTenant && systemUserContext.organization?._id ? { _orgId: systemUserContext.organization._id } : {};
+                const orgDoc = isMultiTenant && systemUserContext.organization?._id
+                    ? { _orgId: systemUserContext.organization._id }
+                    : {};
                 const hashedPassword = await passwordUtils.hashPassword(dbConfig.adminUser.password);
                 const email = dbConfig.adminUser.email.toLowerCase();
-                const personResult = await db.collection('persons').insertOne({
+                const personResult = await db.collection("persons").insertOne({
                     ...orgDoc,
-                    externalId: 'admin-user-person-external-id',
-                    firstName: 'Admin',
-                    lastName: 'User',
+                    externalId: "admin-user-person-external-id",
+                    firstName: "Admin",
+                    lastName: "User",
                     isAgent: false,
                     isClient: false,
                     isEmployee: false,
                     _created: new Date(),
-                    _createdBy: 'system',
+                    _createdBy: "system",
                     _updated: new Date(),
-                    _updatedBy: 'system'
+                    _updatedBy: "system",
                 });
-                await db.collection('users').insertOne({
+                await db.collection("users").insertOne({
                     ...orgDoc,
-                    externalId: 'admin-user-external-id',
+                    externalId: "admin-user-external-id",
                     email,
                     password: hashedPassword,
-                    displayName: 'Admin User',
+                    displayName: "Admin User",
                     personId: personResult.insertedId,
                     _created: new Date(),
-                    _createdBy: 'system',
+                    _createdBy: "system",
                     _updated: new Date(),
-                    _updatedBy: 'system'
+                    _updatedBy: "system",
                 });
             },
             down: async ({ context: db }) => {
                 if (!dbConfig?.adminUser?.email)
                     return;
-                await db.collection('users').deleteOne({ email: dbConfig.adminUser.email.toLowerCase() });
-            }
+                await db
+                    .collection("users")
+                    .deleteOne({ email: dbConfig.adminUser.email.toLowerCase() });
+            },
         });
     }
     if (isAuthEnabled && dbConfig.adminUser) {
         migrations.push({
-            name: '00000000000012_data-admin-authorizations',
+            name: "00000000000012_data-admin-authorizations",
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
+                const metaOrg = isMultiTenant
+                    ? await organizationService.getMetaOrg(EmptyUserContext)
+                    : undefined;
                 if (isMultiTenant && !metaOrg) {
-                    throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');
+                    throw new Error("Meta organization not found. Ensure meta-org migration ran successfully.");
                 }
                 const email = dbConfig.adminUser.email.toLowerCase();
-                const adminUser = await db.collection('users').findOne({ email });
+                const adminUser = await db.collection("users").findOne({ email });
                 if (!adminUser) {
-                    throw new Error('Admin user not found. Ensure admin-user migration ran successfully.');
+                    throw new Error("Admin user not found. Ensure admin-user migration ran successfully.");
                 }
                 const orgDoc = isMultiTenant && metaOrg ? { _orgId: metaOrg._id } : {};
-                const roleResult = await db.collection('roles').insertOne({
+                const roleResult = await db.collection("roles").insertOne({
                     ...orgDoc,
-                    name: 'admin'
+                    name: "admin",
                 });
-                await db.collection('user_roles').insertOne({
+                await db.collection("user_roles").insertOne({
                     ...orgDoc,
                     userId: adminUser._id,
                     roleId: roleResult.insertedId,
                     _created: new Date(),
-                    _createdBy: 'system',
+                    _createdBy: "system",
                     _updated: new Date(),
-                    _updatedBy: 'system',
+                    _updatedBy: "system",
                     _deleted: undefined,
-                    _deletedBy: undefined
+                    _deletedBy: undefined,
                 });
-                const featureResult = await db.collection('features').insertOne({
+                const featureResult = await db.collection("features").insertOne({
                     ...orgDoc,
-                    name: 'admin'
+                    name: "admin",
                 });
-                await db.collection('authorizations').insertOne({
+                await db.collection("authorizations").insertOne({
                     ...orgDoc,
                     roleId: roleResult.insertedId,
                     featureId: featureResult.insertedId,
@@ -280,38 +327,48 @@ export const getMongoInitialSchema = (dbConfig) => {
                     endDate: undefined,
                     config: undefined,
                     _created: new Date(),
-                    _createdBy: 'system',
+                    _createdBy: "system",
                     _updated: new Date(),
-                    _updatedBy: 'system',
+                    _updatedBy: "system",
                     _deleted: undefined,
-                    _deletedBy: undefined
+                    _deletedBy: undefined,
                 });
             },
             down: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
+                const metaOrg = isMultiTenant
+                    ? await organizationService.getMetaOrg(EmptyUserContext)
+                    : undefined;
                 if (isMultiTenant && !metaOrg)
                     return;
                 const orgFilter = isMultiTenant && metaOrg ? { _orgId: metaOrg._id } : {};
-                const adminRole = await db.collection('roles').findOne({ ...orgFilter, name: 'admin' });
-                const adminFeature = await db.collection('features').findOne({ ...orgFilter, name: 'admin' });
+                const adminRole = await db
+                    .collection("roles")
+                    .findOne({ ...orgFilter, name: "admin" });
+                const adminFeature = await db
+                    .collection("features")
+                    .findOne({ ...orgFilter, name: "admin" });
                 if (adminRole && adminFeature) {
-                    await db.collection('authorizations').deleteMany({
+                    await db.collection("authorizations").deleteMany({
                         ...orgFilter,
                         roleId: adminRole._id,
-                        featureId: adminFeature._id
+                        featureId: adminFeature._id,
                     });
                 }
-                await db.collection('features').deleteMany({ ...orgFilter, name: 'admin' });
+                await db
+                    .collection("features")
+                    .deleteMany({ ...orgFilter, name: "admin" });
                 if (adminRole) {
-                    await db.collection('user_roles').deleteMany({
+                    await db.collection("user_roles").deleteMany({
                         ...orgFilter,
-                        roleId: adminRole._id
+                        roleId: adminRole._id,
                     });
                 }
-                await db.collection('roles').deleteMany({ ...orgFilter, name: 'admin' });
-            }
+                await db
+                    .collection("roles")
+                    .deleteMany({ ...orgFilter, name: "admin" });
+            },
         });
     }
     return migrations;

package/dist/services/auth.service.d.ts

@@ -1,17 +1,16 @@
-import { Request, Response } from 'express';
-import { IUserContext, ITokenResponse, ILoginResponse, IUser, IPersonModel } from '@loomcore/common/models';
-import type { AppIdType } from '@loomcore/common/types';
-import { MultiTenantApiService } from './multi-tenant-api.service.js';
-import { UpdateResult } from '../databases/models/update-result.js';
-import { IRefreshToken } from '../models/refresh-token.model.js';
-import { IDatabase } from '../databases/models/index.js';
+import { type ILoginResponse, type ITokenResponse, type IUser, type IUserContext } from "@loomcore/common/models";
+import type { AppIdType } from "@loomcore/common/types";
+import type { Request, Response } from "express";
+import type { IDatabase } from "../databases/models/index.js";
+import type { UpdateResult } from "../databases/models/update-result.js";
+import { type IRefreshToken } from "../models/refresh-token.model.js";
+import { MultiTenantApiService } from "./multi-tenant-api.service.js";
 export declare class AuthService extends MultiTenantApiService<IUser> {
     private refreshTokenService;
     private passwordResetTokenService;
     private emailService;
     private organizationService;
     private authConfig;
-    private personService;
     constructor(database: IDatabase);
     attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
     logUserIn(userContext: IUserContext, deviceId: string): Promise<{
@@ -23,7 +22,7 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
         userContext: IUserContext;
     } | null>;
     getUserByEmail(email: string): Promise<IUser | null>;
-    createUser(userContext: IUserContext, user: Partial<IUser>, person?: Partial<IPersonModel>): Promise<IUser | null>;
+    createUser(userContext: IUserContext, user: Partial<IUser>): Promise<IUser | null>;
     requestTokenUsingRefreshToken(refreshToken: string, deviceId: string): Promise<ITokenResponse | null>;
     changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult>;
     changePassword(userContext: IUserContext, queryObject: any, password: string): Promise<UpdateResult>;