@solidstarters/solid-code-builder 1.0.0

package/src/code-builder/lib/field/decorator-managers/entity/OneToManyDecoratorManager.ts

@@ -0,0 +1,217 @@
+import { camelize, classify } from "@angular-devkit/core/src/utils/strings";
+import ts, { ModifierLike, ObjectLiteralElementLike, PropertyDeclaration } from "@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript";
+import { insertImport } from "@schematics/angular/utility/ast-utils";
+import { Change } from "@schematics/angular/utility/change";
+import { DecoratorManager, DeleteType, PartialAddFieldChange } from "../../FieldManager";
+
+interface OneToManyDecoratorOptions {
+    isOneToMany: boolean;
+    relationCascade: DeleteType;
+    source: ts.SourceFile;
+    field: any;
+    fieldName: string;
+    modelName: string;
+}
+
+export class OneToManyDecoratorManager implements DecoratorManager {
+    constructor(public options: OneToManyDecoratorOptions, public fieldNode?: PropertyDeclaration,) { }
+    isApplyDecorator(): boolean {
+        return this.options.isOneToMany;
+    }
+    decoratorName(): string {
+        return 'OneToMany';
+    }
+
+    buildDecorator(): PartialAddFieldChange {
+        const changes: Change[] = [];
+        const fieldSourceLines: string[] = [];
+
+        // Add the one-to-many import
+        // const oneToManyImport = insertImport(
+        //     this.options.source,    
+        //     this.options.source.fileName,
+        //     this.decoratorName(),
+        //     'typeorm',
+        // );
+        // if (oneToManyImport) {
+        //     changes.push(oneToManyImport);
+        // }
+        fieldSourceLines.push(
+            `@${this.decoratorName()}(() => ${classify(this.options.modelName)}, ${camelize(this.options.modelName)} => ${camelize(this.options.modelName)}.${this.options.fieldName}, ${this.buildRelationOptionsCode()})`,
+        );
+        changes.push(...this.decoratorImports());
+
+        return {
+            filePath: this.options.source.fileName,
+            field: this.options.field,
+            changes: changes,
+            fieldSourceLines: fieldSourceLines,
+        };
+    }
+
+    setFieldNode(fieldNode: PropertyDeclaration): void {
+        this.fieldNode = fieldNode;
+    }
+
+    decoratorImports(): Change[] {
+        return [insertImport(
+            this.options.source,
+            this.options.source.fileName,
+            this.decoratorName(),
+            'typeorm')]
+    }
+
+    updateDecorator(): [PropertyDeclaration, Change[]] {
+        // Check if the field property declaration exists, if not throw an error
+        if (!this.fieldNode) throw new Error('Field node is required for updating the one to many decorator');
+
+        let newModifiers: ModifierLike[] = [];
+        let existingModifiers = this.fieldNode.modifiers;
+
+        // Check if field has an existing one-to-many relation decorator
+        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
+
+        //Remove the many-to-one decorator if it exists
+        //TODO probably this too can be done in a lesser intrusive way i.e update everything instead of removing and adding
+        newModifiers = [...this.filterNonDecorators(existingModifiers), ...this.filterOtherDecorators(this.decoratorName(), existingModifiers)];
+
+        //Add the one-to-many decorator if it is required  
+        const changes: Change[] = [];  
+
+        if (this.isApplyDecorator()) {
+            newModifiers = [...newModifiers, this.createRelationDecorator(existingDecorator)];
+            changes.push(...this.decoratorImports());
+        }
+
+        const updatedProperty = ts.factory.updatePropertyDeclaration(
+            this.fieldNode,
+            newModifiers, //Replace with new modifiers
+            this.fieldNode.name,
+            this.fieldNode.questionToken,
+            this.fieldNode.type,
+            this.fieldNode.initializer,
+        );
+        return [updatedProperty, changes];
+    }
+
+    private buildRelationOptionsCode(): string {
+        return `{ cascade: true }`;
+    }
+
+    private createRelationDecorator(existingRelationDecorator: ts.Decorator | undefined): ts.Decorator {
+        // Capture the existing relation decorator options
+        let existingRelationDecoratorPropertyAssignments: ts.ObjectLiteralElementLike[] = this.existingDecoratorOptions(existingRelationDecorator);
+
+        // Create the new relation decorator options
+        const decoratorOptions = this.createRelationDecoratorOptions();
+        const newPropertyAssignments: ObjectLiteralElementLike[] = Array.from(decoratorOptions.values()).filter(p => p !== null) as ts.PropertyAssignment[];
+
+        // console.log('newPropertyAssignments', newPropertyAssignments.map(p => JSON.stringify(p.name)).join(', '));
+
+        // Add the other unhandled column decorator options
+        const handledDecoratorOptions = Array.from(decoratorOptions.keys());
+        //@ts-ignore
+        const otherPropertyAssignments = existingRelationDecoratorPropertyAssignments.filter(ps => !handledDecoratorOptions.includes(ps.name?.escapedText as string));
+        newPropertyAssignments.push(...otherPropertyAssignments);
+
+        // Re-create the relation decorator with the merged relation decorator options
+        const decoratorIdentifier = ts.factory.createIdentifier(this.decoratorName());
+        const argumentsArray: ts.Expression[] = this.createDecoratorArguments(newPropertyAssignments);
+        const call = ts.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
+        return ts.factory.createDecorator(call)
+    }
+
+    private createDecoratorArguments(newPropertyAssignments: ts.ObjectLiteralElementLike[]) {
+        const argumentsArray: ts.Expression[] = [];
+        // 1st Argument: Target
+        const typeFunctionOrTarget = ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [],
+            undefined,
+            ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+            ts.factory.createIdentifier(classify(this.options.modelName))
+        );
+        argumentsArray.push(typeFunctionOrTarget);
+        // 2nd Argument: Inverse side
+        const inverseSide = ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                ts.factory.createIdentifier(camelize(this.options.modelName)),
+                undefined,
+                undefined,
+                undefined
+            )],
+            undefined,
+            ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+            ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(camelize(this.options.modelName)),
+                ts.factory.createIdentifier(this.options.fieldName)
+            )
+        );
+        argumentsArray.push(inverseSide);
+        // 3rd Argument: Options. This argument is optional
+        if (newPropertyAssignments.length > 0) {
+            const decoratorOptions = ts.factory.createObjectLiteralExpression(newPropertyAssignments);
+            argumentsArray.push(decoratorOptions);
+        }
+        return argumentsArray;
+    }
+
+    private existingDecoratorOptions(existingRelationDecorator: ts.Decorator | undefined): ts.ObjectLiteralElementLike[] {
+        let existingRelationDecoratorPropertyAssignments: ts.ObjectLiteralElementLike[] = [];
+        if (existingRelationDecorator !== undefined) {
+            //Pre-set the relation options from the existing relation decorator
+            const existingCallExpression = existingRelationDecorator.expression as ts.CallExpression;
+            // Check if  call expression has at least 1 arguments
+            if (existingCallExpression.arguments.length > 2) { //Because we are interested in the 2nd argument, we check for length > 1
+                if (!ts.isObjectLiteralExpression(existingCallExpression.arguments[2])) { throw new Error('OneToMany decorator 3rd argument must be an object literal containing the relation options'); }
+                const existingObjectLiteralExpression = existingCallExpression.arguments[2] as ts.ObjectLiteralExpression;
+                existingRelationDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
+            }
+        }
+        return existingRelationDecoratorPropertyAssignments;
+    }
+
+    private createRelationDecoratorOptions(): Map<string, ts.PropertyAssignment | null> {
+        const options: any = new Map<string, ts.Expression>();
+        options.set('cascade', ts.factory.createTrue());
+        return this.optionsToPropertyAssignmentsOrNull(options);
+    }
+
+    private optionsToPropertyAssignmentsOrNull(options: Map<string, ts.Expression | null>): Map<string, ts.PropertyAssignment | null> {
+        const decoratorOptions = new Map<string, ts.PropertyAssignment | null>();
+        options.forEach((value, key) => {
+            if (value !== null) {
+                decoratorOptions.set(key, ts.factory.createPropertyAssignment(ts.factory.createIdentifier(key), value));
+            }
+            else {
+                decoratorOptions.set(key, null);
+            }
+        });
+        return decoratorOptions;
+    }
+
+
+    private findDecorator(name: string, existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Decorator | undefined {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind === ts.SyntaxKind.Decorator)).map(m => m as ts.Decorator).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
+    }
+
+    private filterOtherDecorators(name: string, existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Decorator[] {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind === ts.SyntaxKind.Decorator)).map(m => m as ts.Decorator).filter(m => !this.containsIdentifierName(m, name)) : [];
+    }
+
+    private filterNonDecorators(existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Modifier[] {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== ts.SyntaxKind.Decorator)).map(m => m as ts.Modifier) : [];
+    }
+
+    private containsIdentifierName(m: ts.Decorator, identifierName: string): boolean {
+        const callExpression = m.expression as ts.CallExpression;
+        const identifier = callExpression.expression as ts.Identifier;
+        return identifier.text === identifierName;
+    }
+
+}

package/src/code-builder/lib/field/decorator-managers/entity/UniqueIndexDecoratorManager.d.ts

@@ -0,0 +1,31 @@
+import ts, { ClassDeclaration } from "@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript";
+import { Change } from "@schematics/angular/utility/change";
+import { PartialAddFieldChange } from "../../FieldManager";
+interface UniqueIndexDecoratorOptions {
+    unique: boolean;
+    fieldName: string;
+    source: ts.SourceFile;
+    field: any;
+}
+export declare class UniqueIndexDecoratorManager {
+    options: UniqueIndexDecoratorOptions;
+    classNode: ClassDeclaration;
+    fieldNode?: ts.PropertyDeclaration | undefined;
+    constructor(options: UniqueIndexDecoratorOptions, classNode: ClassDeclaration, fieldNode?: ts.PropertyDeclaration | undefined);
+    isApplyDecorator(): boolean;
+    decoratorName(): string;
+    setFieldNode(fieldNode: ts.PropertyDeclaration): void;
+    buildDecorator(): PartialAddFieldChange;
+    decoratorImports(): Change[];
+    updateDecorator(): [ClassDeclaration, Change[]];
+    private findUniqueIndexDecorator;
+    private createUniqueIndexDecorator;
+    private createUniqueIndexDecoratorOptions;
+    private optionsToPropertyAssignmentsOrNull;
+    private filterOtherDecorators;
+    private filterOtherIndexDecorators;
+    private filterNonDecorators;
+    private containsIdentifierName;
+    private containsIndexForField;
+}
+export {};

package/src/code-builder/lib/field/decorator-managers/entity/UniqueIndexDecoratorManager.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueIndexDecoratorManager = void 0;
+const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+class UniqueIndexDecoratorManager {
+    constructor(options, classNode, fieldNode) {
+        this.options = options;
+        this.classNode = classNode;
+        this.fieldNode = fieldNode;
+    }
+    isApplyDecorator() {
+        return this.options.unique;
+    }
+    decoratorName() {
+        return 'Index';
+    }
+    setFieldNode(fieldNode) {
+        this.fieldNode = fieldNode;
+    }
+    buildDecorator() {
+        const fieldSourceLines = [];
+        const changes = [];
+        const indexDecoratorLine = `@Index(["${this.options.fieldName}", "deletedTracker"], { unique: true })`;
+        fieldSourceLines.push(indexDecoratorLine);
+        changes.push(...this.decoratorImports());
+        return {
+            filePath: this.options.source.fileName,
+            field: this.options.field,
+            changes: changes,
+            fieldSourceLines: fieldSourceLines,
+        };
+    }
+    decoratorImports() {
+        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'typeorm')];
+    }
+    //Updates the index decorator for the fieldNode based on the options provided
+    // @returns the updated property declaration
+    updateDecorator() {
+        if (!this.classNode)
+            throw new Error('Class node is required for updating the unique index decorator');
+        let newModifiers = [];
+        let existingModifiers = this.classNode.modifiers;
+        // Get the existing unique index decorator if it exists
+        const existingUniqueIndexDecorator = this.findUniqueIndexDecorator(existingModifiers);
+        //Remove the Index decorator if the Index decorator exists
+        newModifiers = [...this.filterOtherDecorators(this.decoratorName(), existingModifiers), ...this.filterOtherIndexDecorators(this.decoratorName(), this.options, existingModifiers), ...this.filterNonDecorators(existingModifiers)];
+        //Add the column decorator if column decorator is required  
+        const changes = [];
+        if (this.isApplyDecorator()) {
+            newModifiers = [...newModifiers, this.createUniqueIndexDecorator(existingUniqueIndexDecorator)];
+            changes.push(...this.decoratorImports());
+        }
+        // If field node is provided, replace the class members with the updated field node
+        const newMembers = this.classNode.members.filter((member) => {
+            // Check if the member is a PropertyDeclaration
+            if (typescript_1.default.isPropertyDeclaration(member)) {
+                // Compare the name of the property with the field name
+                const memberName = member.name.getText();
+                return memberName !== this.options.fieldName; // Exclude members with the matching field name
+            }
+            return true; // Keep non-PropertyDeclaration members
+        });
+        if (this.fieldNode) {
+            newMembers.push(this.fieldNode);
+        }
+        // Update the class node with the new modifiers
+        const updatedClass = typescript_1.default.factory.updateClassDeclaration(this.classNode, newModifiers, this.classNode.name, this.classNode.typeParameters, this.classNode.heritageClauses, newMembers);
+        return [updatedClass, changes];
+    }
+    findUniqueIndexDecorator(existingModifiers) {
+        return existingModifiers ? existingModifiers
+            .filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator))
+            .map(m => m)
+            .filter(m => this.containsIdentifierName(m, this.decoratorName()))
+            .filter(m => this.containsIndexForField(m, this.options.fieldName))
+            .pop()
+            : undefined;
+    }
+    createUniqueIndexDecorator(existingDecorator) {
+        // Capture the existing column decorator options
+        let existingUniqueIndexDecoratorPropertyAssignments = [];
+        if (existingDecorator !== undefined) {
+            //Pre-set the column options from the existing column decorator
+            const existingCallExpression = existingDecorator.expression;
+            // Check if  call expression has at least 2 arguments
+            if (existingCallExpression.arguments.length > 1) {
+                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[1])) {
+                    throw new Error('Column decorator 1st arguments must be an object literal containing the column options');
+                }
+                const existingObjectLiteralExpression = existingCallExpression.arguments[1];
+                existingUniqueIndexDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
+            }
+        }
+        // Create the new unique index decorator options as property assignments, 
+        const uniqueIndexDecoratorOptions = this.createUniqueIndexDecoratorOptions();
+        const newPropertyAssignments = Array.from(uniqueIndexDecoratorOptions.values()).filter(p => p !== null);
+        // Add the other unhandled column decorator options
+        const handledColumnDecoratorOptions = Array.from(uniqueIndexDecoratorOptions.keys());
+        //@ts-ignore
+        const otherPropertyAssignments = existingUniqueIndexDecoratorPropertyAssignments.filter(ps => { var _a; return !handledColumnDecoratorOptions.includes((_a = ps.name) === null || _a === void 0 ? void 0 : _a.escapedText); });
+        newPropertyAssignments.push(...otherPropertyAssignments);
+        // Re-create the column decorator with the merged column decorator options
+        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
+        const fieldsArray = typescript_1.default.factory.createArrayLiteralExpression([
+            typescript_1.default.factory.createStringLiteral(this.options.fieldName),
+            typescript_1.default.factory.createStringLiteral("deletedTracker")
+        ], false);
+        const decoratorOptions = typescript_1.default.factory.createObjectLiteralExpression(newPropertyAssignments);
+        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, [fieldsArray, decoratorOptions]);
+        return typescript_1.default.factory.createDecorator(call);
+    }
+    createUniqueIndexDecoratorOptions() {
+        const options = new Map();
+        options.set('unique', typescript_1.default.factory.createTrue());
+        return this.optionsToPropertyAssignmentsOrNull(options);
+    }
+    optionsToPropertyAssignmentsOrNull(options) {
+        const decoratorOptions = new Map();
+        options.forEach((value, key) => {
+            if (value !== null) {
+                decoratorOptions.set(key, typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createIdentifier(key), value));
+            }
+            else {
+                decoratorOptions.set(key, null);
+            }
+        });
+        return decoratorOptions;
+    }
+    filterOtherDecorators(name, existingModifiers) {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
+    }
+    filterOtherIndexDecorators(name, decoratorOptions, existingModifiers) {
+        return existingModifiers
+            ? existingModifiers
+                .filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator))
+                .map(m => m)
+                .filter(m => this.containsIdentifierName(m, name))
+                .filter(m => !this.containsIndexForField(m, decoratorOptions.fieldName))
+            : [];
+    }
+    filterNonDecorators(existingModifiers) {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== typescript_1.default.SyntaxKind.Decorator)).map(m => m) : [];
+    }
+    containsIdentifierName(m, identifierName) {
+        const callExpression = m.expression;
+        const identifier = callExpression.expression;
+        return identifier.text === identifierName;
+    }
+    containsIndexForField(m, fieldName) {
+        // Check if the Index decorator contains the field name
+        const callExpression = m.expression;
+        const args = callExpression.arguments;
+        if (args.length === 0)
+            return false;
+        let indexAlreadyPresent = false;
+        const fields = args[0];
+        if (typescript_1.default.isArrayLiteralExpression(fields)) {
+            const fieldNames = fields.elements.map(e => e.getText().replace(/^["']|["']$/g, ""));
+            // Check if fieldNames only contains the field name and deletedTracker
+            indexAlreadyPresent = fieldNames.includes(fieldName) && fieldNames.includes('deletedTracker') && fieldNames.length === 2;
+            console.log('fieldNames', fieldNames);
+            console;
+        }
+        if (!indexAlreadyPresent)
+            return false;
+        return true;
+    }
+}
+exports.UniqueIndexDecoratorManager = UniqueIndexDecoratorManager;
+//# sourceMappingURL=UniqueIndexDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/entity/UniqueIndexDecoratorManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueIndexDecoratorManager.js","sourceRoot":"","sources":["UniqueIndexDecoratorManager.ts"],"names":[],"mappings":"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"}

package/src/code-builder/lib/field/decorator-managers/entity/UniqueIndexDecoratorManager.ts

@@ -0,0 +1,204 @@
+import ts, { ClassDeclaration, ModifierLike, ObjectLiteralElementLike, PropertyDeclaration } from "@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript";
+import { insertImport } from "@schematics/angular/utility/ast-utils";
+import { Change } from "@schematics/angular/utility/change";
+import { PartialAddFieldChange } from "../../FieldManager";
+
+interface UniqueIndexDecoratorOptions {
+    unique: boolean;
+    fieldName: string;
+    source: ts.SourceFile;
+    field: any;
+}
+
+export class UniqueIndexDecoratorManager {
+    constructor(public options: UniqueIndexDecoratorOptions, public classNode: ClassDeclaration, public fieldNode?: PropertyDeclaration) { }
+    isApplyDecorator(): boolean {
+        return this.options.unique;
+    }
+    decoratorName(): string {
+        return 'Index';
+    }
+    setFieldNode(fieldNode: ts.PropertyDeclaration): void {
+        this.fieldNode = fieldNode;
+    }
+    buildDecorator(): PartialAddFieldChange {
+        const fieldSourceLines = [];
+        const changes: Change[] = [];
+        const indexDecoratorLine = `@Index(["${this.options.fieldName}", "deletedTracker"], { unique: true })`;
+        fieldSourceLines.push(indexDecoratorLine);
+        changes.push(...this.decoratorImports());
+        return {
+            filePath: this.options.source.fileName,
+            field: this.options.field,
+            changes: changes,
+            fieldSourceLines: fieldSourceLines,
+        };
+    }
+
+    decoratorImports(): Change[] {
+        return [insertImport(
+            this.options.source,
+            this.options.source.fileName,
+            this.decoratorName(),
+            'typeorm')]
+    }
+
+    //Updates the index decorator for the fieldNode based on the options provided
+    // @returns the updated property declaration
+    updateDecorator(): [ClassDeclaration, Change[]] {
+        if (!this.classNode) throw new Error('Class node is required for updating the unique index decorator');
+
+        let newModifiers: ModifierLike[] | undefined = [];
+        let existingModifiers: ts.NodeArray<ModifierLike> | undefined = this.classNode.modifiers;
+
+        // Get the existing unique index decorator if it exists
+        const existingUniqueIndexDecorator = this.findUniqueIndexDecorator(existingModifiers);
+
+        //Remove the Index decorator if the Index decorator exists
+        newModifiers = [...this.filterOtherDecorators(this.decoratorName(), existingModifiers), ...this.filterOtherIndexDecorators(this.decoratorName(), this.options, existingModifiers), ...this.filterNonDecorators(existingModifiers)];
+
+        //Add the column decorator if column decorator is required  
+        const changes: Change[] = [];
+
+        if (this.isApplyDecorator()) {
+            newModifiers = [...newModifiers, this.createUniqueIndexDecorator(existingUniqueIndexDecorator)];
+            changes.push(...this.decoratorImports());
+        }
+
+        // If field node is provided, replace the class members with the updated field node
+        const newMembers = this.classNode.members.filter((member) => {
+            // Check if the member is a PropertyDeclaration
+            if (ts.isPropertyDeclaration(member)) {
+                // Compare the name of the property with the field name
+                const memberName = member.name.getText();
+                return memberName !== this.options.fieldName; // Exclude members with the matching field name
+            }
+            return true; // Keep non-PropertyDeclaration members
+        });
+        if (this.fieldNode) {
+            newMembers.push(this.fieldNode);
+        }
+
+        // Update the class node with the new modifiers
+        const updatedClass = ts.factory.updateClassDeclaration(
+            this.classNode,
+            newModifiers,
+            this.classNode.name,
+            this.classNode.typeParameters,
+            this.classNode.heritageClauses,
+            newMembers,
+        );
+        return [updatedClass, changes];
+    }
+
+    private findUniqueIndexDecorator(existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Decorator | undefined {
+        return existingModifiers ? existingModifiers
+            .filter((m) => (m.kind === ts.SyntaxKind.Decorator))
+            .map(m => m as ts.Decorator)
+            .filter(m => this.containsIdentifierName(m, this.decoratorName()))
+            .filter(m => this.containsIndexForField(m, this.options.fieldName))
+            .pop()
+            : undefined;
+    }
+
+    private createUniqueIndexDecorator(existingDecorator: ts.Decorator | undefined): ts.Decorator {
+        // Capture the existing column decorator options
+        let existingUniqueIndexDecoratorPropertyAssignments: ts.ObjectLiteralElementLike[] = [];
+        if (existingDecorator !== undefined) {
+            //Pre-set the column options from the existing column decorator
+            const existingCallExpression = existingDecorator.expression as ts.CallExpression;
+            // Check if  call expression has at least 2 arguments
+            if (existingCallExpression.arguments.length > 1) {
+                if (!ts.isObjectLiteralExpression(existingCallExpression.arguments[1])) { throw new Error('Column decorator 1st arguments must be an object literal containing the column options'); }
+                const existingObjectLiteralExpression = existingCallExpression.arguments[1] as ts.ObjectLiteralExpression;
+                existingUniqueIndexDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
+            }
+        }
+
+        // Create the new unique index decorator options as property assignments, 
+        const uniqueIndexDecoratorOptions = this.createUniqueIndexDecoratorOptions();
+        const newPropertyAssignments: ObjectLiteralElementLike[] = Array.from(uniqueIndexDecoratorOptions.values()).filter(p => p !== null) as ts.PropertyAssignment[];
+
+        // Add the other unhandled column decorator options
+        const handledColumnDecoratorOptions = Array.from(uniqueIndexDecoratorOptions.keys());
+        //@ts-ignore
+        const otherPropertyAssignments = existingUniqueIndexDecoratorPropertyAssignments.filter(ps => !handledColumnDecoratorOptions.includes(ps.name?.escapedText as string));
+        newPropertyAssignments.push(...otherPropertyAssignments);
+
+        // Re-create the column decorator with the merged column decorator options
+        const decoratorIdentifier = ts.factory.createIdentifier(this.decoratorName());
+        const fieldsArray = ts.factory.createArrayLiteralExpression(
+            [
+                ts.factory.createStringLiteral(this.options.fieldName),
+                ts.factory.createStringLiteral("deletedTracker")
+            ],
+            false
+        )
+        const decoratorOptions = ts.factory.createObjectLiteralExpression(newPropertyAssignments);
+        const call = ts.factory.createCallExpression(decoratorIdentifier, undefined, [fieldsArray, decoratorOptions]);
+        return ts.factory.createDecorator(call)
+    }
+
+    private createUniqueIndexDecoratorOptions(): Map<string, ts.PropertyAssignment | null> { //This function is used while updating the field
+        const options = new Map<string, ts.Expression | null>();
+        options.set('unique', ts.factory.createTrue());
+        return this.optionsToPropertyAssignmentsOrNull(options);
+    }
+
+    private optionsToPropertyAssignmentsOrNull(options: Map<string, ts.Expression | null>): Map<string, ts.PropertyAssignment | null> {
+        const decoratorOptions = new Map<string, ts.PropertyAssignment | null>();
+        options.forEach((value, key) => {
+            if (value !== null) {
+                decoratorOptions.set(key, ts.factory.createPropertyAssignment(ts.factory.createIdentifier(key), value));
+            }
+            else {
+                decoratorOptions.set(key, null);
+            }
+        });
+        return decoratorOptions;
+    }
+
+    private filterOtherDecorators(name: string, existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Decorator[] {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind === ts.SyntaxKind.Decorator)).map(m => m as ts.Decorator).filter(m => !this.containsIdentifierName(m, name)) : [];
+    }
+
+    private filterOtherIndexDecorators(name: string, decoratorOptions: UniqueIndexDecoratorOptions, existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Decorator[] {
+        return existingModifiers
+            ? existingModifiers
+                .filter((m) => (m.kind === ts.SyntaxKind.Decorator))
+                .map(m => m as ts.Decorator)
+                .filter(m => this.containsIdentifierName(m, name))
+                .filter(m => !this.containsIndexForField(m, decoratorOptions.fieldName))
+            : [];
+    }
+
+    private filterNonDecorators(existingModifiers: ts.NodeArray<ts.ModifierLike> | undefined): ts.Modifier[] {
+        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== ts.SyntaxKind.Decorator)).map(m => m as ts.Modifier) : [];
+    }
+
+    private containsIdentifierName(m: ts.Decorator, identifierName: string): boolean {
+        const callExpression = m.expression as ts.CallExpression;
+        const identifier = callExpression.expression as ts.Identifier;
+        return identifier.text === identifierName;
+    }
+
+    private containsIndexForField(m: ts.Decorator, fieldName: string): boolean {
+        // Check if the Index decorator contains the field name
+        const callExpression = m.expression as ts.CallExpression;
+        const args = callExpression.arguments;
+        if (args.length === 0) return false;
+        let indexAlreadyPresent = false;
+        const fields = args[0];
+        if (ts.isArrayLiteralExpression(fields)) {
+            const fieldNames = fields.elements.map(e => e.getText().replace(/^["']|["']$/g, ""));
+            // Check if fieldNames only contains the field name and deletedTracker
+            indexAlreadyPresent = fieldNames.includes(fieldName) && fieldNames.includes('deletedTracker') && fieldNames.length === 2;
+            console.log('fieldNames', fieldNames);
+            console
+        }
+        if (!indexAlreadyPresent) return false;
+
+        return true;
+    }
+
+}