@loomcore/api 0.1.24 → 0.1.26

package/dist/__tests__/test-objects.js

@@ -28,6 +28,7 @@ export function getTestMetaOrgUser() {
         authorizations: [{
                 _id: '6939c54e57a1c6576a40c590',
                 _orgId: getTestMetaOrg()._id,
+                role: 'metaorgUser',
                 feature: 'metaorgUser',
                 config: {},
                 _created: new Date(),
@@ -76,6 +77,7 @@ export function getTestOrgUser() {
         authorizations: [{
                 _id: '6939c54e57a1c6576a40c591',
                 _orgId: getTestOrg()._id,
+                role: 'testOrgUser',
                 feature: 'testOrgUser',
                 config: {},
                 _created: new Date(),

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

@@ -2,16 +2,12 @@ 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);
+    constructor(client: Client);
     index: number;
-    execute(): Promise<{
+    execute(adminEmail?: string, adminPassword?: string): Promise<{
         success: boolean;
-        error: Error;
-    } | {
-        success: boolean;
-        error: null;
+        adminUserId: string | undefined;
+        error: Error | null;
     }>;
     revert(): Promise<{
         success: boolean;

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

@@ -4,42 +4,30 @@ import { getSystemUserContext } from "@loomcore/common/models";
 import { AuthService } from "../../../services/auth.service.js";
 export class CreateAdminUserMigration {
     client;
-    adminEmail;
-    adminPassword;
-    constructor(client, adminEmail, adminPassword) {
+    constructor(client) {
         this.client = client;
-        this.adminEmail = adminEmail;
-        this.adminPassword = adminPassword;
     }
     index = 6;
-    async execute() {
+    async execute(adminEmail, adminPassword) {
         const _id = randomUUID().toString();
         const systemUserContext = getSystemUserContext();
+        let createdUser;
         try {
             const database = new PostgresDatabase(this.client);
             const authService = new AuthService(database);
-            const adminUser = await authService.createUser(systemUserContext, {
+            createdUser = await authService.createUser(systemUserContext, {
                 _id: _id,
                 _orgId: systemUserContext._orgId,
-                email: this.adminEmail,
-                password: this.adminPassword,
+                email: adminEmail,
+                password: adminPassword,
                 firstName: 'Admin',
                 lastName: 'User',
                 displayName: 'Admin User',
-                authorizations: [{
-                        _id: randomUUID().toString(),
-                        feature: 'metaorgAdmin',
-                        config: {},
-                        _created: new Date(),
-                        _createdBy: systemUserContext.user._id,
-                        _updated: new Date(),
-                        _updatedBy: systemUserContext.user._id
-                    }],
             });
         }
         catch (error) {
             return {
-                success: false, error: new Error(`Error creating admin user: ${error.message}`)
+                success: false, adminUserId: undefined, error: new Error(`Error creating admin user: ${error.message}`)
             };
         }
         try {
@@ -48,13 +36,13 @@ export class CreateAdminUserMigration {
                 VALUES ('${_id}', ${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`) };
+                return { success: false, adminUserId: undefined, 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: false, adminUserId: undefined, error: new Error(`Error inserting migration ${this.index} to migrations table: ${error.message}`) };
         }
-        return { success: true, error: null };
+        return { success: true, adminUserId: createdUser?._id, error: null };
     }
     async revert() {
         throw new Error('Not implemented');

package/dist/databases/postgres/migrations/008-create-user-roles-table.migration.js

@@ -18,7 +18,13 @@ export class CreateUserRolesTableMigration {
                         "_orgId" VARCHAR(255),
                         "_userId" VARCHAR(255) NOT NULL,
                         "_roleId" VARCHAR(255) NOT NULL,
-                        CONSTRAINT "fk_user_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE
+                        "_created" TIMESTAMP NOT NULL,
+                        "_createdBy" VARCHAR(255) NOT NULL,
+                        "_updated" TIMESTAMP NOT NULL,
+                        "_updatedBy" VARCHAR(255) NOT NULL,
+                        "_deleted" TIMESTAMP,
+                        "_deletedBy" VARCHAR(255),
+                        CONSTRAINT "fk_user_roles_organization" FOREIGN KEY ("_orgId") REFERENCES "organizations"("_id") ON DELETE CASCADE,
                         CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("_userId") REFERENCES "users"("_id") ON DELETE CASCADE,
                         CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("_roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
                         CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "_userId", "_roleId")

package/dist/databases/postgres/migrations/011-create-admin-authorization.migration.d.ts

@@ -0,0 +1,23 @@
+import { Client } from "pg";
+import { IMigration } from "./migration.interface.js";
+export declare class CreateAdminAuthorizationMigration implements IMigration {
+    private readonly client;
+    private readonly adminUserId;
+    private readonly metaOrgId?;
+    constructor(client: Client, adminUserId: string, metaOrgId?: string | undefined);
+    index: number;
+    execute(): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+    revert(metaOrgId?: string): Promise<{
+        success: boolean;
+        error: Error;
+    } | {
+        success: boolean;
+        error: null;
+    }>;
+}

package/dist/databases/postgres/migrations/011-create-admin-authorization.migration.js

@@ -0,0 +1,117 @@
+import { randomUUID } from "crypto";
+export class CreateAdminAuthorizationMigration {
+    client;
+    adminUserId;
+    metaOrgId;
+    constructor(client, adminUserId, metaOrgId) {
+        this.client = client;
+        this.adminUserId = adminUserId;
+        this.metaOrgId = metaOrgId;
+    }
+    index = 11;
+    async execute() {
+        const _id = randomUUID().toString();
+        try {
+            await this.client.query('BEGIN');
+            const roleId = randomUUID().toString();
+            const roleResult = await this.client.query(`
+                INSERT INTO "roles" ("_id", "_orgId", "name")
+                VALUES ($1, $2, 'admin')
+            `, [roleId, this.metaOrgId]);
+            if (roleResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error('Failed to create admin role') };
+            }
+            const userRoleId = randomUUID().toString();
+            const userRoleResult = await this.client.query(`
+                INSERT INTO "user_roles" ("_id", "_orgId", "_userId", "_roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                VALUES ($1, $2, $3, $4, NOW(), 'system', NOW(), 'system')
+            `, [userRoleId, this.metaOrgId, this.adminUserId, roleId]);
+            if (userRoleResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error('Failed to create user role') };
+            }
+            const featureId = randomUUID().toString();
+            const featureResult = await this.client.query(`
+                INSERT INTO "features" ("_id", "_orgId", "name")
+                VALUES ($1, $2, 'admin')
+            `, [featureId, this.metaOrgId]);
+            if (featureResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error('Failed to create admin feature') };
+            }
+            const authorizationId = randomUUID().toString();
+            const authorizationResult = await this.client.query(`
+                INSERT INTO "authorizations" (
+                    "_id", "_orgId", "_roleId", "_featureId", 
+                    "_created", "_createdBy", "_updated", "_updatedBy"
+                )
+                VALUES ($1, $2, $3, $4, NOW(), 'system', NOW(), 'system')
+            `, [authorizationId, this.metaOrgId, roleId, featureId]);
+            if (authorizationResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error('Failed to create admin authorization') };
+            }
+            const migrationResult = await this.client.query(`
+                INSERT INTO "migrations" ("_id", "index", "hasRun", "reverted")
+                VALUES ($1, $2, TRUE, FALSE)
+            `, [_id, this.index]);
+            if (migrationResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error inserting migration ${this.index} to migrations table: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error executing migration ${this.index}: ${error.message}`) };
+        }
+    }
+    async revert(metaOrgId) {
+        try {
+            await this.client.query('BEGIN');
+            await this.client.query(`
+                DELETE FROM "authorizations" 
+                WHERE "_orgId" = $1 
+                AND "_featureId" IN (
+                    SELECT "_id" FROM "features" 
+                    WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+                AND "_roleId" IN (
+                    SELECT "_id" FROM "roles" 
+                    WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+            `, [metaOrgId]);
+            await this.client.query(`
+                DELETE FROM "features" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
+            `, [metaOrgId]);
+            await this.client.query(`
+                DELETE FROM "user_roles" 
+                WHERE "_orgId" = $1 
+                AND "_roleId" IN (
+                    SELECT "_id" FROM "roles" 
+                    WHERE "_orgId" = $1 AND "name" = 'admin'
+                )
+            `, [metaOrgId]);
+            await this.client.query(`
+                DELETE FROM "roles" 
+                WHERE "_orgId" = $1 AND "name" = 'admin'
+            `, [metaOrgId]);
+            const updateResult = await this.client.query(`
+                UPDATE "migrations" SET "reverted" = TRUE WHERE "index" = $1
+            `, [this.index]);
+            if (updateResult.rowCount === 0) {
+                await this.client.query('ROLLBACK');
+                return { success: false, error: new Error(`Error updating migration record for index ${this.index}: No row returned`) };
+            }
+            await this.client.query('COMMIT');
+            return { success: true, error: null };
+        }
+        catch (error) {
+            await this.client.query('ROLLBACK');
+            return { success: false, error: new Error(`Error reverting migration ${this.index}: ${error.message}`) };
+        }
+    }
+}

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, adminUsername: string, adminPassword: string): Promise<{
+export declare function setupDatabaseForAuth(client: Client, adminUsername: string, adminPassword: string, metaOrgId?: string): Promise<{
     success: boolean;
     error: Error | null;
 }>;

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

@@ -7,7 +7,8 @@ import { CreateUserRolesTableMigration } from "./008-create-user-roles-table.mig
 import { CreateRoleTableMigration } from "./007-create-roles-table.migration.js";
 import { CreateAuthorizationsTableMigration } from "./010-create-authorizations-table.migration.js";
 import { CreateFeaturesTableMigration } from "./009-create-features-table.migration.js";
-export async function setupDatabaseForAuth(client, adminUsername, adminPassword) {
+import { CreateAdminAuthorizationMigration } from "./011-create-admin-authorization.migration.js";
+export async function setupDatabaseForAuth(client, adminUsername, adminPassword, metaOrgId) {
     let runMigrations = [];
     if (await doesTableExist(client, 'migrations')) {
         const migrations = await client.query(`
@@ -19,25 +20,79 @@ export async function setupDatabaseForAuth(client, adminUsername, adminPassword)
             return row.index;
         });
     }
-    let migrationsToRun = [];
-    if (!runMigrations.includes(1))
-        migrationsToRun.push(new CreateMigrationTableMigration(client));
-    if (!runMigrations.includes(3))
-        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));
-    if (!runMigrations.includes(7))
-        migrationsToRun.push(new CreateRoleTableMigration(client));
-    if (!runMigrations.includes(8))
-        migrationsToRun.push(new CreateUserRolesTableMigration(client));
-    if (!runMigrations.includes(9))
-        migrationsToRun.push(new CreateFeaturesTableMigration(client));
-    if (!runMigrations.includes(10))
-        migrationsToRun.push(new CreateAuthorizationsTableMigration(client));
-    for (const migration of migrationsToRun) {
-        await migration.execute();
+    let adminUserId;
+    if (!runMigrations.includes(1)) {
+        const migration = new CreateMigrationTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating migrations table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(3)) {
+        const migration = new CreateUsersTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating users table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(4)) {
+        const migration = new CreateRefreshTokenTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating refresh_tokens table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(6)) {
+        const migration = new CreateAdminUserMigration(client);
+        const result = await migration.execute(adminUsername, adminPassword);
+        adminUserId = result.adminUserId;
+    }
+    if (!runMigrations.includes(7)) {
+        const migration = new CreateRoleTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating roles table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(8)) {
+        const migration = new CreateUserRolesTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating user_roles table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(9)) {
+        const migration = new CreateFeaturesTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating features table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(10)) {
+        const migration = new CreateAuthorizationsTableMigration(client);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating authorizations table', result.error);
+            return { success: false, error: result.error };
+        }
+    }
+    if (!runMigrations.includes(11)) {
+        if (!adminUserId) {
+            console.error('setupDatabaseForAuth: Admin user ID is required');
+            return { success: true, error: null };
+        }
+        const migration = new CreateAdminAuthorizationMigration(client, adminUserId, metaOrgId);
+        const result = await migration.execute();
+        if (!result.success) {
+            console.error('setupDatabaseForAuth: error creating admin authorization', result.error);
+            return { success: false, error: result.error };
+        }
     }
     return { success: true, error: null };
 }

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

@@ -28,4 +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[]>>;
 }

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

@@ -66,4 +66,63 @@ export class PostgresDatabase {
     async findOne(queryObject, pluralResourceName) {
         return findOneQuery(this.client, queryObject, pluralResourceName);
     }
+    async getUserAuthorizations(userIds, orgId) {
+        if (userIds.length === 0) {
+            return new Map();
+        }
+        const now = new Date();
+        const placeholders = userIds.map((_, i) => `$${i + 1}`).join(', ');
+        let query = `
+            SELECT DISTINCT
+                ur."_userId" as "userId",
+                r."name" as "role",
+                f."name" as "feature",
+                a."config",
+                a."_id",
+                a."_orgId",
+                a."_created",
+                a."_createdBy",
+                a."_updated",
+                a."_updatedBy"
+            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})
+                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})
+        `;
+        const values = [...userIds, 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}`;
+            values.push(orgId);
+        }
+        const result = await this.client.query(query, values);
+        const authorizationsMap = new Map();
+        for (const row of result.rows) {
+            const userId = row.userId;
+            if (!authorizationsMap.has(userId)) {
+                authorizationsMap.set(userId, []);
+            }
+            authorizationsMap.get(userId).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;
+    }
 }

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

@@ -0,0 +1,7 @@
+import { IEntity } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+export interface IFeature extends IEntity {
+    name: string;
+}
+export declare const FeatureSchema: TSchema;
+export declare const FeatureModelSpec: import("@loomcore/common/models").IModelSpec<TSchema>;

package/dist/models/feature.model.js

@@ -0,0 +1,6 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const FeatureSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+});
+export const FeatureModelSpec = entityUtils.getModelSpec(FeatureSchema);

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

@@ -0,0 +1,7 @@
+import { IEntity } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+export interface IRole extends IEntity {
+    name: string;
+}
+export declare const RoleSchema: TSchema;
+export declare const RoleModelSpec: import("@loomcore/common/models").IModelSpec<TSchema>;

package/dist/models/role.model.js

@@ -0,0 +1,6 @@
+import { Type } from "@sinclair/typebox";
+import { entityUtils } from "@loomcore/common/utils";
+export const RoleSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+});
+export const RoleModelSpec = entityUtils.getModelSpec(RoleSchema);

package/dist/models/user-role.model.d.ts

@@ -0,0 +1,8 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+import { TSchema } from "@sinclair/typebox";
+export interface IUserRole extends IEntity, IAuditable {
+    userId: string;
+    roleId: string;
+}
+export declare const UserRoleSchema: TSchema;
+export declare const UserRoleModelSpec: import("@loomcore/common/models").IModelSpec<TSchema>;

package/dist/models/user-role.model.js

@@ -0,0 +1,7 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const UserRoleSchema = Type.Object({
+    userId: Type.String({ minLength: 1 }),
+    roleId: Type.String({ minLength: 1 }),
+});
+export const UserRoleModelSpec = entityUtils.getModelSpec(UserRoleSchema, { isAuditable: true });

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.js';
+export * from './user-service/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.js';
+export * from './user-service/user.service.js';

package/dist/services/user-service/user.service.d.ts

@@ -0,0 +1,12 @@
+import { IUser, IUserContext, IPagedResult, IQueryOptions } from '@loomcore/common/models';
+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>;
+    getById(userContext: IUserContext, id: string): Promise<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

@@ -0,0 +1,65 @@
+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';
+export class UserService extends MultiTenantApiService {
+    constructor(database) {
+        super(database, 'users', 'user', UserSpec);
+    }
+    async fullUpdateById(userContext, id, entity) {
+        throw new ServerError('Cannot full update a user. Either use PATCH or /auth/change-password to update password.');
+    }
+    async getById(userContext, id) {
+        const { operations, queryObject } = this.prepareQuery(userContext, {}, []);
+        const user = await this.database.getById(operations, queryObject, id, this.pluralResourceName);
+        if (!user) {
+            throw new IdNotFoundError();
+        }
+        const usersWithAuth = await this.addAuthorizationsToUsers(userContext, [user]);
+        return usersWithAuth[0];
+    }
+    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 || []);
+        return {
+            ...pagedResult,
+            entities: transformedEntities
+        };
+    }
+    async getAll(userContext) {
+        const { operations } = this.prepareQuery(userContext, {}, []);
+        const users = await this.database.getAll(operations, this.pluralResourceName);
+        return this.addAuthorizationsToUsers(userContext, users);
+    }
+    async preprocessEntity(userContext, entity, isCreate, allowId = false) {
+        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate);
+        if (preparedEntity.email) {
+            preparedEntity.email = preparedEntity.email.toLowerCase();
+        }
+        if (!isCreate) {
+            return Value.Clean(PublicUserSchema, preparedEntity);
+        }
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "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.27",
+    "@loomcore/common": "^0.0.28",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

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

@@ -1,8 +0,0 @@
-import { IUser, IUserContext } from '@loomcore/common/models';
-import { MultiTenantApiService } from '../services/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>;
-    preprocessEntity(userContext: IUserContext, entity: Partial<IUser>, isCreate: boolean, allowId?: boolean): Promise<Partial<IUser>>;
-}

package/dist/services/user.service.js

@@ -1,22 +0,0 @@
-import { Value } from '@sinclair/typebox/value';
-import { UserSpec, PublicUserSchema } from '@loomcore/common/models';
-import { MultiTenantApiService } from '../services/index.js';
-import { ServerError } from '../errors/index.js';
-export class UserService extends MultiTenantApiService {
-    constructor(database) {
-        super(database, 'users', 'user', UserSpec);
-    }
-    async fullUpdateById(userContext, id, entity) {
-        throw new ServerError('Cannot full update a user. Either use PATCH or /auth/change-password to update password.');
-    }
-    async preprocessEntity(userContext, entity, isCreate, allowId = false) {
-        const preparedEntity = await super.preprocessEntity(userContext, entity, isCreate);
-        if (preparedEntity.email) {
-            preparedEntity.email = preparedEntity.email.toLowerCase();
-        }
-        if (!isCreate) {
-            return Value.Clean(PublicUserSchema, preparedEntity);
-        }
-        return preparedEntity;
-    }
-}