@loomcore/api 0.1.35 → 0.1.37

package/dist/__tests__/common-test.utils.d.ts

@@ -1,5 +1,5 @@
 import { Application } from 'express';
-import { IUser, IUserContext, IQueryOptions } from '@loomcore/common/models';
+import { IUserContext, IQueryOptions, IUser } from '@loomcore/common/models';
 import { ApiController } from '../controllers/api.controller.js';
 import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
 import { Operation } from '../databases/operations/operation.js';

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

@@ -9,11 +9,12 @@ import { OrganizationService } from '../services/organization.service.js';
 import { AuthService, GenericApiService } from '../services/index.js';
 import { ObjectId } from 'mongodb';
 import * as testObjectsModule from './test-objects.js';
-const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUser, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId } = testObjectsModule;
+const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId } = testObjectsModule;
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
 import { setBaseApiConfig } from '../config/index.js';
 import { entityUtils } from '@loomcore/common/utils';
+import { getTestOrgUser } from './test-objects.js';
 let deviceIdCookie;
 let authService;
 let organizationService;
@@ -123,7 +124,7 @@ async function simulateloginWithTestUser() {
             return res;
         }
     };
-    const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, getTestMetaOrgUser().password);
+    const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD);
     if (!loginResponse?.tokens?.accessToken) {
         throw new Error('Failed to login with test user');
     }
@@ -131,11 +132,13 @@ async function simulateloginWithTestUser() {
 }
 function getAuthToken() {
     const metaOrgUser = getTestMetaOrgUser();
+    const metaOrg = getTestMetaOrg();
     const payload = {
         user: {
             _id: metaOrgUser._id,
             email: metaOrgUser.email
         },
+        organization: metaOrg,
         _orgId: metaOrgUser._orgId
     };
     const token = JwtService.sign(payload, JWT_SECRET, { expiresIn: 3600 });

package/dist/__tests__/test-objects.d.ts

@@ -1,10 +1,12 @@
-import { IOrganization, IUser, IUserContext } from "@loomcore/common/models";
+import { IOrganization, IUserContext, IUser } from "@loomcore/common/models";
 export declare let TEST_META_ORG_ID: string;
 export declare function setTestMetaOrgId(metaOrgId: string): void;
+export declare const TEST_META_ORG_USER_PASSWORD = "test-meta-org-user-password";
 export declare function getTestMetaOrg(): IOrganization;
 export declare function getTestMetaOrgUser(): IUser;
 export declare function getTestMetaOrgUserContext(): IUserContext;
 export declare function setTestOrgId(orgId: string): void;
 export declare function getTestOrg(): IOrganization;
+export declare const TEST_ORG_USER_PASSWORD = "test-org-user-password";
 export declare function getTestOrgUser(): IUser;
 export declare function getTestOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -2,6 +2,7 @@ export let TEST_META_ORG_ID = '69261691f936c45f85da24d0';
 export function setTestMetaOrgId(metaOrgId) {
     TEST_META_ORG_ID = metaOrgId;
 }
+export const TEST_META_ORG_USER_PASSWORD = 'test-meta-org-user-password';
 export function getTestMetaOrg() {
     return {
         _id: TEST_META_ORG_ID,
@@ -21,33 +22,27 @@ export function getTestMetaOrgUser() {
         _id: '69261672f48fb7bf76e54dfb',
         _orgId: getTestMetaOrg()._id,
         email: 'test@example.com',
-        password: 'testpassword',
         firstName: 'Test',
         lastName: 'User',
         displayName: 'Test User',
-        authorizations: [{
-                _id: '6939c54e57a1c6576a40c590',
-                _orgId: getTestMetaOrg()._id,
-                role: 'metaorgUser',
-                feature: 'metaorgUser',
-                config: {},
-                _created: new Date(),
-                _createdBy: 'system',
-                _updated: new Date(),
-                _updatedBy: 'system',
-            }],
+        password: TEST_META_ORG_USER_PASSWORD,
         _created: new Date(),
         _createdBy: 'system',
-        _lastLoggedIn: new Date(),
         _updated: new Date(),
         _updatedBy: 'system',
     };
 }
-;
 export function getTestMetaOrgUserContext() {
     return {
         user: getTestMetaOrgUser(),
-        _orgId: getTestMetaOrg()._id,
+        organization: getTestMetaOrg(),
+        authorizations: [{
+                _id: '6939c54e57a1c6576a40c590',
+                _orgId: getTestMetaOrg()._id,
+                role: 'metaorgUser',
+                feature: 'metaorgUser',
+                config: {},
+            }],
     };
 }
 ;
@@ -69,38 +64,33 @@ export function getTestOrg() {
     };
 }
 ;
+export const TEST_ORG_USER_PASSWORD = 'test-org-user-password';
 export function getTestOrgUser() {
     return {
         _id: '6926167d06c0073a778a1250',
         _orgId: getTestOrg()._id,
         email: 'test-org-user@example.com',
-        password: 'testpassword',
         firstName: 'Test',
         lastName: 'User',
         displayName: 'Test User',
-        authorizations: [{
-                _id: '6939c54e57a1c6576a40c591',
-                _orgId: getTestOrg()._id,
-                role: 'testOrgUser',
-                feature: 'testOrgUser',
-                config: {},
-                _created: new Date(),
-                _createdBy: 'system',
-                _updated: new Date(),
-                _updatedBy: 'system',
-            }],
+        password: TEST_ORG_USER_PASSWORD,
         _created: new Date(),
         _createdBy: 'system',
-        _lastLoggedIn: new Date(),
         _updated: new Date(),
         _updatedBy: 'system',
     };
 }
-;
 export function getTestOrgUserContext() {
     return {
         user: getTestOrgUser(),
-        _orgId: getTestOrg()._id,
+        organization: getTestOrg(),
+        authorizations: [{
+                _id: '6939c54e57a1c6576a40c591',
+                _orgId: getTestOrg()._id,
+                role: 'testOrgUser',
+                feature: 'testOrgUser',
+                config: {},
+            }],
     };
 }
 ;

package/dist/config/base-api-config.js

@@ -24,17 +24,16 @@ export async function initSystemUserContext(database) {
     }
     if (!isSystemUserContextSet) {
         const systemEmail = config.email?.systemEmailAddress || 'system@example.com';
-        let metaOrgId = undefined;
+        let metaOrg = undefined;
         if (config.app.isMultiTenant) {
             const { OrganizationService } = await import('../services/organization.service.js');
             const organizationService = new OrganizationService(database);
-            const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+            metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
             if (!metaOrg) {
                 throw new Error('Meta organization not found. Please create an organization with isMetaOrg=true before starting the API.');
             }
-            metaOrgId = metaOrg._id;
         }
-        initializeSystemUserContext(systemEmail, metaOrgId);
+        initializeSystemUserContext(systemEmail, metaOrg);
         isSystemUserContextSet = true;
     }
     else if (config.env !== 'test') {

package/dist/controllers/authorizations.controller.d.ts

@@ -1,4 +1,4 @@
-import { IAuthorization } from "@loomcore/common/models";
+import { IAuthorization } from "../models/authorization.model.js";
 import { ApiController } from "./api.controller.js";
 import { Application } from "express";
 import { IDatabase } from "../databases/models/index.js";

package/dist/controllers/authorizations.controller.js

@@ -1,4 +1,4 @@
-import { AuthorizationModelSpec } from "@loomcore/common/models";
+import { AuthorizationModelSpec } from "../models/authorization.model.js";
 import { ApiController } from "./api.controller.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
 export class AuthorizationsController extends ApiController {

package/dist/databases/mongo-db/commands/mongo-batch-update.command.js

@@ -1,6 +1,8 @@
 import { ObjectId } from "mongodb";
 import { BadRequestError } from "../../../errors/index.js";
 import { convertOperationsToPipeline } from "../utils/index.js";
+import { buildNoSqlMatch } from "../utils/build-no-sql-match.util.js";
+import NoSqlPipeline from "../models/no-sql-pipeline.js";
 export async function batchUpdate(db, entities, operations, queryObject, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
     if (!entities || entities.length === 0) {
@@ -8,15 +10,18 @@ export async function batchUpdate(db, entities, operations, queryObject, pluralR
     }
     const bulkOperations = [];
     const entityIds = [];
+    const queryObjectMatch = buildNoSqlMatch(queryObject);
+    const baseFilter = queryObjectMatch.$match || {};
     for (const entity of entities) {
         const { _id, ...updateData } = entity;
         if (!_id || !(_id instanceof ObjectId)) {
             throw new BadRequestError('Each entity in a batch update must have a valid _id that has been converted to an ObjectId.');
         }
         entityIds.push(_id);
+        const updateFilter = { ...baseFilter, _id };
         bulkOperations.push({
             updateOne: {
-                filter: { _id },
+                filter: updateFilter,
                 update: { $set: updateData },
             },
         });
@@ -24,18 +29,26 @@ export async function batchUpdate(db, entities, operations, queryObject, pluralR
     if (bulkOperations.length > 0) {
         await collection.bulkWrite(bulkOperations);
     }
-    const baseQuery = { _id: { $in: entityIds } };
+    const retrievalQueryObject = {
+        ...queryObject,
+        filters: {
+            ...(queryObject.filters || {}),
+            _id: { in: entityIds.map(id => id.toString()) }
+        }
+    };
     const operationsDocuments = convertOperationsToPipeline(operations);
     let updatedEntities;
     if (operationsDocuments.length > 0) {
-        const pipeline = [
-            { $match: baseQuery },
-            ...operationsDocuments
-        ];
+        const pipeline = new NoSqlPipeline()
+            .addMatch(retrievalQueryObject)
+            .addOperations(operations)
+            .build();
         updatedEntities = await collection.aggregate(pipeline).toArray();
     }
     else {
-        updatedEntities = await collection.find(baseQuery).toArray();
+        const retrievalMatch = buildNoSqlMatch(retrievalQueryObject);
+        const retrievalFilter = retrievalMatch.$match || {};
+        updatedEntities = await collection.find(retrievalFilter).toArray();
     }
     return updatedEntities;
 }

package/dist/databases/postgres/migrations/005-create-meta-org.migration.js

@@ -14,13 +14,13 @@ export class CreateMetaOrgMigration {
             const orgResult = await this.client.query(`
                 INSERT INTO "organizations" ("_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
                 VALUES ('${_id}', '${config.app.metaOrgName}', '${config.app.metaOrgCode}', 1, true, NOW(), 'system', NOW(), 'system')
-                RETURNING "_id";
+                RETURNING "_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy";
             `);
             if (orgResult.rowCount === 0) {
                 await this.client.query('ROLLBACK');
                 return { success: false, error: new Error(`Error creating meta org: No row returned`) };
             }
-            initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', orgResult.rows[0]._id);
+            initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', orgResult.rows[0]);
             const migrationResult = await this.client.query(`
                 INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
                 VALUES ('${_id}', ${this.index}, TRUE, FALSE);

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

@@ -15,11 +15,10 @@ export class CreateAdminUserMigration {
     async execute() {
         const _id = randomUUID().toString();
         const systemUserContext = getSystemUserContext();
-        let createdUser;
         try {
-            createdUser = await this.authService.createUser(systemUserContext, {
+            await this.authService.createUser(systemUserContext, {
                 _id: _id,
-                _orgId: systemUserContext._orgId,
+                _orgId: systemUserContext.organization?._id,
                 email: config.adminUser?.email,
                 password: config.adminUser?.password,
                 firstName: 'Admin',

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

@@ -1,4 +1,4 @@
-import { IQueryOptions, IModelSpec, IPagedResult, IEntity } from "@loomcore/common/models";
+import { IQueryOptions, IModelSpec, IPagedResult, IEntity, IUserContextAuthorization } from "@loomcore/common/models";
 import { TSchema } from "@sinclair/typebox";
 import { DeleteResult, IDatabase } from "../models/index.js";
 import { Operation } from "../operations/operation.js";
@@ -28,5 +28,5 @@ export declare class PostgresDatabase implements IDatabase {
     deleteMany(queryObject: IQueryOptions, pluralResourceName: string): Promise<DeleteResult>;
     find<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T[]>;
     findOne<T extends IEntity>(queryObject: IQueryOptions, pluralResourceName: string): Promise<T | null>;
-    getUserAuthorizations(userIds: string[], orgId?: string): Promise<Map<string, any[]>>;
+    getUserAuthorizations(userId: string, orgId?: string): Promise<IUserContextAuthorization[]>;
 }

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

@@ -66,12 +66,8 @@ export class PostgresDatabase {
     async findOne(queryObject, pluralResourceName) {
         return findOneQuery(this.client, queryObject, pluralResourceName);
     }
-    async getUserAuthorizations(userIds, orgId) {
-        if (userIds.length === 0) {
-            return new Map();
-        }
+    async getUserAuthorizations(userId, orgId) {
         const now = new Date();
-        const placeholders = userIds.map((_, i) => `$${i + 1}`).join(', ');
         let query = `
             SELECT DISTINCT
                 ur."userId" as "userId",
@@ -79,50 +75,34 @@ export class PostgresDatabase {
                 f."name" as "feature",
                 a."config",
                 a."_id",
-                a."_orgId",
-                a."_created",
-                a."_createdBy",
-                a."_updated",
-                a."_updatedBy"
+                a."_orgId"
             FROM "user_roles" ur
             INNER JOIN "roles" r ON ur."roleId" = r."_id"
             INNER JOIN "authorizations" a ON r."_id" = a."roleId"
             INNER JOIN "features" f ON a."featureId" = f."_id"
-            WHERE ur."userId" IN (${placeholders})
+            WHERE ur."userId" = $1
                 AND ur."_deleted" IS NULL
                 AND a."_deleted" IS NULL
-                AND (a."startDate" IS NULL OR a."startDate" <= $${userIds.length + 1})
-                AND (a."endDate" IS NULL OR a."endDate" >= $${userIds.length + 1})
+                AND (a."startDate" IS NULL OR a."startDate" <= $2)
+                AND (a."endDate" IS NULL OR a."endDate" >= $2)
         `;
-        const values = [...userIds, now];
+        const values = [userId, now];
         if (orgId) {
-            query += ` AND ur."_orgId" = $${userIds.length + 2} AND r."_orgId" = $${userIds.length + 2} AND a."_orgId" = $${userIds.length + 2} AND f."_orgId" = $${userIds.length + 2}`;
+            query += ` AND ur."_orgId" = $3 AND r."_orgId" = $3 AND a."_orgId" = $3 AND f."_orgId" = $3`;
             values.push(orgId);
         }
         const result = await this.client.query(query, values);
-        const authorizationsMap = new Map();
+        const authorizations = [];
         for (const row of result.rows) {
             const userId = row.userId;
-            if (!authorizationsMap.has(userId)) {
-                authorizationsMap.set(userId, []);
-            }
-            authorizationsMap.get(userId).push({
+            authorizations.push({
                 _id: row._id,
                 _orgId: row._orgId,
                 role: row.role,
                 feature: row.feature,
                 config: row.config || undefined,
-                _created: row._created,
-                _createdBy: row._createdBy,
-                _updated: row._updated,
-                _updatedBy: row._updatedBy,
             });
         }
-        for (const userId of userIds) {
-            if (!authorizationsMap.has(userId)) {
-                authorizationsMap.set(userId, []);
-            }
-        }
-        return authorizationsMap;
+        return authorizations;
     }
 }

package/dist/models/authorization.model.d.ts

@@ -0,0 +1,16 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IAuthorization extends IEntity, IAuditable {
+    roleId: string;
+    featureId: string;
+    startDate?: Date;
+    endDate?: Date;
+    config?: any;
+}
+export declare const AuthorizationSchema: import("@sinclair/typebox").TObject<{
+    roleId: import("@sinclair/typebox").TString;
+    featureId: import("@sinclair/typebox").TString;
+    startDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>>;
+    endDate: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TString, Date>>;
+    config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+export declare const AuthorizationModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/models/authorization.model.js

@@ -0,0 +1,11 @@
+import { Type } from "@sinclair/typebox";
+import { entityUtils } from "@loomcore/common/utils";
+import { TypeboxIsoDate } from "@loomcore/common/validation";
+export const AuthorizationSchema = Type.Object({
+    roleId: Type.String({ minLength: 1, title: 'Role ID' }),
+    featureId: Type.String({ minLength: 1, title: 'Feature ID' }),
+    startDate: Type.Optional(TypeboxIsoDate({ title: 'Start Date' })),
+    endDate: Type.Optional(TypeboxIsoDate({ title: 'End Date' })),
+    config: Type.Optional(Type.Any({ title: 'Config' }))
+});
+export const AuthorizationModelSpec = entityUtils.getModelSpec(AuthorizationSchema, { isAuditable: true });

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

@@ -1,5 +1,5 @@
 import { Request, Response } from 'express';
-import { IUserContext, IUser, ITokenResponse, ILoginResponse } from '@loomcore/common/models';
+import { IUserContext, ITokenResponse, ILoginResponse, IUser } from '@loomcore/common/models';
 import { MultiTenantApiService } from './multi-tenant-api.service.js';
 import { UpdateResult } from '../databases/models/update-result.js';
 import { IRefreshToken } from '../models/refresh-token.model.js';

package/dist/services/auth.service.js

@@ -11,6 +11,7 @@ import { OrganizationService } from './organization.service.js';
 import { passwordUtils } from '../utils/index.js';
 import { config } from '../config/index.js';
 import { refreshTokenModelSpec } from '../models/refresh-token.model.js';
+import { getUserContextAuthorizations } from './utils/getUserContextAuthorizations.util.js';
 export class AuthService extends MultiTenantApiService {
     refreshTokenService;
     passwordResetTokenService;
@@ -26,6 +27,7 @@ export class AuthService extends MultiTenantApiService {
     async attemptLogin(req, res, email, password) {
         const lowerCaseEmail = email.toLowerCase();
         const user = await this.getUserByEmail(lowerCaseEmail);
+        const organization = await this.organizationService.findOne(EmptyUserContext, { filters: { _id: { eq: user?._orgId } } });
         if (!user) {
             throw new BadRequestError('Invalid Credentials');
         }
@@ -33,9 +35,11 @@ export class AuthService extends MultiTenantApiService {
         if (!passwordsMatch) {
             throw new BadRequestError('Invalid Credentials');
         }
+        const authorizations = await getUserContextAuthorizations(this.database, user);
         const userContext = {
             user: user,
-            _orgId: user._orgId
+            organization: organization ?? undefined,
+            authorizations: authorizations
         };
         const deviceId = this.getAndSetDeviceIdCookie(req, res);
         const loginResponse = await this.logUserIn(userContext, deviceId);
@@ -44,7 +48,7 @@ export class AuthService extends MultiTenantApiService {
     async logUserIn(userContext, deviceId) {
         const payload = userContext;
         const accessToken = this.generateJwt(payload);
-        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id, deviceId, userContext._orgId);
+        const refreshTokenObject = await this.createNewRefreshToken(userContext.user._id, deviceId, userContext.organization?._id);
         const accessTokenExpiresOn = this.getExpiresOnFromSeconds(config.auth.jwtExpirationInSeconds);
         let loginResponse = null;
         if (refreshTokenObject) {
@@ -66,27 +70,28 @@ export class AuthService extends MultiTenantApiService {
         if (!rawUser) {
             return null;
         }
-        const userContext = {
-            _orgId: rawUser._orgId,
-            user: rawUser
-        };
-        return this.postprocessEntity(userContext, rawUser);
+        const dbPostprocessed = this.database.postprocessEntity(rawUser, this.modelSpec.fullSchema);
+        return dbPostprocessed;
     }
     async createUser(userContext, user) {
+        if (userContext.user?._id === 'system') {
+            if (user._orgId) {
+                const org = await this.organizationService.findOne(userContext, { filters: { _id: { eq: user._orgId } } });
+                if (!org) {
+                    throw new BadRequestError('The specified organization does not exist');
+                }
+            }
+            if (config.app.isMultiTenant && userContext.organization?._id !== user._orgId) {
+                throw new BadRequestError('User is not authorized to create a user in this organization');
+            }
+        }
         if (user.email) {
             const existingUser = await this.getUserByEmail(user.email);
             if (existingUser) {
                 throw new BadRequestError('A user with this email address already exists');
             }
         }
-        if (user._orgId && userContext._orgId && userContext._orgId !== user._orgId && userContext.user?._id !== 'system') {
-            const org = await this.organizationService.findOne(userContext, { filters: { _id: { eq: user._orgId } } });
-            if (!org) {
-                throw new BadRequestError('The specified organization does not exist');
-            }
-        }
-        const createdUser = await this.create(userContext, user);
-        return createdUser;
+        return await this.create(userContext, user);
     }
     async requestTokenUsingRefreshToken(refreshToken, deviceId) {
         let tokens = null;
@@ -94,9 +99,12 @@ export class AuthService extends MultiTenantApiService {
         if (activeRefreshToken) {
             const systemUserContext = getSystemUserContext();
             const user = await this.getById(systemUserContext, activeRefreshToken.userId);
+            const organization = await this.organizationService.findOne(EmptyUserContext, { filters: { _id: { eq: user?._orgId } } });
+            const authorizations = await getUserContextAuthorizations(this.database, user);
             const userContext = {
-                _orgId: user._orgId,
-                user: user
+                user: user,
+                organization: organization ?? undefined,
+                authorizations: authorizations
             };
             tokens = await this.createNewTokens(userContext, activeRefreshToken);
         }

package/dist/services/index.d.ts

@@ -7,4 +7,4 @@ export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';
 export * from './password-reset-token.service.js';
 export * from './tenant-query-decorator.js';
-export * from './user-service/user.service.js';
+export * from './user.service.js';

package/dist/services/index.js

@@ -7,4 +7,4 @@ export * from './multi-tenant-api.service.js';
 export * from './organization.service.js';
 export * from './password-reset-token.service.js';
 export * from './tenant-query-decorator.js';
-export * from './user-service/user.service.js';
+export * from './user.service.js';

package/dist/services/multi-tenant-api.service.js

@@ -14,7 +14,7 @@ export class MultiTenantApiService extends GenericApiService {
         if (!config?.app?.isMultiTenant || userContext?.user?._id === 'system') {
             return super.prepareQuery(userContext, queryOptions, operations);
         }
-        if (!userContext || !userContext._orgId) {
+        if (!userContext || !userContext.organization?._id) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareQuery');
         }
         const queryObject = this.tenantDecorator.applyTenantToQuery(userContext, queryOptions, this.pluralResourceName);
@@ -24,12 +24,12 @@ export class MultiTenantApiService extends GenericApiService {
         if (!config?.app?.isMultiTenant) {
             return super.preprocessEntity(userContext, entity, isCreate, allowId);
         }
-        if (!userContext || !userContext._orgId) {
+        if (!userContext || !userContext.organization?._id) {
             throw new BadRequestError('A valid userContext was not provided to MultiTenantApiService.prepareEntity');
         }
         const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate, allowId);
         if (isCreate && userContext.user._id !== 'system') {
-            preparedEntity._orgId = userContext._orgId;
+            preparedEntity._orgId = userContext.organization?._id;
         }
         return preparedEntity;
     }

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

@@ -1,6 +1,6 @@
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
 import { IOrganization, IUserContext } from '@loomcore/common/models';
 import { IDatabase } from '../databases/models/database.interface.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 export declare class OrganizationService extends GenericApiService<IOrganization> {
     constructor(database: IDatabase);
     preprocessEntity(userContext: IUserContext, entity: Partial<IOrganization>, isCreate: boolean, allowId?: boolean): Promise<Partial<IOrganization>>;

package/dist/services/organization.service.js

@@ -1,6 +1,6 @@
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
 import { OrganizationSpec } from '@loomcore/common/models';
 import { BadRequestError } from '../errors/index.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 export class OrganizationService extends GenericApiService {
     constructor(database) {
         super(database, 'organizations', 'organization', OrganizationSpec);
@@ -11,7 +11,7 @@ export class OrganizationService extends GenericApiService {
             if (metaOrg && entity.isMetaOrg) {
                 throw new BadRequestError('Meta organization already exists');
             }
-            if (metaOrg && userContext._orgId !== metaOrg._id) {
+            if (metaOrg && userContext.organization?._id !== metaOrg._id) {
                 throw new BadRequestError('User is not authorized to create an organization');
             }
         }

package/dist/services/password-reset-token.service.d.ts

@@ -1,6 +1,6 @@
 import { IPasswordResetToken } from '@loomcore/common/models';
-import { GenericApiService } from './generic-api-service/generic-api.service.js';
 import { IDatabase } from '../databases/models/index.js';
+import { GenericApiService } from './generic-api-service/generic-api.service.js';
 export declare class PasswordResetTokenService extends GenericApiService<IPasswordResetToken> {
     constructor(database: IDatabase);
     createPasswordResetToken(email: string, expiresOn: number): Promise<IPasswordResetToken | null>;

package/dist/services/tenant-query-decorator.js

@@ -11,12 +11,12 @@ export class TenantQueryDecorator {
     applyTenantToQuery(userContext, queryObject, collectionName) {
         let result = queryObject;
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
-            userContext?._orgId;
+            userContext?.organization?._id;
         if (shouldApplyTenantFilter) {
             const orgIdField = this.options.orgIdField || '_orgId';
-            result = { ...queryObject, filters: { ...queryObject.filters, [orgIdField]: { eq: userContext._orgId } } };
+            result = { ...queryObject, filters: { ...queryObject.filters, [orgIdField]: { eq: userContext.organization?._id } } };
         }
-        else if (!userContext?._orgId) {
+        else if (!userContext?.organization?._id) {
             if (!this.options.excludedCollections?.includes(collectionName)) {
                 throw new ServerError('No _orgId found in userContext');
             }
@@ -27,29 +27,29 @@ export class TenantQueryDecorator {
         const result = { ...queryOptions };
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName);
         if (shouldApplyTenantFilter) {
-            if (!userContext._orgId) {
+            if (!userContext?.organization?._id) {
                 throw new ServerError('userContext must have an _orgId property to apply tenant filtering');
             }
             if (!result.filters) {
                 result.filters = {};
             }
             const orgIdField = this.getOrgIdField();
-            result.filters[orgIdField] = { eq: userContext._orgId };
+            result.filters[orgIdField] = { eq: userContext.organization?._id };
         }
         return result;
     }
     applyTenantToEntity(userContext, entity, collectionName) {
         let result = entity;
         const shouldApplyTenantFilter = !this.options.excludedCollections?.includes(collectionName) &&
-            userContext?._orgId;
+            userContext?.organization?._id;
         if (shouldApplyTenantFilter) {
             const orgIdField = this.options.orgIdField || '_orgId';
             result = {
                 ...entity,
-                [orgIdField]: userContext._orgId
+                [orgIdField]: userContext.organization?._id
             };
         }
-        else if (!userContext?._orgId) {
+        else if (!userContext?.organization?._id) {
             if (!this.options.excludedCollections?.includes(collectionName)) {
                 throw new ServerError('No _orgId found in userContext');
             }

package/dist/services/{user-service/user.service.d.ts → user.service.d.ts}

@@ -1,6 +1,6 @@
 import { IUser, IUserContext, IPagedResult, IQueryOptions } from '@loomcore/common/models';
-import { MultiTenantApiService } from '../index.js';
-import { IDatabase } from '../../databases/models/index.js';
+import { MultiTenantApiService } from './index.js';
+import { IDatabase } from '../databases/models/index.js';
 export declare class UserService extends MultiTenantApiService<IUser> {
     constructor(database: IDatabase);
     fullUpdateById(userContext: IUserContext, id: string, entity: IUser): Promise<IUser>;
@@ -8,5 +8,4 @@ export declare class UserService extends MultiTenantApiService<IUser> {
     get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<IUser>>;
     getAll(userContext: IUserContext): Promise<IUser[]>;
     preprocessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId?: boolean): Promise<Partial<IUser>>;
-    private addAuthorizationsToUsers;
 }

package/dist/services/{user-service/user.service.js → user.service.js}

@@ -1,8 +1,7 @@
 import { Value } from '@sinclair/typebox/value';
 import { UserSpec, PublicUserSchema } from '@loomcore/common/models';
-import { MultiTenantApiService } from '../index.js';
-import { IdNotFoundError, ServerError } from '../../errors/index.js';
-import { PostgresDatabase } from '../../databases/postgres/postgres.database.js';
+import { MultiTenantApiService } from './index.js';
+import { IdNotFoundError, ServerError } from '../errors/index.js';
 export class UserService extends MultiTenantApiService {
     constructor(database) {
         super(database, 'users', 'user', UserSpec);
@@ -16,13 +15,12 @@ export class UserService extends MultiTenantApiService {
         if (!user) {
             throw new IdNotFoundError();
         }
-        const usersWithAuth = await this.addAuthorizationsToUsers(userContext, [user]);
-        return usersWithAuth[0];
+        return this.postprocessEntity(userContext, user);
     }
     async get(userContext, queryOptions) {
         const { operations, queryObject } = this.prepareQuery(userContext, queryOptions, []);
         const pagedResult = await this.database.get(operations, queryObject, this.modelSpec, this.pluralResourceName);
-        const transformedEntities = await this.addAuthorizationsToUsers(userContext, pagedResult.entities || []);
+        const transformedEntities = (pagedResult.entities || []).map(entity => this.postprocessEntity(userContext, entity));
         return {
             ...pagedResult,
             entities: transformedEntities
@@ -31,7 +29,7 @@ export class UserService extends MultiTenantApiService {
     async getAll(userContext) {
         const { operations } = this.prepareQuery(userContext, {}, []);
         const users = await this.database.getAll(operations, this.pluralResourceName);
-        return this.addAuthorizationsToUsers(userContext, users);
+        return users.map(user => this.postprocessEntity(userContext, user));
     }
     async preprocessEntity(userContext, entity, isCreate, allowId = false) {
         const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate);
@@ -43,23 +41,4 @@ export class UserService extends MultiTenantApiService {
         }
         return preparedEntity;
     }
-    async addAuthorizationsToUsers(userContext, users) {
-        if (users.length === 0) {
-            return users;
-        }
-        if (!(this.database instanceof PostgresDatabase)) {
-            return users.map(user => this.postprocessEntity(userContext, user));
-        }
-        const userIds = users.map(user => user._id);
-        const orgId = userContext._orgId;
-        const authorizationsMap = await this.database.getUserAuthorizations(userIds, orgId);
-        return users.map(user => {
-            const authorizations = authorizationsMap.get(user._id) || [];
-            const userWithAuth = {
-                ...user,
-                authorizations
-            };
-            return this.postprocessEntity(userContext, userWithAuth);
-        });
-    }
 }

package/dist/services/utils/getUserContextAuthorizations.util.d.ts

@@ -0,0 +1,3 @@
+import { IUser, IUserContextAuthorization } from "@loomcore/common/models";
+import { IDatabase } from "../../databases/models/index.js";
+export declare function getUserContextAuthorizations(database: IDatabase, user: IUser): Promise<IUserContextAuthorization[]>;

package/dist/services/utils/getUserContextAuthorizations.util.js

@@ -0,0 +1,9 @@
+import { PostgresDatabase } from "../../databases/postgres/postgres.database.js";
+export async function getUserContextAuthorizations(database, user) {
+    if (!(database instanceof PostgresDatabase)) {
+        return [];
+    }
+    const orgId = user._orgId;
+    const authorizations = await database.getUserAuthorizations(user._id, orgId);
+    return authorizations;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -53,7 +53,7 @@
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.29",
+    "@loomcore/common": "^0.0.32",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",