@loomcore/api 0.1.85 → 0.1.86

package/dist/__tests__/models/product.model.d.ts

@@ -1,17 +1,18 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
 import { ICategory } from "./category.model.js";
+import { AppIdType } from "@loomcore/common/types";
 export interface IProduct extends IEntity, IAuditable {
     name: string;
     description?: string;
     internalNumber?: string;
-    categoryId: string;
+    categoryId: AppIdType;
     category?: ICategory;
 }
 export declare const ProductSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
     description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     internalNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    categoryId: import("@sinclair/typebox").TString;
+    categoryId: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
 }>;
 export declare const ProductSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
 export declare const PublicProductSchema: import("@sinclair/typebox").TObject<{}>;

package/dist/__tests__/models/product.model.js

@@ -4,7 +4,7 @@ export const ProductSchema = Type.Object({
     name: Type.String(),
     description: Type.Optional(Type.String()),
     internalNumber: Type.Optional(Type.String()),
-    categoryId: Type.String({ title: 'Category ID' }),
+    categoryId: Type.Union([Type.String({ title: 'Category ID' }), Type.Number({ title: 'Category ID' })]),
 });
 export const ProductSpec = entityUtils.getModelSpec(ProductSchema, { isAuditable: true });
 export const PublicProductSchema = Type.Omit(ProductSpec.fullSchema, ['internalNumber']);

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -11,7 +11,7 @@ export const getPostgresTestSchema = (config) => {
           ${orgColumnDef}
           "name" VARCHAR(255) NOT NULL,
           "description" TEXT,
-          "isActive" BOOLEAN,
+          "is_active" BOOLEAN,
           "tags" TEXT[],
           "count" INTEGER,
           "_created" TIMESTAMPTZ NOT NULL,
@@ -53,15 +53,15 @@ export const getPostgresTestSchema = (config) => {
           ${orgColumnDef}
           "name" VARCHAR(255) NOT NULL,
           "description" TEXT,
-          "internalNumber" VARCHAR(255),
-          "categoryId" INTEGER NOT NULL,
+          "internal_number" VARCHAR(255),
+          "category_id" INTEGER NOT NULL,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,
           "_updatedBy" INTEGER NOT NULL,
           "_deleted" TIMESTAMPTZ,
           "_deletedBy" INTEGER,
-          CONSTRAINT "fk_products_category" FOREIGN KEY ("categoryId") REFERENCES "categories"("_id") ON DELETE CASCADE
+          CONSTRAINT "fk_products_category" FOREIGN KEY ("category_id") REFERENCES "categories"("_id") ON DELETE CASCADE
         )
       `);
         },
@@ -79,7 +79,7 @@ export const getPostgresTestSchema = (config) => {
           ${orgColumnDef}
           "name" VARCHAR(255) NOT NULL,
           "value" INTEGER,
-          "eventDate" TIMESTAMPTZ,
+          "event_date" TIMESTAMPTZ,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,

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

@@ -1,24 +1,24 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
 import { ITestPersonModel } from "./test-person.model.js";
 export interface ITestAgentModel extends IEntity, IAuditable {
-    person_id: number;
-    agent_person?: ITestPersonModel;
+    personId: number;
+    agentPerson?: ITestPersonModel;
 }
 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;
-        middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        last_name: import("@sinclair/typebox").TString;
-        client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            phone_number: import("@sinclair/typebox").TString;
-            phone_number_type: import("@sinclair/typebox").TString;
-            is_default: import("@sinclair/typebox").TBoolean;
+    personId: import("@sinclair/typebox").TNumber;
+    agentPerson: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        firstName: import("@sinclair/typebox").TString;
+        middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        lastName: import("@sinclair/typebox").TString;
+        clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            phoneNumber: import("@sinclair/typebox").TString;
+            phoneNumberType: import("@sinclair/typebox").TString;
+            isDefault: import("@sinclair/typebox").TBoolean;
         }>>;
-        client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            person_id: import("@sinclair/typebox").TNumber;
-            email_address: import("@sinclair/typebox").TString;
-            is_default: import("@sinclair/typebox").TBoolean;
+        clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            personId: import("@sinclair/typebox").TNumber;
+            emailAddress: import("@sinclair/typebox").TString;
+            isDefault: import("@sinclair/typebox").TBoolean;
         }>>;
     }>>;
 }>;

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

@@ -2,7 +2,7 @@ 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),
+    personId: Type.Number(),
+    agentPerson: Type.Optional(testPersonSchema),
 });
 export const testAgentModelSpec = entityUtils.getModelSpec(testAgentSchema, { isAuditable: true });

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

@@ -3,68 +3,68 @@ import { ITestAgentModel } from "./test-agent.model.js";
 import { ITestPolicyModel } from "./test-policy.model.js";
 import type { IAuditable, IEntity } from "@loomcore/common/models";
 export interface ITestClientReportsModel extends IEntity, IAuditable {
-    client_person: ITestPersonModel;
+    clientPerson: ITestPersonModel;
     agent?: ITestAgentModel;
-    client_policies?: ITestPolicyModel[];
+    clientPolicies?: ITestPolicyModel[];
 }
 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>;
-        last_name: import("@sinclair/typebox").TString;
-        client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            phone_number: import("@sinclair/typebox").TString;
-            phone_number_type: import("@sinclair/typebox").TString;
-            is_default: import("@sinclair/typebox").TBoolean;
+    clientPerson: import("@sinclair/typebox").TObject<{
+        firstName: import("@sinclair/typebox").TString;
+        middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        lastName: import("@sinclair/typebox").TString;
+        clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            phoneNumber: import("@sinclair/typebox").TString;
+            phoneNumberType: import("@sinclair/typebox").TString;
+            isDefault: import("@sinclair/typebox").TBoolean;
         }>>;
-        client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            person_id: import("@sinclair/typebox").TNumber;
-            email_address: import("@sinclair/typebox").TString;
-            is_default: import("@sinclair/typebox").TBoolean;
+        clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            personId: import("@sinclair/typebox").TNumber;
+            emailAddress: import("@sinclair/typebox").TString;
+            isDefault: import("@sinclair/typebox").TBoolean;
         }>>;
     }>;
     agent: import("@sinclair/typebox").TOptional<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;
-            middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            last_name: import("@sinclair/typebox").TString;
-            client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                phone_number: import("@sinclair/typebox").TString;
-                phone_number_type: import("@sinclair/typebox").TString;
-                is_default: import("@sinclair/typebox").TBoolean;
+        personId: import("@sinclair/typebox").TNumber;
+        agentPerson: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            firstName: import("@sinclair/typebox").TString;
+            middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            lastName: import("@sinclair/typebox").TString;
+            clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                phoneNumber: import("@sinclair/typebox").TString;
+                phoneNumberType: import("@sinclair/typebox").TString;
+                isDefault: import("@sinclair/typebox").TBoolean;
             }>>;
-            client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                person_id: import("@sinclair/typebox").TNumber;
-                email_address: import("@sinclair/typebox").TString;
-                is_default: import("@sinclair/typebox").TBoolean;
+            clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                personId: import("@sinclair/typebox").TNumber;
+                emailAddress: import("@sinclair/typebox").TString;
+                isDefault: import("@sinclair/typebox").TBoolean;
             }>>;
         }>>;
     }>>;
-    client_policies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        client_id: import("@sinclair/typebox").TNumber;
+    clientPolicies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        clientId: import("@sinclair/typebox").TNumber;
         amount: import("@sinclair/typebox").TNumber;
         frequency: import("@sinclair/typebox").TString;
         agents: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<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;
-                middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-                last_name: import("@sinclair/typebox").TString;
-                client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                    phone_number: import("@sinclair/typebox").TString;
-                    phone_number_type: import("@sinclair/typebox").TString;
-                    is_default: import("@sinclair/typebox").TBoolean;
+            personId: import("@sinclair/typebox").TNumber;
+            agentPerson: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                firstName: import("@sinclair/typebox").TString;
+                middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+                lastName: import("@sinclair/typebox").TString;
+                clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    phoneNumber: import("@sinclair/typebox").TString;
+                    phoneNumberType: import("@sinclair/typebox").TString;
+                    isDefault: import("@sinclair/typebox").TBoolean;
                 }>>;
-                client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                    person_id: import("@sinclair/typebox").TNumber;
-                    email_address: import("@sinclair/typebox").TString;
-                    is_default: import("@sinclair/typebox").TBoolean;
+                clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    personId: import("@sinclair/typebox").TNumber;
+                    emailAddress: import("@sinclair/typebox").TString;
+                    isDefault: import("@sinclair/typebox").TBoolean;
                 }>>;
             }>>;
         }>>>;
-        policy_premiums: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            policy_id: import("@sinclair/typebox").TNumber;
+        policyPremiums: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            policyId: import("@sinclair/typebox").TNumber;
             amount: import("@sinclair/typebox").TNumber;
             date: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TString]>;
         }>>>;

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

@@ -4,8 +4,8 @@ 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,
+    clientPerson: testPersonSchema,
     agent: Type.Optional(testAgentSchema),
-    client_policies: Type.Optional(Type.Array(testPolicySchema))
+    clientPolicies: Type.Optional(Type.Array(testPolicySchema))
 });
 export const testClientReportsModelSpec = entityUtils.getModelSpec(testClientReportsSchema, { isAuditable: true });

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

@@ -2,11 +2,11 @@ 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;
+    stateId: number;
     state?: ITestStateModel;
 }
 export declare const testDistrictSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
-    state_id: import("@sinclair/typebox").TNumber;
+    stateId: import("@sinclair/typebox").TNumber;
 }>;
 export declare const testDistrictModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

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

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

@@ -1,12 +1,12 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
 export interface ITestEmailAddressModel extends IEntity, IAuditable {
-    person_id: number;
-    email_address: string;
-    is_default: boolean;
+    personId: number;
+    emailAddress: string;
+    isDefault: boolean;
 }
 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;
+    personId: import("@sinclair/typebox").TNumber;
+    emailAddress: import("@sinclair/typebox").TString;
+    isDefault: import("@sinclair/typebox").TBoolean;
 }>;
 export declare const testEmailAddressModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

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

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

@@ -3,26 +3,26 @@ 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: ITestEmailAddressModel[];
-    client_phone_numbers: ITestPhoneNumberModel[];
+    firstName: string;
+    middleName: string | null;
+    lastName: string;
+    clientEmailAddresses: ITestEmailAddressModel[];
+    clientPhoneNumbers: ITestPhoneNumberModel[];
     school?: ITestSchoolModel;
 }
 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;
-    client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        phone_number: import("@sinclair/typebox").TString;
-        phone_number_type: import("@sinclair/typebox").TString;
-        is_default: import("@sinclair/typebox").TBoolean;
+    firstName: import("@sinclair/typebox").TString;
+    middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    lastName: import("@sinclair/typebox").TString;
+    clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        phoneNumber: import("@sinclair/typebox").TString;
+        phoneNumberType: import("@sinclair/typebox").TString;
+        isDefault: import("@sinclair/typebox").TBoolean;
     }>>;
-    client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        person_id: import("@sinclair/typebox").TNumber;
-        email_address: import("@sinclair/typebox").TString;
-        is_default: import("@sinclair/typebox").TBoolean;
+    clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        personId: import("@sinclair/typebox").TNumber;
+        emailAddress: import("@sinclair/typebox").TString;
+        isDefault: import("@sinclair/typebox").TBoolean;
     }>>;
 }>;
 export declare const testPersonModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -3,10 +3,10 @@ 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),
+    firstName: Type.String(),
+    middleName: Type.Optional(Type.String()),
+    lastName: Type.String(),
+    clientPhoneNumbers: Type.Array(testPhoneNumberSchema),
+    clientEmailAddresses: Type.Array(testEmailAddressSchema),
 });
 export const testPersonModelSpec = entityUtils.getModelSpec(testPersonSchema, { isAuditable: true });

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

@@ -1,12 +1,12 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
 export interface ITestPhoneNumberModel extends IEntity, IAuditable {
-    phone_number: string;
-    phone_number_type: string;
-    is_default: boolean;
+    phoneNumber: string;
+    phoneNumberType: string;
+    isDefault: boolean;
 }
 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;
+    phoneNumber: import("@sinclair/typebox").TString;
+    phoneNumberType: import("@sinclair/typebox").TString;
+    isDefault: import("@sinclair/typebox").TBoolean;
 }>;
 export declare const testPhoneNumberModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

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

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

@@ -2,36 +2,36 @@ import type { IAuditable, IEntity } from "@loomcore/common/models";
 import { ITestAgentModel } from "./test-agent.model.js";
 import { ITestPremiumModel } from "./test-premium.model.js";
 export interface ITestPolicyModel extends IEntity, IAuditable {
-    client_id: number;
+    clientId: number;
     amount: number;
     frequency: string;
     agents?: ITestAgentModel[];
-    policy_premiums?: ITestPremiumModel[];
+    policyPremiums?: ITestPremiumModel[];
 }
 export declare const testPolicySchema: import("@sinclair/typebox").TObject<{
-    client_id: import("@sinclair/typebox").TNumber;
+    clientId: import("@sinclair/typebox").TNumber;
     amount: import("@sinclair/typebox").TNumber;
     frequency: import("@sinclair/typebox").TString;
     agents: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<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;
-            middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-            last_name: import("@sinclair/typebox").TString;
-            client_phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                phone_number: import("@sinclair/typebox").TString;
-                phone_number_type: import("@sinclair/typebox").TString;
-                is_default: import("@sinclair/typebox").TBoolean;
+        personId: import("@sinclair/typebox").TNumber;
+        agentPerson: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            firstName: import("@sinclair/typebox").TString;
+            middleName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            lastName: import("@sinclair/typebox").TString;
+            clientPhoneNumbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                phoneNumber: import("@sinclair/typebox").TString;
+                phoneNumberType: import("@sinclair/typebox").TString;
+                isDefault: import("@sinclair/typebox").TBoolean;
             }>>;
-            client_email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-                person_id: import("@sinclair/typebox").TNumber;
-                email_address: import("@sinclair/typebox").TString;
-                is_default: import("@sinclair/typebox").TBoolean;
+            clientEmailAddresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                personId: import("@sinclair/typebox").TNumber;
+                emailAddress: import("@sinclair/typebox").TString;
+                isDefault: import("@sinclair/typebox").TBoolean;
             }>>;
         }>>;
     }>>>;
-    policy_premiums: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        policy_id: import("@sinclair/typebox").TNumber;
+    policyPremiums: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        policyId: import("@sinclair/typebox").TNumber;
         amount: import("@sinclair/typebox").TNumber;
         date: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TDate, import("@sinclair/typebox").TString]>;
     }>>>;

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

@@ -3,10 +3,10 @@ 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(),
+    clientId: Type.Number(),
     amount: Type.Number(),
     frequency: Type.String(),
     agents: Type.Optional(Type.Array(testAgentSchema)),
-    policy_premiums: Type.Optional(Type.Array(testPremiumSchema))
+    policyPremiums: Type.Optional(Type.Array(testPremiumSchema))
 });
 export const testPolicyModelSpec = entityUtils.getModelSpec(testPolicySchema, { isAuditable: true });

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

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

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

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

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

@@ -2,11 +2,11 @@ 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;
+    districtId: number;
     district?: ITestDistrictModel;
 }
 export declare const testSchoolSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
-    district_id: import("@sinclair/typebox").TNumber;
+    districtId: import("@sinclair/typebox").TNumber;
 }>;
 export declare const testSchoolModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

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

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.js

@@ -3,7 +3,10 @@ import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 export async function partialUpdateById(client, operations, id, entity, pluralResourceName) {
     try {
+        console.log('entity', JSON.stringify(entity, null, 2));
         const { columns, values } = columnsAndValuesFromEntity(entity);
+        console.log('columns', JSON.stringify(columns, null, 2));
+        console.log('values', JSON.stringify(values, null, 2));
         const updateColumns = columns.filter(col => col !== '"_id"');
         const updateValues = values.filter((_, index) => columns[index] !== '"_id"');
         if (updateColumns.length === 0) {

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

@@ -25,8 +25,8 @@ export const getPostgresInitialSchema = (config) => {
             "code" VARCHAR(255) NOT NULL UNIQUE,
             "description" TEXT,
             "status" INTEGER NOT NULL,
-            "isMetaOrg" BOOLEAN NOT NULL,
-            "authToken" TEXT,
+            "is_meta_org" BOOLEAN NOT NULL,
+            "auth_token" TEXT,
             "_created" TIMESTAMPTZ NOT NULL,
             "_createdBy" INTEGER NOT NULL,
             "_updated" TIMESTAMPTZ NOT NULL,
@@ -50,15 +50,15 @@ export const getPostgresInitialSchema = (config) => {
           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,
+            "external_id" VARCHAR(255) UNIQUE,
+            "first_name" VARCHAR(255) NOT NULL,
+            "middle_name" VARCHAR(255),
+            "last_name" VARCHAR(255) NOT NULL,
+            "date_of_birth" DATE,
+            "is_agent" BOOLEAN NOT NULL DEFAULT FALSE,
+            "is_client" BOOLEAN NOT NULL DEFAULT FALSE,
+            "is_employee" BOOLEAN NOT NULL DEFAULT FALSE,
+            "extended_types" INTEGER,
             "_created" TIMESTAMPTZ NOT NULL,
             "_createdBy" INTEGER NOT NULL,
             "_updated" TIMESTAMPTZ NOT NULL,
@@ -81,16 +81,16 @@ export const getPostgresInitialSchema = (config) => {
                     ? '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`;
+          CONSTRAINT "fk_users_person_id" FOREIGN KEY("person_id") 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,
+          "external_id" VARCHAR(255) UNIQUE,
           "email" VARCHAR(255) NOT NULL,
-          "displayName" VARCHAR(255),
+          "display_name" VARCHAR(255),
           "password" VARCHAR(255) NOT NULL,
-          "personId" INTEGER UNIQUE,
+          "person_id" INTEGER UNIQUE,
           "_lastLoggedIn" TIMESTAMPTZ,
           "_lastPasswordChange" TIMESTAMPTZ,
           "_created" TIMESTAMPTZ NOT NULL,
@@ -117,12 +117,12 @@ export const getPostgresInitialSchema = (config) => {
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
           ${orgColumnDef}
           "token" VARCHAR(255) NOT NULL,
-          "deviceId" VARCHAR(255) NOT NULL,
-          "userId" INTEGER NOT NULL,
-          "expiresOn" BIGINT NOT NULL,
+          "device_id" VARCHAR(255) NOT NULL,
+          "user_id" INTEGER NOT NULL,
+          "expires_on" BIGINT NOT NULL,
           "created" TIMESTAMPTZ NOT NULL,
-          "createdBy" INTEGER NOT NULL,
-          CONSTRAINT "fk_refresh_tokens_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE
+          "created_by" INTEGER NOT NULL,
+          CONSTRAINT "fk_refresh_tokens_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE
         )
       `);
             },
@@ -144,7 +144,7 @@ export const getPostgresInitialSchema = (config) => {
           ${orgColumnDef}
           "email" VARCHAR(255) NOT NULL,
           "token" VARCHAR(255) NOT NULL,
-          "expiresOn" BIGINT NOT NULL,
+          "expires_on" BIGINT NOT NULL,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,
@@ -156,7 +156,7 @@ export const getPostgresInitialSchema = (config) => {
       `);
             },
             down: async ({ context: pool }) => {
-                await pool.query('DROP TABLE IF EXISTS "passwordResetTokens"');
+                await pool.query('DROP TABLE IF EXISTS "password_reset_tokens"');
             }
         });
     if (isAuthEnabled)
@@ -187,22 +187,22 @@ export const getPostgresInitialSchema = (config) => {
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
-                    ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "userId", "roleId")'
-                    : 'CONSTRAINT "uk_user_roles" UNIQUE ("userId", "roleId")';
+                    ? 'CONSTRAINT "uk_user_roles" UNIQUE ("_orgId", "user_id", "role_id")'
+                    : 'CONSTRAINT "uk_user_roles" UNIQUE ("user_id", "role_id")';
                 await pool.query(`
         CREATE TABLE IF NOT EXISTS "user_roles" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
           ${orgColumnDef}
-          "userId" INTEGER NOT NULL,
-          "roleId" INTEGER NOT NULL,
+          "user_id" INTEGER NOT NULL,
+          "role_id" INTEGER NOT NULL,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,
           "_updatedBy" INTEGER NOT NULL,
           "_deleted" TIMESTAMPTZ,
           "_deletedBy" INTEGER,
-          CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("userId") REFERENCES "users"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_user_roles_user" FOREIGN KEY ("user_id") REFERENCES "users"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_user_roles_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
           ${uniqueConstraint}
         )
       `);
@@ -239,16 +239,16 @@ export const getPostgresInitialSchema = (config) => {
             up: async ({ context: pool }) => {
                 const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
                 const uniqueConstraint = isMultiTenant
-                    ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "roleId", "featureId")'
-                    : 'CONSTRAINT "uk_authorizations" UNIQUE ("roleId", "featureId")';
+                    ? 'CONSTRAINT "uk_authorizations" UNIQUE ("_orgId", "role_id", "feature_id")'
+                    : 'CONSTRAINT "uk_authorizations" UNIQUE ("role_id", "feature_id")';
                 await pool.query(`
         CREATE TABLE IF NOT EXISTS "authorizations" (
           "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
           ${orgColumnDef}
-          "roleId" INTEGER NOT NULL,
-          "featureId" INTEGER NOT NULL,
-          "startDate" TIMESTAMPTZ,
-          "endDate" TIMESTAMPTZ,
+          "role_id" INTEGER NOT NULL,
+          "feature_id" INTEGER NOT NULL,
+          "start_date" TIMESTAMPTZ,
+          "end_date" TIMESTAMPTZ,
           "config" JSONB,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
@@ -256,8 +256,8 @@ export const getPostgresInitialSchema = (config) => {
           "_updatedBy" INTEGER NOT NULL,
           "_deleted" TIMESTAMPTZ,
           "_deletedBy" INTEGER,
-          CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("roleId") REFERENCES "roles"("_id") ON DELETE CASCADE,
-          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("featureId") REFERENCES "features"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_authorizations_role" FOREIGN KEY ("role_id") REFERENCES "roles"("_id") ON DELETE CASCADE,
+          CONSTRAINT "fk_authorizations_feature" FOREIGN KEY ("feature_id") REFERENCES "features"("_id") ON DELETE CASCADE,
           ${uniqueConstraint}
         )
       `);
@@ -271,9 +271,9 @@ export const getPostgresInitialSchema = (config) => {
             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")
+          INSERT INTO "organizations" ("name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy")
           VALUES ($1, $2, 1, true, NOW(), 0, NOW(), 0)
-          RETURNING "_id", "name", "code", "status", "isMetaOrg", "_created", "_createdBy", "_updated", "_updatedBy"
+          RETURNING "_id", "name", "code", "status", "is_meta_org", "_created", "_createdBy", "_updated", "_updatedBy"
         `, [config.multiTenant?.metaOrgName, config.multiTenant?.metaOrgCode]);
                 if (result.rowCount === 0) {
                     throw new Error('Failed to create meta organization');
@@ -281,7 +281,7 @@ export const getPostgresInitialSchema = (config) => {
                 initializeSystemUserContext(config.email?.systemEmailAddress || 'system@example.com', result.rows[0]);
             },
             down: async ({ context: pool }) => {
-                await pool.query(`DELETE FROM "organizations" WHERE "isMetaOrg" = TRUE`);
+                await pool.query(`DELETE FROM "organizations" WHERE "is_meta_org" = TRUE`);
             }
         });
     }
@@ -367,11 +367,11 @@ export const getPostgresInitialSchema = (config) => {
                         const roleId = roleResult.rows[0]._id;
                         const userRoleResult = isMultiTenant
                             ? await client.query(`
-                  INSERT INTO "user_roles" ("_orgId", "userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  INSERT INTO "user_roles" ("_orgId", "user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
                   VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
                 `, [metaOrg._id, adminUser._id, roleId])
                             : await client.query(`
-                  INSERT INTO "user_roles" ("userId", "roleId", "_created", "_createdBy", "_updated", "_updatedBy")
+                  INSERT INTO "user_roles" ("user_id", "role_id", "_created", "_createdBy", "_updated", "_updatedBy")
                   VALUES ($1, $2, NOW(), 0, NOW(), 0)
                 `, [adminUser._id, roleId]);
                         if (userRoleResult.rowCount === 0) {
@@ -395,14 +395,14 @@ export const getPostgresInitialSchema = (config) => {
                         const authorizationResult = isMultiTenant
                             ? await client.query(`
                   INSERT INTO "authorizations" (
-                    "_orgId", "roleId", "featureId", 
+                    "_orgId", "role_id", "feature_id", 
                     "_created", "_createdBy", "_updated", "_updatedBy"
                   )
                   VALUES ($1, $2, $3, NOW(), 0, NOW(), 0)
                 `, [metaOrg._id, roleId, featureId])
                             : await client.query(`
                   INSERT INTO "authorizations" (
-                    "roleId", "featureId", 
+                    "role_id", "feature_id", 
                     "_created", "_createdBy", "_updated", "_updatedBy"
                   )
                   VALUES ($1, $2, NOW(), 0, NOW(), 0)
@@ -435,11 +435,11 @@ export const getPostgresInitialSchema = (config) => {
                             await client.query(`
                 DELETE FROM "authorizations" 
                 WHERE "_orgId" = $1 
-                AND "featureId" IN (
+                AND "feature_id" IN (
                   SELECT "_id" FROM "features" 
                   WHERE "_orgId" = $1 AND "name" = 'admin'
                 )
-                AND "roleId" IN (
+                AND "role_id" IN (
                   SELECT "_id" FROM "roles" 
                   WHERE "_orgId" = $1 AND "name" = 'admin'
                 )
@@ -451,7 +451,7 @@ export const getPostgresInitialSchema = (config) => {
                             await client.query(`
                 DELETE FROM "user_roles" 
                 WHERE "_orgId" = $1 
-                AND "roleId" IN (
+                AND "role_id" IN (
                   SELECT "_id" FROM "roles" 
                   WHERE "_orgId" = $1 AND "name" = 'admin'
                 )
@@ -464,11 +464,11 @@ export const getPostgresInitialSchema = (config) => {
                         else {
                             await client.query(`
                 DELETE FROM "authorizations" 
-                WHERE "featureId" IN (
+                WHERE "feature_id" IN (
                   SELECT "_id" FROM "features" 
                   WHERE "name" = 'admin'
                 )
-                AND "roleId" IN (
+                AND "role_id" IN (
                   SELECT "_id" FROM "roles" 
                   WHERE "name" = 'admin'
                 )
@@ -479,7 +479,7 @@ export const getPostgresInitialSchema = (config) => {
               `);
                             await client.query(`
                 DELETE FROM "user_roles" 
-                WHERE "roleId" IN (
+                WHERE "role_id" IN (
                   SELECT "_id" FROM "roles" 
                   WHERE "name" = 'admin'
                 )

package/dist/databases/postgres/postgres.database.js

@@ -13,16 +13,18 @@ import { get as getQuery } from "./queries/postgres-get.query.js";
 import { getById as getByIdQuery } from "./queries/postgres-get-by-id.query.js";
 import { getCount as getCountQuery } from "./queries/postgres-get-count.query.js";
 import { convertNullToUndefined } from "./utils/convert-null-to-undefined.util.js";
+import { convertKeysToSnakeCase, convertKeysToCamelCase } from "./utils/convert-keys.util.js";
 export class PostgresDatabase {
     client;
     constructor(client) {
         this.client = client;
     }
     preProcessEntity(entity, modelSpec) {
-        return entity;
+        return convertKeysToSnakeCase(entity);
     }
     postProcessEntity(entity, modelSpec) {
-        return convertNullToUndefined(entity, modelSpec);
+        const withNullsConverted = convertNullToUndefined(entity, modelSpec);
+        return convertKeysToCamelCase(withNullsConverted);
     }
     async getAll(operations, pluralResourceName) {
         return getAllQuery(this.client, operations, pluralResourceName);
@@ -70,21 +72,21 @@ export class PostgresDatabase {
         const now = new Date();
         let query = `
             SELECT DISTINCT
-                ur."userId" as "userId",
+                ur."user_id" as "userId",
                 r."name" as "role",
                 f."name" as "feature",
                 a."config",
                 a."_id",
                 a."_orgId"
             FROM "user_roles" ur
-            INNER JOIN "roles" r ON ur."roleId" = r."_id"
-            INNER JOIN "authorizations" a ON r."_id" = a."roleId"
-            INNER JOIN "features" f ON a."featureId" = f."_id"
-            WHERE ur."userId" = $1
+            INNER JOIN "roles" r ON ur."role_id" = r."_id"
+            INNER JOIN "authorizations" a ON r."_id" = a."role_id"
+            INNER JOIN "features" f ON a."feature_id" = f."_id"
+            WHERE ur."user_id" = $1
                 AND ur."_deleted" IS NULL
                 AND a."_deleted" IS NULL
-                AND (a."startDate" IS NULL OR a."startDate" <= $2)
-                AND (a."endDate" IS NULL OR a."endDate" >= $2)
+                AND (a."start_date" IS NULL OR a."start_date" <= $2)
+                AND (a."end_date" IS NULL OR a."end_date" >= $2)
         `;
         const values = [userId, now];
         if (orgId) {

package/dist/databases/postgres/utils/build-join-clauses.js

@@ -2,11 +2,24 @@ import { Join } from "../../operations/join.operation.js";
 import { JoinMany } from "../../operations/join-many.operation.js";
 import { JoinThrough } from "../../operations/join-through.operation.js";
 import { JoinThroughMany } from "../../operations/join-through-many.operation.js";
+import { toSnakeCase } from "./convert-keys.util.js";
+function convertFieldToSnakeCase(field) {
+    if (field.startsWith('_')) {
+        return field;
+    }
+    else if (field === 'id') {
+        return '_id';
+    }
+    else {
+        return toSnakeCase(field);
+    }
+}
 function resolveLocalField(localField, mainTableName, operations) {
     if (!localField.includes('.')) {
+        const snakeField = convertFieldToSnakeCase(localField);
         return mainTableName
-            ? `"${mainTableName}"."${localField}"`
-            : `"${localField}"`;
+            ? `"${mainTableName}"."${snakeField}"`
+            : `"${snakeField}"`;
     }
     const [alias, field] = localField.split('.');
     const objectJoin = operations.find(op => op instanceof JoinThrough && op.as === alias);
@@ -17,7 +30,8 @@ function resolveLocalField(localField, mainTableName, operations) {
     if (arrayJoin) {
         return `(${alias}.aggregated->>'${field}')::integer`;
     }
-    return `${alias}."${field}"`;
+    const snakeField = convertFieldToSnakeCase(field);
+    return `${alias}."${snakeField}"`;
 }
 function findEnrichmentTarget(operation, operations) {
     if (!operation.localField.includes('.')) {
@@ -76,7 +90,10 @@ export function buildJoinClauses(operations, mainTableName) {
                     const { target, field } = enrichment;
                     const targetLocalFieldRef = target.localField.includes('.')
                         ? resolveLocalField(target.localField, mainTableName, operations)
-                        : (mainTableName ? `"${mainTableName}"."${target.localField}"` : `"${target.localField}"`);
+                        : (() => {
+                            const snakeField = convertFieldToSnakeCase(target.localField);
+                            return mainTableName ? `"${mainTableName}"."${snakeField}"` : `"${snakeField}"`;
+                        })();
                     let enrichmentJoins = '';
                     let jsonBuildObjects = '';
                     for (const enrich of enrichments) {
@@ -188,7 +205,10 @@ export function buildJoinClauses(operations, mainTableName) {
                     const { target, field } = enrichment;
                     const targetLocalFieldRef = target.localField.includes('.')
                         ? resolveLocalField(target.localField, mainTableName, operations)
-                        : (mainTableName ? `"${mainTableName}"."${target.localField}"` : `"${target.localField}"`);
+                        : (() => {
+                            const snakeField = convertFieldToSnakeCase(target.localField);
+                            return mainTableName ? `"${mainTableName}"."${snakeField}"` : `"${snakeField}"`;
+                        })();
                     const isTargetJoinMany = target instanceof JoinMany;
                     let enrichmentJoins = '';
                     let jsonBuildObjects = '';

package/dist/databases/postgres/utils/build-where-clause.js

@@ -1,3 +1,4 @@
+import { toSnakeCase } from "./convert-keys.util.js";
 export function buildWhereClause(queryObject, values = [], tablePrefix) {
     const filters = queryObject.filters || {};
     const conditions = [];
@@ -7,7 +8,17 @@ export function buildWhereClause(queryObject, values = [], tablePrefix) {
     };
     for (const [key, value] of Object.entries(filters)) {
         if (value) {
-            const qualifiedKey = qualifyColumn(key);
+            let snakeKey;
+            if (key.startsWith('_')) {
+                snakeKey = key;
+            }
+            else if (key === 'id') {
+                snakeKey = '_id';
+            }
+            else {
+                snakeKey = toSnakeCase(key);
+            }
+            const qualifiedKey = qualifyColumn(snakeKey);
             if (value.eq !== undefined) {
                 conditions.push(`${qualifiedKey} = $${paramIndex}`);
                 values.push(value.eq);

package/dist/databases/postgres/utils/columns-and-values-from-entity.js

@@ -2,8 +2,10 @@ export function columnsAndValuesFromEntity(entity) {
     const columns = [];
     const values = [];
     for (const [key, value] of Object.entries(entity)) {
-        columns.push(`"${key}"`);
-        values.push(value);
+        if (value !== undefined) {
+            columns.push(`"${key}"`);
+            values.push(value);
+        }
     }
     return { columns, values };
 }

package/dist/databases/postgres/utils/convert-keys.util.d.ts

@@ -0,0 +1,4 @@
+export declare function toSnakeCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function convertKeysToSnakeCase<T>(obj: T): T;
+export declare function convertKeysToCamelCase<T>(obj: T): T;

package/dist/databases/postgres/utils/convert-keys.util.js

@@ -0,0 +1,85 @@
+import _ from 'lodash';
+export function toSnakeCase(str) {
+    let result = str.replace(/([a-z])([A-Z])/g, '$1_$2');
+    result = result.toLowerCase()
+        .replace(/[\s-]/g, '_');
+    result = result.replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+    return result;
+}
+export function toCamelCase(str) {
+    return str.split(/[-_]+/)
+        .map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+}
+export function convertKeysToSnakeCase(obj) {
+    if (!obj)
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map(item => convertKeysToSnakeCase(item));
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    const clone = _.cloneDeep(obj);
+    const result = {};
+    for (const [key, value] of Object.entries(clone)) {
+        const snakeKey = key.startsWith('_') ? key : toSnakeCase(key);
+        if (value !== null && value !== undefined) {
+            if (Array.isArray(value)) {
+                result[snakeKey] = value.map(item => convertKeysToSnakeCase(item));
+            }
+            else if (typeof value === 'object' && !(value instanceof Date)) {
+                result[snakeKey] = convertKeysToSnakeCase(value);
+            }
+            else {
+                result[snakeKey] = value;
+            }
+        }
+        else {
+            result[snakeKey] = value;
+        }
+    }
+    return result;
+}
+export function convertKeysToCamelCase(obj) {
+    if (!obj)
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map(item => convertKeysToCamelCase(item));
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    const clone = _.cloneDeep(obj);
+    const result = {};
+    for (const [key, value] of Object.entries(clone)) {
+        const camelKey = key.startsWith('_') ? key : toCamelCase(key);
+        if (value !== null && value !== undefined) {
+            if (Array.isArray(value)) {
+                result[camelKey] = value.map(item => convertKeysToCamelCase(item));
+            }
+            else if (typeof value === 'object' && !(value instanceof Date)) {
+                result[camelKey] = convertKeysToCamelCase(value);
+            }
+            else {
+                result[camelKey] = value;
+            }
+        }
+        else {
+            result[camelKey] = value;
+        }
+    }
+    return result;
+}

package/dist/databases/postgres/utils/convert-null-to-undefined.util.js

@@ -1,4 +1,5 @@
 import _ from 'lodash';
+import { toCamelCase } from './convert-keys.util.js';
 function isPropertyOptional(key, schema) {
     if (!schema || typeof schema !== 'object')
         return false;
@@ -36,12 +37,13 @@ export function convertNullToUndefined(data, schema) {
             return;
         }
         if (subSchema.type === 'object' && subSchema.properties) {
-            for (const [key, propSchema] of Object.entries(subSchema.properties)) {
+            for (const [key, value] of Object.entries(obj)) {
+                const schemaKey = key.startsWith('_') ? key : toCamelCase(key);
+                const propSchema = subSchema.properties[schemaKey];
                 if (!propSchema || typeof propSchema !== 'object')
                     continue;
                 const typedPropSchema = propSchema;
-                const value = obj[key];
-                if (isPropertyOptional(key, subSchema)) {
+                if (isPropertyOptional(schemaKey, subSchema)) {
                     if (value === null) {
                         delete obj[key];
                     }

package/dist/services/user.service.js

@@ -1,5 +1,4 @@
-import { Value } from '@sinclair/typebox/value';
-import { UserSpec, PublicUserSchema } from '@loomcore/common/models';
+import { UserSpec } from '@loomcore/common/models';
 import { MultiTenantApiService } from './index.js';
 import { ServerError } from '../errors/index.js';
 export class UserService extends MultiTenantApiService {
@@ -15,7 +14,8 @@ export class UserService extends MultiTenantApiService {
             preparedEntity.email = preparedEntity.email.toLowerCase();
         }
         if (!isCreate) {
-            return Value.Clean(PublicUserSchema, preparedEntity);
+            const { password, ...cleanedEntity } = preparedEntity;
+            return cleanedEntity;
         }
         return preparedEntity;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {