@loomcore/api 0.0.1

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

@@ -0,0 +1,35 @@
+import { Db } from 'mongodb';
+import { IUser, IUserContext } from '@loomcore/common/models';
+declare function initialize(database: Db): void;
+declare function createIndexes(db: Db): Promise<void>;
+declare function setupTestUser(): Promise<Partial<IUser>>;
+declare function deleteTestUser(): Promise<null>;
+declare function simulateloginWithTestUser(): Promise<string>;
+declare function getAuthToken(): string;
+declare function verifyToken(token: string): any;
+declare function getTestUser(): Partial<IUser>;
+declare function configureJwtSecret(): void;
+declare function loginWithTestUser(agent: any): Promise<string>;
+declare const testUtils: {
+    configureJwtSecret: typeof configureJwtSecret;
+    constDeviceIdCookie: string;
+    createIndexes: typeof createIndexes;
+    deleteTestUser: typeof deleteTestUser;
+    getAuthToken: typeof getAuthToken;
+    getTestUser: typeof getTestUser;
+    initialize: typeof initialize;
+    loginWithTestUser: typeof loginWithTestUser;
+    newUser1Email: string;
+    newUser1Password: string;
+    setupTestUser: typeof setupTestUser;
+    simulateloginWithTestUser: typeof simulateloginWithTestUser;
+    testUserContext: IUserContext;
+    testUserId: string;
+    testUserEmail: string;
+    testUserEmailCaseInsensitive: string;
+    testUserPassword: string;
+    testOrgId: string;
+    testOrgName: string;
+    verifyToken: typeof verifyToken;
+};
+export default testUtils;

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

@@ -0,0 +1,181 @@
+import { ObjectId } from 'mongodb';
+import crypto from 'crypto';
+import jwt from 'jsonwebtoken';
+import { JwtService } from '../services/jwt.service.js';
+import { passwordUtils } from '../utils/password.utils.js';
+import { AuthService } from '../services/auth.service.js';
+let db;
+let collections = {};
+let deviceIdCookie;
+let authService;
+let testUser;
+const JWT_SECRET = 'test-secret';
+const newUser1Email = 'one@test.com';
+const newUser1Password = 'testone';
+const testUserId = '67f33ed5b75090e0dda18a3c';
+const testOrgId = '67e8e19b149f740323af93d7';
+const testOrgName = 'Test Organization';
+const testUserEmail = 'test@example.com';
+const testUserEmailCaseInsensitive = 'tesT@example.com';
+const testUserPassword = 'testPassword';
+const constDeviceIdCookie = crypto.randomBytes(16).toString('hex');
+const testUserContext = {
+    user: {
+        _id: testUserId,
+        email: testUserEmail,
+        _created: new Date(),
+        _createdBy: 'system',
+        _updated: new Date(),
+        _updatedBy: 'system'
+    },
+    _orgId: testOrgId
+};
+function initialize(database) {
+    db = database;
+    collections = {
+        users: db.collection('users'),
+        organizations: db.collection('organizations'),
+    };
+    authService = new AuthService(db);
+}
+async function createIndexes(db) {
+    await db.command({
+        createIndexes: "users", indexes: [{ key: { email: 1 }, name: 'email_index', unique: true, collation: { locale: 'en', strength: 1 } }]
+    });
+}
+async function setupTestUser() {
+    try {
+        const result = await deleteTestUser();
+        return createTestUser();
+    }
+    catch (error) {
+        console.log(error);
+        throw error;
+    }
+}
+async function createTestUser() {
+    if (!db || !collections.users) {
+        throw new Error('Database not initialized. Call initialize() first.');
+    }
+    try {
+        const hashedAndSaltedTestUserPassword = await passwordUtils.hashPassword(testUserPassword);
+        const existingOrg = await collections.organizations.findOne({ _id: testOrgId });
+        if (!existingOrg) {
+            const orgInsertResult = await collections.organizations.insertOne({
+                _id: new ObjectId(testOrgId),
+                name: testOrgName,
+                _created: new Date(),
+                _createdBy: 'system',
+                _updated: new Date(),
+                _updatedBy: 'system'
+            });
+        }
+        const localTestUser = {
+            _id: testUserId,
+            email: testUserEmail,
+            password: hashedAndSaltedTestUserPassword,
+            _orgId: testOrgId,
+            _created: new Date(),
+            _createdBy: 'system',
+            _updated: new Date(),
+            _updatedBy: 'system'
+        };
+        const insertResult = await collections.users.insertOne(localTestUser);
+        delete localTestUser['password'];
+        testUser = localTestUser;
+        return localTestUser;
+    }
+    catch (error) {
+        console.log('Error in createTestUser:', error);
+        throw error;
+    }
+}
+function deleteTestUser() {
+    let promise = Promise.resolve(null);
+    if (testUser) {
+        promise = collections.users.deleteOne({ _id: testUser._id });
+    }
+    return promise;
+}
+async function simulateloginWithTestUser() {
+    const req = {
+        cookies: {}
+    };
+    if (deviceIdCookie) {
+        req.cookies['deviceId'] = deviceIdCookie;
+    }
+    const res = {
+        cookie: function (name, value) {
+            if (name === 'deviceId') {
+                deviceIdCookie = value;
+            }
+            return res;
+        }
+    };
+    const loginResponse = await authService.attemptLogin(req, res, testUserEmail, testUserPassword);
+    if (!loginResponse?.tokens?.accessToken) {
+        throw new Error('Failed to login with test user');
+    }
+    return `Bearer ${loginResponse.tokens.accessToken}`;
+}
+function getAuthToken() {
+    const payload = {
+        user: {
+            _id: new ObjectId(testUserId),
+            email: testUserEmail
+        },
+        _orgId: testOrgId
+    };
+    const token = JwtService.sign(payload, JWT_SECRET, { expiresIn: 3600 });
+    return `Bearer ${token}`;
+}
+function verifyToken(token) {
+    return JwtService.verify(token, JWT_SECRET);
+}
+function getTestUser() {
+    return testUser;
+}
+function configureJwtSecret() {
+    const originalJwtVerify = jwt.verify;
+    jwt.verify = function (token, secret, options) {
+        return originalJwtVerify(token, JWT_SECRET, options);
+    };
+}
+async function loginWithTestUser(agent) {
+    agent.set('Cookie', [`deviceId=${deviceIdCookie}`]);
+    const response = await agent
+        .post('/api/auth/login')
+        .send({
+        email: testUserEmail,
+        password: testUserPassword,
+    });
+    if (!response.body?.data?.tokens?.accessToken) {
+        console.error('Login failed:', response.body);
+        throw new Error('Failed to login with test user');
+    }
+    const authorizationHeaderValue = `Bearer ${response.body?.data?.tokens?.accessToken}`;
+    return authorizationHeaderValue;
+}
+const testUtils = {
+    configureJwtSecret,
+    constDeviceIdCookie,
+    createIndexes,
+    deleteTestUser,
+    getAuthToken,
+    getTestUser,
+    initialize,
+    loginWithTestUser,
+    newUser1Email,
+    newUser1Password,
+    setupTestUser,
+    simulateloginWithTestUser,
+    testUserContext,
+    testUserId,
+    testUserEmail,
+    testUserEmailCaseInsensitive,
+    testUserPassword,
+    testOrgId,
+    testOrgName,
+    verifyToken
+};
+export default testUtils;

package/dist/__tests__/test-express-app.d.ts

@@ -0,0 +1,16 @@
+import { Application } from 'express';
+import { Db } from 'mongodb';
+export declare class TestExpressApp {
+    private static app;
+    private static mongoServer;
+    private static client;
+    private static db;
+    static init(): Promise<{
+        app: Application;
+        db: Db;
+        agent: any;
+    }>;
+    static setupErrorHandling(): Promise<void>;
+    static cleanup(): Promise<void>;
+    static clearCollections(): Promise<void>;
+}

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

@@ -0,0 +1,83 @@
+import express from 'express';
+import bodyParser from 'body-parser';
+import cookieParser from 'cookie-parser';
+import supertest from 'supertest';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { initializeTypeBox } from '@loomcore/common/validation';
+import testUtils from './common-test.utils.js';
+import { setApiCommonConfig } from '../config/api-common-config.js';
+import { errorHandler } from '../middleware/error-handler.js';
+import { ensureUserContext } from '../middleware/ensure-user-context.js';
+export class TestExpressApp {
+    static app;
+    static mongoServer;
+    static client;
+    static db;
+    static async init() {
+        setApiCommonConfig({
+            env: 'test',
+            hostName: 'localhost',
+            appName: 'test-app',
+            clientSecret: 'test-secret',
+            debug: {
+                showErrors: false
+            },
+            app: { multiTenant: true },
+            auth: {
+                jwtExpirationInSeconds: 3600,
+                refreshTokenExpirationInDays: 7,
+                deviceIdCookieMaxAgeInDays: 730,
+                passwordResetTokenExpirationInMinutes: 20
+            },
+            email: {
+                sendGridApiKey: 'SG.WeDontHaveAKeyYet',
+                fromAddress: undefined
+            }
+        });
+        initializeTypeBox();
+        if (!this.db) {
+            this.mongoServer = await MongoMemoryServer.create();
+            const uri = this.mongoServer.getUri();
+            this.client = await MongoClient.connect(uri);
+            this.db = this.client.db();
+            testUtils.initialize(this.db);
+            await testUtils.createIndexes(this.db);
+        }
+        if (!this.app) {
+            this.app = express();
+            this.app.use(bodyParser.json());
+            this.app.use(cookieParser());
+            this.app.use(ensureUserContext);
+            this.app.use((req, res, next) => {
+                next();
+            });
+        }
+        const agent = supertest.agent(this.app);
+        return {
+            app: this.app,
+            db: this.db,
+            agent
+        };
+    }
+    static async setupErrorHandling() {
+        this.app.use(errorHandler);
+    }
+    static async cleanup() {
+        if (this.client) {
+            await this.client.close();
+        }
+        if (this.mongoServer) {
+            await this.mongoServer.stop();
+        }
+    }
+    static async clearCollections() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const collections = await this.db.collections();
+        for (const collection of collections) {
+            await collection.deleteMany({});
+        }
+    }
+}

package/dist/config/api-common-config.d.ts

@@ -0,0 +1,3 @@
+import { IApiCommonConfig } from '../models/index.js';
+export declare let config: IApiCommonConfig;
+export declare function setApiCommonConfig(apiCommonConfig: IApiCommonConfig): void;

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

@@ -0,0 +1,11 @@
+export let config;
+let isConfigSet = false;
+export function setApiCommonConfig(apiCommonConfig) {
+    if (!isConfigSet) {
+        config = apiCommonConfig;
+        isConfigSet = true;
+    }
+    else if (config.env !== 'test') {
+        console.warn('ApiCommonConfig data has already been set. Ignoring subsequent calls to setApiCommonConfig.');
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export * from './api-common-config.js';

package/dist/config/index.js

@@ -0,0 +1 @@
+export * from './api-common-config.js';

package/dist/controllers/api-controller.utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controllers/api-controller.utils.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import { Application, NextFunction, Request, Response } from 'express';
+import { TSchema } from '@sinclair/typebox';
+import { IEntity, IModelSpec } from '@loomcore/common/models';
+import { IGenericApiService } from '../services/index.js';
+export declare abstract class ApiController<T extends IEntity> {
+    protected app: Application;
+    protected service: IGenericApiService<T>;
+    protected slug: string;
+    protected apiResourceName: string;
+    protected modelSpec?: IModelSpec;
+    protected publicSchema?: TSchema;
+    protected constructor(slug: string, app: Application, service: IGenericApiService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSchema?: TSchema);
+    mapRoutes(app: Application): void;
+    getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
+    get(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getById(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getCount(req: Request, res: Response, next: NextFunction): Promise<void>;
+    create(req: Request, res: Response, next: NextFunction): Promise<void>;
+    fullUpdateById(req: Request, res: Response, next: NextFunction): Promise<void>;
+    partialUpdateById(req: Request, res: Response, next: NextFunction): Promise<void>;
+    deleteById(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/controllers/api.controller.js

@@ -0,0 +1,71 @@
+import { isAuthenticated } from '../middleware/index.js';
+import { apiUtils } from '../utils/index.js';
+export class ApiController {
+    app;
+    service;
+    slug;
+    apiResourceName;
+    modelSpec;
+    publicSchema;
+    constructor(slug, app, service, resourceName = '', modelSpec, publicSchema) {
+        this.slug = slug;
+        this.app = app;
+        this.service = service;
+        this.apiResourceName = resourceName;
+        this.modelSpec = modelSpec;
+        this.publicSchema = publicSchema;
+        this.mapRoutes(app);
+    }
+    mapRoutes(app) {
+        app.get(`/api/${this.slug}`, isAuthenticated, this.get.bind(this));
+        app.get(`/api/${this.slug}/all`, isAuthenticated, this.getAll.bind(this));
+        app.get(`/api/${this.slug}/count`, isAuthenticated, this.getCount.bind(this));
+        app.get(`/api/${this.slug}/:id`, isAuthenticated, this.getById.bind(this));
+        app.post(`/api/${this.slug}`, isAuthenticated, this.create.bind(this));
+        app.put(`/api/${this.slug}/:id`, isAuthenticated, this.fullUpdateById.bind(this));
+        app.patch(`/api/${this.slug}/:id`, isAuthenticated, this.partialUpdateById.bind(this));
+        app.delete(`/api/${this.slug}/:id`, isAuthenticated, this.deleteById.bind(this));
+    }
+    async getAll(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const entities = await this.service.getAll(req.userContext);
+        apiUtils.apiResponse(res, 200, { data: entities }, this.modelSpec, this.publicSchema);
+    }
+    async get(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const queryOptions = apiUtils.getQueryOptionsFromRequest(req);
+        const pagedResult = await this.service.get(req.userContext, queryOptions);
+        apiUtils.apiResponse(res, 200, { data: pagedResult }, this.modelSpec, this.publicSchema);
+    }
+    async getById(req, res, next) {
+        let id = req.params?.id;
+        res.set('Content-Type', 'application/json');
+        const entity = await this.service.getById(req.userContext, id);
+        apiUtils.apiResponse(res, 200, { data: entity }, this.modelSpec, this.publicSchema);
+    }
+    async getCount(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const count = await this.service.getCount(req.userContext);
+        apiUtils.apiResponse(res, 200, { data: count }, this.modelSpec, this.publicSchema);
+    }
+    async create(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const entity = await this.service.create(req.userContext, req.body);
+        apiUtils.apiResponse(res, 201, { data: entity || undefined }, this.modelSpec, this.publicSchema);
+    }
+    async fullUpdateById(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, req.body);
+        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
+    }
+    async partialUpdateById(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, req.body);
+        apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
+    }
+    async deleteById(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const deleteResult = await this.service.deleteById(req.userContext, req.params.id);
+        apiUtils.apiResponse(res, 200, { data: deleteResult }, this.modelSpec, this.publicSchema);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Application, Request, Response, NextFunction } from 'express';
+import { Db } from 'mongodb';
+import { AuthService } from '../services/index.js';
+export declare class AuthController {
+    authService: AuthService;
+    constructor(app: Application, db: Db);
+    mapRoutes(app: Application): void;
+    login(req: Request, res: Response, next: NextFunction): 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;
+    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

@@ -0,0 +1,73 @@
+import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec } from '@loomcore/common/models';
+import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
+import { isAuthenticated } from '../middleware/index.js';
+import { apiUtils } from '../utils/index.js';
+import { AuthService } from '../services/index.js';
+export class AuthController {
+    authService;
+    constructor(app, db) {
+        const authService = new AuthService(db);
+        this.authService = authService;
+        this.mapRoutes(app);
+    }
+    mapRoutes(app) {
+        app.post(`/api/auth/login`, this.login.bind(this), this.afterAuth.bind(this));
+        app.post(`/api/auth/register`, this.registerUser.bind(this));
+        app.get(`/api/auth/refresh`, this.requestTokenUsingRefreshToken.bind(this));
+        app.get(`/api/auth/get-user-context`, isAuthenticated, this.getUserContext.bind(this));
+        app.patch(`/api/auth/change-password`, isAuthenticated, this.changePassword.bind(this));
+        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;
+        res.set('Content-Type', 'application/json');
+        const loginResponse = await this.authService.attemptLogin(req, res, email, password);
+        apiUtils.apiResponse(res, 200, { data: loginResponse }, LoginResponseSpec);
+    }
+    async registerUser(req, res) {
+        const userContext = req.userContext;
+        const body = req.body;
+        const user = await this.authService.createUser(userContext, body);
+        apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
+    }
+    async requestTokenUsingRefreshToken(req, res, next) {
+        let tokens = await this.authService.requestTokenUsingRefreshToken(req);
+        if (tokens) {
+            apiUtils.apiResponse(res, 200, { data: tokens }, TokenResponseSpec);
+        }
+        else {
+            throw new UnauthenticatedError();
+        }
+    }
+    async getUserContext(req, res, next) {
+        const userContext = req.userContext;
+        const clientUserContext = { user: userContext.user };
+        apiUtils.apiResponse(res, 200, { data: clientUserContext }, UserContextSpec);
+    }
+    afterAuth(req, res, loginResponse) {
+        console.log('in afterAuth');
+    }
+    async changePassword(req, res) {
+        const userContext = req.userContext;
+        const body = req.body;
+        const updateResult = await this.authService.changeLoggedInUsersPassword(userContext, body);
+        apiUtils.apiResponse(res, 200, { data: updateResult });
+    }
+    async forgotPassword(req, res) {
+        const email = req.body?.email;
+        const user = await this.authService.getUserByEmail(email);
+        if (user) {
+            await this.authService.sendResetPasswordEmail(email);
+        }
+        apiUtils.apiResponse(res, 200);
+    }
+    async resetPassword(req, res) {
+        const { email, token, password } = 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);
+        apiUtils.apiResponse(res, 200, { data: response });
+    }
+}

package/dist/controllers/index.d.ts

@@ -0,0 +1 @@
+export * from './api.controller.js';

package/dist/controllers/index.js

@@ -0,0 +1 @@
+export * from './api.controller.js';

package/dist/errors/bad-request.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class BadRequestError extends CustomError {
+    statusCode: number;
+    constructor(message: string);
+    serializeErrors(): {
+        message: string;
+        field?: string | undefined;
+    }[];
+}

package/dist/errors/bad-request.error.js

@@ -0,0 +1,12 @@
+import { CustomError } from '@loomcore/common/errors';
+export class BadRequestError extends CustomError {
+    statusCode = 400;
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+        Error.captureStackTrace(this, BadRequestError);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}

package/dist/errors/database-connection.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class DatabaseConnectionError extends CustomError {
+    statusCode: number;
+    reason: string;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/dist/errors/database-connection.error.js

@@ -0,0 +1,12 @@
+import { CustomError } from '@loomcore/common/errors';
+export class DatabaseConnectionError extends CustomError {
+    statusCode = 500;
+    reason = 'Error connecting to database';
+    constructor() {
+        super('Error connecting to database');
+        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.reason }];
+    }
+}

package/dist/errors/duplicate-key.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class DuplicateKeyError extends CustomError {
+    statusCode: number;
+    constructor(message: string);
+    serializeErrors(): {
+        message: string;
+        field?: string | undefined;
+    }[];
+}

package/dist/errors/duplicate-key.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '@loomcore/common/errors';
+export class DuplicateKeyError extends CustomError {
+    statusCode = 400;
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, DuplicateKeyError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}

package/dist/errors/id-not-found.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class IdNotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+        field?: string | undefined;
+    }[];
+}

package/dist/errors/id-not-found.error.js

@@ -0,0 +1,11 @@
+import { CustomError } from '@loomcore/common/errors';
+export class IdNotFoundError extends CustomError {
+    statusCode = 404;
+    constructor() {
+        super('Id not found');
+        Object.setPrototypeOf(this, IdNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: 'Id not found' }];
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,8 @@
+export * from './bad-request.error.js';
+export * from './database-connection.error.js';
+export * from './duplicate-key.error.js';
+export * from './id-not-found.error.js';
+export * from './not-found.error.js';
+export * from './server.error.js';
+export * from './unauthenticated.error.js';
+export * from './unauthorized.error.js';

package/dist/errors/index.js

@@ -0,0 +1,8 @@
+export * from './bad-request.error.js';
+export * from './database-connection.error.js';
+export * from './duplicate-key.error.js';
+export * from './id-not-found.error.js';
+export * from './not-found.error.js';
+export * from './server.error.js';
+export * from './unauthenticated.error.js';
+export * from './unauthorized.error.js';

package/dist/errors/not-found.error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@loomcore/common/errors';
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor(message?: string);
+    serializeErrors(): {
+        message: string;
+        field?: string | undefined;
+    }[];
+}