@loomcore/api 0.1.78 → 0.1.79

package/README.md

@@ -63,7 +63,7 @@ The test suite supports two modes for PostgreSQL testing:
    npm run test:db:stop
    ```
 
-The container uses port `5433` to avoid conflicts with local PostgreSQL instances. Set `USE_REAL_POSTGRES=true` to use the container instead of pg-mem.
+The container uses port `5444` to avoid conflicts with local PostgreSQL instances. Set `USE_REAL_POSTGRES=true` to use the container instead of pg-mem.
 
 ## Example Usage
 

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

@@ -17,7 +17,7 @@ import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
 import { setBaseApiConfig, config } from '../config/index.js';
 import { entityUtils } from '@loomcore/common/utils';
-import { getTestOrgUser } from './test-objects.js';
+import { getTestMetaOrgUserPerson, getTestOrgUser, getTestOrgUserPerson, setTestMetaOrgUserPersonId, setTestOrgUserPersonId } from './test-objects.js';
 import { TestEmailClient } from './test-email-client.js';
 let deviceIdCookie;
 let authService;
@@ -110,13 +110,15 @@ async function createTestUsers() {
         else {
             setTestOrgId(existingTestOrg._id);
         }
-        const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser());
-        const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser());
+        const createdTestOrgUser = await authService.createUser(getTestOrgUserContext(), getTestOrgUser(), getTestOrgUserPerson());
+        const createdMetaOrgUser = await authService.createUser(getTestMetaOrgUserContext(), getTestMetaOrgUser(), getTestMetaOrgUserPerson());
         if (!createdTestOrgUser || !createdMetaOrgUser) {
             throw new Error('Failed to create test user');
         }
         setTestMetaOrgUserId(createdMetaOrgUser._id);
+        setTestMetaOrgUserPersonId(createdMetaOrgUser.personId);
         setTestOrgUserId(createdTestOrgUser._id);
+        setTestOrgUserPersonId(createdTestOrgUser.personId);
         return { metaOrgUser: createdMetaOrgUser, testOrgUser: createdTestOrgUser };
     }
     catch (error) {

package/dist/__tests__/postgres.test-database.js

@@ -25,7 +25,7 @@ export class TestPostgresDatabase {
             let postgresClient;
             let pool;
             if (USE_REAL_POSTGRES) {
-                const connectionString = `postgresql://test-user:test-password@localhost:5433/test-db`;
+                const connectionString = `postgresql://test-user:test-password@localhost:5444/test-db`;
                 postgresClient = new Client({
                     connectionString,
                     connectionTimeoutMillis: 5000,
@@ -43,7 +43,7 @@ export class TestPostgresDatabase {
                             `3. Try: docker ps (to verify Docker access)\n` +
                             `Original error: ${errorMessage}`);
                     }
-                    throw new Error(`Failed to connect to PostgreSQL test container at localhost:5433.\n` +
+                    throw new Error(`Failed to connect to PostgreSQL test container at localhost:5444.\n` +
                         `Make sure the container is running: npm run test:db:start\n` +
                         `Check container status: docker ps | grep postgres-test\n` +
                         `View container logs: npm run test:db:logs\n` +

package/dist/__tests__/test-objects.d.ts

@@ -1,15 +1,20 @@
-import { IOrganization, IUserContext, IUser } from "@loomcore/common/models";
+import { IOrganization, IUserContext, IUser, IPersonModel } from "@loomcore/common/models";
 export declare let TEST_META_ORG_ID: string | number;
 export declare let TEST_META_ORG_USER_ID: string | number;
+export declare let TEST_META_ORG_USER_PERSON_ID: string | number;
 export declare function setTestMetaOrgId(metaOrgId: string | number): void;
 export declare function setTestMetaOrgUserId(userId: string | number): void;
+export declare function setTestMetaOrgUserPersonId(personId: string | number): void;
 export declare const TEST_META_ORG_USER_PASSWORD = "test-meta-org-user-password";
 export declare function getTestMetaOrg(): IOrganization;
 export declare function getTestMetaOrgUser(): IUser;
+export declare function getTestMetaOrgUserPerson(): IPersonModel;
 export declare function getTestMetaOrgUserContext(): IUserContext;
 export declare function setTestOrgId(orgId: string | number): void;
 export declare function setTestOrgUserId(userId: string | number): void;
+export declare function setTestOrgUserPersonId(personId: string | number): void;
 export declare function getTestOrg(): IOrganization;
 export declare const TEST_ORG_USER_PASSWORD = "test-org-user-password";
 export declare function getTestOrgUser(): IUser;
+export declare function getTestOrgUserPerson(): IPersonModel;
 export declare function getTestOrgUserContext(): IUserContext;

package/dist/__tests__/test-objects.js

@@ -1,11 +1,15 @@
 export let TEST_META_ORG_ID = '69261691f936c45f85da24d0';
 export let TEST_META_ORG_USER_ID = '69261672f48fb7bf76e54dfb';
+export let TEST_META_ORG_USER_PERSON_ID = '69261672f48fb7bf76e54dfc';
 export function setTestMetaOrgId(metaOrgId) {
     TEST_META_ORG_ID = metaOrgId;
 }
 export function setTestMetaOrgUserId(userId) {
     TEST_META_ORG_USER_ID = userId;
 }
+export function setTestMetaOrgUserPersonId(personId) {
+    TEST_META_ORG_USER_PERSON_ID = personId;
+}
 export const TEST_META_ORG_USER_PASSWORD = 'test-meta-org-user-password';
 export function getTestMetaOrg() {
     return {
@@ -25,9 +29,9 @@ export function getTestMetaOrgUser() {
     return {
         _id: TEST_META_ORG_USER_ID,
         _orgId: getTestMetaOrg()._id,
+        externalId: 'test-meta-org-user-external-id',
+        personId: TEST_META_ORG_USER_PERSON_ID,
         email: 'test@example.com',
-        firstName: 'Test',
-        lastName: 'User',
         displayName: 'Test User',
         password: TEST_META_ORG_USER_PASSWORD,
         _created: new Date(),
@@ -36,6 +40,25 @@ export function getTestMetaOrgUser() {
         _updatedBy: 'system',
     };
 }
+export function getTestMetaOrgUserPerson() {
+    return {
+        _id: TEST_META_ORG_USER_PERSON_ID,
+        _orgId: getTestMetaOrg()._id,
+        externalId: 'test-meta-org-user-person-external-id',
+        middleName: null,
+        firstName: 'Test',
+        lastName: 'User',
+        isAgent: false,
+        isClient: false,
+        isEmployee: false,
+        dateOfBirth: null,
+        extendedTypes: 0,
+        _created: new Date(),
+        _createdBy: 'system',
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
 export function getTestMetaOrgUserContext() {
     return {
         user: getTestMetaOrgUser(),
@@ -52,12 +75,16 @@ export function getTestMetaOrgUserContext() {
 ;
 let TEST_ORG_ID = '6926167d06c0073a778a124f';
 let TEST_ORG_USER_ID = '6926167d06c0073a778a1250';
+let TEST_ORG_USER_PERSON_ID = '6926167d06c0073a778a1251';
 export function setTestOrgId(orgId) {
     TEST_ORG_ID = orgId;
 }
 export function setTestOrgUserId(userId) {
     TEST_ORG_USER_ID = userId;
 }
+export function setTestOrgUserPersonId(personId) {
+    TEST_ORG_USER_PERSON_ID = personId;
+}
 export function getTestOrg() {
     return {
         _id: TEST_ORG_ID,
@@ -77,9 +104,9 @@ export function getTestOrgUser() {
     return {
         _id: TEST_ORG_USER_ID,
         _orgId: getTestOrg()._id,
+        externalId: 'test-org-user-external-id',
         email: 'test-org-user@example.com',
-        firstName: 'Test',
-        lastName: 'User',
+        personId: TEST_ORG_USER_PERSON_ID,
         displayName: 'Test User',
         password: TEST_ORG_USER_PASSWORD,
         _created: new Date(),
@@ -88,6 +115,25 @@ export function getTestOrgUser() {
         _updatedBy: 'system',
     };
 }
+export function getTestOrgUserPerson() {
+    return {
+        _id: TEST_ORG_USER_PERSON_ID,
+        _orgId: getTestOrg()._id,
+        externalId: 'test-org-user-person-external-id',
+        middleName: null,
+        firstName: 'Test',
+        lastName: 'User',
+        isAgent: false,
+        isClient: false,
+        isEmployee: false,
+        dateOfBirth: null,
+        extendedTypes: 0,
+        _created: new Date(),
+        _createdBy: 'system',
+        _updated: new Date(),
+        _updatedBy: 'system',
+    };
+}
 export function getTestOrgUserContext() {
     return {
         user: getTestOrgUser(),

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

@@ -1,8 +1,10 @@
 import { Application, Request, Response, NextFunction } from 'express';
 import { AuthService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
+import { PersonService } from '../services/person.service.js';
 export declare class AuthController {
     authService: AuthService;
+    personService: PersonService;
     constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
     login(req: Request, res: Response, next: NextFunction): Promise<void>;

package/dist/controllers/auth.controller.js

@@ -4,10 +4,13 @@ import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 import { apiUtils } from '../utils/index.js';
 import { AuthService } from '../services/index.js';
 import { isAuthorized } from '../middleware/index.js';
+import { PersonService } from '../services/person.service.js';
 export class AuthController {
     authService;
+    personService;
     constructor(app, database) {
         this.authService = new AuthService(database);
+        this.personService = new PersonService(database);
         this.mapRoutes(app);
     }
     mapRoutes(app) {
@@ -27,13 +30,15 @@ export class AuthController {
     }
     async registerUser(req, res) {
         const userContext = req.userContext;
-        const body = req.body;
-        const validationErrors = this.authService.validate(body);
-        entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
         if (!userContext) {
             throw new BadRequestError('Missing required fields: userContext is required.');
         }
-        const user = await this.authService.createUser(userContext, body);
+        const body = req.body;
+        let validationErrors = this.authService.validate(body.user);
+        entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
+        validationErrors = this.personService.validate(body.person);
+        entityUtils.handleValidationResult(validationErrors, 'AuthController.registerUser');
+        const user = await this.authService.createUser(userContext, body.user, body.person);
         apiUtils.apiResponse(res, 201, { data: user || undefined }, UserSpec, PublicUserSpec);
     }
     async requestTokenUsingRefreshToken(req, res, next) {

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'crypto';
-import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
+import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized, personModelSpec } from '@loomcore/common/models';
 import { MongoDBDatabase } from '../mongo-db.database.js';
-import { AuthService, OrganizationService } from '../../../services/index.js';
+import { AuthService, GenericApiService, OrganizationService } from '../../../services/index.js';
 export const getMongoInitialSchema = (config) => {
     const migrations = [];
     const isMultiTenant = config.app.isMultiTenant;
@@ -167,6 +167,7 @@ export const getMongoInitialSchema = (config) => {
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const authService = new AuthService(database);
+                const personService = new GenericApiService(database, 'persons', 'person', personModelSpec);
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
                         ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000008_data-meta-org) should have run before this migration. ' +
@@ -178,15 +179,32 @@ export const getMongoInitialSchema = (config) => {
                 }
                 const systemUserContext = getSystemUserContext();
                 const _id = randomUUID().toString();
+                const personId = randomUUID().toString();
+                const person = {
+                    _id: personId,
+                    _orgId: systemUserContext.organization?._id,
+                    externalId: 'admin-user-person-external-id',
+                    middleName: null,
+                    firstName: 'Admin',
+                    lastName: 'User',
+                    isAgent: false,
+                    isClient: false,
+                    isEmployee: false,
+                    dateOfBirth: null,
+                    extendedTypes: 0,
+                    _created: new Date(),
+                    _createdBy: 'system',
+                    _updated: new Date(),
+                    _updatedBy: 'system'
+                };
                 await authService.createUser(systemUserContext, {
                     _id: _id,
                     _orgId: systemUserContext.organization?._id,
+                    externalId: 'admin-user-external-id',
                     email: config.auth?.adminUser?.email,
                     password: config.auth?.adminUser?.password,
-                    firstName: 'Admin',
-                    lastName: 'User',
                     displayName: 'Admin User',
-                });
+                }, person);
             },
             down: async ({ context: db }) => {
                 if (!config.auth?.adminUser?.email)

package/dist/databases/operations/__tests__/models/{agent.model.d.ts → test-agent.model.d.ts}

@@ -1,10 +1,10 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
-import { IPersonModel } from "./person.model.js";
-export interface IAgentModel extends IEntity, IAuditable {
+import { ITestPersonModel } from "./test-person.model.js";
+export interface ITestAgentModel extends IEntity, IAuditable {
     person_id: number;
-    agent_person?: IPersonModel;
+    agent_person?: ITestPersonModel;
 }
-export declare const agentSchema: import("@sinclair/typebox").TObject<{
+export declare const testAgentSchema: import("@sinclair/typebox").TObject<{
     person_id: import("@sinclair/typebox").TNumber;
     agent_person: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         first_name: import("@sinclair/typebox").TString;
@@ -22,4 +22,4 @@ export declare const agentSchema: import("@sinclair/typebox").TObject<{
         }>>;
     }>>;
 }>;
-export declare const agentModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testAgentModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/test-agent.model.js

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { testPersonSchema } from "./test-person.model.js";
+export const testAgentSchema = Type.Object({
+    person_id: Type.Number(),
+    agent_person: Type.Optional(testPersonSchema),
+});
+export const testAgentModelSpec = entityUtils.getModelSpec(testAgentSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/{client-report.model.d.ts → test-client-report.model.d.ts}

@@ -1,13 +1,13 @@
-import { IPersonModel } from "./person.model.js";
-import { IAgentModel } from "./agent.model.js";
-import { IPolicyModel } from "./policy.model.js";
+import { ITestPersonModel } from "./test-person.model.js";
+import { ITestAgentModel } from "./test-agent.model.js";
+import { ITestPolicyModel } from "./test-policy.model.js";
 import type { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IClientReportsModel extends IEntity, IAuditable {
-    client_person: IPersonModel;
-    agent?: IAgentModel;
-    client_policies?: IPolicyModel[];
+export interface ITestClientReportsModel extends IEntity, IAuditable {
+    client_person: ITestPersonModel;
+    agent?: ITestAgentModel;
+    client_policies?: ITestPolicyModel[];
 }
-export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
+export declare const testClientReportsSchema: import("@sinclair/typebox").TObject<{
     client_person: import("@sinclair/typebox").TObject<{
         first_name: import("@sinclair/typebox").TString;
         middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -70,4 +70,4 @@ export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
         }>>>;
     }>>>;
 }>;
-export declare const clientReportsModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testClientReportsModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/test-client-report.model.js

@@ -0,0 +1,11 @@
+import { testPersonSchema } from "./test-person.model.js";
+import { testAgentSchema } from "./test-agent.model.js";
+import { testPolicySchema } from "./test-policy.model.js";
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const testClientReportsSchema = Type.Object({
+    client_person: testPersonSchema,
+    agent: Type.Optional(testAgentSchema),
+    client_policies: Type.Optional(Type.Array(testPolicySchema))
+});
+export const testClientReportsModelSpec = entityUtils.getModelSpec(testClientReportsSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/test-district.model.d.ts

@@ -0,0 +1,12 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { ITestStateModel } from "./test-state.model.js";
+export interface ITestDistrictModel extends IEntity, IAuditable {
+    name: string;
+    state_id: number;
+    state?: ITestStateModel;
+}
+export declare const testDistrictSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    state_id: import("@sinclair/typebox").TNumber;
+}>;
+export declare const testDistrictModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/{district.model.js → test-district.model.js}

@@ -1,7 +1,7 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
-export const districtSchema = Type.Object({
+export const testDistrictSchema = Type.Object({
     name: Type.String(),
     state_id: Type.Number(),
 });
-export const districtModelSpec = entityUtils.getModelSpec(districtSchema, { isAuditable: true });
+export const testDistrictModelSpec = entityUtils.getModelSpec(testDistrictSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/{email-address.model.d.ts → test-email-address.model.d.ts}

@@ -1,12 +1,12 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IEmailAddressModel extends IEntity, IAuditable {
+export interface ITestEmailAddressModel extends IEntity, IAuditable {
     person_id: number;
     email_address: string;
     is_default: boolean;
 }
-export declare const emailAddressSchema: import("@sinclair/typebox").TObject<{
+export declare const testEmailAddressSchema: import("@sinclair/typebox").TObject<{
     person_id: import("@sinclair/typebox").TNumber;
     email_address: import("@sinclair/typebox").TString;
     is_default: import("@sinclair/typebox").TBoolean;
 }>;
-export declare const emailAddressModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testEmailAddressModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/{email-address.model.js → test-email-address.model.js}

@@ -1,8 +1,8 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
-export const emailAddressSchema = Type.Object({
+export const testEmailAddressSchema = Type.Object({
     person_id: Type.Number(),
     email_address: Type.String(),
     is_default: Type.Boolean(),
 });
-export const emailAddressModelSpec = entityUtils.getModelSpec(emailAddressSchema);
+export const testEmailAddressModelSpec = entityUtils.getModelSpec(testEmailAddressSchema);

package/dist/databases/operations/__tests__/models/{person.model.d.ts → test-person.model.d.ts}

@@ -1,16 +1,16 @@
 import type { IAuditable, IEntity } from "@loomcore/common/models";
-import { IEmailAddressModel } from "./email-address.model.js";
-import { IPhoneNumberModel } from "./phone-number.model.js";
-import { ISchoolModel } from "./school.model.js";
-export interface IPersonModel extends IEntity, IAuditable {
+import { ITestEmailAddressModel } from "./test-email-address.model.js";
+import { ITestPhoneNumberModel } from "./test-phone-number.model.js";
+import { ITestSchoolModel } from "./test-school.model.js";
+export interface ITestPersonModel extends IEntity, IAuditable {
     first_name: string;
     middle_name: string | null;
     last_name: string;
-    client_email_addresses: IEmailAddressModel[];
-    client_phone_numbers: IPhoneNumberModel[];
-    school?: ISchoolModel;
+    client_email_addresses: ITestEmailAddressModel[];
+    client_phone_numbers: ITestPhoneNumberModel[];
+    school?: ITestSchoolModel;
 }
-export declare const personSchema: import("@sinclair/typebox").TObject<{
+export declare const testPersonSchema: import("@sinclair/typebox").TObject<{
     first_name: import("@sinclair/typebox").TString;
     middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     last_name: import("@sinclair/typebox").TString;
@@ -25,4 +25,4 @@ export declare const personSchema: import("@sinclair/typebox").TObject<{
         is_default: import("@sinclair/typebox").TBoolean;
     }>>;
 }>;
-export declare const personModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testPersonModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/test-person.model.js

@@ -0,0 +1,12 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { testEmailAddressSchema } from "./test-email-address.model.js";
+import { testPhoneNumberSchema } from "./test-phone-number.model.js";
+export const testPersonSchema = Type.Object({
+    first_name: Type.String(),
+    middle_name: Type.Optional(Type.String()),
+    last_name: Type.String(),
+    client_phone_numbers: Type.Array(testPhoneNumberSchema),
+    client_email_addresses: Type.Array(testEmailAddressSchema),
+});
+export const testPersonModelSpec = entityUtils.getModelSpec(testPersonSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/{phone-number.model.d.ts → test-phone-number.model.d.ts}

@@ -1,12 +1,12 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IPhoneNumberModel extends IEntity, IAuditable {
+export interface ITestPhoneNumberModel extends IEntity, IAuditable {
     phone_number: string;
     phone_number_type: string;
     is_default: boolean;
 }
-export declare const phoneNumberSchema: import("@sinclair/typebox").TObject<{
+export declare const testPhoneNumberSchema: import("@sinclair/typebox").TObject<{
     phone_number: import("@sinclair/typebox").TString;
     phone_number_type: import("@sinclair/typebox").TString;
     is_default: import("@sinclair/typebox").TBoolean;
 }>;
-export declare const phoneNumberModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testPhoneNumberModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/{phone-number.model.js → test-phone-number.model.js}

@@ -1,8 +1,8 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
-export const phoneNumberSchema = Type.Object({
+export const testPhoneNumberSchema = Type.Object({
     phone_number: Type.String(),
     phone_number_type: Type.String(),
     is_default: Type.Boolean(),
 });
-export const phoneNumberModelSpec = entityUtils.getModelSpec(phoneNumberSchema, { isAuditable: true });
+export const testPhoneNumberModelSpec = entityUtils.getModelSpec(testPhoneNumberSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/{policy.model.d.ts → test-policy.model.d.ts}

@@ -1,14 +1,14 @@
 import type { IAuditable, IEntity } from "@loomcore/common/models";
-import { IAgentModel } from "./agent.model.js";
-import { IPremiumModel } from "./premium.model.js";
-export interface IPolicyModel extends IEntity, IAuditable {
+import { ITestAgentModel } from "./test-agent.model.js";
+import { ITestPremiumModel } from "./test-premium.model.js";
+export interface ITestPolicyModel extends IEntity, IAuditable {
     client_id: number;
     amount: number;
     frequency: string;
-    agents?: IAgentModel[];
-    policy_premiums?: IPremiumModel[];
+    agents?: ITestAgentModel[];
+    policy_premiums?: ITestPremiumModel[];
 }
-export declare const policySchema: import("@sinclair/typebox").TObject<{
+export declare const testPolicySchema: import("@sinclair/typebox").TObject<{
     client_id: import("@sinclair/typebox").TNumber;
     amount: import("@sinclair/typebox").TNumber;
     frequency: import("@sinclair/typebox").TString;
@@ -36,4 +36,4 @@ export declare const policySchema: import("@sinclair/typebox").TObject<{
         date: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TString]>;
     }>>>;
 }>;
-export declare const policyModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testPolicyModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/test-policy.model.js

@@ -0,0 +1,12 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { testAgentSchema } from "./test-agent.model.js";
+import { testPremiumSchema } from "./test-premium.model.js";
+export const testPolicySchema = Type.Object({
+    client_id: Type.Number(),
+    amount: Type.Number(),
+    frequency: Type.String(),
+    agents: Type.Optional(Type.Array(testAgentSchema)),
+    policy_premiums: Type.Optional(Type.Array(testPremiumSchema))
+});
+export const testPolicyModelSpec = entityUtils.getModelSpec(testPolicySchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/{premium.model.d.ts → test-premium.model.d.ts}

@@ -1,12 +1,12 @@
 import type { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IPremiumModel extends IEntity, IAuditable {
+export interface ITestPremiumModel extends IEntity, IAuditable {
     policy_id: number;
     amount: number;
     date: Date | string;
 }
-export declare const premiumSchema: import("@sinclair/typebox").TObject<{
+export declare const testPremiumSchema: import("@sinclair/typebox").TObject<{
     policy_id: import("@sinclair/typebox").TNumber;
     amount: import("@sinclair/typebox").TNumber;
     date: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TString]>;
 }>;
-export declare const premiumModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const testPremiumModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/{premium.model.js → test-premium.model.js}

@@ -1,8 +1,8 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
-export const premiumSchema = Type.Object({
+export const testPremiumSchema = Type.Object({
     policy_id: Type.Number(),
     amount: Type.Number(),
     date: Type.Union([Type.Date(), Type.String()])
 });
-export const premiumModelSpec = entityUtils.getModelSpec(premiumSchema, { isAuditable: true });
+export const testPremiumModelSpec = entityUtils.getModelSpec(testPremiumSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/test-school.model.d.ts

@@ -0,0 +1,12 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { ITestDistrictModel } from "./test-district.model.js";
+export interface ITestSchoolModel extends IEntity, IAuditable {
+    name: string;
+    district_id: number;
+    district?: ITestDistrictModel;
+}
+export declare const testSchoolSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    district_id: import("@sinclair/typebox").TNumber;
+}>;
+export declare const testSchoolModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/{school.model.js → test-school.model.js}

@@ -1,7 +1,7 @@
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
-export const schoolSchema = Type.Object({
+export const testSchoolSchema = Type.Object({
     name: Type.String(),
     district_id: Type.Number(),
 });
-export const schoolModelSpec = entityUtils.getModelSpec(schoolSchema, { isAuditable: true });
+export const testSchoolModelSpec = entityUtils.getModelSpec(testSchoolSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/test-state.model.d.ts

@@ -0,0 +1,8 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+export interface ITestStateModel extends IEntity, IAuditable {
+    name: string;
+}
+export declare const testStateSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>;
+export declare const testStateModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/test-state.model.js

@@ -0,0 +1,6 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const testStateSchema = Type.Object({
+    name: Type.String(),
+});
+export const testStateModelSpec = entityUtils.getModelSpec(testStateSchema, { isAuditable: true });

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -43,21 +43,54 @@ export const getPostgresInitialSchema = (config) => {
     }
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000002_schema-users',
+            name: '00000000000002_schema-persons',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
-                const uniqueConstraint = isMultiTenant
+                await pool.query(`
+          CREATE TABLE IF NOT EXISTS "persons" (
+            "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+            ${orgColumnDef}
+            "externalId" VARCHAR(255) UNIQUE,
+            "firstName" VARCHAR(255) NOT NULL,
+            "middleName" VARCHAR(255),
+            "lastName" VARCHAR(255) NOT NULL,
+            "dateOfBirth" DATE,
+            "isAgent" BOOLEAN NOT NULL DEFAULT FALSE,
+            "isClient" BOOLEAN NOT NULL DEFAULT FALSE,
+            "isEmployee" BOOLEAN NOT NULL DEFAULT FALSE,
+            "extendedTypes" INTEGER NOT NULL DEFAULT 0,
+            "_created" TIMESTAMPTZ NOT NULL,
+            "_createdBy" INTEGER NOT NULL,
+            "_updated" TIMESTAMPTZ NOT NULL,
+            "_updatedBy" INTEGER NOT NULL,
+            "_deleted" TIMESTAMPTZ,
+            "_deletedBy" INTEGER
+          )
+        `);
+            },
+            down: async ({ context: pool }) => {
+                await pool.query('DROP TABLE IF EXISTS "persons"');
+            }
+        });
+    if (isAuthEnabled)
+        migrations.push({
+            name: '00000000000003_schema-users',
+            up: async ({ context: pool }) => {
+                const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+                let uniqueConstraint = isMultiTenant
                     ? 'CONSTRAINT "uk_users_email" UNIQUE ("_orgId", "email")'
                     : 'CONSTRAINT "uk_users_email" UNIQUE ("email")';
+                uniqueConstraint += `,
+          CONSTRAINT "fk_users_personId" FOREIGN KEY("personId") REFERENCES "persons"("_id") ON DELETE CASCADE`;
                 await pool.query(`
         CREATE TABLE IF NOT EXISTS "users" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
           ${orgColumnDef}
+          "externalId" VARCHAR(255) UNIQUE,
           "email" VARCHAR(255) NOT NULL,
-          "firstName" VARCHAR(255),
-          "lastName" VARCHAR(255),
           "displayName" VARCHAR(255),
           "password" VARCHAR(255) NOT NULL,
+          "personId" INTEGER UNIQUE,
           "_lastLoggedIn" TIMESTAMPTZ,
           "_lastPasswordChange" TIMESTAMPTZ,
           "_created" TIMESTAMPTZ NOT NULL,
@@ -76,7 +109,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000003_schema-refresh-tokens',
+            name: '00000000000004_schema-refresh-tokens',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 await pool.query(`
@@ -99,7 +132,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000004_schema-password-reset-tokens',
+            name: '00000000000005_schema-password-reset-tokens',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -128,7 +161,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000005_schema-roles',
+            name: '00000000000006_schema-roles',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -150,7 +183,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000006_schema-user-roles',
+            name: '00000000000007_schema-user-roles',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -180,7 +213,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000007_schema-features',
+            name: '00000000000008_schema-features',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -202,7 +235,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isAuthEnabled)
         migrations.push({
-            name: '00000000000008_schema-authorizations',
+            name: '00000000000009_schema-authorizations',
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
@@ -235,7 +268,7 @@ export const getPostgresInitialSchema = (config) => {
         });
     if (isMultiTenant) {
         migrations.push({
-            name: '00000000000009_data-meta-org',
+            name: '00000000000010_data-meta-org',
             up: async ({ context: pool }) => {
                 const result = await pool.query(`
           INSERT INTO "organizations" ("name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy")
@@ -254,7 +287,7 @@ export const getPostgresInitialSchema = (config) => {
     }
     if (isAuthEnabled) {
         migrations.push({
-            name: '00000000000010_data-admin-user',
+            name: '00000000000011_data-admin-user',
             up: async ({ context: pool }) => {
                 const client = await pool.connect();
                 try {
@@ -273,14 +306,19 @@ export const getPostgresInitialSchema = (config) => {
                     const userData = {
                         email: config.auth?.adminUser?.email,
                         password: config.auth?.adminUser?.password,
-                        firstName: 'Admin',
-                        lastName: 'User',
                         displayName: 'Admin User',
                     };
                     if (isMultiTenant && systemUserContext.organization?._id) {
                         userData._orgId = systemUserContext.organization._id;
                     }
-                    await authService.createUser(systemUserContext, userData);
+                    const personData = {
+                        firstName: 'Admin',
+                        lastName: 'User',
+                    };
+                    if (isMultiTenant && systemUserContext.organization?._id) {
+                        personData._orgId = systemUserContext.organization._id;
+                    }
+                    await authService.createUser(systemUserContext, userData, personData);
                 }
                 finally {
                     client.release();
@@ -295,7 +333,7 @@ export const getPostgresInitialSchema = (config) => {
     }
     if (config.auth) {
         migrations.push({
-            name: '00000000000011_data-admin-authorizations',
+            name: '00000000000012_data-admin-authorizations',
             up: async ({ context: pool }) => {
                 const client = await pool.connect();
                 try {

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

@@ -1,5 +1,5 @@
 import { Request, Response } from 'express';
-import { IUserContext, ITokenResponse, ILoginResponse, IUser } from '@loomcore/common/models';
+import { IUserContext, ITokenResponse, ILoginResponse, IUser, IPersonModel } from '@loomcore/common/models';
 import type { AppIdType } from '@loomcore/common/types';
 import { MultiTenantApiService } from './multi-tenant-api.service.js';
 import { UpdateResult } from '../databases/models/update-result.js';
@@ -11,6 +11,7 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
     private emailService;
     private organizationService;
     private authConfig;
+    private personService;
     constructor(database: IDatabase);
     attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
     logUserIn(userContext: IUserContext, deviceId: string): Promise<{
@@ -22,7 +23,7 @@ export declare class AuthService extends MultiTenantApiService<IUser> {
         userContext: IUserContext;
     } | null>;
     getUserByEmail(email: string): Promise<IUser | null>;
-    createUser(userContext: IUserContext, user: Partial<IUser>): Promise<IUser | null>;
+    createUser(userContext: IUserContext, user: Partial<IUser>, person: Partial<IPersonModel>): Promise<IUser | null>;
     requestTokenUsingRefreshToken(refreshToken: string, deviceId: string): Promise<ITokenResponse | null>;
     changeLoggedInUsersPassword(userContext: IUserContext, body: any): Promise<UpdateResult>;
     changePassword(userContext: IUserContext, queryObject: any, password: string): Promise<UpdateResult>;

package/dist/services/auth.service.js

@@ -12,18 +12,21 @@ import { passwordUtils } from '../utils/index.js';
 import { config } from '../config/index.js';
 import { refreshTokenModelSpec } from '../models/refresh-token.model.js';
 import { getUserContextAuthorizations } from './utils/getUserContextAuthorizations.util.js';
+import { PersonService } from './person.service.js';
 export class AuthService extends MultiTenantApiService {
     refreshTokenService;
     passwordResetTokenService;
     emailService;
     organizationService;
     authConfig;
+    personService;
     constructor(database) {
         super(database, 'users', 'user', UserSpec);
         this.refreshTokenService = new GenericApiService(database, 'refresh_tokens', 'refresh_token', refreshTokenModelSpec);
         this.passwordResetTokenService = new PasswordResetTokenService(database);
         this.emailService = new EmailService();
         this.organizationService = new OrganizationService(database);
+        this.personService = new PersonService(database);
         if (!config.auth) {
             throw new ServerError('Auth configuration is not set');
         }
@@ -77,7 +80,7 @@ export class AuthService extends MultiTenantApiService {
         }
         return this.database.postProcessEntity(rawUser, this.modelSpec.fullSchema);
     }
-    async createUser(userContext, user) {
+    async createUser(userContext, user, person) {
         if (userContext.user._id === 'system') {
             if (config.app.isMultiTenant && userContext.organization?._id !== user._orgId) {
                 throw new BadRequestError('User is not authorized to create a user in this organization');
@@ -95,6 +98,17 @@ export class AuthService extends MultiTenantApiService {
                 throw new BadRequestError('A user with this email address already exists');
             }
         }
+        let personId = user.personId;
+        if (personId && person) {
+            const updatePersonResult = await this.personService.partialUpdateById(userContext, personId, person);
+        }
+        if (!personId) {
+            const newPerson = await this.personService.create(userContext, person);
+            if (newPerson) {
+                personId = newPerson._id;
+            }
+        }
+        user.personId = personId;
         return await this.create(userContext, user);
     }
     async requestTokenUsingRefreshToken(refreshToken, deviceId) {

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

@@ -0,0 +1,6 @@
+import { IPersonModel } from "@loomcore/common/models";
+import { IDatabase } from "../databases/index.js";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+export declare class PersonService extends GenericApiService<IPersonModel> {
+    constructor(database: IDatabase);
+}

package/dist/services/person.service.js

@@ -0,0 +1,7 @@
+import { personModelSpec } from "@loomcore/common/models";
+import { GenericApiService } from "./generic-api-service/generic-api.service.js";
+export class PersonService extends GenericApiService {
+    constructor(database) {
+        super(database, 'persons', 'person', personModelSpec);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -57,7 +57,7 @@
     "qs": "^6.14.1"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.43",
+    "@loomcore/common": "^0.0.46",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
@@ -82,7 +82,7 @@
     "cross-env": "^7.0.3",
     "mongodb-memory-server": "^9.3.0",
     "npm-run-all": "^4.1.5",
-    "pg-mem": "^3.0.8",
+    "pg-mem": "^3.0.12",
     "rxjs": "^7.8.0",
     "supertest": "^7.1.0",
     "typescript": "^5.8.3",

package/dist/databases/operations/__tests__/models/agent.model.js

@@ -1,8 +0,0 @@
-import { entityUtils } from "@loomcore/common/utils";
-import { Type } from "@sinclair/typebox";
-import { personSchema } from "./person.model.js";
-export const agentSchema = Type.Object({
-    person_id: Type.Number(),
-    agent_person: Type.Optional(personSchema),
-});
-export const agentModelSpec = entityUtils.getModelSpec(agentSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/client-report.model.js

@@ -1,11 +0,0 @@
-import { personSchema } from "./person.model.js";
-import { agentSchema } from "./agent.model.js";
-import { policySchema } from "./policy.model.js";
-import { entityUtils } from "@loomcore/common/utils";
-import { Type } from "@sinclair/typebox";
-export const clientReportsSchema = Type.Object({
-    client_person: personSchema,
-    agent: Type.Optional(agentSchema),
-    client_policies: Type.Optional(Type.Array(policySchema))
-});
-export const clientReportsModelSpec = entityUtils.getModelSpec(clientReportsSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/district.model.d.ts

@@ -1,12 +0,0 @@
-import type { IAuditable, IEntity } from "@loomcore/common/models";
-import { IStateModel } from "./state.model.js";
-export interface IDistrictModel extends IEntity, IAuditable {
-    name: string;
-    state_id: number;
-    state?: IStateModel;
-}
-export declare const districtSchema: import("@sinclair/typebox").TObject<{
-    name: import("@sinclair/typebox").TString;
-    state_id: import("@sinclair/typebox").TNumber;
-}>;
-export declare const districtModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/person.model.js

@@ -1,12 +0,0 @@
-import { entityUtils } from "@loomcore/common/utils";
-import { Type } from "@sinclair/typebox";
-import { emailAddressSchema } from "./email-address.model.js";
-import { phoneNumberSchema } from "./phone-number.model.js";
-export const personSchema = Type.Object({
-    first_name: Type.String(),
-    middle_name: Type.Optional(Type.String()),
-    last_name: Type.String(),
-    client_phone_numbers: Type.Array(phoneNumberSchema),
-    client_email_addresses: Type.Array(emailAddressSchema),
-});
-export const personModelSpec = entityUtils.getModelSpec(personSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/policy.model.js

@@ -1,12 +0,0 @@
-import { entityUtils } from "@loomcore/common/utils";
-import { Type } from "@sinclair/typebox";
-import { agentSchema } from "./agent.model.js";
-import { premiumSchema } from "./premium.model.js";
-export const policySchema = Type.Object({
-    client_id: Type.Number(),
-    amount: Type.Number(),
-    frequency: Type.String(),
-    agents: Type.Optional(Type.Array(agentSchema)),
-    policy_premiums: Type.Optional(Type.Array(premiumSchema))
-});
-export const policyModelSpec = entityUtils.getModelSpec(policySchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/school.model.d.ts

@@ -1,12 +0,0 @@
-import type { IAuditable, IEntity } from "@loomcore/common/models";
-import { IDistrictModel } from "./district.model.js";
-export interface ISchoolModel extends IEntity, IAuditable {
-    name: string;
-    district_id: number;
-    district?: IDistrictModel;
-}
-export declare const schoolSchema: import("@sinclair/typebox").TObject<{
-    name: import("@sinclair/typebox").TString;
-    district_id: import("@sinclair/typebox").TNumber;
-}>;
-export declare const schoolModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/state.model.d.ts

@@ -1,8 +0,0 @@
-import type { IAuditable, IEntity } from "@loomcore/common/models";
-export interface IStateModel extends IEntity, IAuditable {
-    name: string;
-}
-export declare const stateSchema: import("@sinclair/typebox").TObject<{
-    name: import("@sinclair/typebox").TString;
-}>;
-export declare const stateModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/state.model.js

@@ -1,6 +0,0 @@
-import { entityUtils } from "@loomcore/common/utils";
-import { Type } from "@sinclair/typebox";
-export const stateSchema = Type.Object({
-    name: Type.String(),
-});
-export const stateModelSpec = entityUtils.getModelSpec(stateSchema, { isAuditable: true });