@dynamatix/gb-schemas 2.0.34 → 2.0.36

package/dist/users/permission.model.js

@@ -0,0 +1,10 @@
+import mongoose from "mongoose";
+const permissionSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    controllerName: { type: String, required: true },
+    methodName: { type: String, required: true }
+}, {
+    timestamps: true
+});
+const PermissionModel = mongoose.model('Permission', permissionSchema);
+export default PermissionModel;

package/dist/users/role-group.model.d.ts

@@ -0,0 +1,62 @@
+import mongoose from "mongoose";
+declare const RoleGroupModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    groupId: string;
+    roles: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default RoleGroupModel;
+//# sourceMappingURL=role-group.model.d.ts.map

package/dist/users/role-group.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-group.model.d.ts","sourceRoot":"","sources":["../../users/role-group.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAehC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AACpE,eAAe,cAAc,CAAC"}

package/dist/users/role-group.model.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+const RoleGroupSchema = new mongoose.Schema({
+    groupId: { type: String, required: true },
+    name: { type: String, required: true },
+    description: { type: String },
+    roles: [{
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Role'
+        }]
+}, {
+    timestamps: true
+});
+const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
+export default RoleGroupModel;

package/dist/users/role.model.d.ts

@@ -0,0 +1,62 @@
+import mongoose from "mongoose";
+declare const RoleModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name: string;
+    roleId: string;
+    permissions: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default RoleModel;
+//# sourceMappingURL=role.model.d.ts.map

package/dist/users/role.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.model.d.ts","sourceRoot":"","sources":["../../users/role.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAchC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}

package/dist/users/role.model.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+const RoleSchema = new mongoose.Schema({
+    roleId: { type: String, required: true },
+    name: { type: String, required: true },
+    description: { type: String },
+    permissions: [{
+            type: mongoose.Schema.Types.ObjectId, ref: 'Permission'
+        }]
+}, {
+    timestamps: true
+});
+const RoleModel = mongoose.model('Role', RoleSchema);
+export default RoleModel;

package/dist/users/tasks.model.d.ts

@@ -0,0 +1,86 @@
+import mongoose from "mongoose";
+declare const TasksModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    createdByUserId: mongoose.Types.ObjectId;
+    statusLid: mongoose.Types.ObjectId;
+    assignedToUserId: mongoose.Types.ObjectId;
+    taskTypeLid: mongoose.Types.ObjectId;
+    actionTypeLid: mongoose.Types.ObjectId;
+    entityId: mongoose.Types.ObjectId;
+    priorityLid: mongoose.Types.ObjectId;
+    expiryDate: NativeDate;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default TasksModel;
+//# sourceMappingURL=tasks.model.d.ts.map

package/dist/users/tasks.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.model.d.ts","sourceRoot":"","sources":["../../users/tasks.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAgBhC,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuC,CAAC;AAExD,eAAe,UAAU,CAAC"}

package/dist/users/tasks.model.js

@@ -0,0 +1,15 @@
+import mongoose from "mongoose";
+const TasksSchema = new mongoose.Schema({
+    taskTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskType ["Document", "Information"]
+    actionTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // Example: "Request Document Delete"
+    entityId: { type: mongoose.Schema.Types.ObjectId, required: true }, // Could be documentId, applicationId, applicantId
+    createdByUserId: { ref: "User", type: mongoose.Schema.Types.ObjectId, required: true },
+    assignedToUserId: { ref: "User", type: mongoose.Schema.Types.ObjectId, required: true },
+    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskStatus ["Requested", "Completed", "Cancelled"]
+    priorityLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskPriority ["High", "Medium", "Low"]
+    expiryDate: { type: Date, required: true },
+}, {
+    timestamps: true
+});
+const TasksModel = mongoose.model("Tasks", TasksSchema);
+export default TasksModel;

package/dist/users/user.model.d.ts

@@ -0,0 +1,188 @@
+import mongoose from "mongoose";
+declare const UserModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    accountId: string;
+    fullName: string;
+    status: string;
+    email: string;
+    password: string;
+    groups: mongoose.Types.ObjectId[];
+    claims: mongoose.Types.DocumentArray<{
+        value: string;
+        key: string;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        value: string;
+        key: string;
+    }> & {
+        value: string;
+        key: string;
+    }>;
+    organisationId?: any;
+    externalData?: any;
+    modifiedOn?: string | null | undefined;
+    modifiedById?: string | null | undefined;
+    createdOnInApprivo?: string | null | undefined;
+    createdById?: string | null | undefined;
+    deletedOn?: string | null | undefined;
+    deletedById?: string | null | undefined;
+    token?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default UserModel;
+//# sourceMappingURL=user.model.d.ts.map

package/dist/users/user.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.model.d.ts","sourceRoot":"","sources":["../../users/user.model.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAgChC,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAErD,eAAe,SAAS,CAAC"}

package/dist/users/user.model.js

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+const ClaimSchema = new mongoose.Schema({
+    key: { type: String, required: true },
+    value: { type: String, required: true }
+});
+const userSchema = new mongoose.Schema({
+    accountId: { type: String, required: true },
+    email: { type: String, required: true },
+    fullName: { type: String, required: true },
+    password: { type: String, required: true },
+    organisationId: { type: mongoose.Schema.Types.Mixed },
+    status: { type: String, required: true },
+    groups: [{
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'RoleGroup'
+        }],
+    claims: [ClaimSchema],
+    externalData: { type: mongoose.Schema.Types.Mixed },
+    modifiedOn: { type: String },
+    modifiedById: { type: String },
+    createdOnInApprivo: { type: String },
+    createdById: { type: String },
+    deletedOn: { type: String },
+    deletedById: { type: String },
+    token: { type: String }
+}, {
+    timestamps: true
+});
+const UserModel = mongoose.model('User', userSchema);
+export default UserModel;

package/dist/value-objects/pound.d.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+declare module 'mongoose' {
+    namespace Schema {
+        namespace Types {
+            class Pound extends SchemaType {
+            }
+        }
+    }
+}
+declare class Pound extends mongoose.SchemaType {
+    constructor(key: string, options: mongoose.AnyObject | undefined);
+    cast(val: any): any;
+}
+export { Pound };
+//# sourceMappingURL=pound.d.ts.map

package/dist/value-objects/pound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pound.d.ts","sourceRoot":"","sources":["../../value-objects/pound.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAGhC,OAAO,QAAQ,UAAU,CAAC;IACtB,UAAU,MAAM,CAAC;QACb,UAAU,KAAK,CAAC;YACZ,MAAM,KAAM,SAAQ,UAAU;aAAI;SACrC;KACJ;CACJ;AAED,cAAM,KAAM,SAAQ,QAAQ,CAAC,UAAU;gBACvB,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,SAAS,GAAG,SAAS;IAKhE,IAAI,CAAC,GAAG,EAAE,GAAG;CA4BhB;AAKD,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/value-objects/pound.js

@@ -0,0 +1,26 @@
+// pound.ts
+import mongoose from 'mongoose';
+class Pound extends mongoose.SchemaType {
+    constructor(key, options) {
+        super(key, options, 'Pound');
+    }
+    // Casting method that validates and formats the value
+    cast(val) {
+        if (val == null) {
+            return val; // Allow null or undefined values
+        }
+        // Ensure the value is a string
+        if (typeof val !== 'number') {
+            throw new mongoose.Error.CastError('Pound', val, this.path, new Error('Pound value must be a string or number'));
+        }
+        // Check if the cleaned value is a valid number
+        if (isNaN(Number(val))) {
+            throw new mongoose.Error.CastError('Pound', val, this.path, new Error(`${val} is not a valid currency value`));
+        }
+        // Return without symbol prefixed
+        return parseFloat(val.toFixed(2));
+    }
+}
+// Register custom type
+mongoose.Schema.Types.Pound = Pound;
+export { Pound };

package/dist/value-objects/sort-code.d.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+declare module 'mongoose' {
+    namespace Schema {
+        namespace Types {
+            class SortCode extends SchemaType {
+            }
+        }
+    }
+}
+declare class SortCode extends mongoose.SchemaType {
+    constructor(key: string, options: mongoose.AnyObject | undefined);
+    cast(val: any): any;
+}
+export { SortCode };
+//# sourceMappingURL=sort-code.d.ts.map

package/dist/value-objects/sort-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-code.d.ts","sourceRoot":"","sources":["../../value-objects/sort-code.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,QAAQ,UAAU,CAAC;IACtB,UAAU,MAAM,CAAC;QACb,UAAU,KAAK,CAAC;YACZ,MAAM,QAAS,SAAQ,UAAU;aAAI;SACxC;KACJ;CACJ;AAED,cAAM,QAAS,SAAQ,QAAQ,CAAC,UAAU;gBAC1B,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,SAAS,GAAG,SAAS;IAIhE,IAAI,CAAC,GAAG,EAAE,GAAG;CA+BhB;AAKD,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/value-objects/sort-code.js

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+class SortCode extends mongoose.SchemaType {
+    constructor(key, options) {
+        super(key, options, 'SortCode');
+    }
+    cast(val) {
+        if (val == null) {
+            return val; // Allow null or undefined
+        }
+        if (typeof val === 'number') {
+            val = val.toString();
+        }
+        if (typeof val !== 'string') {
+            throw new mongoose.Error.CastError('SortCode', val, this.path, new Error('SortCode must be a string or number'));
+        }
+        const cleaned = val.replace(/\D/g, '');
+        if (cleaned.length !== 6) {
+            throw new mongoose.Error.CastError('SortCode', val, this.path, new Error(`${val} is not a valid UK sort code. Must contain exactly 6 digits.`));
+        }
+        return `${cleaned.slice(0, 2)}-${cleaned.slice(2, 4)}-${cleaned.slice(4, 6)}`;
+    }
+}
+// Register the custom type globally with Mongoose
+mongoose.Schema.Types.SortCode = SortCode;
+export { SortCode };

package/entities/applications/application-mortgage.entity.ts

@@ -14,7 +14,7 @@ export class ApplicationMortgageEntity {
     repaymentTypeLid!: string;
     exitStrategyLid!: string;
     isCapitalRaise?: boolean;
-    purchaseDate!: Date;
+    purchaseDate!: string;
     estimatedValue!: number;
     loanRequired!: number;
     monthlyRentalIncome!: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "2.0.34",
+  "version": "2.0.36",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prisma/applications/application-mortgage.prisma

@@ -6,12 +6,12 @@ model ApplicationMortgage {
   purposeOfMortgage           String   @map("purpose_of_mortgage") @db.VarChar(50)
   depositComeFromLids         String[] @map("deposit_come_from_lids")
   ifOtherDetails              String   @map("if_other_details") @db.VarChar(50)
-  giftDetails                 String?   @map("gift_details") @db.VarChar(50)
+  giftDetails                 String?  @map("gift_details") @db.VarChar(50)
   purchasePrice               Decimal  @map("purchase_price") @db.Decimal(10, 2)
   repaymentTypeLid            String   @map("repayment_type_lid")
   exitStrategyLid             String   @map("exit_strategy_lid")
   isCapitalRaise              Boolean? @default(false) @map("is_capital_raise")
-  purchaseDate                DateTime @map("purchase_date")
+  purchaseDate                String   @map("purchase_date")
   estimatedValue              Decimal  @map("estimated_value") @db.Decimal(10, 2)
   loanRequired                Decimal  @map("loan_required") @db.Decimal(10, 2)
   monthlyRentalIncome         Decimal  @map("monthly_rental_income") @db.Decimal(10, 2)

package/prisma/migrations/20250512071728_update_mortgage_schema/migration.sql

@@ -1,15 +1,15 @@
-/*
-  Warnings:
-
-  - Added the required column `gift_details` to the `application_mortgages` table without a default value. This is not possible if the table is not empty.
-
-*/
--- AlterTable
-ALTER TABLE "application_mortgages" ADD COLUMN     "gift_details" VARCHAR(50) NOT NULL,
-ALTER COLUMN "is_capital_raise" DROP NOT NULL,
-ALTER COLUMN "is_distressed_sale" DROP NOT NULL,
-ALTER COLUMN "is_purchased_below_market_value" DROP NOT NULL,
-ALTER COLUMN "is_purchased_as_sale" DROP NOT NULL,
-ALTER COLUMN "is_ready_to_sell" DROP NOT NULL,
-ALTER COLUMN "is_government_initiative" DROP NOT NULL,
-ALTER COLUMN "is_the_intention_to_let" DROP NOT NULL;
+/*
+  Warnings:
+
+  - Added the required column `gift_details` to the `application_mortgages` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "application_mortgages" ADD COLUMN     "gift_details" VARCHAR(50) NOT NULL,
+ALTER COLUMN "is_capital_raise" DROP NOT NULL,
+ALTER COLUMN "is_distressed_sale" DROP NOT NULL,
+ALTER COLUMN "is_purchased_below_market_value" DROP NOT NULL,
+ALTER COLUMN "is_purchased_as_sale" DROP NOT NULL,
+ALTER COLUMN "is_ready_to_sell" DROP NOT NULL,
+ALTER COLUMN "is_government_initiative" DROP NOT NULL,
+ALTER COLUMN "is_the_intention_to_let" DROP NOT NULL;