@loomcore/api 0.0.21 → 0.0.23

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/controllers/api.controller.d.ts

@@ -1,6 +1,6 @@
 import { Application, NextFunction, Request, Response } from 'express';
 import { TSchema } from '@sinclair/typebox';
-import { IEntity, IModelSpec } from '@loomcore/common/models';
+import { IEntity, IModelSpec, IUserContext } from '@loomcore/common/models';
 import { IGenericApiService } from '../services/index.js';
 export declare abstract class ApiController<T extends IEntity> {
     protected app: Application;
@@ -11,6 +11,12 @@ export declare abstract class ApiController<T extends IEntity> {
     protected publicSchema?: TSchema;
     protected constructor(slug: string, app: Application, service: IGenericApiService<T>, resourceName?: string, modelSpec?: IModelSpec, publicSchema?: TSchema);
     mapRoutes(app: Application): void;
+    protected validate(entity: any, isPartial?: boolean): void;
+    protected validateMany(entities: any[], isPartial?: boolean): void;
+    protected prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
+    protected prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
+    protected prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
+    protected prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     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>;

package/dist/controllers/api.controller.js

@@ -1,3 +1,4 @@
+import { entityUtils } from '@loomcore/common/utils';
 import { isAuthenticated } from '../middleware/index.js';
 import { apiUtils } from '../utils/index.js';
 export class ApiController {
@@ -26,6 +27,17 @@ export class ApiController {
         app.patch(`/api/${this.slug}/:id`, isAuthenticated, this.partialUpdateById.bind(this));
         app.delete(`/api/${this.slug}/:id`, isAuthenticated, this.deleteById.bind(this));
     }
+    validate(entity, isPartial = false) {
+        const validationErrors = this.service.validate(entity, isPartial);
+        entityUtils.handleValidationResult(validationErrors, `ApiController.validate for ${this.slug}`);
+    }
+    validateMany(entities, isPartial = false) {
+        const validationErrors = this.service.validateMany(entities, isPartial);
+        entityUtils.handleValidationResult(validationErrors, `ApiController.validateMany for ${this.slug}`);
+    }
+    async prepareDataForDb(userContext, entity, isCreate = false) {
+        return await this.service.prepareDataForDb(userContext, entity, isCreate);
+    }
     async getAll(req, res, next) {
         res.set('Content-Type', 'application/json');
         const entities = await this.service.getAll(req.userContext);
@@ -50,17 +62,23 @@ export class ApiController {
     }
     async create(req, res, next) {
         res.set('Content-Type', 'application/json');
-        const entity = await this.service.create(req.userContext, req.body);
+        this.validate(req.body);
+        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, true);
+        const entity = await this.service.create(req.userContext, preparedEntity);
         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);
+        this.validate(req.body);
+        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, false);
+        const updateResult = await this.service.fullUpdateById(req.userContext, req.params.id, preparedEntity);
         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);
+        this.validate(req.body, true);
+        const preparedEntity = await this.prepareDataForDb(req.userContext, req.body, false);
+        const updateResult = await this.service.partialUpdateById(req.userContext, req.params.id, preparedEntity);
         apiUtils.apiResponse(res, 200, { data: updateResult }, this.modelSpec, this.publicSchema);
     }
     async deleteById(req, res, next) {

package/dist/controllers/auth.controller.js

@@ -1,4 +1,5 @@
-import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec } from '@loomcore/common/models';
+import { LoginResponseSpec, TokenResponseSpec, UserSpec, PublicUserSchema, UserContextSpec, passwordValidator } from '@loomcore/common/models';
+import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 import { isAuthenticated } from '../middleware/index.js';
 import { apiUtils } from '../utils/index.js';
@@ -28,7 +29,10 @@ export class AuthController {
     async registerUser(req, res) {
         const userContext = req.userContext;
         const body = req.body;
-        const user = await this.authService.createUser(userContext, body);
+        const validationErrors = this.authService.validate(body);
+        entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
+        const preparedUser = await this.authService.prepareDataForDb(userContext, body, true);
+        const user = await this.authService.createUser(userContext, preparedUser);
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSchema);
     }
     async requestTokenUsingRefreshToken(req, res, next) {
@@ -51,6 +55,8 @@ export class AuthController {
     async changePassword(req, res) {
         const userContext = req.userContext;
         const body = req.body;
+        const validationErrors = entityUtils.validate(passwordValidator, { password: body.password });
+        entityUtils.handleValidationResult(validationErrors, 'AuthController.changePassword');
         const updateResult = await this.authService.changeLoggedInUsersPassword(userContext, body);
         apiUtils.apiResponse(res, 200, { data: updateResult });
     }

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, 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 };
@@ -88,8 +88,6 @@ export class AuthService extends GenericApiService {
         return tokens;
     }
     async changeLoggedInUsersPassword(userContext, body) {
-        const validationResult = entityUtils.validate(passwordValidator, { password: body.password });
-        entityUtils.handleValidationResult(validationResult, 'AuthService.changePassword');
         const queryObject = { _id: new ObjectId(userContext.user._id) };
         const result = await this.changePassword(userContext, queryObject, body.password);
         return result;
@@ -266,8 +264,9 @@ export class AuthService extends GenericApiService {
             if (!entityUtils.isValidObjectId(userId)) {
                 throw new BadRequestError('userId is not a valid ObjectId');
             }
-            const updates = { _lastLoggedIn: moment().utc().toISOString() };
-            await this.partialUpdateById(EmptyUserContext, userId, updates);
+            const updates = { _lastLoggedIn: moment().utc().toDate() };
+            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

@@ -4,6 +4,10 @@ import { IUserContext, IEntity, IPagedResult, QueryOptions } from '@loomcore/com
 export interface IGenericApiService<T extends IEntity> {
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
+    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
+    prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
+    prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
+    prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     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

@@ -30,7 +30,7 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     auditForCreate(userContext: IUserContext, doc: any): void;
     auditForUpdate(userContext: IUserContext, doc: any): void;
     onBeforeCreate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
-    onAfterCreate<E extends T | T[]>(userContext: IUserContext | undefined, entities: E): Promise<E | E[]>;
+    onAfterCreate<E extends T | T[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
     onBeforeUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entities: E): Promise<E | E[]>;
     onAfterUpdate<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext | undefined, entities: E): Promise<E>;
     onBeforeDelete(userContext: IUserContext, queryObject: any): Promise<any>;
@@ -38,7 +38,10 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     transformList(list: any[]): T[];
     transformSingle(single: any): T;
     private stripSenderProvidedSystemProperties;
-    protected preparePayload<E extends T | T[] | Partial<T> | Partial<T>[]>(userContext: IUserContext, entity: E, isCreate?: boolean): Promise<E | E[]>;
+    prepareDataForDb(userContext: IUserContext, entity: T, isCreate?: boolean): Promise<T>;
+    prepareDataForDb(userContext: IUserContext, entity: Partial<T>, isCreate?: boolean): Promise<Partial<T>>;
+    prepareDataForDb(userContext: IUserContext, entity: T[], isCreate?: boolean): Promise<T[]>;
+    prepareDataForDb(userContext: IUserContext, entity: Partial<T>[], isCreate?: boolean): Promise<Partial<T>[]>;
     protected prepareEntity(userContext: IUserContext, entity: T | Partial<T>, isCreate: boolean): Promise<T | Partial<T>>;
     protected prepareQuery(userContext: IUserContext | undefined, query: any): any;
     protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: QueryOptions): QueryOptions;

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

@@ -135,8 +135,6 @@ export class GenericApiService {
         return count;
     }
     async create(userContext, entity) {
-        const validationErrors = this.validate(entity);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.create');
         let createdEntity = null;
         try {
             const preparedEntity = await this.onBeforeCreate(userContext, entity);
@@ -160,8 +158,6 @@ export class GenericApiService {
         let createdEntities = [];
         if (entities.length) {
             try {
-                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) {
@@ -182,8 +178,6 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.fullUpdateById');
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
         const existingEntity = await this.collection.findOne(query);
@@ -194,13 +188,13 @@ export class GenericApiService {
             _created: existingEntity._created,
             _createdBy: existingEntity._createdBy,
         };
-        const clone = await this.onBeforeUpdate(userContext, entity);
-        Object.assign(clone, auditProperties);
-        const mongoUpdateResult = await this.collection.replaceOne(query, clone);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
+        Object.assign(preparedEntity, auditProperties);
+        const mongoUpdateResult = await this.collection.replaceOne(query, preparedEntity);
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new IdNotFoundError();
         }
-        await this.onAfterUpdate(userContext, clone);
+        await this.onAfterUpdate(userContext, preparedEntity);
         const updatedEntity = await this.collection.findOne(query);
         return this.transformSingle(updatedEntity);
     }
@@ -208,12 +202,10 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity, true);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateById');
-        const clone = await this.onBeforeUpdate(userContext, entity);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: clone }, { returnDocument: 'after' });
+        const updatedEntity = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
         if (!updatedEntity) {
             throw new IdNotFoundError();
         }
@@ -227,12 +219,9 @@ export class GenericApiService {
         if (!entityUtils.isValidObjectId(id)) {
             throw new BadRequestError('id is not a valid ObjectId');
         }
-        const validationErrors = this.validate(entity, true);
-        entityUtils.handleValidationResult(validationErrors, 'GenericApiService.partialUpdateByIdWithoutBeforeAndAfter');
-        const preparedEntity = this.preparePayload(userContext, entity, false);
         const baseQuery = { _id: new ObjectId(id) };
         const query = this.prepareQuery(userContext, baseQuery);
-        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: preparedEntity }, { returnDocument: 'after' });
+        const modifyResult = await this.collection.findOneAndUpdate(query, { $set: entity }, { returnDocument: 'after' });
         let updatedEntity = null;
         if (modifyResult?.ok === 1) {
             updatedEntity = modifyResult.value;
@@ -248,13 +237,13 @@ export class GenericApiService {
         return this.transformSingle(updatedEntity);
     }
     async update(userContext, queryObject, entity) {
-        const clone = await this.onBeforeUpdate(userContext, entity);
+        const preparedEntity = await this.onBeforeUpdate(userContext, entity);
         const query = this.prepareQuery(userContext, queryObject);
-        const mongoUpdateResult = await this.collection.updateMany(query, { $set: clone });
+        const mongoUpdateResult = await this.collection.updateMany(query, { $set: preparedEntity });
         if (mongoUpdateResult?.matchedCount <= 0) {
             throw new NotFoundError('No records found matching update query');
         }
-        await this.onAfterUpdate(userContext, clone);
+        await this.onAfterUpdate(userContext, preparedEntity);
         const updatedEntities = await this.collection.find(query).toArray();
         return this.transformList(updatedEntities);
     }
@@ -304,15 +293,13 @@ export class GenericApiService {
         doc._updatedBy = userId;
     }
     async onBeforeCreate(userContext, entities) {
-        const preparedEntities = await this.preparePayload(userContext, entities, true);
-        return Promise.resolve(preparedEntities);
+        return Promise.resolve(entities);
     }
     async onAfterCreate(userContext, entities) {
         return Promise.resolve(entities);
     }
     async onBeforeUpdate(userContext, entities) {
-        const preparedEntities = await this.preparePayload(userContext, entities, false);
-        return Promise.resolve(preparedEntities);
+        return Promise.resolve(entities);
     }
     onAfterUpdate(userContext, entities) {
         return Promise.resolve(entities);
@@ -337,26 +324,28 @@ 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('_') && key !== '_orgId') {
                 delete doc[key];
             }
         }
     }
-    async preparePayload(userContext, entity, isCreate = false) {
-        let result;
+    async prepareDataForDb(userContext, entity, isCreate = false) {
         if (Array.isArray(entity)) {
-            result = await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
+            return await Promise.all(entity.map(item => this.prepareEntity(userContext, item, isCreate)));
         }
         else {
-            result = await this.prepareEntity(userContext, entity, isCreate);
+            return await this.prepareEntity(userContext, entity, isCreate);
         }
-        return result;
     }
     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.21",
+  "version": "0.0.23",
   "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",