@loomcore/api 0.1.77 → 0.1.79

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/test-premium.model.d.ts

@@ -0,0 +1,12 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+export interface ITestPremiumModel extends IEntity, IAuditable {
+    policy_id: number;
+    amount: number;
+    date: Date | string;
+}
+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 testPremiumModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const testPremiumSchema = Type.Object({
+    policy_id: Type.Number(),
+    amount: Type.Number(),
+    date: Type.Union([Type.Date(), Type.String()])
+});
+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/operations/join-many.operation.js

@@ -4,6 +4,9 @@ export class JoinMany {
     foreignField;
     as;
     constructor(from, localField, foreignField, as) {
+        if (from === as) {
+            throw new Error(`JoinMany alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
+        }
         this.from = from;
         this.localField = localField;
         this.foreignField = foreignField;

package/dist/databases/operations/join-through-many.operation.js

@@ -7,6 +7,9 @@ export class JoinThroughMany {
     foreignField;
     as;
     constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
+        if (from === as) {
+            throw new Error(`JoinThroughMany alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
+        }
         this.from = from;
         this.through = through;
         this.localField = localField;

package/dist/databases/operations/join-through.operation.js

@@ -7,6 +7,9 @@ export class JoinThrough {
     foreignField;
     as;
     constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
+        if (from === as) {
+            throw new Error(`JoinThrough alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
+        }
         this.from = from;
         this.through = through;
         this.localField = localField;

package/dist/databases/operations/join.operation.js

@@ -4,6 +4,9 @@ export class Join {
     foreignField;
     as;
     constructor(from, localField, foreignField, as) {
+        if (from === as) {
+            throw new Error(`Join alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
+        }
         this.from = from;
         this.localField = localField;
         this.foreignField = foreignField;

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 {