codebase-models 2.0.4 → 2.0.6

package/dist/src/models/ClientScript.d.ts

@@ -23,26 +23,24 @@
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
-export interface IClientScriptSchema extends Document {
-    scriptUrl: string;
-    viewId: string;
-}
 export interface IClientScript extends Document {
+    iid: string;
     organizationId?: mongoose.Schema.Types.ObjectId;
     client?: mongoose.Schema.Types.ObjectId;
+    adhere_dnt: Boolean;
+    allow_in_iframes: Boolean;
     viewId?: string;
     clientScriptURL: string;
     jquery_include: string;
     debug: Boolean;
     restrict_debug: Boolean;
-    adhere_dnt: Boolean;
     max_cookie_lifetime: Number;
     activation_mode: string;
     use_antiflicker: Boolean;
     snippet_revision: Number;
+    snippet_version: Number;
     rules: string;
     rules_tracking: string;
-    tracker_url: string;
     asset_url: string;
     metadata_key_exp_1: mongoose.Schema.Types.Mixed;
     metadata_key_exp_2: mongoose.Schema.Types.Mixed;
@@ -50,15 +48,18 @@ export interface IClientScript extends Document {
     metadata_key_var_1: mongoose.Schema.Types.Mixed;
     metadata_key_var_2: mongoose.Schema.Types.Mixed;
     metadata_key_var_3: mongoose.Schema.Types.Mixed;
-    cookie_domain: string;
-    snippet_version: Number;
+    logDomain: string;
     storage: string;
     run_only_on_reinit: Boolean;
-    allow_in_iframes: Boolean;
     visual_editor_version: Number;
-    jscode: string;
-    csscode: string;
+    js: string;
+    css: string;
+    helper_js: string;
     is_spa: Boolean;
+    isPreview: Boolean;
+    goalsEnabled: Boolean;
+    optedOut: Boolean;
+    liveEventListenersSet: Boolean;
 }
 declare const ClientScript: mongoose.Model<any, {}, {}, {}, any, any>;
 export default ClientScript;

package/dist/src/models/ClientScript.js

@@ -22,9 +22,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
 const ClientScriptSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
     organizationId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "organization",
@@ -84,10 +98,6 @@ const ClientScriptSchema = new mongoose_1.Schema({
         default: "return true;",
         trim: true,
     },
-    tracker_url: {
-        type: String,
-        trim: true,
-    },
     asset_url: {
         type: String,
         trim: true,
@@ -110,7 +120,7 @@ const ClientScriptSchema = new mongoose_1.Schema({
     metadata_key_var_3: {
         type: mongoose_1.default.Schema.Types.Mixed,
     },
-    cookie_domain: {
+    logDomain: {
         type: String,
         trim: true,
     },
@@ -133,11 +143,15 @@ const ClientScriptSchema = new mongoose_1.Schema({
     visual_editor_version: {
         type: Number,
     },
-    jscode: {
+    js: {
+        type: String,
+        trim: true,
+    },
+    css: {
         type: String,
         trim: true,
     },
-    csscode: {
+    helper_js: {
         type: String,
         trim: true,
     },
@@ -145,14 +159,46 @@ const ClientScriptSchema = new mongoose_1.Schema({
         type: Boolean,
         default: false,
     },
+    isPreview: {
+        type: Boolean,
+        default: false,
+    },
+    goalsEnabled: {
+        type: Boolean,
+        default: false,
+    },
+    optedOut: {
+        type: Boolean,
+        default: false,
+    },
+    liveEventListenersSet: {
+        type: Boolean,
+        default: false,
+    },
 }, {
     timestamps: true,
 });
+ClientScriptSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.clientscript.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
+ClientScriptSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 ClientScriptSchema.index({ client: 1 });
 // Sparse indexes for optional fields
 ClientScriptSchema.index({ organisationId: 1 }, { sparse: true });
-ClientScriptSchema.index({ tracker_url: 1 }, { sparse: true });
 ClientScriptSchema.index({ asset_url: 1 }, { sparse: true });
 const ClientScript = mongoose_1.default.models.clientscript || (0, mongoose_1.model)("clientscript", ClientScriptSchema);
 exports.default = ClientScript;

package/dist/src/models/ClientStrategy.d.ts

@@ -24,6 +24,7 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IClientStrategy extends Document {
+    iid: string;
     year: mongoose.Schema.Types.Mixed;
     month: mongoose.Schema.Types.Mixed;
     startDate?: Date;

package/dist/src/models/ClientStrategy.js

@@ -22,9 +22,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
 const ClientStrategySchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
     year: {
         type: mongoose_1.default.Schema.Types.Mixed,
         required: true,
@@ -64,6 +78,23 @@ const ClientStrategySchema = new mongoose_1.Schema({
 }, {
     timestamps: true,
 });
+ClientStrategySchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.clientstrategy.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
+ClientStrategySchema.index({ iid: 1 }, { unique: true });
 ClientStrategySchema.index({
     year: 1,
     month: 1,

package/dist/src/models/CustomQuery.d.ts

@@ -0,0 +1,38 @@
+/// <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/schematypes" />
+/// <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/inferschematype" />
+import mongoose, { Document } from 'mongoose';
+interface ICustomQuery extends Document {
+    iid: string;
+    organizationId?: mongoose.Schema.Types.ObjectId;
+    title: string;
+    module: string;
+    client: mongoose.Schema.Types.ObjectId;
+    query: string;
+    createdBy?: mongoose.Schema.Types.ObjectId;
+}
+declare const CustomQuery: mongoose.Model<ICustomQuery, {}, {}, {}, mongoose.Document<unknown, {}, ICustomQuery> & ICustomQuery & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default CustomQuery;

package/dist/src/models/CustomQuery.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
+const CustomQuerySchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
+    organizationId: { type: mongoose_1.default.Schema.Types.ObjectId, ref: "organization", default: null },
+    title: { type: String, required: true },
+    module: { type: String, required: true },
+    client: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'client', required: true },
+    query: { type: String, required: true },
+    createdBy: { type: mongoose_1.default.Schema.Types.ObjectId, ref: 'user', default: null },
+}, {
+    timestamps: true, // Automatically adds createdAt and updatedAt fields
+});
+CustomQuerySchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.customquery.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
+const CustomQuery = (0, mongoose_1.model)('CustomQuery', CustomQuerySchema);
+exports.default = CustomQuery;

package/dist/src/models/Environment.d.ts

@@ -24,11 +24,13 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IEnvironment extends Document {
+    iid: string;
     name: string;
     rules_js?: string;
     client?: mongoose.Schema.Types.ObjectId;
     organizationId?: mongoose.Schema.Types.ObjectId;
     isActive?: boolean;
+    default?: boolean;
 }
 declare const Environment: mongoose.Model<any, {}, {}, {}, any, any>;
 export default Environment;

package/dist/src/models/Environment.js

@@ -22,9 +22,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
 const EnvironmentSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
     name: {
         type: String,
         required: true,
@@ -40,6 +54,10 @@ const EnvironmentSchema = new mongoose_1.Schema({
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "organization",
     },
+    default: {
+        type: Boolean,
+        default: false,
+    },
     rules_js: {
         type: String,
         default: "return true",
@@ -52,6 +70,22 @@ const EnvironmentSchema = new mongoose_1.Schema({
 }, {
     timestamps: true
 });
+EnvironmentSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.environment.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
 // Compound indexes for common query patterns
 EnvironmentSchema.index({ client: 1, name: 1 }, { unique: true });
 EnvironmentSchema.index({ client: 1, isActive: 1 });

package/dist/src/models/Goal.d.ts

@@ -24,6 +24,7 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IGoal extends Document {
+    iid: string;
     name: string;
     details?: string;
     slug?: string;

package/dist/src/models/Goal.js

@@ -22,14 +22,28 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
 const mongoose_slug_updater_1 = __importDefault(require("mongoose-slug-updater"));
+const constant_1 = require("../constant");
 mongoose_1.default.plugin(mongoose_slug_updater_1.default);
 const GoalSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
     name: {
         type: String,
         required: true,
@@ -85,10 +99,26 @@ const GoalSchema = new mongoose_1.Schema({
 }, {
     timestamps: true
 });
-// Compound indexes for common query patterns
+GoalSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.goal.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
 GoalSchema.index({ client: 1 });
 GoalSchema.index({ client: 1, isActive: 1 });
 GoalSchema.index({ organizationId: 1, client: 1 });
 GoalSchema.index({ client: 1, name: 1 }, { unique: true });
+GoalSchema.index({ iid: 1 }, { unique: true });
 const Goal = mongoose_1.default.models.goal || (0, mongoose_1.model)("goal", GoalSchema);
 exports.default = Goal;

package/dist/src/models/Page.d.ts

@@ -24,11 +24,13 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IUrltargetings extends Document {
+    iid: string;
     type: string;
     url: string;
     url_type: string;
 }
 export interface IPage extends Document {
+    iid: string;
     name: string;
     client?: mongoose.Schema.Types.ObjectId;
     organizationId?: mongoose.Schema.Types.ObjectId;

package/dist/src/models/Page.js

@@ -22,14 +22,28 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
 const mongoose_slug_updater_1 = __importDefault(require("mongoose-slug-updater"));
+const constant_1 = require("../constant");
 mongoose_1.default.plugin(mongoose_slug_updater_1.default);
 const UrltargetingsSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        unique: true,
+    },
     type: {
         type: String,
         required: true,
@@ -47,6 +61,10 @@ const UrltargetingsSchema = new mongoose_1.Schema({
     },
 });
 const PageSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        unique: true,
+    },
     name: {
         type: String,
         required: true,
@@ -100,6 +118,36 @@ const PageSchema = new mongoose_1.Schema({
 }, {
     timestamps: true
 });
+PageSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.page.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        for (const urltargeting of this.urltargetings) {
+            if (!urltargeting.iid) {
+                let uniqueVar = false;
+                while (!uniqueVar) {
+                    const id = (0, constant_1.generateRandomIID)();
+                    const existingVar = yield mongoose_1.default.models.page.findOne({ "urltargetings.iid": id });
+                    if (!existingVar) {
+                        urltargeting.iid = id;
+                        uniqueVar = true;
+                    }
+                }
+            }
+        }
+        next();
+    });
+});
+PageSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 PageSchema.index({ client: 1, name: 1 }, { unique: true });
 PageSchema.index({ client: 1, isActive: 1 });

package/dist/src/models/Report.d.ts

@@ -24,6 +24,7 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IReports extends Document {
+    iid: string;
     name: string;
     segmentName?: string;
     reportLink?: string;

package/dist/src/models/Report.js

@@ -22,9 +22,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
 const ReportsSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        trim: true,
+    },
     organizationId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "organization",
@@ -63,6 +77,22 @@ const ReportsSchema = new mongoose_1.Schema({
 }, {
     timestamps: true
 });
+ReportsSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.report.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
 // Add compound indexes for better query performance
 ReportsSchema.index({ client: 1, conclusion: 1 });
 ReportsSchema.index({ test: 1, to: -1 }); // For sorting reports by date

package/dist/src/models/StageInCustomerJourney.d.ts

@@ -24,6 +24,7 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IStageInCustomerJourney extends Document {
+    iid: string;
     name?: string;
     stages?: string;
     slug?: string;

package/dist/src/models/StageInCustomerJourney.js

@@ -22,14 +22,28 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
 const mongoose_slug_updater_1 = __importDefault(require("mongoose-slug-updater"));
+const constant_1 = require("../constant");
 mongoose_1.default.plugin(mongoose_slug_updater_1.default);
 const StageInCustomerJourneySchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        unique: true,
+    },
     name: {
         type: String,
         required: true,
@@ -67,6 +81,23 @@ const StageInCustomerJourneySchema = new mongoose_1.Schema({
 }, {
     timestamps: true,
 });
+StageInCustomerJourneySchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.stageincustomerjourney.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
+StageInCustomerJourneySchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 // StageInCustomerJourneySchema.index({ client: 1, slug: 1 });
 const StageInCustomerJourney = mongoose_1.default.models.stageincustomerjourney || (0, mongoose_1.model)("stageincustomerjourney", StageInCustomerJourneySchema);