@memberjunction/codegen-lib 1.0.6 → 1.0.7

package/dist/sql_codegen.js

@@ -15,6 +15,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -26,7 +32,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SPType = exports.generateSingleEntitySQLFileHeader = exports.generateAllEntitiesSQLFileHeader = exports.generateEntitySQL = exports.getEntityPermissionFileNames = exports.getSPName = exports.generateSingleEntitySQLToSeparateFiles = exports.generateAndExecuteSingleEntitySQLToSeparateFiles = exports.createCombinedEntitySQLFiles = exports.generateAndExecuteAllEntitiesSQLToSeparateFiles = exports.applyPermissions = exports.runCustomSQLScripts = exports.manageSQLScriptsAndExecution = void 0;
+exports.SQLCodeGenBase = exports.SPType = void 0;
 const core_1 = require("@memberjunction/core");
 const logging_1 = require("./logging");
 const fs = __importStar(require("fs"));
@@ -36,625 +42,696 @@ const config_1 = require("./config");
 const manageMetadata_1 = require("./manageMetadata");
 const sqlserver_dataprovider_1 = require("@memberjunction/sqlserver-dataprovider");
 const util_1 = require("./util");
-//import { LoadGeneratedEntities } from 'mj_generatedentities';
-//LoadGeneratedEntities(); // make sure we have everything loaded up
-async function manageSQLScriptsAndExecution(ds, entities, directory) {
-    try {
-        // STEP 1 - execute any custom SQL scripts for object creation that need to happen first - for example, if 
-        //          we have custom base views, need to have them defined before we do 
-        //          the rest as the generated stuff might use custom base views in compiled 
-        //          objects like spCreate for a given entity might reference the vw for that entity
-        const startTime = new Date();
-        if (!await runCustomSQLScripts(ds, 'before-sql'))
-            return false;
-        (0, logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
-        // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
-        const baselineEntities = entities.filter(e => e.IncludeInAPI);
-        const includedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) === undefined); //only include entities that are NOT in the excludeSchemas list
-        const excludedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) !== undefined); //only include entities that ARE in the excludeSchemas list in this array
-        // STEP 2(a) - generate all the SQL files and execute them
-        const step2StartTime = new Date();
-        if (!await generateAndExecuteAllEntitiesSQLToSeparateFiles(ds, includedEntities, directory, false)) {
-            (0, logging_1.logError)('Error generating and executing all entities SQL to separate files');
-            return false;
+const global_1 = require("@memberjunction/global");
+exports.SPType = {
+    Create: 'Create',
+    Update: 'Update',
+    Delete: 'Delete',
+};
+/**
+ * This class is responsible for generating database level objects like views, stored procedures, permissions, etc. You can sub-class this class to create your own SQL generation logic or implement support for other
+ * databases. The base class implements support for SQL Server. In future versions of MJ, we will break out an abstract base class that has the skeleton of the logic and then the SQL Server version will be a sub-class
+ * of that abstract base class and other databases will be sub-classes of the abstract base class as well.
+ */
+let SQLCodeGenBase = class SQLCodeGenBase {
+    constructor() {
+        this._sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
+    }
+    get SQLUtilityObject() {
+        return this._sqlUtilityObject;
+    }
+    async manageSQLScriptsAndExecution(ds, entities, directory) {
+        try {
+            // STEP 1 - execute any custom SQL scripts for object creation that need to happen first - for example, if 
+            //          we have custom base views, need to have them defined before we do 
+            //          the rest as the generated stuff might use custom base views in compiled 
+            //          objects like spCreate for a given entity might reference the vw for that entity
+            const startTime = new Date();
+            if (!await this.runCustomSQLScripts(ds, 'before-sql'))
+                return false;
+            (0, logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+            // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
+            const baselineEntities = entities.filter(e => e.IncludeInAPI);
+            const includedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) === undefined); //only include entities that are NOT in the excludeSchemas list
+            const excludedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) !== undefined); //only include entities that ARE in the excludeSchemas list in this array
+            // STEP 2(a) - generate all the SQL files and execute them
+            const step2StartTime = new Date();
+            if (!await this.generateAndExecuteEntitySQLToSeparateFiles(ds, includedEntities, directory, false)) {
+                (0, logging_1.logError)('Error generating and executing all entities SQL to separate files');
+                return false;
+            }
+            // STEP 2(b) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
+            if (!await this.generateAndExecuteEntitySQLToSeparateFiles(ds, excludedEntities, directory, true)) {
+                (0, logging_1.logError)('Error generating and executing permissions SQL for excluded entities to separate files');
+                return false;
+            }
+            (0, logging_1.logStatus)(`   Time to Generate/Execute Entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+            // now that we've generated the SQL, let's create a combined file in each schema sub-directory for convenience for a DBA
+            this.createCombinedEntitySQLFiles(directory, baselineEntities);
+            const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manageMetadata_1.ManageMetadataBase);
+            // STEP 3 - re-run the process to manage entity fields since the Step 1 and 2 above might have resulted in differences in base view columns compared to what we had at first
+            if (!await manageMD.manageEntityFields(ds, config_1.configInfo.excludeSchemas)) {
+                (0, logging_1.logError)('Error managing entity fields');
+                return false;
+            }
+            // no logStatus/timer for this because manageEntityFields() has its own internal logging for this including the total, so it is redundant to log it here
+            // STEP 4- Apply permissions, executing all .permissions files
+            const step4StartTime = new Date();
+            if (!await this.applyPermissions(ds, directory, baselineEntities)) {
+                (0, logging_1.logError)('Error applying permissions');
+                return false;
+            }
+            (0, logging_1.logStatus)(`   Time to Apply Permissions: ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
+            // STEP 5 - execute any custom SQL scripts that should run afterwards
+            const step5StartTime = new Date();
+            if (!await this.runCustomSQLScripts(ds, 'after-sql'))
+                return false;
+            (0, logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
+            (0, logging_1.logStatus)('   Total time to run generate and execute SQL scripts: ' + ((new Date().getTime() - startTime.getTime()) / 1000) + ' seconds');
+            // now - we need to tell our metadata object to refresh itself
+            const md = new core_1.Metadata();
+            await md.Refresh();
+            return true;
         }
-        // STEP 2(b) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
-        if (!await generateAndExecuteAllEntitiesSQLToSeparateFiles(ds, excludedEntities, directory, true)) {
-            (0, logging_1.logError)('Error generating and executing permissions SQL for excluded entities to separate files');
+        catch (err) {
+            (0, logging_1.logError)(err);
             return false;
         }
-        (0, logging_1.logStatus)(`   Time to Generate/Execute Entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
-        // now that we've generated the SQL, let's create a combined file in each schema sub-directory for convenience for a DBA
-        createCombinedEntitySQLFiles(directory, baselineEntities);
-        // STEP 3 - re-run the process to manage entity fields since the Step 1 and 2 above might have resulted in differences in base view columns compared to what we had at first
-        if (!await (0, manageMetadata_1.manageEntityFields)(ds, config_1.configInfo.excludeSchemas)) {
-            (0, logging_1.logError)('Error managing entity fields');
-            return false;
+    }
+    async runCustomSQLScripts(ds, when) {
+        try {
+            const scripts = (0, config_1.customSqlScripts)(when);
+            let bSuccess = true;
+            if (scripts) {
+                for (let i = 0; i < scripts.length; ++i) {
+                    const s = scripts[i];
+                    if (!await this.SQLUtilityObject.executeSQLFile(ds, s.scriptFile, true)) {
+                        (0, logging_1.logError)(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
+                        bSuccess = false; // keep going if we have more scripts, but make sure we return false
+                    }
+                }
+            }
+            return bSuccess;
         }
-        // no logStatus/timer for this because manageEntityFields() has its own internal logging for this including the total, so it is redundant to log it here
-        // STEP 4- Apply permissions, executing all .permissions files
-        const step4StartTime = new Date();
-        if (!await applyPermissions(ds, directory, baselineEntities)) {
-            (0, logging_1.logError)('Error applying permissions');
+        catch (e) {
+            (0, logging_1.logError)(e);
             return false;
         }
-        (0, logging_1.logStatus)(`   Time to Apply Permissions: ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
-        // STEP 5 - execute any custom SQL scripts that should run afterwards
-        const step5StartTime = new Date();
-        if (!await runCustomSQLScripts(ds, 'after-sql'))
-            return false;
-        (0, logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
-        (0, logging_1.logStatus)('   Total time to run generate and execute SQL scripts: ' + ((new Date().getTime() - startTime.getTime()) / 1000) + ' seconds');
-        // now - we need to tell our metadata object to refresh itself
-        const md = new core_1.Metadata();
-        await md.Refresh();
-        return true;
-    }
-    catch (err) {
-        (0, logging_1.logError)(err);
-        return false;
-    }
-}
-exports.manageSQLScriptsAndExecution = manageSQLScriptsAndExecution;
-async function runCustomSQLScripts(ds, when) {
-    try {
-        const scripts = (0, config_1.customSqlScripts)(when);
-        let bSuccess = true;
-        if (scripts) {
-            for (let i = 0; i < scripts.length; ++i) {
-                const s = scripts[i];
-                if (!await (0, sql_1.executeSQLFile)(ds, s.scriptFile, true)) {
-                    (0, logging_1.logError)(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
-                    bSuccess = false; // keep going if we have more scripts, but make sure we return false
+    }
+    async applyPermissions(ds, directory, entities, batchSize = 5) {
+        try {
+            let bSuccess = true;
+            for (let i = 0; i < entities.length; i += batchSize) {
+                const batch = entities.slice(i, i + batchSize);
+                const promises = batch.map(async (e) => {
+                    // generate the file names for the entity
+                    const files = this.getEntityPermissionFileNames(e);
+                    let innerSuccess = true;
+                    for (const f of files) {
+                        const fullPath = path_1.default.join(directory, f);
+                        if (fs.existsSync(fullPath)) {
+                            if (!await this.SQLUtilityObject.executeSQLFile(ds, fullPath, true))
+                                innerSuccess = false; // we keep going, just note that something failed
+                        }
+                        else {
+                            // we don't have the file, so we can't execute it, but we should log it as an error 
+                            // and then keep going
+                            (0, logging_1.logError)(`Permissions file ${fullPath} does not exist for entity ${e.Name}`);
+                        }
+                    }
+                    return innerSuccess;
+                });
+                const results = await Promise.all(promises);
+                if (results.includes(false)) {
+                    (0, logging_1.logError)(`Error executing one or more permissions files in batch starting from index ${i}`);
+                    bSuccess = false; // keep going, but will return false at the end
                 }
             }
+            return bSuccess;
         }
-        return bSuccess;
-    }
-    catch (e) {
-        (0, logging_1.logError)(e);
-        return false;
-    }
-}
-exports.runCustomSQLScripts = runCustomSQLScripts;
-async function applyPermissions(ds, directory, entities, batchSize = 5) {
-    try {
-        let bSuccess = true;
-        for (let i = 0; i < entities.length; i += batchSize) {
-            const batch = entities.slice(i, i + batchSize);
-            const promises = batch.map(async (e) => {
-                // generate the file names for the entity
-                const files = getEntityPermissionFileNames(e);
-                let innerSuccess = true;
-                for (const f of files) {
-                    const fullPath = path_1.default.join(directory, f);
-                    if (fs.existsSync(fullPath)) {
-                        if (!await (0, sql_1.executeSQLFile)(ds, fullPath, true))
-                            innerSuccess = false; // we keep going, just note that something failed
-                    }
-                    else {
-                        // we don't have the file, so we can't execute it, but we should log it as an error 
-                        // and then keep going
-                        (0, logging_1.logError)(`Permissions file ${fullPath} does not exist for entity ${e.Name}`);
+        catch (err) {
+            (0, logging_1.logError)(err);
+            return false;
+        }
+    }
+    /**
+     * This function will handle the process of creating all of the generated objects like base view, stored procedures, etc. for all entities in the entities array. It will generate the SQL for each entity and then execute it.
+     * @param ds The DataSource object to use to execute the SQL
+     * @param entities The array of EntityInfo objects to generate SQL for
+     * @param directory The directory to save the generated SQL files to
+     * @param onlyPermissions If true, only the permissions files will be generated and executed, not the actual SQL files. Use this if you are simply setting permission changes but no actual changes to the entities have occured.
+     */
+    async generateAndExecuteEntitySQLToSeparateFiles(ds, entities, directory, onlyPermissions, writeFiles = true, batchSize = 5) {
+        try {
+            let bFail = false;
+            const totalEntities = entities.length;
+            for (let i = 0; i < totalEntities; i += batchSize) {
+                const batch = entities.slice(i, i + batchSize);
+                const promises = batch.map(async (e) => {
+                    const pkeyField = e.Fields.find(f => f.IsPrimaryKey);
+                    if (!pkeyField) {
+                        (0, logging_1.logError)(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have a primary key field defined. A table must have a primary key defined to quality to be a MemberJunction entity`);
+                        return false;
                     }
+                    return this.generateAndExecuteSingleEntitySQLToSeparateFiles(ds, e, directory, onlyPermissions, writeFiles);
+                });
+                const results = await Promise.all(promises);
+                if (results.includes(false)) {
+                    bFail = true; // keep going, but will return false at the end
                 }
-                return innerSuccess;
-            });
-            const results = await Promise.all(promises);
-            if (results.includes(false)) {
-                (0, logging_1.logError)(`Error executing one or more permissions files in batch starting from index ${i}`);
-                bSuccess = false; // keep going, but will return false at the end
             }
+            return !bFail;
         }
-        return bSuccess;
-    }
-    catch (err) {
-        (0, logging_1.logError)(err);
-        return false;
-    }
-}
-exports.applyPermissions = applyPermissions;
-async function generateAndExecuteAllEntitiesSQLToSeparateFiles(ds, entities, directory, onlyPermissions, batchSize = 5) {
-    try {
-        let bFail = false;
-        const totalEntities = entities.length;
-        for (let i = 0; i < totalEntities; i += batchSize) {
-            const batch = entities.slice(i, i + batchSize);
-            const promises = batch.map(async (e) => {
-                const pkeyField = e.Fields.find(f => f.IsPrimaryKey);
-                if (!pkeyField) {
-                    (0, logging_1.logError)(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have a primary key field defined. A table must have a primary key defined to quality to be a MemberJunction entity`);
-                    return false;
-                }
-                return generateAndExecuteSingleEntitySQLToSeparateFiles(ds, e, directory, onlyPermissions);
-            });
-            const results = await Promise.all(promises);
-            if (results.includes(false)) {
-                bFail = true; // keep going, but will return false at the end
+        catch (err) {
+            (0, logging_1.logError)(err);
+            return false;
+        }
+    }
+    async createCombinedEntitySQLFiles(directory, entities) {
+        // first, get a disinct list of schemanames from the entities
+        const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
+        for (const s of schemaNames) {
+            // generate the all-entities.sql file and all-entities.permissions.sql file in each schema folder
+            const fullPath = path_1.default.join(directory, s);
+            if (fs.statSync(fullPath).isDirectory()) {
+                (0, util_1.combineFiles)(fullPath, '_all_entities.sql', '*.generated.sql', true);
+                (0, util_1.combineFiles)(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
             }
         }
-        return !bFail;
-    }
-    catch (err) {
-        (0, logging_1.logError)(err);
-        return false;
-    }
-}
-exports.generateAndExecuteAllEntitiesSQLToSeparateFiles = generateAndExecuteAllEntitiesSQLToSeparateFiles;
-async function createCombinedEntitySQLFiles(directory, entities) {
-    // first, get a disinct list of schemanames from the entities
-    const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
-    for (const s of schemaNames) {
-        // generate the all-entities.sql file and all-entities.permissions.sql file in each schema folder
-        const fullPath = path_1.default.join(directory, s);
-        if (fs.statSync(fullPath).isDirectory()) {
-            (0, util_1.combineFiles)(fullPath, '_all_entities.sql', '*.generated.sql', true);
-            (0, util_1.combineFiles)(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
-        }
-    }
-}
-exports.createCombinedEntitySQLFiles = createCombinedEntitySQLFiles;
-async function generateAndExecuteSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions) {
-    try {
-        const sSQL = await generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions); // this creates the files and returns a single string with all the SQL we can then execute
-        return await (0, sql_1.executeSQLScript)(ds, sSQL, true);
-    }
-    catch (err) {
-        (0, logging_1.logError)(err);
-        return false;
-    }
-}
-exports.generateAndExecuteSingleEntitySQLToSeparateFiles = generateAndExecuteSingleEntitySQLToSeparateFiles;
-async function generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions) {
-    try {
-        // create the directory if it doesn't exist
-        if (!fs.existsSync(directory))
-            fs.mkdirSync(directory, { recursive: true });
-        // now do the same thing for the /schema directory within the provided directory
-        const schemaDirectory = path_1.default.join(directory, entity.SchemaName);
-        if (!fs.existsSync(schemaDirectory))
-            fs.mkdirSync(schemaDirectory, { recursive: true }); // create the directory if it doesn't exist
-        let sRet = '';
-        // BASE VIEW  
-        if (!onlyPermissions && entity.BaseViewGenerated && !entity.VirtualEntity) {
-            // generate the base view
-            const s = generateSingleEntitySQLFileHeader(entity, entity.BaseView) + await generateBaseView(ds, entity);
-            const filePath = path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('view', entity.SchemaName, entity.BaseView, false, true));
-            fs.writeFileSync(filePath, s);
-            sRet += s + '\nGO\n';
-        }
-        // always generate permissions for the base view
-        const s = generateSingleEntitySQLFileHeader(entity, 'Permissions for ' + entity.BaseView) + generateViewPermissions(entity);
-        fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('view', entity.SchemaName, entity.BaseView, true, true)), s);
-        // now, append the permissions to the return string IF we did NOT generate the base view - because if we generated the base view, that
-        // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
-        if (!entity.BaseViewGenerated)
-            sRet += s + '\nGO\n';
-        // CREATE SP
-        if (entity.AllowCreateAPI && !entity.VirtualEntity) {
-            const spName = getSPName(entity, exports.SPType.Create);
-            if (!onlyPermissions && entity.spCreateGenerated) {
-                // generate the create SP
-                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPCreate(entity);
-                fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, false, true)), s);
+    }
+    async generateAndExecuteSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles = true) {
+        try {
+            const { sql, permissionsSQL } = await this.generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles); // this creates the files and returns a single string with all the SQL we can then execute
+            return await this.SQLUtilityObject.executeSQLScript(ds, sql, true) &&
+                await this.SQLUtilityObject.executeSQLScript(ds, permissionsSQL, true);
+        }
+        catch (err) {
+            (0, logging_1.logError)(err);
+            return false;
+        }
+    }
+    async generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles = true) {
+        try {
+            // create the directory if it doesn't exist
+            if (writeFiles && !fs.existsSync(directory))
+                fs.mkdirSync(directory, { recursive: true });
+            // now do the same thing for the /schema directory within the provided directory
+            const schemaDirectory = path_1.default.join(directory, entity.SchemaName);
+            if (writeFiles && !fs.existsSync(schemaDirectory))
+                fs.mkdirSync(schemaDirectory, { recursive: true }); // create the directory if it doesn't exist
+            let sRet = '';
+            let permissionsSQL = '';
+            // BASE VIEW  
+            if (!onlyPermissions && entity.BaseViewGenerated && !entity.VirtualEntity) {
+                // generate the base view
+                const s = this.generateSingleEntitySQLFileHeader(entity, entity.BaseView) + await this.generateBaseView(ds, entity);
+                const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, false, true));
+                if (writeFiles)
+                    fs.writeFileSync(filePath, s);
                 sRet += s + '\nGO\n';
             }
-            const s = generateSPPermissions(entity, spName, exports.SPType.Create) + '\n\n';
-            fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, true, true)), s);
-            // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
+            // always generate permissions for the base view
+            const s = this.generateSingleEntitySQLFileHeader(entity, 'Permissions for ' + entity.BaseView) + this.generateViewPermissions(entity);
+            if (s.length > 0)
+                permissionsSQL += s + '\nGO\n';
+            if (writeFiles)
+                fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, true, true)), s);
+            // now, append the permissions to the return string IF we did NOT generate the base view - because if we generated the base view, that
             // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
-            if (!entity.spCreateGenerated)
+            if (!entity.BaseViewGenerated)
                 sRet += s + '\nGO\n';
+            // CREATE SP
+            if (entity.AllowCreateAPI && !entity.VirtualEntity) {
+                const spName = this.getSPName(entity, exports.SPType.Create);
+                if (!onlyPermissions && entity.spCreateGenerated) {
+                    // generate the create SP
+                    const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPCreate(entity);
+                    if (writeFiles)
+                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    sRet += s + '\nGO\n';
+                }
+                const s = this.generateSPPermissions(entity, spName, exports.SPType.Create) + '\n\n';
+                if (s.length > 0)
+                    permissionsSQL += s + '\nGO\n';
+                if (writeFiles)
+                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
+                // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
+                if (!entity.spCreateGenerated)
+                    sRet += s + '\nGO\n';
+            }
+            // UPDATE SP
+            if (entity.AllowUpdateAPI && !entity.VirtualEntity) {
+                const spName = this.getSPName(entity, exports.SPType.Update);
+                if (!onlyPermissions && entity.spUpdateGenerated) {
+                    // generate the update SP
+                    const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPUpdate(entity);
+                    if (writeFiles)
+                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    sRet += s + '\nGO\n';
+                }
+                const s = this.generateSPPermissions(entity, spName, exports.SPType.Update) + '\n\n';
+                if (s.length > 0)
+                    permissionsSQL += s + '\nGO\n';
+                if (writeFiles)
+                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
+                // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
+                if (!entity.spUpdateGenerated)
+                    sRet += s + '\nGO\n';
+            }
+            // DELETE SP
+            if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
+                const spName = this.getSPName(entity, exports.SPType.Delete);
+                if (!onlyPermissions && entity.spDeleteGenerated) {
+                    // generate the delete SP
+                    const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPDelete(entity);
+                    if (writeFiles)
+                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    sRet += s + '\nGO\n';
+                }
+                const s = this.generateSPPermissions(entity, spName, exports.SPType.Delete) + '\n\n';
+                if (s.length > 0)
+                    permissionsSQL += s + '\nGO\n';
+                if (writeFiles)
+                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
+                // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
+                if (!entity.spDeleteGenerated)
+                    sRet += s + '\nGO\n';
+            }
+            // check to see if the entity supports full text search or not
+            if (entity.FullTextSearchEnabled) {
+                // always generate the code so we can get the function name from the below function call
+                const ft = await this.generateEntityFullTextSearchSQL(ds, entity);
+                if (!onlyPermissions) {
+                    // only write the actual sql out if we're not only generating permissions
+                    const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, false, true));
+                    if (writeFiles)
+                        fs.writeFileSync(filePath, ft.sql);
+                    sRet += ft.sql + '\nGO\n';
+                }
+                const sP = this.generateFullTextSearchFunctionPermissions(entity, ft.functionName) + '\n\n';
+                if (sP.length > 0)
+                    permissionsSQL += sP + '\nGO\n';
+                const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
+                if (writeFiles)
+                    fs.writeFileSync(filePath, sP);
+                // now, append the permissions to the return string IF we did NOT generate the function - because if we generated the function, that
+                // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
+                if (!entity.FullTextSearchFunctionGenerated)
+                    sRet += sP + '\nGO\n';
+            }
+            return { sql: sRet, permissionsSQL: permissionsSQL };
+        }
+        catch (err) {
+            (0, logging_1.logError)(err);
+            return null;
+        }
+    }
+    getSPName(entity, type) {
+        switch (type) {
+            case exports.SPType.Create:
+                return entity.spCreate && entity.spCreate.length > 0 ? entity.spCreate : 'spCreate' + entity.ClassName;
+            case exports.SPType.Update:
+                return entity.spUpdate && entity.spUpdate.length > 0 ? entity.spUpdate : 'spUpdate' + entity.ClassName;
+            case exports.SPType.Delete:
+                return entity.spDelete && entity.spDelete.length > 0 ? entity.spDelete : 'spDelete' + entity.ClassName;
+        }
+    }
+    getEntityPermissionFileNames(entity) {
+        const files = [];
+        // all entities have a base view - and we always generate permissions for the base view even if not generated base view
+        files.push(this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, true, true));
+        // only add the SP files if the entity is not a virtual entity
+        if (!entity.VirtualEntity) {
+            // only add each SP file if the Allow flags are set to true, doesn't matter if the SPs are generated or not, we always generate permissions
+            if (entity.AllowCreateAPI)
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Create), true, true));
+            if (entity.AllowUpdateAPI)
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Update), true, true));
+            if (entity.AllowDeleteAPI)
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Delete), true, true));
+        }
+        if (entity.FullTextSearchEnabled)
+            files.push(this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
+        return files;
+    }
+    async generateEntitySQL(ds, entity) {
+        let sOutput = '';
+        if (entity.BaseViewGenerated && !entity.VirtualEntity)
+            // generated the base view (will include permissions)
+            sOutput += await this.generateBaseView(ds, entity) + '\n\n';
+        else
+            // still generate the permissions for the view even if a custom view
+            sOutput += this.generateViewPermissions(entity) + '\n\n';
+        if (entity.AllowCreateAPI && !entity.VirtualEntity) {
+            if (entity.spCreateGenerated)
+                // generated SP, will include permissions
+                sOutput += this.generateSPCreate(entity) + '\n\n';
+            else
+                // custom SP, still generate the permissions
+                sOutput += this.generateSPPermissions(entity, entity.spCreate, exports.SPType.Create) + '\n\n';
         }
-        // UPDATE SP
         if (entity.AllowUpdateAPI && !entity.VirtualEntity) {
-            const spName = getSPName(entity, exports.SPType.Update);
-            if (!onlyPermissions && entity.spUpdateGenerated) {
-                // generate the update SP
-                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPUpdate(entity);
-                fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, false, true)), s);
-                sRet += s + '\nGO\n';
-            }
-            const s = generateSPPermissions(entity, spName, exports.SPType.Update) + '\n\n';
-            fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, true, true)), s);
-            // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
-            // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
-            if (!entity.spUpdateGenerated)
-                sRet += s + '\nGO\n';
+            if (entity.spUpdateGenerated)
+                // generated SP, will include permissions
+                sOutput += this.generateSPUpdate(entity) + '\n\n';
+            else
+                // custom SP, still generate the permissions
+                sOutput += this.generateSPPermissions(entity, entity.spUpdate, exports.SPType.Update) + '\n\n';
         }
-        // DELETE SP
         if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
-            const spName = getSPName(entity, exports.SPType.Delete);
-            if (!onlyPermissions && entity.spDeleteGenerated) {
-                // generate the delete SP
-                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPDelete(entity);
-                fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, false, true)), s);
-                sRet += s + '\nGO\n';
-            }
-            const s = generateSPPermissions(entity, spName, exports.SPType.Delete) + '\n\n';
-            fs.writeFileSync(path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, spName, true, true)), s);
-            // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
-            // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
-            if (!entity.spDeleteGenerated)
-                sRet += s + '\nGO\n';
+            if (entity.spDeleteGenerated)
+                // generated SP, will include permissions
+                sOutput += this.generateSPDelete(entity) + '\n\n';
+            else
+                // custom SP, still generate the permissions
+                sOutput += this.generateSPPermissions(entity, entity.spDelete, exports.SPType.Delete) + '\n\n';
         }
         // check to see if the entity supports full text search or not
         if (entity.FullTextSearchEnabled) {
-            // always generate the code so we can get the function name from the below function call
-            const ft = await generateEntityFullTextSearchSQL(ds, entity);
-            if (!onlyPermissions) {
-                // only write the actual sql out if we're not only generating permissions
-                const filePath = path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('full_text_search_function', entity.SchemaName, entity.BaseTable, false, true));
-                fs.writeFileSync(filePath, ft.sql);
-                sRet += ft.sql + '\nGO\n';
+            sOutput += await this.generateEntityFullTextSearchSQL(ds, entity) + '\n\n';
+        }
+        return sOutput;
+    }
+    async generateEntityFullTextSearchSQL(ds, entity) {
+        let sql = '';
+        const catalogName = entity.FullTextCatalog && entity.FullTextCatalog.length > 0 ? entity.FullTextCatalog : config_1.dbDatabase + '_FullTextCatalog';
+        if (entity.FullTextCatalogGenerated) {
+            // this situation means we have a generated catalog and the user has provided a name specific to THIS entity
+            sql += `                -- CREATE THE FULL TEXT CATALOG FOR THE ENTITY, IF NOT ALREADY CREATED
+                IF NOT EXISTS (
+                    SELECT * 
+                    FROM sys.fulltext_catalogs 
+                    WHERE name = '${catalogName}'
+                )
+                    CREATE FULLTEXT CATALOG ${catalogName};
+                GO
+    `;
+        }
+        if (entity.FullTextIndexGenerated) {
+            const fullTextFields = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => `${f.Name} LANGUAGE 'English'`).join(', ');
+            if (fullTextFields.length === 0)
+                throw new Error(`FullTextIndexGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
+            // drop and recreate the full text index
+            const entity_pk_name = await this.getEntityPrimaryKeyIndexName(ds, entity);
+            sql += `                -- DROP AND RECREATE THE FULL TEXT INDEX
+                IF EXISTS (
+                    SELECT * 
+                    FROM sys.fulltext_indexes 
+                    WHERE object_id = OBJECT_ID('${entity.SchemaName}.${entity.BaseTable}')
+                )
+                BEGIN
+                    DROP FULLTEXT INDEX ON [${entity.SchemaName}].[${entity.BaseTable}];
+                END
+                GO
+                
+                IF NOT EXISTS (
+                    SELECT * 
+                    FROM sys.fulltext_indexes 
+                    WHERE object_id = OBJECT_ID('${entity.SchemaName}.${entity.BaseTable}')
+                )
+                BEGIN
+                    CREATE FULLTEXT INDEX ON [${entity.SchemaName}].[${entity.BaseTable}]
+                    (
+                        ${fullTextFields}
+                    )
+                    KEY INDEX ${entity_pk_name} 
+                    ON ${catalogName};
+                END
+                GO
+    `;
+        }
+        const functionName = entity.FullTextSearchFunction && entity.FullTextSearchFunction.length > 0 ? entity.FullTextSearchFunction : `fnSearch${entity.CodeName}`;
+        if (entity.FullTextSearchFunctionGenerated) {
+            const fullTextFieldsSimple = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => '[' + f.Name + ']').join(', ');
+            if (fullTextFieldsSimple.length === 0)
+                throw new Error(`FullTextSearchFunctionGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
+            if (!entity.FullTextSearchFunction || entity.FullTextSearchFunction.length === 0) {
+                // update this in the DB
+                const md = new core_1.Metadata();
+                const u = sqlserver_dataprovider_1.UserCache.Instance.Users[0];
+                if (!u)
+                    throw new Error('Could not find the first user in the cache, cant generate the full text search function without a user');
+                const e = await md.GetEntityObject('Entities', u);
+                await e.Load(entity.ID);
+                e.FullTextSearchFunction = functionName;
+                if (!await e.Save())
+                    throw new Error(`Could not update the FullTextSearchFunction for entity ${entity.Name}`);
             }
-            const sP = generateFullTextSearchFunctionPermissions(entity, ft.functionName) + '\n\n';
-            const filePath = path_1.default.join(directory, (0, sql_1.getDBObjectFileName)('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
-            fs.writeFileSync(filePath, sP);
-            // now, append the permissions to the return string IF we did NOT generate the function - because if we generated the function, that
-            // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
-            if (!entity.FullTextSearchFunctionGenerated)
-                sRet += sP + '\nGO\n';
-        }
-        return sRet;
-    }
-    catch (err) {
-        (0, logging_1.logError)(err);
-        return null;
-    }
-}
-exports.generateSingleEntitySQLToSeparateFiles = generateSingleEntitySQLToSeparateFiles;
-function getSPName(entity, type) {
-    switch (type) {
-        case exports.SPType.Create:
-            return entity.spCreate && entity.spCreate.length > 0 ? entity.spCreate : 'spCreate' + entity.ClassName;
-        case exports.SPType.Update:
-            return entity.spUpdate && entity.spUpdate.length > 0 ? entity.spUpdate : 'spUpdate' + entity.ClassName;
-        case exports.SPType.Delete:
-            return entity.spDelete && entity.spDelete.length > 0 ? entity.spDelete : 'spDelete' + entity.ClassName;
-    }
-}
-exports.getSPName = getSPName;
-function getEntityPermissionFileNames(entity) {
-    const files = [];
-    // all entities have a base view - and we always generate permissions for the base view even if not generated base view
-    files.push((0, sql_1.getDBObjectFileName)('view', entity.SchemaName, entity.BaseView, true, true));
-    // only add the SP files if the entity is not a virtual entity
-    if (!entity.VirtualEntity) {
-        // only add each SP file if the Allow flags are set to true, doesn't matter if the SPs are generated or not, we always generate permissions
-        if (entity.AllowCreateAPI)
-            files.push((0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, getSPName(entity, exports.SPType.Create), true, true));
-        if (entity.AllowUpdateAPI)
-            files.push((0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, getSPName(entity, exports.SPType.Update), true, true));
-        if (entity.AllowDeleteAPI)
-            files.push((0, sql_1.getDBObjectFileName)('sp', entity.SchemaName, getSPName(entity, exports.SPType.Delete), true, true));
-    }
-    if (entity.FullTextSearchEnabled)
-        files.push((0, sql_1.getDBObjectFileName)('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
-    return files;
-}
-exports.getEntityPermissionFileNames = getEntityPermissionFileNames;
-async function generateEntitySQL(ds, entity) {
-    let sOutput = '';
-    if (entity.BaseViewGenerated && !entity.VirtualEntity)
-        // generated the base view (will include permissions)
-        sOutput += await generateBaseView(ds, entity) + '\n\n';
-    else
-        // still generate the permissions for the view even if a custom view
-        sOutput += generateViewPermissions(entity) + '\n\n';
-    if (entity.AllowCreateAPI && !entity.VirtualEntity) {
-        if (entity.spCreateGenerated)
-            // generated SP, will include permissions
-            sOutput += generateSPCreate(entity) + '\n\n';
-        else
-            // custom SP, still generate the permissions
-            sOutput += generateSPPermissions(entity, entity.spCreate, exports.SPType.Create) + '\n\n';
-    }
-    if (entity.AllowUpdateAPI && !entity.VirtualEntity) {
-        if (entity.spUpdateGenerated)
-            // generated SP, will include permissions
-            sOutput += generateSPUpdate(entity) + '\n\n';
-        else
-            // custom SP, still generate the permissions
-            sOutput += generateSPPermissions(entity, entity.spUpdate, exports.SPType.Update) + '\n\n';
-    }
-    if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
-        if (entity.spDeleteGenerated)
-            // generated SP, will include permissions
-            sOutput += generateSPDelete(entity) + '\n\n';
+            const pkeyList = entity.PrimaryKeys.map(pk => '[' + pk.Name + ']').join(', ');
+            // drop and recreate the full text search function
+            sql += `                -- DROP AND RECREATE THE FULL TEXT SEARCH FUNCTION
+                -- Create an inline table-valued function to perform full-text search
+                -- Drop the function if it already exists
+                IF OBJECT_ID('${entity.SchemaName}.${functionName}', 'IF') IS NOT NULL
+                    DROP FUNCTION ${entity.SchemaName}.${functionName};
+                GO
+                CREATE FUNCTION ${entity.SchemaName}.${functionName} (@searchTerm NVARCHAR(255))
+                RETURNS TABLE
+                AS
+                RETURN (
+                    SELECT ${pkeyList}
+                    FROM [${entity.SchemaName}].[${entity.BaseTable}]
+                    WHERE CONTAINS((${fullTextFieldsSimple}), @searchTerm)
+                )
+                GO
+    `;
+            sql += this.generateFullTextSearchFunctionPermissions(entity, functionName) + '\n\nGO\n';
+        }
+        return { sql, functionName };
+    }
+    async getEntityPrimaryKeyIndexName(ds, entity) {
+        const sSQL = `  SELECT 
+        i.name AS IndexName
+    FROM 
+        sys.indexes i
+    INNER JOIN 
+        sys.objects o ON i.object_id = o.object_id
+    INNER JOIN 
+        sys.key_constraints kc ON i.object_id = kc.parent_object_id AND 
+        i.index_id = kc.unique_index_id
+    WHERE 
+        o.name = '${entity.BaseTable}' AND 
+        o.schema_id = SCHEMA_ID('${entity.SchemaName}') AND 
+        kc.type = 'PK';
+        `;
+        const result = await ds.query(sSQL);
+        if (result && result.length > 0)
+            return result[0].IndexName;
         else
-            // custom SP, still generate the permissions
-            sOutput += generateSPPermissions(entity, entity.spDelete, exports.SPType.Delete) + '\n\n';
-    }
-    // check to see if the entity supports full text search or not
-    if (entity.FullTextSearchEnabled) {
-        sOutput += await generateEntityFullTextSearchSQL(ds, entity) + '\n\n';
-    }
-    return sOutput;
-}
-exports.generateEntitySQL = generateEntitySQL;
-async function generateEntityFullTextSearchSQL(ds, entity) {
-    let sql = '';
-    const catalogName = entity.FullTextCatalog && entity.FullTextCatalog.length > 0 ? entity.FullTextCatalog : config_1.dbDatabase + '_FullTextCatalog';
-    if (entity.FullTextCatalogGenerated) {
-        // this situation means we have a generated catalog and the user has provided a name specific to THIS entity
-        sql += `                -- CREATE THE FULL TEXT CATALOG FOR THE ENTITY, IF NOT ALREADY CREATED
-                IF NOT EXISTS (
-                    SELECT * 
-                    FROM sys.fulltext_catalogs 
-                    WHERE name = '${catalogName}'
-                )
-                    CREATE FULLTEXT CATALOG ${catalogName};
-                GO
+            throw new Error(`Could not find primary key index for entity ${entity.Name}`);
+    }
+    generateAllEntitiesSQLFileHeader() {
+        return `-----------------------------------------------------------------
+-- SQL Code Generation for Entities
+-- Generated: ${new Date().toLocaleString()}
+--
+-- This file contains the SQL code for the entities in the database 
+-- that are included in the API and have generated SQL elements like views and 
+-- stored procedures.
+--
+-- It is generated by the MemberJunction CodeGen tool.
+-- It is not intended to be edited by hand.
+-----------------------------------------------------------------
 `;
     }
-    if (entity.FullTextIndexGenerated) {
-        const fullTextFields = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => `${f.Name} LANGUAGE 'English'`).join(', ');
-        if (fullTextFields.length === 0)
-            throw new Error(`FullTextIndexGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
-        // drop and recreate the full text index
-        const entity_pk_name = await getEntityPrimaryKeyIndexName(ds, entity);
-        sql += `                -- DROP AND RECREATE THE FULL TEXT INDEX
-                IF EXISTS (
-                    SELECT * 
-                    FROM sys.fulltext_indexes 
-                    WHERE object_id = OBJECT_ID('${entity.SchemaName}.${entity.BaseTable}')
-                )
-                BEGIN
-                    DROP FULLTEXT INDEX ON [${entity.SchemaName}].[${entity.BaseTable}];
-                END
-                GO
-                
-                IF NOT EXISTS (
-                    SELECT * 
-                    FROM sys.fulltext_indexes 
-                    WHERE object_id = OBJECT_ID('${entity.SchemaName}.${entity.BaseTable}')
-                )
-                BEGIN
-                    CREATE FULLTEXT INDEX ON [${entity.SchemaName}].[${entity.BaseTable}]
-                    (
-                        ${fullTextFields}
-                    )
-                    KEY INDEX ${entity_pk_name} 
-                    ON ${catalogName};
-                END
-                GO
+    generateSingleEntitySQLFileHeader(entity, itemName) {
+        return `-----------------------------------------------------------------
+-- SQL Code Generation
+-- Entity: ${entity.Name}
+-- Item: ${itemName}
+-- Generated: ${new Date().toLocaleString()}
+--
+-- This was generated by the MemberJunction CodeGen tool.
+-- This file should NOT be edited by hand.
+-----------------------------------------------------------------
 `;
     }
-    const functionName = entity.FullTextSearchFunction && entity.FullTextSearchFunction.length > 0 ? entity.FullTextSearchFunction : `fnSearch${entity.CodeName}`;
-    if (entity.FullTextSearchFunctionGenerated) {
-        const fullTextFieldsSimple = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => '[' + f.Name + ']').join(', ');
-        if (fullTextFieldsSimple.length === 0)
-            throw new Error(`FullTextSearchFunctionGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
-        if (!entity.FullTextSearchFunction || entity.FullTextSearchFunction.length === 0) {
-            // update this in the DB
-            const md = new core_1.Metadata();
-            const u = sqlserver_dataprovider_1.UserCache.Instance.Users[0];
-            if (!u)
-                throw new Error('Could not find the first user in the cache, cant generate the full text search function without a user');
-            const e = await md.GetEntityObject('Entities', u);
-            await e.Load(entity.ID);
-            e.FullTextSearchFunction = functionName;
-            if (!await e.Save())
-                throw new Error(`Could not update the FullTextSearchFunction for entity ${entity.Name}`);
-        }
-        const pkeyList = entity.PrimaryKeys.map(pk => '[' + pk.Name + ']').join(', ');
-        // drop and recreate the full text search function
-        sql += `                -- DROP AND RECREATE THE FULL TEXT SEARCH FUNCTION
-                -- Create an inline table-valued function to perform full-text search
-                -- Drop the function if it already exists
-                IF OBJECT_ID('${entity.SchemaName}.${functionName}', 'IF') IS NOT NULL
-                    DROP FUNCTION ${entity.SchemaName}.${functionName};
-                GO
-                CREATE FUNCTION ${entity.SchemaName}.${functionName} (@searchTerm NVARCHAR(255))
-                RETURNS TABLE
-                AS
-                RETURN (
-                    SELECT ${pkeyList}
-                    FROM [${entity.SchemaName}].[${entity.BaseTable}]
-                    WHERE CONTAINS((${fullTextFieldsSimple}), @searchTerm)
-                )
-                GO
-`;
-        sql += generateFullTextSearchFunctionPermissions(entity, functionName) + '\n\nGO\n';
-    }
-    return { sql, functionName };
-}
-async function getEntityPrimaryKeyIndexName(ds, entity) {
-    const sSQL = `  SELECT 
-                        i.name AS IndexName
-                    FROM 
-                        sys.indexes i
-                    INNER JOIN 
-                        sys.objects o ON i.object_id = o.object_id
-                    INNER JOIN 
-                        sys.key_constraints kc ON i.object_id = kc.parent_object_id AND 
-                        i.index_id = kc.unique_index_id
-                    WHERE 
-                        o.name = '${entity.BaseTable}' AND 
-                        o.schema_id = SCHEMA_ID('${entity.SchemaName}') AND 
-                        kc.type = 'PK';
+    async generateBaseView(ds, entity) {
+        const viewName = entity.BaseView ? entity.BaseView : `vw${entity.CodeName}`;
+        const baseTableFirstChar = entity.BaseTable.charAt(0).toLowerCase();
+        const relatedFieldsString = await this.generateBaseViewRelatedFieldsString(ds, entity.Fields);
+        const relatedFieldsJoinString = this.generateBaseViewJoins(entity.Fields);
+        const permissions = this.generateViewPermissions(entity);
+        return `
+------------------------------------------------------------
+----- BASE VIEW FOR ENTITY:      ${entity.Name}
+-----               SCHEMA:      ${entity.SchemaName}
+-----               BASE TABLE:  ${entity.BaseTable}
+-----               PRIMARY KEY: ${entity.PrimaryKey.Name}
+------------------------------------------------------------
+DROP VIEW IF EXISTS [${entity.SchemaName}].[${viewName}]
+GO
+
+CREATE VIEW [${entity.SchemaName}].[${viewName}]
+AS
+SELECT 
+    ${baseTableFirstChar}.*${relatedFieldsString.length > 0 ? ',' : ''}${relatedFieldsString}
+FROM
+    [${entity.SchemaName}].[${entity.BaseTable}] AS ${baseTableFirstChar}${relatedFieldsJoinString ? '\n' + relatedFieldsJoinString : ''}
+GO${permissions}
     `;
-    const result = await ds.query(sSQL);
-    if (result && result.length > 0)
-        return result[0].IndexName;
-    else
-        throw new Error(`Could not find primary key index for entity ${entity.Name}`);
-}
-function generateAllEntitiesSQLFileHeader() {
-    return `-----------------------------------------------------------------
--- SQL Code Generation for Entities
--- Generated: ${new Date().toLocaleString()}
---
--- This file contains the SQL code for the entities in the database 
--- that are included in the API and have generated SQL elements like views and 
--- stored procedures.
---
--- It is generated by the MemberJunction CodeGen tool.
--- It is not intended to be edited by hand.
------------------------------------------------------------------
-`;
-}
-exports.generateAllEntitiesSQLFileHeader = generateAllEntitiesSQLFileHeader;
-function generateSingleEntitySQLFileHeader(entity, itemName) {
-    return `-----------------------------------------------------------------
--- SQL Code Generation
--- Entity: ${entity.Name}
--- Item: ${itemName}
--- Generated: ${new Date().toLocaleString()}
---
--- This was generated by the MemberJunction CodeGen tool.
--- This file should NOT be edited by hand.
------------------------------------------------------------------
-`;
-}
-exports.generateSingleEntitySQLFileHeader = generateSingleEntitySQLFileHeader;
-async function generateBaseView(ds, entity) {
-    const viewName = entity.BaseView ? entity.BaseView : `vw${entity.CodeName}`;
-    const baseTableFirstChar = entity.BaseTable.charAt(0).toLowerCase();
-    const relatedFieldsString = await generateBaseViewRelatedFieldsString(ds, entity.Fields);
-    const relatedFieldsJoinString = generateBaseViewJoins(entity.Fields);
-    const permissions = generateViewPermissions(entity);
-    return `
-------------------------------------------------------------
------ BASE VIEW FOR ENTITY:      ${entity.Name}
------               SCHEMA:      ${entity.SchemaName}
------               BASE TABLE:  ${entity.BaseTable}
------               PRIMARY KEY: ${entity.PrimaryKey.Name}
-------------------------------------------------------------
-DROP VIEW IF EXISTS [${entity.SchemaName}].[${viewName}]
-GO
-
-CREATE VIEW [${entity.SchemaName}].[${viewName}]
-AS
-SELECT 
-    ${baseTableFirstChar}.*${relatedFieldsString.length > 0 ? ',' : ''}${relatedFieldsString}
-FROM
-    [${entity.SchemaName}].[${entity.BaseTable}] AS ${baseTableFirstChar}${relatedFieldsJoinString ? '\n' + relatedFieldsJoinString : ''}
-GO${permissions}
-`;
-}
-function generateViewPermissions(entity) {
-    let sOutput = '';
-    for (let i = 0; i < entity.Permissions.length; i++) {
-        const ep = entity.Permissions[i];
-        sOutput += (sOutput == '' ? `GRANT SELECT ON [${entity.SchemaName}].[${entity.BaseView}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
-    }
-    return (sOutput == '' ? '' : '\n') + sOutput;
-}
-function generateBaseViewJoins(entityFields) {
-    let sOutput = '';
-    for (let i = 0; i < entityFields.length; i++) {
-        const ef = entityFields[i];
-        if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView && ef._RelatedEntityTableAlias) {
-            sOutput += sOutput == '' ? '' : '\n';
-            sOutput += `${ef.AllowsNull ? 'LEFT OUTER' : 'INNER'} JOIN\n    ${ef._RelatedEntityNameFieldIsVirtual ? '' : '[' + ef.RelatedEntitySchemaName + '].'}[${ef._RelatedEntityNameFieldIsVirtual ? ef.RelatedEntityBaseView : ef.RelatedEntityBaseTable}] AS ${ef._RelatedEntityTableAlias}\n  ON\n    [${ef.Entity.charAt(0).toLowerCase()}].[${ef.Name}] = ${ef._RelatedEntityTableAlias}.[${ef.RelatedEntityFieldName}]`;
-        }
-    }
-    return sOutput;
-}
-async function generateBaseViewRelatedFieldsString(ds, entityFields) {
-    let sOutput = '';
-    let fieldCount = 0;
-    for (let i = 0; i < entityFields.length; i++) {
-        const ef = entityFields[i];
-        if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView) {
-            const { nameField, nameFieldIsVirtual } = getIsNameFieldForSingleEntity(ef.RelatedEntity);
-            if (nameField !== '') {
-                // only add to the output, if we found a name field for the related entity.
-                ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
-                ef._RelatedEntityNameFieldIsVirtual = nameFieldIsVirtual;
-                // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
-                const candidateName = stripID(ef.Name);
-                // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating) 
-                // because if it is, we need to change it to something else
-                const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined;
-                if (bFound)
-                    ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
-                else
-                    ef._RelatedEntityNameFieldMap = candidateName;
-                // now we have a safe field name alias for the new virtual field in the _RelatedEntityNameFieldMap property, so use it...
-                sOutput += `${fieldCount == 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${nameField}] AS [${ef._RelatedEntityNameFieldMap}]`;
-                // check to see if the database already knows about the RelatedEntityNameFieldMap or not
-                if (ef.RelatedEntityNameFieldMap === null ||
-                    ef.RelatedEntityNameFieldMap === undefined ||
-                    ef.RelatedEntityNameFieldMap.trim().length === 0) {
-                    // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
-                    // first update the actul field in the metadata object so it can be used from this point forward
-                    // and it also reflects what the DB will hold
-                    ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
-                    // then update the database itself
-                    await (0, manageMetadata_1.updateEntityFieldRelatedEntityNameFieldMap)(ds, ef.ID, ef.RelatedEntityNameFieldMap);
+    }
+    generateViewPermissions(entity) {
+        let sOutput = '';
+        for (let i = 0; i < entity.Permissions.length; i++) {
+            const ep = entity.Permissions[i];
+            sOutput += (sOutput == '' ? `GRANT SELECT ON [${entity.SchemaName}].[${entity.BaseView}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
+        }
+        return (sOutput == '' ? '' : '\n') + sOutput;
+    }
+    generateBaseViewJoins(entityFields) {
+        let sOutput = '';
+        for (let i = 0; i < entityFields.length; i++) {
+            const ef = entityFields[i];
+            if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView && ef._RelatedEntityTableAlias) {
+                sOutput += sOutput == '' ? '' : '\n';
+                sOutput += `${ef.AllowsNull ? 'LEFT OUTER' : 'INNER'} JOIN\n    ${ef._RelatedEntityNameFieldIsVirtual ? '' : '[' + ef.RelatedEntitySchemaName + '].'}[${ef._RelatedEntityNameFieldIsVirtual ? ef.RelatedEntityBaseView : ef.RelatedEntityBaseTable}] AS ${ef._RelatedEntityTableAlias}\n  ON\n    [${ef.Entity.charAt(0).toLowerCase()}].[${ef.Name}] = ${ef._RelatedEntityTableAlias}.[${ef.RelatedEntityFieldName}]`;
+            }
+        }
+        return sOutput;
+    }
+    async generateBaseViewRelatedFieldsString(ds, entityFields) {
+        let sOutput = '';
+        let fieldCount = 0;
+        const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manageMetadata_1.ManageMetadataBase);
+        for (let i = 0; i < entityFields.length; i++) {
+            const ef = entityFields[i];
+            if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView) {
+                const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
+                if (nameField !== '') {
+                    // only add to the output, if we found a name field for the related entity.
+                    ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
+                    ef._RelatedEntityNameFieldIsVirtual = nameFieldIsVirtual;
+                    // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
+                    const candidateName = this.stripID(ef.Name);
+                    // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating) 
+                    // because if it is, we need to change it to something else
+                    const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined;
+                    if (bFound)
+                        ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
+                    else
+                        ef._RelatedEntityNameFieldMap = candidateName;
+                    // now we have a safe field name alias for the new virtual field in the _RelatedEntityNameFieldMap property, so use it...
+                    sOutput += `${fieldCount == 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${nameField}] AS [${ef._RelatedEntityNameFieldMap}]`;
+                    // check to see if the database already knows about the RelatedEntityNameFieldMap or not
+                    if (ef.RelatedEntityNameFieldMap === null ||
+                        ef.RelatedEntityNameFieldMap === undefined ||
+                        ef.RelatedEntityNameFieldMap.trim().length === 0) {
+                        // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
+                        // first update the actul field in the metadata object so it can be used from this point forward
+                        // and it also reflects what the DB will hold
+                        ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
+                        // then update the database itself
+                        await manageMD.updateEntityFieldRelatedEntityNameFieldMap(ds, ef.ID, ef.RelatedEntityNameFieldMap);
+                    }
+                    fieldCount++;
                 }
-                fieldCount++;
             }
         }
+        return sOutput;
+    }
+    getIsNameFieldForSingleEntity(entityName) {
+        const md = new core_1.Metadata(); // use the full metadata entity list, not the filtered version that we receive
+        const e = md.Entities.find(e => e.Name === entityName);
+        if (e) {
+            const ef = e.NameField;
+            if (e.NameField)
+                return { nameField: ef.Name, nameFieldIsVirtual: ef.IsVirtual };
+        }
+        else
+            (0, logging_1.logStatus)(`ERROR: Could not find entity with name ${entityName}`);
+        return { nameField: '', nameFieldIsVirtual: false };
     }
-    return sOutput;
-}
-function getIsNameFieldForSingleEntity(entityName) {
-    const md = new core_1.Metadata(); // use the full metadata entity list, not the filtered version that we receive
-    const e = md.Entities.find(e => e.Name === entityName);
-    if (e) {
-        const ef = e.NameField;
-        if (e.NameField)
-            return { nameField: ef.Name, nameFieldIsVirtual: ef.IsVirtual };
-    }
-    else
-        (0, logging_1.logStatus)(`ERROR: Could not find entity with name ${entityName}`);
-    return { nameField: '', nameFieldIsVirtual: false };
-}
-function stripID(name) {
-    if (name.endsWith('ID'))
-        return name.substring(0, name.length - 2);
-    else
-        return name;
-}
-exports.SPType = {
-    Create: 'Create',
-    Update: 'Update',
-    Delete: 'Delete',
-};
-function generateSPPermissions(entity, spName, type) {
-    let sOutput = '';
-    for (let i = 0; i < entity.Permissions.length; i++) {
-        const ep = entity.Permissions[i];
-        if ((type == exports.SPType.Create && ep.CanCreate) ||
-            (type == exports.SPType.Update && ep.CanUpdate) ||
-            (type == exports.SPType.Delete && ep.CanDelete))
-            sOutput += (sOutput == '' ? `GRANT EXECUTE ON [${entity.SchemaName}].[${spName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
-    }
-    return (sOutput == '' ? '' : '\n') + sOutput;
-}
-function generateFullTextSearchFunctionPermissions(entity, functionName) {
-    let sOutput = '';
-    for (let i = 0; i < entity.Permissions.length; i++) {
-        const ep = entity.Permissions[i];
-        if (ep.CanRead)
-            sOutput += (sOutput == '' ? `GRANT SELECT ON [${entity.SchemaName}].[${functionName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
-    }
-    return (sOutput == '' ? '' : '\n') + sOutput;
-}
-function generateSPCreate(entity) {
-    const spName = entity.spCreate ? entity.spCreate : `spCreate${entity.ClassName}`;
-    const autoGeneratedPrimaryKey = entity.PrimaryKey.AutoIncrement || entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier';
-    const efString = createEntityFieldsParamString(entity.Fields, !autoGeneratedPrimaryKey);
-    const permissions = generateSPPermissions(entity, spName, exports.SPType.Create);
-    let primaryKeyInsertValue = '';
-    let selectInsertedRecord = '';
-    let additionalFieldList = '';
-    let additionalValueList = '';
-    if (entity.PrimaryKey.AutoIncrement) {
-        selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.PrimaryKey.Name}] = SCOPE_IDENTITY()`;
-    }
-    else if (entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier') {
-        primaryKeyInsertValue = `DECLARE @newId UNIQUEIDENTIFIER = NEWID();\n    SET @${entity.PrimaryKey.Name} = @newId;\n`;
-        additionalFieldList = ',\n            [' + entity.PrimaryKey.CodeName + ']';
-        additionalValueList = ',\n            @newId';
-        selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.PrimaryKey.Name}] = @newId`;
-    }
-    else {
-        selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE `;
+    stripID(name) {
+        if (name.endsWith('ID'))
+            return name.substring(0, name.length - 2);
+        else
+            return name;
+    }
+    generateSPPermissions(entity, spName, type) {
+        let sOutput = '';
+        for (let i = 0; i < entity.Permissions.length; i++) {
+            const ep = entity.Permissions[i];
+            if ((type == exports.SPType.Create && ep.CanCreate) ||
+                (type == exports.SPType.Update && ep.CanUpdate) ||
+                (type == exports.SPType.Delete && ep.CanDelete))
+                sOutput += (sOutput == '' ? `GRANT EXECUTE ON [${entity.SchemaName}].[${spName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
+        }
+        return (sOutput == '' ? '' : '\n') + sOutput;
+    }
+    generateFullTextSearchFunctionPermissions(entity, functionName) {
+        let sOutput = '';
+        for (let i = 0; i < entity.Permissions.length; i++) {
+            const ep = entity.Permissions[i];
+            if (ep.CanRead)
+                sOutput += (sOutput == '' ? `GRANT SELECT ON [${entity.SchemaName}].[${functionName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
+        }
+        return (sOutput == '' ? '' : '\n') + sOutput;
+    }
+    generateSPCreate(entity) {
+        const spName = entity.spCreate ? entity.spCreate : `spCreate${entity.ClassName}`;
+        const autoGeneratedPrimaryKey = entity.PrimaryKey.AutoIncrement || entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier';
+        const efString = this.createEntityFieldsParamString(entity.Fields, !autoGeneratedPrimaryKey);
+        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Create);
+        let primaryKeyInsertValue = '';
+        let selectInsertedRecord = '';
+        let additionalFieldList = '';
+        let additionalValueList = '';
+        if (entity.PrimaryKey.AutoIncrement) {
+            selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.PrimaryKey.Name}] = SCOPE_IDENTITY()`;
+        }
+        else if (entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier') {
+            primaryKeyInsertValue = `DECLARE @newId UNIQUEIDENTIFIER = NEWID();\n    SET @${entity.PrimaryKey.Name} = @newId;\n`;
+            additionalFieldList = ',\n            [' + entity.PrimaryKey.CodeName + ']';
+            additionalValueList = ',\n            @newId';
+            selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.PrimaryKey.Name}] = @newId`;
+        }
+        else {
+            selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE `;
+            let isFirst = true;
+            for (let k of entity.PrimaryKeys) {
+                if (!isFirst)
+                    selectInsertedRecord += ' AND ';
+                selectInsertedRecord += `[${k.CodeName}] = @${k.CodeName}`;
+                isFirst = false;
+            }
+        }
+        return `
+------------------------------------------------------------
+----- CREATE PROCEDURE FOR ${entity.BaseTable}
+------------------------------------------------------------
+DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
+GO
+
+CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
+    ${efString}
+AS
+BEGIN
+    SET NOCOUNT ON;
+    ${primaryKeyInsertValue}
+    INSERT INTO 
+    [${entity.SchemaName}].[${entity.BaseTable}]
+        (
+            ${this.createEntityFieldsInsertString(entity, entity.Fields, '')}${additionalFieldList}
+        )
+    VALUES
+        (
+            ${this.createEntityFieldsInsertString(entity, entity.Fields, '@')}${additionalValueList}
+        )
+    -- return the new record from the base view, which might have some calculated fields
+    ${selectInsertedRecord}
+END
+GO${permissions}
+    `;
+    }
+    generateSPUpdate(entity) {
+        const spName = entity.spUpdate ? entity.spUpdate : `spUpdate${entity.ClassName}`;
+        const efParamString = this.createEntityFieldsParamString(entity.Fields, true);
+        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Update);
+        let selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE `;
         let isFirst = true;
         for (let k of entity.PrimaryKeys) {
             if (!isFirst)
@@ -662,226 +739,190 @@ function generateSPCreate(entity) {
             selectInsertedRecord += `[${k.CodeName}] = @${k.CodeName}`;
             isFirst = false;
         }
-    }
-    return `
-------------------------------------------------------------
------ CREATE PROCEDURE FOR ${entity.BaseTable}
-------------------------------------------------------------
-DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
-GO
-
-CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
-    ${efString}
-AS
-BEGIN
-    SET NOCOUNT ON;
-    ${primaryKeyInsertValue}
-    INSERT INTO 
-    [${entity.SchemaName}].[${entity.BaseTable}]
-        (
-            ${createEntityFieldsInsertString(entity, entity.Fields, '')}${additionalFieldList}
-        )
-    VALUES
-        (
-            ${createEntityFieldsInsertString(entity, entity.Fields, '@')}${additionalValueList}
-        )
-    -- return the new record from the base view, which might have some calculated fields
-    ${selectInsertedRecord}
-END
-GO${permissions}
-`;
-}
-function generateSPUpdate(entity) {
-    const spName = entity.spUpdate ? entity.spUpdate : `spUpdate${entity.ClassName}`;
-    const efParamString = createEntityFieldsParamString(entity.Fields, true);
-    const permissions = generateSPPermissions(entity, spName, exports.SPType.Update);
-    let selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE `;
-    let isFirst = true;
-    for (let k of entity.PrimaryKeys) {
-        if (!isFirst)
-            selectInsertedRecord += ' AND ';
-        selectInsertedRecord += `[${k.CodeName}] = @${k.CodeName}`;
-        isFirst = false;
-    }
-    return `
-------------------------------------------------------------
------ UPDATE PROCEDURE FOR ${entity.BaseTable}  
-------------------------------------------------------------
-DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
-GO
-
-CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
-    ${efParamString}
-AS
-BEGIN
-    SET NOCOUNT ON;
-    UPDATE 
-        [${entity.SchemaName}].[${entity.BaseTable}]
-    SET 
-        ${createEntityFieldsUpdateString(entity.Fields)}
-    WHERE 
-        [${entity.PrimaryKey.Name}] = @${entity.PrimaryKey.Name}
-
-    -- return the updated record so the caller can see the updated values and any calculated fields
-    ${selectInsertedRecord}
-END
-GO${permissions}
-    `;
-}
-function createEntityFieldsParamString(entityFields, isUpdate) {
-    let sOutput = '', isFirst = true;
-    for (let i = 0; i < entityFields.length; ++i) {
-        const ef = entityFields[i];
-        const autoGeneratedPrimaryKey = ef.AutoIncrement || ef.Type.toLowerCase().trim() === 'uniqueidentifier';
-        if ((ef.AllowUpdateAPI || (ef.IsPrimaryKey && isUpdate)) &&
-            !ef.IsVirtual &&
-            ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) || isUpdate) &&
-            ef.Name.toLowerCase().trim() !== 'updatedat' &&
-            ef.Name.toLowerCase().trim() !== 'createdat' &&
-            ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
-            if (!isFirst)
-                sOutput += ',\n    ';
-            else
-                isFirst = false;
-            sOutput += `@${ef.CodeName} ${ef.SQLFullType}`;
-        }
-    }
-    return sOutput;
-}
-function createEntityFieldsInsertString(entity, entityFields, prefix) {
-    const autoGeneratedPrimaryKey = entity.PrimaryKey.AutoIncrement || entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier';
-    let sOutput = '', isFirst = true;
-    for (let i = 0; i < entityFields.length; ++i) {
-        const ef = entityFields[i];
-        if ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) &&
-            ef.IsVirtual === false &&
-            ef.AllowUpdateAPI &&
-            ef.AutoIncrement === false &&
-            ef.Type.trim().toLowerCase() !== 'uniqueidentifier') {
-            if (!isFirst)
-                sOutput += ',\n            ';
-            else
-                isFirst = false;
-            if (prefix !== '' && (ef.Name.toLowerCase().trim() === 'updatedat' ||
-                ef.Name.toLowerCase().trim() === 'createdat'))
-                sOutput += `GETDATE()`;
-            else {
-                let sVal = prefix + (prefix !== '' ? ef.CodeName : ef.Name); // if we have a prefix, then we need to use the CodeName, otherwise we use the actual field name
-                if (!prefix || prefix.length === 0)
-                    sVal = '[' + sVal + ']'; // always put field names in brackets so that if reserved words are being used for field names in a table like "USER" and so on, they still work
-                sOutput += sVal;
+        return `
+------------------------------------------------------------
+----- UPDATE PROCEDURE FOR ${entity.BaseTable}  
+------------------------------------------------------------
+DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
+GO
+
+CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
+    ${efParamString}
+AS
+BEGIN
+    SET NOCOUNT ON;
+    UPDATE 
+        [${entity.SchemaName}].[${entity.BaseTable}]
+    SET 
+        ${this.createEntityFieldsUpdateString(entity.Fields)}
+    WHERE 
+        [${entity.PrimaryKey.Name}] = @${entity.PrimaryKey.Name}
+
+    -- return the updated record so the caller can see the updated values and any calculated fields
+    ${selectInsertedRecord}
+END
+GO${permissions}
+        `;
+    }
+    createEntityFieldsParamString(entityFields, isUpdate) {
+        let sOutput = '', isFirst = true;
+        for (let i = 0; i < entityFields.length; ++i) {
+            const ef = entityFields[i];
+            const autoGeneratedPrimaryKey = ef.AutoIncrement || ef.Type.toLowerCase().trim() === 'uniqueidentifier';
+            if ((ef.AllowUpdateAPI || (ef.IsPrimaryKey && isUpdate)) &&
+                !ef.IsVirtual &&
+                ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) || isUpdate) &&
+                ef.Name.toLowerCase().trim() !== 'updatedat' &&
+                ef.Name.toLowerCase().trim() !== 'createdat' &&
+                ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
+                if (!isFirst)
+                    sOutput += ',\n    ';
+                else
+                    isFirst = false;
+                sOutput += `@${ef.CodeName} ${ef.SQLFullType}`;
             }
         }
-    }
-    return sOutput;
-}
-function createEntityFieldsUpdateString(entityFields) {
-    let sOutput = '', isFirst = true;
-    for (let i = 0; i < entityFields.length; ++i) {
-        const ef = entityFields[i];
-        if (!ef.IsPrimaryKey &&
-            ef.IsVirtual === false &&
-            ef.AllowUpdateAPI &&
-            ef.AutoIncrement === false &&
-            ef.Name.toLowerCase().trim() !== 'createdat' &&
-            ef.Name.toLowerCase().trim() !== 'updatedat' &&
-            ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
-            if (!isFirst)
-                sOutput += ',\n        ';
-            else
-                isFirst = false;
-            sOutput += `[${ef.Name}] = @${ef.CodeName}`; // always put field names in brackets for field names that have spaces or use reserved words. Also, we use CodeName for the param name, which is the field name unless it has spaces
+        return sOutput;
+    }
+    createEntityFieldsInsertString(entity, entityFields, prefix) {
+        const autoGeneratedPrimaryKey = entity.PrimaryKey.AutoIncrement || entity.PrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier';
+        let sOutput = '', isFirst = true;
+        for (let i = 0; i < entityFields.length; ++i) {
+            const ef = entityFields[i];
+            if ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) &&
+                ef.IsVirtual === false &&
+                ef.AllowUpdateAPI &&
+                ef.AutoIncrement === false &&
+                ef.Type.trim().toLowerCase() !== 'uniqueidentifier') {
+                if (!isFirst)
+                    sOutput += ',\n            ';
+                else
+                    isFirst = false;
+                if (prefix !== '' && (ef.Name.toLowerCase().trim() === 'updatedat' ||
+                    ef.Name.toLowerCase().trim() === 'createdat'))
+                    sOutput += `GETDATE()`;
+                else {
+                    let sVal = prefix + (prefix !== '' ? ef.CodeName : ef.Name); // if we have a prefix, then we need to use the CodeName, otherwise we use the actual field name
+                    if (!prefix || prefix.length === 0)
+                        sVal = '[' + sVal + ']'; // always put field names in brackets so that if reserved words are being used for field names in a table like "USER" and so on, they still work
+                    sOutput += sVal;
+                }
+            }
         }
-        else if (ef.Name.trim().toLowerCase() === 'updatedat') {
-            if (!isFirst)
-                sOutput += ',\n        ';
-            else
-                isFirst = false;
-            sOutput += `[${ef.Name}] = GETDATE()`;
-        }
-    }
-    return sOutput;
-}
-function generateSPDelete(entity) {
-    const spName = entity.spDelete ? entity.spDelete : `spDelete${entity.ClassName}`;
-    const sCascadeDeletes = generateCascadeDeletes(entity);
-    const permissions = generateSPPermissions(entity, spName, exports.SPType.Delete);
-    let sVariables = '';
-    let sSelect = '';
-    for (let k of entity.PrimaryKeys) {
-        if (sVariables !== '')
-            sVariables += ', ';
-        sVariables += `@${k.CodeName} ${k.SQLFullType}`;
-        if (sSelect !== '')
-            sSelect += ', ';
-        sSelect += `@${k.CodeName} AS [${k.CodeName}]`;
-    }
-    return `
-------------------------------------------------------------
------ DELETE PROCEDURE FOR ${entity.BaseTable}
-------------------------------------------------------------
-DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
-GO
-
-CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
-    ${sVariables}
-AS  
-BEGIN
-    SET NOCOUNT ON;${sCascadeDeletes}
-
-    DELETE FROM 
-        [${entity.SchemaName}].[${entity.BaseTable}]
-    WHERE 
-        [${entity.PrimaryKey.Name}] = @${entity.PrimaryKey.CodeName}
-
-    SELECT ${sSelect} -- Return the primary key to indicate we successfully deleted the record
-END
-GO${permissions}
-`;
-}
-function generateCascadeDeletes(entity) {
-    let sOutput = '';
-    if (entity.CascadeDeletes) {
-        const md = new core_1.Metadata();
-        // we need to find all of the fields in other entities that are foreign keys to this entity
-        // and generate DELETE statements for those tables
-        for (let i = 0; i < md.Entities.length; ++i) {
-            const e = md.Entities[i];
-            for (let j = 0; j < e.Fields.length; ++j) {
-                const ef = e.Fields[j];
-                if (ef.RelatedEntityID === entity.ID && ef.IsVirtual === false) {
-                    let sql = '';
-                    if (ef.AllowsNull === false) {
-                        // we have a non-virtual field that is a foreign key to this entity
-                        // and only those that are non-null. If they allow null we want to UPDATE those rows to be null 
-                        // so we need to generate a DELETE statement for that table
-                        sql = `
-    -- Cascade delete from ${e.BaseTable}
-    DELETE FROM 
-        [${e.SchemaName}].[${e.BaseTable}] 
-    WHERE 
+        return sOutput;
+    }
+    createEntityFieldsUpdateString(entityFields) {
+        let sOutput = '', isFirst = true;
+        for (let i = 0; i < entityFields.length; ++i) {
+            const ef = entityFields[i];
+            if (!ef.IsPrimaryKey &&
+                ef.IsVirtual === false &&
+                ef.AllowUpdateAPI &&
+                ef.AutoIncrement === false &&
+                ef.Name.toLowerCase().trim() !== 'createdat' &&
+                ef.Name.toLowerCase().trim() !== 'updatedat' &&
+                ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
+                if (!isFirst)
+                    sOutput += ',\n        ';
+                else
+                    isFirst = false;
+                sOutput += `[${ef.Name}] = @${ef.CodeName}`; // always put field names in brackets for field names that have spaces or use reserved words. Also, we use CodeName for the param name, which is the field name unless it has spaces
+            }
+            else if (ef.Name.trim().toLowerCase() === 'updatedat') {
+                if (!isFirst)
+                    sOutput += ',\n        ';
+                else
+                    isFirst = false;
+                sOutput += `[${ef.Name}] = GETDATE()`;
+            }
+        }
+        return sOutput;
+    }
+    generateSPDelete(entity) {
+        const spName = entity.spDelete ? entity.spDelete : `spDelete${entity.ClassName}`;
+        const sCascadeDeletes = this.generateCascadeDeletes(entity);
+        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Delete);
+        let sVariables = '';
+        let sSelect = '';
+        for (let k of entity.PrimaryKeys) {
+            if (sVariables !== '')
+                sVariables += ', ';
+            sVariables += `@${k.CodeName} ${k.SQLFullType}`;
+            if (sSelect !== '')
+                sSelect += ', ';
+            sSelect += `@${k.CodeName} AS [${k.CodeName}]`;
+        }
+        return `
+------------------------------------------------------------
+----- DELETE PROCEDURE FOR ${entity.BaseTable}
+------------------------------------------------------------
+DROP PROCEDURE IF EXISTS [${entity.SchemaName}].[${spName}]
+GO
+
+CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
+    ${sVariables}
+AS  
+BEGIN
+    SET NOCOUNT ON;${sCascadeDeletes}
+
+    DELETE FROM 
+        [${entity.SchemaName}].[${entity.BaseTable}]
+    WHERE 
+        [${entity.PrimaryKey.Name}] = @${entity.PrimaryKey.CodeName}
+
+    SELECT ${sSelect} -- Return the primary key to indicate we successfully deleted the record
+END
+GO${permissions}
+    `;
+    }
+    generateCascadeDeletes(entity) {
+        let sOutput = '';
+        if (entity.CascadeDeletes) {
+            const md = new core_1.Metadata();
+            // we need to find all of the fields in other entities that are foreign keys to this entity
+            // and generate DELETE statements for those tables
+            for (let i = 0; i < md.Entities.length; ++i) {
+                const e = md.Entities[i];
+                for (let j = 0; j < e.Fields.length; ++j) {
+                    const ef = e.Fields[j];
+                    if (ef.RelatedEntityID === entity.ID && ef.IsVirtual === false) {
+                        let sql = '';
+                        if (ef.AllowsNull === false) {
+                            // we have a non-virtual field that is a foreign key to this entity
+                            // and only those that are non-null. If they allow null we want to UPDATE those rows to be null 
+                            // so we need to generate a DELETE statement for that table
+                            sql = `
+    -- Cascade delete from ${e.BaseTable}
+    DELETE FROM 
+        [${e.SchemaName}].[${e.BaseTable}] 
+    WHERE 
         [${ef.CodeName}] = @${entity.PrimaryKey.CodeName}`;
-                    }
-                    else {
-                        // we have a non-virtual field that is a foreign key to this entity
-                        // and this field ALLOWS nulls, which means we don't delete the rows, we just update them to be null
-                        // so they don't have an orphaned foreign key
-                        sql = `
-    -- Cascade update on ${e.BaseTable} - set FK to null before deleting rows in ${entity.BaseTable}
-    UPDATE 
-        [${e.SchemaName}].[${e.BaseTable}] 
-    SET 
-        [${ef.CodeName}] = NULL 
-    WHERE 
+                        }
+                        else {
+                            // we have a non-virtual field that is a foreign key to this entity
+                            // and this field ALLOWS nulls, which means we don't delete the rows, we just update them to be null
+                            // so they don't have an orphaned foreign key
+                            sql = `
+    -- Cascade update on ${e.BaseTable} - set FK to null before deleting rows in ${entity.BaseTable}
+    UPDATE 
+        [${e.SchemaName}].[${e.BaseTable}] 
+    SET 
+        [${ef.CodeName}] = NULL 
+    WHERE 
         [${ef.CodeName}] = @${entity.PrimaryKey.CodeName}`;
+                        }
+                        if (sOutput !== '')
+                            sOutput += '\n    ';
+                        sOutput += sql;
                     }
-                    if (sOutput !== '')
-                        sOutput += '\n    ';
-                    sOutput += sql;
                 }
             }
         }
+        return sOutput === '' ? '' : `${sOutput}\n    `;
     }
-    return sOutput === '' ? '' : `${sOutput}\n    `;
-}
+};
+exports.SQLCodeGenBase = SQLCodeGenBase;
+exports.SQLCodeGenBase = SQLCodeGenBase = __decorate([
+    (0, global_1.RegisterClass)(SQLCodeGenBase)
+], SQLCodeGenBase);
 //# sourceMappingURL=sql_codegen.js.map