@dynamatix/gb-schemas 2.3.271 → 2.3.272

package/dist/applications/applications-task.model.js

@@ -38,5 +38,8 @@ const applicationsTaskSchema = new mongoose.Schema({
 applyAuditMiddleware(applicationsTaskSchema, "ApplicationsTask");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(applicationsTaskSchema, 'applicationstask');
+// Indexes for query optimization
+applicationsTaskSchema.index({ applicationId: 1, instanceId: 1 }); // Compound index for findByApplicationIdAndInstanceId queries
+applicationsTaskSchema.index({ applicationId: 1, createdOn: -1 }); // Compound index for findAll with sort by createdOn descending
 const ApplicationsTaskModel = mongoose.model("ApplicationsTask", applicationsTaskSchema);
 export default ApplicationsTaskModel;

package/dist/product-catalogues/product-catalogue.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"product-catalogue.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-catalogue.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAuBhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"product-catalogue.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-catalogue.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}

package/dist/product-catalogues/product-catalogue.model.js

@@ -17,5 +17,6 @@ const productCatalogueSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(productCatalogueSchema, 'productcatalogue');
+productCatalogueSchema.index({ productCatalogueId: 1 });
 const ProductCatalogueModel = mongoose.model('ProductCatalogue', productCatalogueSchema);
 export default ProductCatalogueModel;

package/dist/product-catalogues/product-variant.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"product-variant.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-variant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAkBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"product-variant.model.d.ts","sourceRoot":"","sources":["../../product-catalogues/product-variant.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD,CAAC;AACnF,eAAe,mBAAmB,CAAC"}

package/dist/product-catalogues/product-variant.model.js

@@ -9,6 +9,7 @@ const productVariantSchema = new mongoose.Schema({
 }, {
     timestamps: true
 });
+productVariantSchema.index({ productCatalogueId: 1, variantid: 1 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(productVariantSchema, 'productvariant');
 const ProductVariantModel = mongoose.model('ProductVariant', productVariantSchema);

package/dist/properties/security.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"security.model.d.ts","sourceRoot":"","sources":["../../properties/security.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiKhC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}
+{"version":3,"file":"security.model.d.ts","sourceRoot":"","sources":["../../properties/security.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAsKhC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/properties/security.model.js

@@ -145,5 +145,9 @@ securitySchema.virtual('lendingType').get(function () {
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(securitySchema, 'security');
+// Indexes for query optimization
+securitySchema.index({ applicationId: 1 });
+securitySchema.index({ propertyTypeLid: 1 });
+securitySchema.index({ propertyTenureLid: 1 });
 const SecurityModel = mongoose.model("Security", securitySchema);
 export default SecurityModel;

package/dist/shared/api-log.model.d.ts

@@ -40,6 +40,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -52,6 +53,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -64,6 +66,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -82,6 +85,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -94,6 +98,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;
@@ -106,6 +111,7 @@ declare const ApiLogModel: mongoose.Model<{
     statusCode: number;
     loggedAt: NativeDate;
     stackTrace: string[];
+    status?: string | null | undefined;
     errorMessage?: string | null | undefined;
     requestData?: any;
     responseData?: any;

package/dist/shared/api-log.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-log.model.d.ts","sourceRoot":"","sources":["../../shared/api-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAE5D,eAAe,WAAW,CAAC"}
+{"version":3,"file":"api-log.model.d.ts","sourceRoot":"","sources":["../../shared/api-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAyBhC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0C,CAAC;AAE5D,eAAe,WAAW,CAAC"}

package/dist/shared/api-log.model.js

@@ -7,12 +7,16 @@ const apiLogSchema = new mongoose.Schema({
     route: { type: String, required: true },
     createdByUserId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, },
     statusCode: { type: Number, required: true },
+    status: { type: String }, // For future filtering by status
     errorMessage: { type: String },
     loggedAt: { type: Date, default: Date.now },
     stackTrace: [{ type: String }],
     requestData: { type: mongoose.Schema.Types.Mixed }, // to store request payload
     responseData: { type: mongoose.Schema.Types.Mixed }, // to store response payload
 }, { timestamps: true });
+// Indexes for date and status filtering
+apiLogSchema.index({ createdAt: -1 }); // For date-based queries (newest first)
+apiLogSchema.index({ status: 1, createdAt: -1 }); // Compound index for status + date queries
 /**
  * Mongoose model for API logs.
  * @constant {Model}

package/dist/shared/apprivo-sync-journey.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apprivo-sync-journey.model.d.ts","sourceRoot":"","sources":["../../shared/apprivo-sync-journey.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiBhC,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiE,CAAC;AAC/F,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"apprivo-sync-journey.model.d.ts","sourceRoot":"","sources":["../../shared/apprivo-sync-journey.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiE,CAAC;AAC/F,eAAe,uBAAuB,CAAC"}

package/dist/shared/apprivo-sync-journey.model.js

@@ -13,5 +13,7 @@ const ApprivoSyncJourneySchema = new mongoose.Schema({
     startTime: { type: Date, default: null },
     endTime: { type: Date, default: null },
 }, { timestamps: true });
+// Add indexes that exist in database but missing from model
+ApprivoSyncJourneySchema.index({ milestoneLid: 1, applicationId: 1 }); // Compound: milestone + application
 const ApprivoSyncJourneyModel = mongoose.model('ApprivoSyncJourney', ApprivoSyncJourneySchema);
 export default ApprivoSyncJourneyModel;

package/dist/shared/audit-log.model.d.ts

@@ -0,0 +1,180 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const AuditLogModel: mongoose.Model<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, {}> & {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: false;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default AuditLogModel;
+//# sourceMappingURL=audit-log.model.d.ts.map

package/dist/shared/audit-log.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log.model.d.ts","sourceRoot":"","sources":["../../shared/audit-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6ChC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/shared/audit-log.model.js

@@ -0,0 +1,43 @@
+import mongoose from "mongoose";
+const auditLogSchema = new mongoose.Schema({
+    name: { type: String, required: true }, // Collection/model name
+    recordId: { type: mongoose.Schema.Types.ObjectId, required: true }, // ID of the record being audited
+    action: { type: String, required: true, enum: ['create', 'update', 'delete', 'read'] },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false }, // User who performed the action
+    timestamp: { type: Date, default: Date.now, required: true },
+    oldValue: { type: mongoose.Schema.Types.Mixed, required: false }, // Previous value
+    newValue: { type: mongoose.Schema.Types.Mixed, required: false }, // New value
+    fieldName: { type: String, required: false }, // Specific field that changed
+    ipAddress: { type: String, required: false },
+    userAgent: { type: String, required: false },
+    sessionId: { type: String, required: false },
+    source: { type: String, required: false, default: 'application' }, // Source of the change
+    metadata: { type: mongoose.Schema.Types.Mixed, required: false },
+    externalData: {
+        apprivoAuditId: { type: String, required: false }, // External system audit ID
+        syncStatus: { type: String, required: false, enum: ['pending', 'synced', 'failed'] },
+        syncedAt: { type: Date, required: false },
+        externalSystemId: { type: String, required: false }
+    },
+    isSystemGenerated: { type: Boolean, default: false },
+    severity: { type: String, required: false, enum: ['low', 'medium', 'high', 'critical'], default: 'low' }
+}, {
+    timestamps: false, // We use our own timestamp field
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+// Virtual for formatted timestamp
+auditLogSchema.virtual('formattedTimestamp').get(function () {
+    return this.timestamp ? this.timestamp.toISOString() : null;
+});
+// Add indexes to match database
+auditLogSchema.index({ 'externalData.apprivoAuditId': 1 }); // External audit ID lookup
+auditLogSchema.index({ name: 1, newValue: 1, recordId: 1, timestamp: -1 }); // Complex compound index
+auditLogSchema.index({ name: 1, recordId: 1 }); // Filter by collection and record
+auditLogSchema.index({ recordId: 1, timestamp: -1, _id: -1 }); // Record history with fallback sort
+auditLogSchema.index({ timestamp: -1 }); // Sort by recent changes
+auditLogSchema.index({ userId: 1, timestamp: -1 }); // User activity history
+auditLogSchema.index({ action: 1, timestamp: -1 }); // Filter by action type
+auditLogSchema.index({ name: 1, action: 1, timestamp: -1 }); // Collection-specific action history
+const AuditLogModel = mongoose.model("AuditLog", auditLogSchema);
+export default AuditLogModel;

package/dist/shared/checklist.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checklist.model.d.ts","sourceRoot":"","sources":["../../shared/checklist.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiChC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AAEpE,eAAe,cAAc,CAAC"}
+{"version":3,"file":"checklist.model.d.ts","sourceRoot":"","sources":["../../shared/checklist.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAuChC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC;AAEpE,eAAe,cAAc,CAAC"}

package/dist/shared/checklist.model.js

@@ -26,5 +26,10 @@ const checklistSchema = new mongoose.Schema({
     }
 }, { timestamps: true });
 checklistSchema.index({ checkDescription: 'text', source: 'text' });
+// Add recommended indexes for query optimization
+checklistSchema.index({ applicationId: 1 }); // Filter by application
+checklistSchema.index({ checkTypeLid: 1 }); // Filter by check type
+checklistSchema.index({ checkStatusLid: 1 }); // Filter by check status
+checklistSchema.index({ sourceId: 1 }); // Filter by source (applicant/property/application)
 const CheckListModel = mongoose.model("CheckList", checklistSchema);
 export default CheckListModel;

package/dist/shared/document.model.d.ts

@@ -0,0 +1,180 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const DocumentModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default DocumentModel;
+//# sourceMappingURL=document.model.d.ts.map

package/dist/shared/document.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.model.d.ts","sourceRoot":"","sources":["../../shared/document.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA0ChC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/shared/document.model.js

@@ -0,0 +1,40 @@
+import mongoose from "mongoose";
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+import { applyWorkflowPlugin } from "./workflow.plugin";
+const documentSchema = new mongoose.Schema({
+    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
+    contextId: { type: mongoose.Schema.Types.ObjectId, required: false },
+    status: { type: String, required: true, enum: ['pending', 'uploaded', 'verified', 'rejected', 'archived'] },
+    category: { type: String, required: true },
+    subCategory: { type: String, required: false },
+    fileName: { type: String, required: true },
+    originalName: { type: String, required: true },
+    mimeType: { type: String, required: true },
+    fileSize: { type: Number, required: true },
+    filePath: { type: String, required: true },
+    uploadedBy: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+    verifiedBy: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    verifiedAt: { type: Date, required: false },
+    rejectionReason: { type: String, required: false },
+    metadata: { type: mongoose.Schema.Types.Mixed, required: false },
+    tags: [{ type: String }],
+    isActive: { type: Boolean, default: true },
+    expiresAt: { type: Date, required: false }
+}, {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+applyAuditMiddleware(documentSchema, "Document");
+applyWorkflowPlugin(documentSchema, 'document');
+// Add indexes to match database
+documentSchema.index({ applicationId: 1 }); // Filter by application
+documentSchema.index({ contextId: 1 }); // Filter by context
+documentSchema.index({ status: 1 }); // Filter by status
+documentSchema.index({ category: 1 }); // Filter by category
+documentSchema.index({ subCategory: 1 }); // Filter by subcategory
+documentSchema.index({ applicationId: 1, status: 1 }); // Compound: application + status
+documentSchema.index({ contextId: 1, status: 1 }); // Compound: context + status
+documentSchema.index({ category: 1, status: 1 }); // Compound: category + status
+const DocumentModel = mongoose.model("Document", documentSchema);
+export default DocumentModel;

package/dist/shared/lookup-group.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lookup-group.model.d.ts","sourceRoot":"","sources":["../../shared/lookup-group.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAoBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"lookup-group.model.d.ts","sourceRoot":"","sources":["../../shared/lookup-group.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAwBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAC;AAC1E,eAAe,gBAAgB,CAAC"}

package/dist/shared/lookup-group.model.js

@@ -15,5 +15,8 @@ const lookupGroupSchema = new mongoose.Schema({
 });
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(lookupGroupSchema, 'lookupgroup');
+// Database indexes for performance optimization
+// Single field indexes
+lookupGroupSchema.index({ name: 1 }, { unique: true });
 const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
 export default LookupGroupModel;

package/dist/shared/lookup.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lookup.model.d.ts","sourceRoot":"","sources":["../../shared/lookup.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAqBhC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAC3D,eAAe,WAAW,CAAC"}
+{"version":3,"file":"lookup.model.d.ts","sourceRoot":"","sources":["../../shared/lookup.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA+BhC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAC3D,eAAe,WAAW,CAAC"}

package/dist/shared/lookup.model.js

@@ -16,5 +16,11 @@ const lookupSchema = new mongoose.Schema({
         type: String
     }
 });
+lookupSchema.index({ lookupGroupId: 1 });
+lookupSchema.index({ value: 1 });
+// Case-insensitive index for name queries
+lookupSchema.index({ name: 1 }, { collation: { locale: "en", strength: 2 } });
+// Compound index for lookupGroupId + name queries
+lookupSchema.index({ lookupGroupId: 1, name: 1 }, { collation: { locale: "en", strength: 2 } });
 const LookupModel = mongoose.model('Lookup', lookupSchema);
 export default LookupModel;