@loomcore/api 0.0.5 → 0.0.7

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

@@ -1,8 +1,17 @@
-import { Db } from 'mongodb';
+import { Db, ObjectId } 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 setupTestUser(): Promise<{
+    _id: ObjectId;
+    email: string;
+    password: string;
+    _orgId: string;
+    _created: Date;
+    _createdBy: string;
+    _updated: Date;
+    _updatedBy: string;
+}>;
 declare function deleteTestUser(): Promise<null>;
 declare function simulateloginWithTestUser(): Promise<string>;
 declare function getAuthToken(): string;

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

@@ -71,7 +71,7 @@ async function createTestUser() {
             });
         }
         const localTestUser = {
-            _id: testUserId,
+            _id: new ObjectId(testUserId),
             email: testUserEmail,
             password: hashedAndSaltedTestUserPassword,
             _orgId: testOrgId,
@@ -82,7 +82,7 @@ async function createTestUser() {
         };
         const insertResult = await collections.users.insertOne(localTestUser);
         delete localTestUser['password'];
-        testUser = localTestUser;
+        testUser = { ...localTestUser, _id: localTestUser._id.toString() };
         return localTestUser;
     }
     catch (error) {

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

@@ -1,3 +1,3 @@
 import { IBaseApiConfig } from '../models/index.js';
 export declare let config: IBaseApiConfig;
-export declare function setBaseApiConfig(baseApiConfig: IBaseApiConfig): void;
+export declare function setBaseApiConfig(apiConfig: IBaseApiConfig): void;

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

@@ -7,9 +7,9 @@ function copyOnlyBaseApiConfigProperties(obj) {
     });
     return baseConfig;
 }
-export function setBaseApiConfig(baseApiConfig) {
+export function setBaseApiConfig(apiConfig) {
     if (!isConfigSet) {
-        config = copyOnlyBaseApiConfigProperties(baseApiConfig);
+        config = copyOnlyBaseApiConfigProperties(apiConfig);
         isConfigSet = true;
     }
     else if (config.env !== 'test') {

package/dist/controllers/index.d.ts

@@ -1,2 +1,4 @@
 export * from './api.controller.js';
 export * from './auth.controller.js';
+export * from './organizations.controller.js';
+export * from './users.controller.js';

package/dist/controllers/index.js

@@ -1,2 +1,4 @@
 export * from './api.controller.js';
 export * from './auth.controller.js';
+export * from './organizations.controller.js';
+export * from './users.controller.js';

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

@@ -0,0 +1,12 @@
+import { Application, NextFunction, Request, Response } from 'express';
+import { Db } from 'mongodb';
+import { IOrganization } from '@loomcore/common/models';
+import { ApiController } from './api.controller.js';
+import { OrganizationService } from '../services/index.js';
+export declare class OrganizationsController extends ApiController<IOrganization> {
+    orgService: OrganizationService;
+    constructor(app: Application, db: Db);
+    mapRoutes(app: Application): void;
+    getByName(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getByCode(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/controllers/organizations.controller.js

@@ -0,0 +1,47 @@
+import { ApiController } from './api.controller.js';
+import { isAuthenticated } from '../middleware/index.js';
+import { apiUtils } from '../utils/index.js';
+import { BadRequestError } from '../errors/index.js';
+import { OrganizationService } from '../services/index.js';
+export class OrganizationsController extends ApiController {
+    orgService;
+    constructor(app, db) {
+        const orgService = new OrganizationService(db);
+        super('organizations', app, orgService);
+        this.orgService = orgService;
+    }
+    mapRoutes(app) {
+        super.mapRoutes(app);
+        app.get(`/api/${this.slug}/get-by-name/:name`, isAuthenticated, this.getByName.bind(this));
+        app.get(`/api/${this.slug}/get-by-code/:code`, isAuthenticated, this.getByCode.bind(this));
+    }
+    async getByName(req, res, next) {
+        console.log('in OrganizationController.getByName');
+        let name = req.params?.name;
+        try {
+            res.set('Content-Type', 'application/json');
+            const entity = await this.orgService.findOne(req.userContext, { name: { $regex: new RegExp(`^${name}$`, 'i') } });
+            if (!entity)
+                throw new BadRequestError('Name not found');
+            apiUtils.apiResponse(res, 200, { data: entity });
+        }
+        catch (err) {
+            next(err);
+            return;
+        }
+    }
+    async getByCode(req, res, next) {
+        let code = req.params?.code;
+        try {
+            res.set('Content-Type', 'application/json');
+            const entity = await this.orgService.findOne(req.userContext, { code: code });
+            if (!entity)
+                throw new BadRequestError('Code not found');
+            apiUtils.apiResponse(res, 200, { data: entity });
+        }
+        catch (err) {
+            next(err);
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Db } from 'mongodb';
+import { Application } from 'express';
+import { IUser } from '@loomcore/common/models';
+import { ApiController } from './api.controller.js';
+export declare class UsersController extends ApiController<IUser> {
+    private userService;
+    constructor(app: Application, db: Db);
+    mapRoutes(app: Application): void;
+}

package/dist/controllers/users.controller.js

@@ -0,0 +1,22 @@
+import { UserSpec, PublicUserSchema } from '@loomcore/common/models';
+import { ApiController } from './api.controller.js';
+import { isAuthenticated } from '../middleware/index.js';
+import { UserService } from '../services/index.js';
+export class UsersController extends ApiController {
+    userService;
+    constructor(app, db) {
+        const userService = new UserService(db);
+        super('users', app, userService, 'user', UserSpec, PublicUserSchema);
+        this.userService = userService;
+    }
+    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}/find`, isAuthenticated, this.get.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.patch(`/api/${this.slug}/:id`, isAuthenticated, this.partialUpdateById.bind(this));
+        app.delete(`/api/${this.slug}/:id`, isAuthenticated, this.deleteById.bind(this));
+    }
+}

package/dist/services/index.d.ts

@@ -4,5 +4,7 @@ export * from './generic-api.service.js';
 export * from './generic-api-service.interface.js';
 export * from './jwt.service.js';
 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';

package/dist/services/index.js

@@ -4,5 +4,7 @@ export * from './generic-api.service.js';
 export * from './generic-api-service.interface.js';
 export * from './jwt.service.js';
 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';

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

@@ -0,0 +1,8 @@
+import { Db } from 'mongodb';
+import { GenericApiService } from './generic-api.service.js';
+import { IOrganization, IUserContext } from '@loomcore/common/models';
+export declare class OrganizationService extends GenericApiService<IOrganization> {
+    constructor(db: Db);
+    getAuthTokenByRepoCode(userContext: IUserContext, orgId: string): Promise<string | null | undefined>;
+    validateRepoAuthToken(userContext: IUserContext, orgCode: string, authToken: string): Promise<string | null>;
+}

package/dist/services/organization.service.js

@@ -0,0 +1,16 @@
+import { GenericApiService } from './generic-api.service.js';
+import { OrganizationSpec } from '@loomcore/common/models';
+export class OrganizationService extends GenericApiService {
+    constructor(db) {
+        super(db, 'organizations', 'organization', OrganizationSpec);
+    }
+    async getAuthTokenByRepoCode(userContext, orgId) {
+        const org = await this.getById(userContext, orgId);
+        return org ? org.authToken : null;
+    }
+    async validateRepoAuthToken(userContext, orgCode, authToken) {
+        const org = await this.findOne(userContext, { code: orgCode });
+        const orgId = org.authToken === authToken ? org._id.toString() : null;
+        return orgId;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Db } from 'mongodb';
+import { IUser, IUserContext } from '@loomcore/common/models';
+import { MultiTenantApiService } from '../services/index.js';
+export declare class UserService extends MultiTenantApiService<IUser> {
+    constructor(db: Db);
+    fullUpdateById(userContext: IUserContext, id: string, entity: IUser): Promise<any>;
+    protected prepareEntity(userContext: IUserContext, entity: IUser, isCreate: boolean): Promise<IUser | Partial<IUser>>;
+    transformList(users: IUser[]): IUser[];
+    transformSingle(user: IUser): IUser;
+}

package/dist/services/user.service.js

@@ -0,0 +1,25 @@
+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(db) {
+        super(db, '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 prepareEntity(userContext, entity, isCreate) {
+        const preparedEntity = await super.prepareEntity(userContext, entity, isCreate);
+        if (!isCreate) {
+            return Value.Clean(PublicUserSchema, preparedEntity);
+        }
+        return preparedEntity;
+    }
+    transformList(users) {
+        return super.transformList(users);
+    }
+    transformSingle(user) {
+        return super.transformSingle(user);
+    }
+}

package/dist/utils/express.utils.d.ts

@@ -0,0 +1,12 @@
+import { Application } from 'express';
+import { Db, MongoClient } from "mongodb";
+import { Server } from "http";
+import { IBaseApiConfig } from "../models/index.js";
+type RouteSetupFunction = (app: Application, db: Db, config: IBaseApiConfig) => void;
+declare function setupExpressApp(db: Db, config: IBaseApiConfig, setupRoutes: RouteSetupFunction): Application;
+declare function performGracefulShutdown(event: any, mongoClient: MongoClient | null, externalServer: Server | null, internalServer: Server | null): void;
+export declare const expressUtils: {
+    setupExpressApp: typeof setupExpressApp;
+    performGracefulShutdown: typeof performGracefulShutdown;
+};
+export {};

package/dist/utils/express.utils.js

@@ -0,0 +1,96 @@
+import express from 'express';
+import cookieParser from "cookie-parser";
+import bodyParser from "body-parser";
+import cors from "cors";
+import { NotFoundError } from "../errors/not-found.error.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { ensureUserContext } from '../middleware/ensure-user-context.js';
+function setupExpressApp(db, config, setupRoutes) {
+    const app = express();
+    app.use((req, res, next) => {
+        if (req.path !== '/api/health' && process.env.NODE_ENV !== 'test') {
+            console.log(`[${new Date().toLocaleString('en-US', { timeZone: 'America/Chicago' })}] INCOMING REQUEST: ${req.method} ${req.path}`);
+        }
+        next();
+    });
+    app.use(bodyParser.json());
+    app.use(cookieParser());
+    app.use(cors({
+        origin: config.corsAllowedOrigins,
+        credentials: true
+    }));
+    app.use(ensureUserContext);
+    setupRoutes(app, db, config);
+    app.all('*', async (req, res) => {
+        throw new NotFoundError(`Requested path, ${req.path}, Not Found`);
+    });
+    app.use(errorHandler);
+    return app;
+}
+function performGracefulShutdown(event, mongoClient, externalServer, internalServer) {
+    const closeMongoConnection = async () => {
+        if (mongoClient) {
+            console.log('closing mongodb connection');
+            try {
+                await mongoClient.close();
+                console.log('MongoDB connection closed successfully');
+            }
+            catch (err) {
+                console.error('Error closing MongoDB connection:', err);
+            }
+        }
+    };
+    const shutdownServers = new Promise((resolve) => {
+        let serversClosedCount = 0;
+        const totalServers = (externalServer ? 1 : 0) + (internalServer ? 1 : 0);
+        const onServerClosed = () => {
+            serversClosedCount++;
+            if (serversClosedCount >= totalServers) {
+                resolve();
+            }
+        };
+        if (totalServers === 0) {
+            resolve();
+            return;
+        }
+        if (externalServer) {
+            console.log('Closing external HTTP server...');
+            externalServer.close((err) => {
+                if (err)
+                    console.error('Error closing external server:', err);
+                console.log('External HTTP server closed');
+                onServerClosed();
+            });
+        }
+        if (internalServer) {
+            console.log('Closing internal HTTP server...');
+            internalServer.close((err) => {
+                if (err)
+                    console.error('Error closing internal server:', err);
+                console.log('Internal HTTP server closed');
+                onServerClosed();
+            });
+        }
+        setTimeout(() => {
+            console.log('Server shutdown timeout reached, proceeding with MongoDB cleanup');
+            resolve();
+        }, 5000);
+    });
+    Promise.race([
+        shutdownServers.then(() => closeMongoConnection()),
+        new Promise(resolve => {
+            setTimeout(async () => {
+                console.log('Ensuring MongoDB connection is closed before exit');
+                await closeMongoConnection();
+                resolve();
+            }, 6000);
+        })
+    ]).then(() => {
+        console.log('Cleanup complete, exiting process');
+        process.exit(0);
+    });
+}
+export const expressUtils = {
+    setupExpressApp,
+    performGracefulShutdown,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -47,6 +47,7 @@
     "@loomcore/common": "^0.0.7",
     "@sinclair/typebox": "^0.34.31",
     "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
     "express": "^5.1.0",
     "lodash": "^4.17.21",
     "moment": "^2.30.1",
@@ -54,6 +55,7 @@
   },
   "devDependencies": {
     "@types/cookie-parser": "^1.4.7",
+    "@types/cors": "^2.8.18",
     "@types/express": "^5.0.1",
     "@types/jsonwebtoken": "^9.0.9",
     "@types/lodash": "^4.17.13",