@solidstarters/solid-code-builder 1.0.19 → 1.0.21

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

@@ -1,178 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnDecoratorManager = void 0;
-const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
-const lodash_1 = __importDefault(require("lodash"));
-const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
-class ColumnDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isColumn;
-    }
-    decoratorName() {
-        return 'Column';
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        //Add the Column decorator to the field
-        const columnDecoratorLine = `@${this.decoratorName()}(${this.buildColumnOptionsCode()})`;
-        fieldSourceLines.push(columnDecoratorLine);
-        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')];
-    }
-    updateDecorator() {
-        if (!this.fieldNode)
-            throw new Error('Field node is required for updating the index decorator');
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        // Check if the field has an Column decorator.
-        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
-        //Remove the column decorator if the column decorator 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 column decorator if column decorator is required  
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createColumnDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    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;
-    }
-    createColumnDecorator(existingColumnDecorator) {
-        // Capture the existing column decorator options
-        let existingColumnDecoratorPropertyAssignments = [];
-        if (existingColumnDecorator !== undefined) {
-            //Pre-set the column options from the existing column decorator
-            const existingCallExpression = existingColumnDecorator.expression;
-            // Check if  call expression has at least 1 arguments
-            if (existingCallExpression.arguments.length > 0) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error('Column decorator 1st arguments must be an object literal containing the column options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                existingColumnDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        // Create the new column decorator options as property assignments, if the option is not null
-        const columnDecoratorOptions = this.createColumnDecoratorOptions();
-        const newPropertyAssignments = Array.from(columnDecoratorOptions.values()).filter(p => p !== null);
-        // console.log('newPropertyAssignments', newPropertyAssignments.map(p => JSON.stringify(p.name)).join(', '));
-        // Add the other unhandled column decorator options
-        const handledColumnDecoratorOptions = Array.from(columnDecoratorOptions.keys());
-        //@ts-ignore
-        const otherPropertyAssignments = existingColumnDecoratorPropertyAssignments.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 decoratorOptions = typescript_1.default.factory.createObjectLiteralExpression(newPropertyAssignments);
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, [decoratorOptions]);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    createColumnDecoratorOptions() {
-        const options = new Map();
-        //Set common options
-        //TODO Proper types to be used e.g ColumnCommonOptions
-        // if (this.field.defaultValue) {
-        //   options.set('default',  this.field.defaultValue);
-        // }
-        (!lodash_1.default.isEmpty(this.options.columnName)) ? options.set('name', typescript_1.default.factory.createStringLiteral(this.options.columnName)) : options.set('name', null);
-        (this.options.type) ? options.set('type', typescript_1.default.factory.createStringLiteral(this.options.type)) : options.set('type', null);
-        if (!this.options.required) {
-            options.set('nullable', typescript_1.default.factory.createTrue());
-        }
-        //Set additional options
-        this.options.otherOptionExpressions.forEach((value, key) => {
-            options.set(key, value);
-        });
-        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;
-    }
-    buildColumnDecoratorOptions() {
-        const options = new Map();
-        //Set common options
-        //TODO Proper types to be used e.g ColumnCommonOptions
-        // if (this.options.field.defaultValue) {
-        //   options.set('default', this.options.field.defaultValue);
-        // }
-        if (!lodash_1.default.isEmpty(this.options.columnName)) {
-            options.set('name', `${this.options.columnName}`);
-        }
-        if (!lodash_1.default.isEmpty(this.options.type)) {
-            options.set('type', `${this.options.type}`);
-        }
-        if (!this.options.required) {
-            options.set('nullable', true);
-        }
-        // Set some keys as null, to indicate they are handled i.e they will be removed & recreated, if required
-        //Handled keys
-        // options.set('length', null) //TODO Can be improved, since handled keys needs to be managed in this decorator. Ideally it should be managed in the corresponding field
-        //Set additional options
-        this.options.otherOptions.forEach((value, key) => {
-            options.set(key, value);
-        });
-        return options;
-    }
-    buildColumnOptionsCode() {
-        const options = this.buildColumnDecoratorOptions();
-        const keys = Array.from(options.keys());
-        const optionsString = keys
-            .filter((key) => options.get(key) !== null)
-            .map((key) => {
-            if (typeof options.get(key) === 'string') {
-                return `${key}: "${options.get(key)}"`;
-            }
-            else {
-                return `${key}: ${options.get(key)}`;
-            }
-        })
-            .join(', ');
-        return `{ ${optionsString} }`;
-    }
-}
-exports.ColumnDecoratorManager = ColumnDecoratorManager;
-//# sourceMappingURL=ColumnDecoratorManager.js.map

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

@@ -1,79 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexDecoratorManager = void 0;
-const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
-const FieldManager_1 = require("../../FieldManager");
-const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
-class IndexDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.index && this.options.field.relationType !== FieldManager_1.RelationType.ManyToMany;
-    }
-    decoratorName() {
-        return 'Index';
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        // if (this.field.index) {
-        const indexDecoratorLine = `@Index()`;
-        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.fieldNode)
-            throw new Error('Field node is required for updating the index decorator');
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        //Remove the Index decorator if the Index decorator 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 column decorator if column decorator is required  
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createIndexDecorator()];
-            changes.push(...this.decoratorImports());
-        }
-        //If index decorator is present & index is required, no need to update the index decorator
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //newModifiers contains the updated index decorator
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createIndexDecorator() {
-        return typescript_1.default.factory.createDecorator(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('Index'), undefined, []));
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    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;
-    }
-}
-exports.IndexDecoratorManager = IndexDecoratorManager;
-//# sourceMappingURL=IndexDecoratorManager.js.map

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

@@ -1,118 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinTableDecoratorManager = 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 JoinTableDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isManyToManyRelationOwner;
-    }
-    decoratorName() {
-        return 'JoinTable';
-    }
-    buildDecorator() {
-        const changes = [];
-        const fieldSourceLines = [];
-        // Add the many-to-many import
-        // const decoratorImport = insertImport(
-        //     this.options.source,
-        //     this.options.source.fileName,
-        //     this.decoratorName(),
-        //     'typeorm',
-        // );
-        // if (decoratorImport) {
-        //     changes.push(decoratorImport);
-        // }
-        fieldSourceLines.push(`@${this.decoratorName()}()`);
-        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')];
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    updateDecorator() {
-        // 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 = [];
-        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 = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createDecorator(existingDecorator) {
-        let existingRelationOptions = this.existingDecoratorOptions(existingDecorator);
-        // const mergedRelationOptions: ObjectLiteralElementLike[] = this.mergeNewAndExistingDecoratorOptions(existingRelationOptions);
-        // Re-create the decorator with the merged decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = this.createDecoratorArguments(existingRelationOptions);
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    createDecoratorArguments(joinTableOptions) {
-        const argumentsArray = [];
-        if (joinTableOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(joinTableOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        return argumentsArray;
-    }
-    existingDecoratorOptions(existingDecorator) {
-        let existingDecoratorPropertyAssignments = [];
-        if (existingDecorator !== undefined) {
-            //Pre-set the relation options from the existing relation decorator
-            const existingCallExpression = existingDecorator.expression;
-            // Check if  call expression has at least 1 arguments
-            if (existingCallExpression.arguments.length > 0) { //Because we are interested in the 1st argument, we check for length > 0
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error('JoinTable decorator 1st argument must be an object literal containing the joinTable options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                existingDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        return existingDecoratorPropertyAssignments;
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    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;
-    }
-}
-exports.JoinTableDecoratorManager = JoinTableDecoratorManager;
-//# sourceMappingURL=JoinTableDecoratorManager.js.map

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

@@ -1,175 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManyToManyDecoratorManager = void 0;
-const strings_1 = require("@angular-devkit/core/src/utils/strings");
-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 ManyToManyDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isManyToMany;
-    }
-    decoratorName() {
-        return 'ManyToMany';
-    }
-    buildDecorator() {
-        const changes = [];
-        const fieldSourceLines = [];
-        // Add the many-to-many import
-        // const decoratorImport = insertImport(
-        //     this.options.source,    
-        //     this.options.source.fileName,
-        //     this.decoratorName(),
-        //     'typeorm',
-        // );
-        changes.push(...this.decoratorImports());
-        // if (decoratorImport) {
-        //     changes.push(decoratorImport);
-        // }
-        const fieldSourceLineComponents = [];
-        fieldSourceLineComponents.push(`() => ${(0, strings_1.classify)(this.options.relationModelName)}`);
-        this.options.relationInverseFieldName ? fieldSourceLineComponents.push(`${(0, strings_1.camelize)(this.options.relationModelName)} => ${(0, strings_1.camelize)(this.options.relationModelName)}.${this.options.relationInverseFieldName}`) : "no-ops";
-        fieldSourceLineComponents.push(`${this.buildRelationOptionsCode()}`);
-        fieldSourceLines.push(`@${this.decoratorName()}(${fieldSourceLineComponents.join(', ')})`);
-        return {
-            filePath: this.options.source.fileName,
-            field: this.options.field,
-            changes: changes,
-            fieldSourceLines: fieldSourceLines,
-        };
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    decoratorImports() {
-        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'typeorm')];
-    }
-    updateDecorator() {
-        // 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 = [];
-        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 = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createRelationDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    buildRelationOptionsCode() {
-        const relationOptions = new Map();
-        // this.options.owner ? relationOptions.set('cascade', true): "no-ops";
-        this.options.owner ? relationOptions.set('cascade', true) : relationOptions.set('cascade', ['insert', 'update']);
-        const decoratorArgs = Array.from(relationOptions)
-            .map(([key, value]) => {
-            if (Array.isArray(value)) {
-                return `${key}: [${value.map(v => `'${v}'`).join(', ')}]`;
-            }
-            return `${key}: ${value}`;
-        })
-            .join(', ');
-        // Convert the map to a string
-        return `{ ${decoratorArgs} }`;
-    }
-    createRelationDecorator(existingRelationDecorator) {
-        let existingRelationOptions = this.existingDecoratorOptions(existingRelationDecorator);
-        const mergedRelationOptions = this.mergeNewAndExistingDecoratorOptions(existingRelationOptions);
-        // Re-create the decorator with the merged decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = this.createDecoratorArguments(mergedRelationOptions);
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    mergeNewAndExistingDecoratorOptions(existingRelationOptions) {
-        const decoratorOptions = this.createRelationDecoratorOptions();
-        const newPropertyAssignments = Array.from(decoratorOptions.values()).filter(p => p !== null);
-        // 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 = existingRelationOptions.filter(ps => { var _a; return !handledDecoratorOptions.includes((_a = ps.name) === null || _a === void 0 ? void 0 : _a.escapedText); });
-        newPropertyAssignments.push(...otherPropertyAssignments);
-        return newPropertyAssignments;
-    }
-    createDecoratorArguments(newPropertyAssignments) {
-        const argumentsArray = [];
-        // 1st Argument: Target
-        const typeFunctionOrTarget = typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), typescript_1.default.factory.createIdentifier((0, strings_1.classify)(this.options.relationModelName)));
-        argumentsArray.push(typeFunctionOrTarget);
-        if (this.options.relationInverseFieldName) {
-            // 2nd Argument: Inverse side
-            const inverseSide = typescript_1.default.factory.createArrowFunction(undefined, undefined, [typescript_1.default.factory.createParameterDeclaration(undefined, undefined, typescript_1.default.factory.createIdentifier((0, strings_1.camelize)(this.options.relationModelName)), undefined, undefined, undefined)], undefined, typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier((0, strings_1.camelize)(this.options.relationModelName)), typescript_1.default.factory.createIdentifier(this.options.relationInverseFieldName)));
-            argumentsArray.push(inverseSide);
-        }
-        // 3rd Argument: Options. This argument is optional
-        if (newPropertyAssignments.length > 0) {
-            const decoratorOptions = typescript_1.default.factory.createObjectLiteralExpression(newPropertyAssignments);
-            argumentsArray.push(decoratorOptions);
-        }
-        return argumentsArray;
-    }
-    existingDecoratorOptions(existingRelationDecorator) {
-        let existingRelationDecoratorPropertyAssignments = [];
-        if (existingRelationDecorator !== undefined) {
-            //Pre-set the relation options from the existing relation decorator
-            const existingCallExpression = existingRelationDecorator.expression;
-            // 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 (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[2])) {
-                    throw new Error('Many-to-Many decorator 3rd argument must be an object literal containing the relation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[2];
-                existingRelationDecoratorPropertyAssignments.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        return existingRelationDecoratorPropertyAssignments;
-    }
-    createRelationDecoratorOptions() {
-        const relationOptions = new Map();
-        this.options.owner ? relationOptions.set('cascade', typescript_1.default.factory.createTrue()) : "no-ops";
-        return this.optionsToPropertyAssignmentsOrNull(relationOptions);
-    }
-    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;
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    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;
-    }
-}
-exports.ManyToManyDecoratorManager = ManyToManyDecoratorManager;
-//# sourceMappingURL=ManyToManyDecoratorManager.js.map