@loomcore/api 0.0.20 → 0.0.22

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

@@ -2,6 +2,8 @@ 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 createMetaOrg(): Promise<void>;
+declare function deleteMetaOrg(): Promise<void>;
 declare function setupTestUser(): Promise<{
     _id: ObjectId;
     email: string;
@@ -12,17 +14,21 @@ declare function setupTestUser(): Promise<{
     _updated: Date;
     _updatedBy: string;
 }>;
-declare function deleteTestUser(): Promise<null>;
+declare function deleteTestUser(): Promise<any[]>;
 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 function cleanup(): Promise<void>;
 declare const testUtils: {
+    cleanup: typeof cleanup;
     configureJwtSecret: typeof configureJwtSecret;
     constDeviceIdCookie: string;
     createIndexes: typeof createIndexes;
+    createMetaOrg: typeof createMetaOrg;
+    deleteMetaOrg: typeof deleteMetaOrg;
     deleteTestUser: typeof deleteTestUser;
     getAuthToken: typeof getAuthToken;
     getTestUser: typeof getTestUser;

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

@@ -43,9 +43,43 @@ async function createIndexes(db) {
         createIndexes: "users", indexes: [{ key: { email: 1 }, name: 'email_index', unique: true, collation: { locale: 'en', strength: 1 } }]
     });
 }
+async function createMetaOrg() {
+    if (!db || !collections.organizations) {
+        throw new Error('Database not initialized. Call initialize() first.');
+    }
+    try {
+        const existingMetaOrg = await collections.organizations.findOne({ isMetaOrg: true });
+        if (!existingMetaOrg) {
+            const metaOrgInsertResult = await collections.organizations.insertOne({
+                _id: new ObjectId(),
+                name: 'Meta Organization',
+                isMetaOrg: true,
+                _created: new Date(),
+                _createdBy: 'system',
+                _updated: new Date(),
+                _updatedBy: 'system'
+            });
+        }
+    }
+    catch (error) {
+        console.log('Error in createMetaOrg:', error);
+        throw error;
+    }
+}
+async function deleteMetaOrg() {
+    if (!collections.organizations) {
+        return Promise.resolve();
+    }
+    try {
+        await collections.organizations.deleteOne({ isMetaOrg: true });
+    }
+    catch (error) {
+        console.log('Error deleting meta org:', error);
+    }
+}
 async function setupTestUser() {
     try {
-        const result = await deleteTestUser();
+        await deleteTestUser();
         return createTestUser();
     }
     catch (error) {
@@ -91,11 +125,14 @@ async function createTestUser() {
     }
 }
 function deleteTestUser() {
-    let promise = Promise.resolve(null);
+    let promises = [];
     if (testUser) {
-        promise = collections.users.deleteOne({ _id: testUser._id });
+        promises.push(collections.users.deleteOne({ _id: testUser._id }));
     }
-    return promise;
+    if (collections.organizations) {
+        promises.push(collections.organizations.deleteOne({ _id: new ObjectId(testOrgId) }));
+    }
+    return Promise.all(promises);
 }
 async function simulateloginWithTestUser() {
     const req = {
@@ -156,10 +193,22 @@ async function loginWithTestUser(agent) {
     const authorizationHeaderValue = `Bearer ${response.body?.data?.tokens?.accessToken}`;
     return authorizationHeaderValue;
 }
+async function cleanup() {
+    try {
+        await deleteTestUser();
+        await deleteMetaOrg();
+    }
+    catch (error) {
+        console.log('Error during cleanup:', error);
+    }
+}
 const testUtils = {
+    cleanup,
     configureJwtSecret,
     constDeviceIdCookie,
     createIndexes,
+    createMetaOrg,
+    deleteMetaOrg,
     deleteTestUser,
     getAuthToken,
     getTestUser,

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

@@ -6,7 +6,7 @@ import { MongoMemoryServer } from 'mongodb-memory-server';
 import { MongoClient } from 'mongodb';
 import { initializeTypeBox } from '@loomcore/common/validation';
 import testUtils from './common-test.utils.js';
-import { setBaseApiConfig } from '../config/base-api-config.js';
+import { setBaseApiConfig, initSystemUserContext } from '../config/base-api-config.js';
 import { errorHandler } from '../middleware/error-handler.js';
 import { ensureUserContext } from '../middleware/ensure-user-context.js';
 export class TestExpressApp {
@@ -66,7 +66,9 @@ export class TestExpressApp {
             this.db = this.client.db();
             testUtils.initialize(this.db);
             await testUtils.createIndexes(this.db);
+            await testUtils.createMetaOrg();
         }
+        await initSystemUserContext(this.db);
         if (!this.app) {
             this.app = express();
             this.app.use(bodyParser.json());
@@ -87,6 +89,7 @@ export class TestExpressApp {
         this.app.use(errorHandler);
     }
     static async cleanup() {
+        await testUtils.cleanup();
         if (this.client) {
             await this.client.close();
         }

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

@@ -1,3 +1,5 @@
+import { Db } from 'mongodb';
 import { IBaseApiConfig } from '../models/index.js';
 export declare let config: IBaseApiConfig;
 export declare function setBaseApiConfig(apiConfig: IBaseApiConfig): void;
+export declare function initSystemUserContext(db: Db): Promise<void>;

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

@@ -1,5 +1,7 @@
+import { EmptyUserContext, initializeSystemUserContext } from '@loomcore/common/models';
 export let config;
 let isConfigSet = false;
+let isSystemUserContextSet = false;
 function copyOnlyBaseApiConfigProperties(obj) {
     const baseConfig = {};
     Object.keys(obj).forEach((key) => {
@@ -16,3 +18,23 @@ export function setBaseApiConfig(apiConfig) {
         console.warn('BaseApiConfig data has already been set. Ignoring subsequent calls to setBaseApiConfig.');
     }
 }
+export async function initSystemUserContext(db) {
+    if (!isConfigSet) {
+        throw new Error('BaseApiConfig has not been set. Call setBaseApiConfig first.');
+    }
+    if (!isSystemUserContextSet) {
+        const systemEmail = config.email.systemEmailAddress || 'system@example.com';
+        let metaOrgId = undefined;
+        if (config.app.isMultiTenant) {
+            const { OrganizationService } = await import('../services/organization.service.js');
+            const organizationService = new OrganizationService(db);
+            const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
+            metaOrgId = metaOrg._id;
+        }
+        initializeSystemUserContext(systemEmail, metaOrgId);
+        isSystemUserContextSet = true;
+    }
+    else if (config.env !== 'test') {
+        console.warn('SystemUserContext has already been set. Ignoring subsequent calls to initSystemUserContext.');
+    }
+}

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

@@ -26,5 +26,6 @@ export interface IBaseApiConfig {
     email: {
         sendGridApiKey?: string;
         fromAddress?: string;
+        systemEmailAddress?: string;
     };
 }

package/dist/services/auth.service.js

@@ -1,7 +1,7 @@
 import { ObjectId } from 'mongodb';
 import moment from 'moment';
 import crypto from 'crypto';
-import { EmptyUserContext, passwordValidator, UserSpec } from '@loomcore/common/models';
+import { EmptyUserContext, passwordValidator, UserSpec, getSystemUserContext } from '@loomcore/common/models';
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, ServerError } from '../errors/index.js';
 import { JwtService, EmailService } from './index.js';
@@ -49,7 +49,7 @@ export class AuthService extends GenericApiService {
                 refreshToken: refreshTokenObject.token,
                 expiresOn: accessTokenExpiresOn
             };
-            this.updateLastLoggedIn(userContext.user._id.toString())
+            this.updateLastLoggedIn(userContext.user._id)
                 .catch(err => console.log(`Error updating lastLoggedIn: ${err}`));
             this.transformSingle(userContext.user);
             loginResponse = { tokens: tokenResponse, userContext };
@@ -266,8 +266,9 @@ export class AuthService extends GenericApiService {
             if (!entityUtils.isValidObjectId(userId)) {
                 throw new BadRequestError('userId is not a valid ObjectId');
             }
-            const updates = { _lastLoggedIn: moment().utc().toDate() };
-            await this.partialUpdateById(EmptyUserContext, userId, updates);
+            const updates = { _lastLoggedIn: moment().utc().toISOString() };
+            const systemUserContext = getSystemUserContext();
+            await this.partialUpdateById(systemUserContext, userId, updates);
         }
         catch (error) {
             console.log(`Failed to update lastLoggedIn for user ${userId}: ${error}`);

package/dist/services/generic-api-service.interface.d.ts

@@ -1,6 +1,9 @@
 import { DeleteResult, Document, FindOptions } from 'mongodb';
+import { ValueError } from '@sinclair/typebox/errors';
 import { IUserContext, IEntity, IPagedResult, QueryOptions } from '@loomcore/common/models';
 export interface IGenericApiService<T extends IEntity> {
+    validate(doc: any, isPartial?: boolean): ValueError[] | null;
+    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
     getAll(userContext: IUserContext): Promise<T[]>;
     get(userContext: IUserContext, queryOptions: QueryOptions): Promise<IPagedResult<T>>;
     getById(userContext: IUserContext, id: string): Promise<T>;

package/dist/services/generic-api.service.d.ts

@@ -10,6 +10,7 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     protected modelSpec?: IModelSpec;
     constructor(db: Db, pluralResourceName: string, singularResourceName: string, modelSpec?: IModelSpec);
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
+    validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
     protected getAdditionalPipelineStages(): any[];
     protected createAggregationPipeline(userContext: IUserContext, query: any, queryOptions?: QueryOptions): any[];
     getAll(userContext: IUserContext): Promise<T[]>;

package/dist/services/generic-api.service.js

@@ -25,6 +25,20 @@ export class GenericApiService {
         const validator = isPartial ? this.modelSpec.partialValidator : this.modelSpec.validator;
         return entityUtils.validate(validator, doc);
     }
+    validateMany(docs, isPartial = false) {
+        if (!this.modelSpec) {
+            return null;
+        }
+        const validator = isPartial ? this.modelSpec.partialValidator : this.modelSpec.validator;
+        let allErrors = [];
+        for (const doc of docs) {
+            const errors = entityUtils.validate(validator, doc);
+            if (errors && errors.length > 0) {
+                allErrors.push(...errors);
+            }
+        }
+        return allErrors.length > 0 ? allErrors : null;
+    }
     getAdditionalPipelineStages() {
         return [];
     }
@@ -146,10 +160,8 @@ export class GenericApiService {
         let createdEntities = [];
         if (entities.length) {
             try {
-                for (const entity of entities) {
-                    const validationErrors = this.validate(entity);
-                    entityUtils.handleValidationResult(validationErrors, 'GenericApiService.createMany');
-                }
+                const validationErrors = this.validateMany(entities);
+                entityUtils.handleValidationResult(validationErrors, 'GenericApiService.createMany');
                 const preparedEntities = await this.onBeforeCreate(userContext, entities);
                 const insertResult = await this.collection.insertMany(preparedEntities);
                 if (insertResult.insertedIds) {
@@ -325,9 +337,13 @@ export class GenericApiService {
         const transformedEntity = dbUtils.convertObjectIdsToStrings(single, this.modelSpec.fullSchema);
         return transformedEntity;
     }
-    stripSenderProvidedSystemProperties(doc) {
+    stripSenderProvidedSystemProperties(userContext, doc) {
+        const isSystemUser = userContext.user?._id === 'system';
+        if (isSystemUser) {
+            return;
+        }
         for (const key in doc) {
-            if (Object.prototype.hasOwnProperty.call(doc, key) && key.startsWith('_')) {
+            if (Object.prototype.hasOwnProperty.call(doc, key) && key.startsWith('_') && key !== '_orgId') {
                 delete doc[key];
             }
         }
@@ -344,7 +360,7 @@ export class GenericApiService {
     }
     async prepareEntity(userContext, entity, isCreate) {
         const preparedEntity = _.clone(entity);
-        this.stripSenderProvidedSystemProperties(preparedEntity);
+        this.stripSenderProvidedSystemProperties(userContext, preparedEntity);
         if (this.modelSpec?.isAuditable) {
             if (isCreate) {
                 this.auditForCreate(userContext, preparedEntity);

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

@@ -5,4 +5,5 @@ 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>;
+    getMetaOrg(userContext: IUserContext): Promise<IOrganization>;
 }

package/dist/services/organization.service.js

@@ -13,4 +13,8 @@ export class OrganizationService extends GenericApiService {
         const orgId = org.authToken === authToken ? org._id.toString() : null;
         return orgId;
     }
+    async getMetaOrg(userContext) {
+        const org = await this.findOne(userContext, { isMetaOrg: true });
+        return org;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb",
   "scripts": {
@@ -44,7 +44,7 @@
     "jsonwebtoken": "^9.0.2"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.9",
+    "@loomcore/common": "^0.0.12",
     "@sinclair/typebox": "^0.34.31",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",