@loomcore/api 0.2.7 → 0.2.8

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

@@ -1,15 +1,15 @@
-import { IQueryOptions, IUser, IUserContext } from "@loomcore/common/models";
-import { Application, NextFunction, Request, Response } from "express";
+import { type IQueryOptions, type IUser, type IUserContext } from "@loomcore/common/models";
+import type { Application, NextFunction, Request, Response } from "express";
 import { ApiController } from "../controllers/api.controller.js";
-import { IDatabase } from "../databases/models/index.js";
-import { Operation } from "../databases/operations/operation.js";
+import type { IDatabase } from "../databases/models/index.js";
+import type { Operation } from "../databases/operations/operation.js";
 import { GenericApiService } from "../services/index.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
 import type { DbType } from "../databases/db-type.type.js";
 import { type ICategory } from "./models/category.model.js";
 import { type IProduct } from "./models/product.model.js";
 import { type IProductWithCategory } from "./models/product-with-category.model.js";
-declare function initialize(database: IDatabase): void;
+declare function initialize(db: IDatabase): void;
 declare function getRandomId(): string;
 declare function isMongoDatabase(database: IDatabase): boolean;
 declare function isPostgresDatabase(database: IDatabase): boolean;

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

@@ -1,21 +1,21 @@
+import crypto from "node:crypto";
 import { EmptyUserContext, } from "@loomcore/common/models";
 import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import crypto from "crypto";
 import jwt from "jsonwebtoken";
 import { ObjectId } from "mongodb";
 import { ApiController } from "../controllers/api.controller.js";
 import { MongoDBDatabase } from "../databases/mongo-db/mongo-db.database.js";
 import { LeftJoin } from "../databases/operations/left-join.operation.js";
 import { PostgresDatabase } from "../databases/postgres/postgres.database.js";
-import { AuthService, GenericApiService } from "../services/index.js";
-import { JwtService } from "../services/jwt.service.js";
+import { GenericApiService, UserService } from "../services/index.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
 import { OrganizationService } from "../services/organization.service.js";
 import * as testObjectsModule from "./test-objects.js";
 const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId, } = testObjectsModule;
 import { entityUtils } from "@loomcore/common/utils";
 import { config, setBaseApiConfig } from "../config/index.js";
+import { attemptLogin } from "../utils/auth/index.js";
 import { apiUtils } from "../utils/index.js";
 import { CategorySpec } from "./models/category.model.js";
 import { ProductSpec } from "./models/product.model.js";
@@ -23,15 +23,17 @@ import { ProductWithCategoryPublicSpec, ProductWithCategorySpec, } from "./model
 import { TestEmailClient } from "./test-email-client.js";
 import { getTestOrgUser } from "./test-objects.js";
 let deviceIdCookie;
-let authService;
+let database;
 let organizationService;
+let userService;
 const JWT_SECRET = "test-secret";
 const newUser1Email = "one@test.com";
 const newUser1Password = "testone";
 const constDeviceIdCookie = crypto.randomBytes(16).toString("hex");
-function initialize(database) {
-    authService = new AuthService(database);
-    organizationService = new OrganizationService(database);
+function initialize(db) {
+    database = db;
+    organizationService = new OrganizationService(db);
+    userService = new UserService(db);
     deviceIdCookie = constDeviceIdCookie;
 }
 function getRandomId() {
@@ -95,7 +97,7 @@ async function setupTestUsers() {
     }
 }
 async function createTestUsers() {
-    if (!authService || !organizationService) {
+    if (!organizationService || !userService) {
         throw new Error("Database not initialized. Call initialize() first.");
     }
     try {
@@ -115,8 +117,8 @@ async function createTestUsers() {
         else {
             setTestOrgId(existingTestOrg._id);
         }
-        const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser());
-        const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
+        const createdTestOrgUser = await userService.create(getTestOrgUserContext(), getTestOrgUser());
+        const createdMetaOrgUser = await userService.create(getTestMetaOrgUserContext(), getTestMetaOrgUser());
         if (!createdTestOrgUser || !createdMetaOrgUser) {
             throw new Error("Failed to create test user");
         }
@@ -130,18 +132,18 @@ async function createTestUsers() {
     }
 }
 async function deleteTestUser() {
-    if (!authService || !organizationService) {
+    if (!organizationService || !userService) {
         return;
     }
-    await authService
+    await userService
         .deleteById(getTestMetaOrgUserContext(), getTestMetaOrgUser()._id)
         .catch((error) => {
-        return null;
+        console.log("Error deleting test user:", error);
     });
     await organizationService
         .deleteById(getTestMetaOrgUserContext(), getTestOrg()._id)
         .catch((error) => {
-        return null;
+        console.log("Error deleting test organization:", error);
     });
 }
 async function simulateloginWithTestUser() {
@@ -149,20 +151,20 @@ async function simulateloginWithTestUser() {
         cookies: {},
     };
     if (deviceIdCookie) {
-        req.cookies["deviceId"] = deviceIdCookie;
+        req.cookies.deviceId = deviceIdCookie;
     }
     const res = {
-        cookie: function (name, value) {
+        cookie: (name, value) => {
             if (name === "deviceId") {
                 deviceIdCookie = value;
             }
             return res;
         },
     };
-    if (!authService) {
-        throw new Error("AuthService not initialized. Call initialize() first.");
+    if (!database) {
+        throw new Error("Database not initialized. Call initialize() first.");
     }
-    const loginResponse = await authService.attemptLogin(req, res, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD);
+    const loginResponse = await attemptLogin(database, getTestMetaOrgUser().email, testObjectsModule.TEST_META_ORG_USER_PASSWORD, deviceIdCookie, getTestMetaOrg()._id);
     if (!loginResponse?.tokens?.accessToken) {
         throw new Error("Failed to login with test user");
     }
@@ -170,11 +172,11 @@ async function simulateloginWithTestUser() {
 }
 function getAuthToken() {
     const userContext = getTestMetaOrgUserContext();
-    const token = JwtService.sign(userContext, JWT_SECRET, { expiresIn: 3600 });
+    const token = jwt.sign(userContext, JWT_SECRET, { expiresIn: 3600 });
     return `Bearer ${token}`;
 }
 function verifyToken(token) {
-    return JwtService.verify(token, JWT_SECRET);
+    return jwt.verify(token, JWT_SECRET);
 }
 export class CategoryService extends GenericApiService {
     constructor(database) {
@@ -339,6 +341,7 @@ async function loginWithTestUser(agent) {
     const response = await agent.post("/api/auth/login").send({
         email: testUser.email,
         password: testUser.password,
+        organizationId: testUser._orgId,
     });
     if (!response.body?.data?.tokens?.accessToken) {
         console.error("Login failed:", response.body);

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

@@ -1,15 +1,17 @@
-import type { Application, NextFunction, Request, Response } from "express";
+import type { Application, Request, Response } from "express";
 import type { IDatabase } from "../databases/models/index.js";
-import { AuthService } from "../services/index.js";
+import { OrganizationService, UserService } from "../services/index.js";
 export declare class AuthController {
-    authService: AuthService;
+    database: IDatabase;
+    userService: UserService;
+    organizationService: OrganizationService;
     constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
-    login(req: Request, res: Response, next: NextFunction): Promise<void>;
+    login(req: Request, res: Response): Promise<void>;
     registerUser(req: Request, res: Response): Promise<void>;
-    requestTokenUsingRefreshToken(req: Request, res: Response, next: NextFunction): Promise<void>;
-    getUserContext(req: Request, res: Response, next: NextFunction): Promise<void>;
-    afterAuth(req: Request, res: Response, loginResponse: any): void;
+    requestTokenUsingRefreshToken(req: Request, res: Response): Promise<void>;
+    getUserContext(req: Request, res: Response): Promise<void>;
+    afterAuth(_req: Request, _res: Response, _loginResponse: any): void;
     changePassword(req: Request, res: Response): Promise<void>;
     forgotPassword(req: Request, res: Response): Promise<void>;
     resetPassword(req: Request, res: Response): Promise<void>;

package/dist/controllers/auth.controller.js

@@ -1,13 +1,19 @@
-import { LoginResponseSpec, PublicUserContextSpec, PublicUserSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
+import { EmptyUserContext, LoginResponseSpec, PublicUserContextSpec, PublicUserSpec, passwordValidator, TokenResponseSpec, UserSpec, } from "@loomcore/common/models";
 import { entityUtils } from "@loomcore/common/utils";
-import { BadRequestError, UnauthenticatedError } from "../errors/index.js";
+import { config } from "../config/base-api-config.js";
+import { BadRequestError, ServerError, UnauthenticatedError, } from "../errors/index.js";
 import { isAuthorized } from "../middleware/index.js";
-import { AuthService } from "../services/index.js";
+import { OrganizationService, UserService } from "../services/index.js";
+import { attemptLogin, changePassword, getAndSetDeviceIdCookie, getDeviceIdFromCookie, requestTokenUsingRefreshToken, resetPassword, sendResetPasswordEmail, } from "../utils/auth/index.js";
 import { apiUtils } from "../utils/index.js";
 export class AuthController {
-    authService;
+    database;
+    userService;
+    organizationService;
     constructor(app, database) {
-        this.authService = new AuthService(database);
+        this.database = database;
+        this.userService = new UserService(database);
+        this.organizationService = new OrganizationService(database);
         this.mapRoutes(app);
     }
     mapRoutes(app) {
@@ -19,10 +25,20 @@ export class AuthController {
         app.post(`/api/auth/forgot-password`, this.forgotPassword.bind(this));
         app.post(`/api/auth/reset-password`, this.resetPassword.bind(this));
     }
-    async login(req, res, next) {
-        const { email, password } = req.body;
+    async login(req, res) {
+        const { email, password, organizationId } = req.body;
+        if (!email || typeof email !== "string") {
+            throw new BadRequestError("Missing required fields: email is required.");
+        }
+        if (!password || typeof password !== "string") {
+            throw new BadRequestError("Missing required fields: password is required.");
+        }
+        if (config.app.isMultiTenant && !organizationId) {
+            throw new BadRequestError("Missing required fields: organizationId is required.");
+        }
         res.set("Content-Type", "application/json");
-        const loginResponse = await this.authService.attemptLogin(req, res, email, password);
+        const deviceId = getAndSetDeviceIdCookie(req, res);
+        const loginResponse = await attemptLogin(this.database, email, password, deviceId, organizationId);
         apiUtils.apiResponse(res, 200, { data: loginResponse }, LoginResponseSpec);
     }
     async registerUser(req, res) {
@@ -31,30 +47,35 @@ export class AuthController {
             throw new BadRequestError("Missing required fields: userContext is required.");
         }
         const body = req.body;
-        const validationErrors = this.authService.validate(body.user);
+        const validationErrors = this.userService.validate(body.user);
         entityUtils.handleValidationResult(validationErrors, "AuthController.registerUser");
-        const user = await this.authService.createUser(userContext, body.user);
-        apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSpec);
+        const user = await this.userService.create(userContext, body.user);
+        if (!user) {
+            throw new ServerError("Failed to create user");
+        }
+        apiUtils.apiResponse(res, 201, { data: user }, UserSpec, PublicUserSpec);
     }
-    async requestTokenUsingRefreshToken(req, res, next) {
+    async requestTokenUsingRefreshToken(req, res) {
+        const userContext = req.userContext;
+        if (!userContext) {
+            throw new BadRequestError("Missing required fields: userContext is required.");
+        }
         const refreshToken = req.query.refreshToken;
         if (!refreshToken || typeof refreshToken !== "string") {
             throw new BadRequestError("Missing required fields: refreshToken is required.");
         }
-        const deviceId = this.authService.getDeviceIdFromCookie(req);
-        const tokens = await this.authService.requestTokenUsingRefreshToken(refreshToken, deviceId);
-        if (tokens) {
-            apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
-        }
-        else {
+        const deviceId = getDeviceIdFromCookie(req);
+        const tokens = await requestTokenUsingRefreshToken(this.database, userContext, refreshToken, deviceId);
+        if (!tokens) {
             throw new UnauthenticatedError();
         }
+        apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
     }
-    async getUserContext(req, res, next) {
+    async getUserContext(req, res) {
         const userContext = req.userContext;
         apiUtils.apiResponse(res, 200, { data: userContext }, PublicUserContextSpec);
     }
-    afterAuth(req, res, loginResponse) {
+    afterAuth(_req, _res, _loginResponse) {
         console.log("in afterAuth");
     }
     async changePassword(req, res) {
@@ -62,31 +83,52 @@ export class AuthController {
         if (!userContext) {
             throw new BadRequestError("Missing required fields: userContext is required.");
         }
-        const body = req.body;
-        const validationErrors = entityUtils.validate(UserSpec, { password: body.password }, true, passwordValidator);
+        const password = req.body?.password;
+        const validationErrors = entityUtils.validate(UserSpec, { password: password }, true, passwordValidator);
         entityUtils.handleValidationResult(validationErrors, "AuthController.changePassword");
-        const updateResult = await this.authService.changeLoggedInUsersPassword(userContext, body);
+        const updateResult = await changePassword(this.database, userContext, password);
         apiUtils.apiResponse(res, 200, { data: updateResult });
     }
     async forgotPassword(req, res) {
         const email = req.body?.email;
+        const organizationId = req.body?.organizationId;
+        if (!email || typeof email !== "string") {
+            throw new BadRequestError("Missing required fields: email is required.");
+        }
+        if (config.app.isMultiTenant && !organizationId) {
+            throw new BadRequestError("Missing required fields: organizationId is required.");
+        }
         let referer = req.get("referer") || req.headers.referer;
         if (!referer) {
             throw new BadRequestError("Missing required fields: referer is required.");
         }
         referer = referer.replace(/\/$/, "");
-        const user = await this.authService.getUserByEmail(email);
+        const organization = organizationId
+            ? await this.organizationService.findOne(EmptyUserContext, {
+                filters: { _id: { eq: organizationId } },
+            })
+            : null;
+        const userContext = {
+            ...EmptyUserContext,
+            organization: organization || undefined,
+        };
+        const user = await this.userService.findOne(userContext, {
+            filters: { email: { eq: email.toLowerCase() } },
+        });
         if (user) {
-            await this.authService.sendResetPasswordEmail(email, referer);
+            await sendResetPasswordEmail(this.database, email, referer);
         }
         apiUtils.apiResponse(res, 200);
     }
     async resetPassword(req, res) {
-        const { email, token, password } = req.body;
+        const { email, token, password, organizationId, } = req.body;
         if (!email || !token || !password) {
             throw new BadRequestError("Missing required fields: email, token, and password are required.");
         }
-        const response = await this.authService.resetPassword(email, token, password);
+        if (config.app.isMultiTenant && !organizationId) {
+            throw new BadRequestError("Missing required fields: organizationId is required.");
+        }
+        const response = await resetPassword(this.database, email, token, password, organizationId);
         apiUtils.apiResponse(res, 200, { data: response });
     }
 }

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

@@ -1,7 +1,7 @@
-import { IAuthorization } from "../models/authorization.model.js";
+import type { Application } from "express";
+import type { IDatabase } from "../databases/models/index.js";
+import { type IAuthorization } from "../models/authorization.model.js";
 import { ApiController } from "./api.controller.js";
-import { Application } from "express";
-import { IDatabase } from "../databases/models/index.js";
 export declare class AuthorizationsController extends ApiController<IAuthorization> {
     constructor(app: Application, database: IDatabase);
 }

package/dist/controllers/authorizations.controller.js

@@ -1,9 +1,9 @@
-import { AuthorizationModelSpec } from "../models/authorization.model.js";
-import { ApiController } from "./api.controller.js";
+import { AuthorizationModelSpec, } from "../models/authorization.model.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { ApiController } from "./api.controller.js";
 export class AuthorizationsController extends ApiController {
     constructor(app, database) {
-        const authorizationService = new MultiTenantApiService(database, 'authorizations', 'authorization', AuthorizationModelSpec);
-        super('authorizations', app, authorizationService, 'authorization', AuthorizationModelSpec);
+        const authorizationService = new MultiTenantApiService(database, "authorizations", "authorization", AuthorizationModelSpec);
+        super("authorizations", app, authorizationService, "authorization", AuthorizationModelSpec);
     }
 }

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

@@ -1,7 +1,7 @@
+import { Application } from "express";
 import { IDatabase } from "../databases/models/index.js";
 import { IRole } from "../models/role.model.js";
 import { ApiController } from "./api.controller.js";
-import { Application } from "express";
 export declare class RolesController extends ApiController<IRole> {
     constructor(app: Application, database: IDatabase);
 }

package/dist/controllers/roles.controller.js

@@ -1,9 +1,9 @@
 import { RoleModelSpec } from "../models/role.model.js";
-import { ApiController } from "./api.controller.js";
 import { MultiTenantApiService } from "../services/multi-tenant-api.service.js";
+import { ApiController } from "./api.controller.js";
 export class RolesController extends ApiController {
     constructor(app, database) {
-        const roleService = new MultiTenantApiService(database, 'roles', 'role', RoleModelSpec);
-        super('roles', app, roleService, 'role', RoleModelSpec, RoleModelSpec);
+        const roleService = new MultiTenantApiService(database, "roles", "role", RoleModelSpec);
+        super("roles", app, roleService, "role", RoleModelSpec, RoleModelSpec);
     }
 }

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

@@ -1,10 +1,9 @@
-import { Application } from 'express';
-import { IUser } from '@loomcore/common/models';
-import { ApiController } from './api.controller.js';
-import { UserService } from '../services/index.js';
-import { IDatabase } from '../databases/models/index.js';
+import { type IUser } from "@loomcore/common/models";
+import type { Application } from "express";
+import type { IDatabase } from "../databases/models/index.js";
+import { UserService } from "../services/index.js";
+import { ApiController } from "./api.controller.js";
 export declare class UsersController extends ApiController<IUser> {
     userService: UserService;
     constructor(app: Application, database: IDatabase);
-    mapRoutes(app: Application): void;
 }

package/dist/controllers/users.controller.js

@@ -1,22 +1,11 @@
-import { UserSpec, PublicUserSpec } from '@loomcore/common/models';
-import { ApiController } from './api.controller.js';
-import { isAuthorized } from '../middleware/index.js';
-import { UserService } from '../services/index.js';
+import { PublicUserSpec, UserSpec } from "@loomcore/common/models";
+import { UserService } from "../services/index.js";
+import { ApiController } from "./api.controller.js";
 export class UsersController extends ApiController {
     userService;
     constructor(app, database) {
         const userService = new UserService(database);
-        super('users', app, userService, 'user', UserSpec, PublicUserSpec);
+        super("users", app, userService, "user", UserSpec, PublicUserSpec);
         this.userService = userService;
     }
-    mapRoutes(app) {
-        app.get(`/api/${this.slug}`, isAuthorized(), this.get.bind(this));
-        app.get(`/api/${this.slug}/all`, isAuthorized(), this.getAll.bind(this));
-        app.get(`/api/${this.slug}/find`, isAuthorized(), this.get.bind(this));
-        app.get(`/api/${this.slug}/count`, isAuthorized(), this.getCount.bind(this));
-        app.get(`/api/${this.slug}/:id`, isAuthorized(), this.getById.bind(this));
-        app.post(`/api/${this.slug}`, isAuthorized(), this.create.bind(this));
-        app.patch(`/api/${this.slug}/:id`, isAuthorized(), this.partialUpdateById.bind(this));
-        app.delete(`/api/${this.slug}/:id`, isAuthorized(), this.deleteById.bind(this));
-    }
 }

package/dist/databases/postgres/commands/postgres-create.command.d.ts

@@ -1,6 +1,6 @@
-import type { PostgresConnection } from '../postgres-connection.js';
-import { IEntity } from "@loomcore/common/models";
+import type { IEntity } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
+import type { PostgresConnection } from "../postgres-connection.js";
 export declare function create<T extends IEntity>(client: PostgresConnection, pluralResourceName: string, entity: Partial<T>): Promise<{
     insertedId: AppIdType;
     entity: T;

package/dist/databases/postgres/commands/postgres-create.command.js

@@ -1,12 +1,12 @@
 import { BadRequestError, DuplicateKeyError } from "../../../errors/index.js";
-import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
+import { columnsAndValuesFromEntity } from "../utils/columns-and-values-from-entity.js";
 export async function create(client, pluralResourceName, entity) {
     try {
         delete entity._id;
         const { columns, values } = columnsAndValuesFromEntity(entity);
-        const placeholders = columns.map((_, index) => `$${index + 1}`).join(', ');
+        const placeholders = columns.map((_, index) => `$${index + 1}`).join(", ");
         const query = `
-            INSERT INTO "${pluralResourceName}" (${columns.join(', ')})
+            INSERT INTO "${pluralResourceName}" (${columns.join(", ")})
             VALUES (${placeholders})
             RETURNING *
         `;
@@ -18,11 +18,11 @@ export async function create(client, pluralResourceName, entity) {
         const insertedId = insertedRow._id;
         return {
             insertedId: insertedId,
-            entity: insertedRow
+            entity: insertedRow,
         };
     }
     catch (err) {
-        if (err.code === '23505') {
+        if (err.code === "23505") {
             throw new DuplicateKeyError(`${pluralResourceName} already exists`);
         }
         throw new BadRequestError(`Error creating ${pluralResourceName}: ${err.message}`);

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

@@ -1,9 +1,9 @@
-import { IQueryOptions, IModelSpec, IPagedResult, IEntity, IUserContextAuthorization } from "@loomcore/common/models";
+import { IEntity, IModelSpec, IPagedResult, IQueryOptions, IUserContextAuthorization } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
 import { TSchema } from "@sinclair/typebox";
 import { DeleteResult, IDatabase } from "../models/index.js";
 import { Operation } from "../operations/operation.js";
-import type { PostgresConnection } from './postgres-connection.js';
+import type { PostgresConnection } from "./postgres-connection.js";
 export declare class PostgresDatabase implements IDatabase {
     private connection;
     constructor(connection: PostgresConnection);

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

@@ -1,19 +1,19 @@
+import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.command.js";
 import { create as createCommand } from "./commands/postgres-create.command.js";
 import { createMany as createManyCommand } from "./commands/postgres-create-many.command.js";
-import { batchUpdate as batchUpdateCommand } from "./commands/postgres-batch-update.command.js";
+import { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
+import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
 import { fullUpdateById as fullUpdateByIdCommand } from "./commands/postgres-full-update-by-id.command.js";
 import { partialUpdateById as partialUpdateByIdCommand } from "./commands/postgres-partial-update-by-id.command.js";
 import { update as updateCommand } from "./commands/postgres-update.command.js";
-import { deleteById as deleteByIdCommand } from "./commands/postgres-delete-by-id.command.js";
-import { deleteMany as deleteManyCommand } from "./commands/postgres-delete-many.command.js";
-import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
 import { find as findQuery } from "./queries/postgres-find.query.js";
-import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
+import { findOne as findOneQuery } from "./queries/postgres-find-one.query.js";
 import { get as getQuery } from "./queries/postgres-get.query.js";
+import { getAll as getAllQuery } from "./queries/postgres-get-all.query.js";
 import { getById as getByIdQuery } from "./queries/postgres-get-by-id.query.js";
 import { getCount as getCountQuery } from "./queries/postgres-get-count.query.js";
+import { convertKeysToCamelCase, convertKeysToSnakeCase, } from "./utils/convert-keys.util.js";
 import { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
-import { convertKeysToSnakeCase, convertKeysToCamelCase } from "./utils/convert-keys.util.js";
 export class PostgresDatabase {
     connection;
     constructor(connection) {
@@ -72,7 +72,6 @@ export class PostgresDatabase {
         const now = new Date();
         let query = `
             SELECT DISTINCT
-                ur."user_id" as "userId",
                 r."name" as "role",
                 f."name" as "feature",
                 a."config",
@@ -96,7 +95,6 @@ export class PostgresDatabase {
         const result = await this.connection.query(query, values);
         const authorizations = [];
         for (const row of result.rows) {
-            const userId = row.userId;
             authorizations.push({
                 _id: row._id,
                 _orgId: row._orgId,

package/dist/middleware/is-authorized.d.ts

@@ -1,3 +1,3 @@
-import { Request, Response, NextFunction } from 'express';
-declare const isAuthorized: (allowedFeatures?: string[]) => (req: Request, res: Response, next: NextFunction) => void;
+import type { NextFunction, Request, Response } from "express";
+declare const isAuthorized: (allowedFeatures?: string[]) => (req: Request, _res: Response, next: NextFunction) => void;
 export { isAuthorized };

package/dist/middleware/is-authorized.js

@@ -1,13 +1,13 @@
-import { UserContextSpec } from '@loomcore/common/models';
-import { UnauthenticatedError, UnauthorizedError } from '../errors/index.js';
-import { JwtService } from '../services/index.js';
-import { config } from '../config/index.js';
+import { UserContextSpec } from "@loomcore/common/models";
+import jwt from "jsonwebtoken";
+import { UnauthenticatedError, UnauthorizedError } from "../errors/index.js";
+import { getAuthConfig } from "../utils/auth/get-auth-config.util.js";
 const isAuthorized = (allowedFeatures) => {
-    return (req, res, next) => {
+    return (req, _res, next) => {
         let token = null;
         if (req.headers?.authorization) {
-            let authHeader = req.headers.authorization;
-            const authHeaderArray = authHeader.split('Bearer ');
+            const authHeader = req.headers.authorization;
+            const authHeaderArray = authHeader.split("Bearer ");
             if (authHeaderArray?.length > 1) {
                 token = authHeaderArray[1];
             }
@@ -15,15 +15,16 @@ const isAuthorized = (allowedFeatures) => {
         if (!token) {
             throw new UnauthenticatedError();
         }
+        const authConfig = getAuthConfig();
         try {
-            const rawPayload = JwtService.verify(token, config.auth?.clientSecret || '');
+            const rawPayload = jwt.verify(token, authConfig.clientSecret);
             const userContext = UserContextSpec.decode(rawPayload);
             req.userContext = userContext;
-            if (userContext.authorizations.some(authorization => authorization.feature === 'admin')) {
+            if (userContext.authorizations.some((authorization) => authorization.feature === "admin")) {
                 next();
             }
-            else if (allowedFeatures && allowedFeatures.length) {
-                if (!userContext.authorizations.some(authorization => allowedFeatures?.includes(authorization.feature))) {
+            else if (allowedFeatures?.length) {
+                if (!userContext.authorizations.some((authorization) => allowedFeatures.includes(authorization.feature))) {
                     throw new UnauthorizedError();
                 }
                 next();
@@ -33,6 +34,7 @@ const isAuthorized = (allowedFeatures) => {
             }
         }
         catch (err) {
+            console.error(err);
             throw new UnauthenticatedError();
         }
     };

package/dist/models/refresh-token.model.d.ts

@@ -1,4 +1,4 @@
-import { IEntity } from "@loomcore/common/models";
+import type { IEntity } from "@loomcore/common/models";
 import type { AppIdType } from "@loomcore/common/types";
 export interface IRefreshToken extends IEntity {
     token: string;

package/dist/models/refresh-token.model.js

@@ -1,13 +1,12 @@
 import { entityUtils } from "@loomcore/common/utils";
-import { TypeboxIsoDate, getIdSchema } from "@loomcore/common/validation";
+import { getIdSchema, TypeboxIsoDate } from "@loomcore/common/validation";
 import { Type } from "@sinclair/typebox";
-;
 export const refreshTokenSchema = Type.Object({
     token: Type.String({ minLength: 1 }),
     deviceId: Type.String({ minLength: 1 }),
     userId: getIdSchema(),
     expiresOn: Type.Number(),
-    created: TypeboxIsoDate({ title: 'Created Date' }),
-    createdBy: getIdSchema()
+    created: TypeboxIsoDate({ title: "Created Date" }),
+    createdBy: getIdSchema(),
 });
 export const refreshTokenModelSpec = entityUtils.getModelSpec(refreshTokenSchema);