@memberjunction/codegen-lib 0.9.2

package/dist/sql_codegen.js

@@ -0,0 +1,753 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSingleEntitySQLFileHeader = exports.generateAllEntitiesSQLFileHeader = exports.generateEntitySQL = exports.generateSingleEntitySQLToSeparateFiles = exports.generateAndExecuteSingleEntitySQLToSeparateFiles = exports.generateAndExecuteAllEntitiesSQLToSeparateFiles = exports.applyPermissions = exports.runCustomSQLScripts = exports.manageSQLScriptsAndExecution = void 0;
+const core_1 = require("@memberjunction/core");
+const logging_1 = require("./logging");
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sql_1 = require("./sql");
+const config_1 = require("./config");
+const manageMetadata_1 = require("./manageMetadata");
+const sqlserver_dataprovider_1 = require("@memberjunction/sqlserver-dataprovider");
+//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;
+        console.log(`   Time to run custom SQL scripts: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+        // STEP 2 - generate all the SQL files and execute them
+        const step2StartTime = new Date();
+        if (!await generateAndExecuteAllEntitiesSQLToSeparateFiles(ds, entities, directory)) {
+            (0, logging_1.logError)('Error generating and executing all entities SQL to separate files');
+            return false;
+        }
+        console.log(`   Time to Generate/Execute Entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+        // 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)) {
+            (0, logging_1.logError)('Error managing entity fields');
+            return false;
+        }
+        // no console.log/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, entities, directory)) {
+            (0, logging_1.logError)('Error applying permissions');
+            return false;
+        }
+        console.log(`   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;
+        console.log(`   Time to run custom SQL scripts: ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
+        console.log('   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
+                }
+            }
+        }
+        return bSuccess;
+    }
+    catch (e) {
+        (0, logging_1.logError)(e);
+        return false;
+    }
+}
+exports.runCustomSQLScripts = runCustomSQLScripts;
+async function applyPermissions(ds, entities, directory, batchSize = 5) {
+    try {
+        let bSuccess = true;
+        const files = fs.readdirSync(directory);
+        const permissionsFiles = files.filter(file => file.includes('.permissions.'));
+        for (let i = 0; i < permissionsFiles.length; i += batchSize) {
+            const batch = permissionsFiles.slice(i, i + batchSize);
+            const promises = batch.map(async (f) => {
+                return (0, sql_1.executeSQLFile)(ds, path_1.default.join(directory, f), true);
+            });
+            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;
+    }
+    catch (err) {
+        (0, logging_1.logError)(err);
+        return false;
+    }
+}
+exports.applyPermissions = applyPermissions;
+async function generateAndExecuteAllEntitiesSQLToSeparateFiles(ds, entities, directory, 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 idField = e.Fields.find(f => f.Name.toLowerCase().trim() === 'id');
+                if (!idField) {
+                    (0, logging_1.logError)(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have an ID field defined which is required for a MemberJunction entity`);
+                    return false;
+                }
+                return generateAndExecuteSingleEntitySQLToSeparateFiles(ds, e, entities, directory);
+            });
+            const results = await Promise.all(promises);
+            if (results.includes(false)) {
+                bFail = true; // keep going, but will return false at the end
+            }
+        }
+        return !bFail;
+    }
+    catch (err) {
+        (0, logging_1.logError)(err);
+        return false;
+    }
+}
+exports.generateAndExecuteAllEntitiesSQLToSeparateFiles = generateAndExecuteAllEntitiesSQLToSeparateFiles;
+async function generateAndExecuteSingleEntitySQLToSeparateFiles(ds, entity, entities, directory) {
+    try {
+        const sSQL = await generateSingleEntitySQLToSeparateFiles(ds, entity, entities, directory); // 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, entities, directory) {
+    try {
+        if (!fs.existsSync(directory))
+            fs.mkdirSync(directory, { recursive: true }); // create the directory if it doesn't exist
+        let sRet = '';
+        // BASE VIEW  
+        if (entity.BaseViewGenerated && !entity.VirtualEntity) {
+            // generate the base view
+            const s = generateSingleEntitySQLFileHeader(entity, entity.BaseView) + await generateBaseView(ds, entity, entities);
+            fs.writeFileSync(directory + `/${entity.BaseView}.generated.sql`, s);
+            sRet += s + '\nGO\n';
+        }
+        // always generate permissions for the base view
+        const s = generateSingleEntitySQLFileHeader(entity, 'Permissions for ' + entity.BaseView) + generateViewPermissions(entity);
+        fs.writeFileSync(directory + `/${entity.BaseView}.permissions.generated.sql`, 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 = entity.spCreate && entity.spCreate.length > 0 ? entity.spCreate : 'spCreate' + entity.ClassName;
+            if (entity.spCreateGenerated) {
+                // generate the create SP
+                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPCreate(entity);
+                fs.writeFileSync(directory + `/${spName}.generated.sql`, s);
+                sRet += s + '\nGO\n';
+            }
+            const s = generateSPPermissions(entity, spName, SPType.Create) + '\n\n';
+            fs.writeFileSync(directory + `/${spName}.permissions.generated.sql`, 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 = entity.spUpdate && entity.spUpdate.length > 0 ? entity.spUpdate : 'spUpdate' + entity.ClassName;
+            if (entity.spUpdateGenerated) {
+                // generate the update SP
+                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPUpdate(entity);
+                fs.writeFileSync(directory + `/${spName}.generated.sql`, s);
+                sRet += s + '\nGO\n';
+            }
+            const s = generateSPPermissions(entity, spName, SPType.Update) + '\n\n';
+            fs.writeFileSync(directory + `/${spName}.permissions.generated.sql`, 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 = entity.spDelete && entity.spDelete.length > 0 ? entity.spDelete : 'spDelete' + entity.ClassName;
+            if (entity.spDeleteGenerated) {
+                // generate the delete SP
+                const s = generateSingleEntitySQLFileHeader(entity, spName) + generateSPDelete(entity);
+                fs.writeFileSync(directory + `/${spName}.generated.sql`, s);
+                sRet += s + '\nGO\n';
+            }
+            const s = generateSPPermissions(entity, spName, SPType.Delete) + '\n\n';
+            fs.writeFileSync(directory + `/${spName}.permissions.generated.sql`, 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) {
+            const ft = await generateEntityFullTextSearchSQL(ds, entity);
+            fs.writeFileSync(directory + `/${entity.BaseTable}.fulltext.generated.sql`, ft.sql);
+            sRet += ft.sql + '\nGO\n';
+            const sP = generateFullTextSearchFunctionPermissions(entity, ft.functionName) + '\n\n';
+            fs.writeFileSync(directory + `/${entity.BaseTable}.fulltext.permissions.generated.sql`, 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;
+async function generateEntitySQL(ds, entity, entities) {
+    let sOutput = '';
+    if (entity.BaseViewGenerated && !entity.VirtualEntity)
+        // generated the base view (will include permissions)
+        sOutput += await generateBaseView(ds, entity, entities) + '\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, 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, SPType.Update) + '\n\n';
+    }
+    if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
+        if (entity.spDeleteGenerated)
+            // generated SP, will include permissions
+            sOutput += generateSPDelete(entity) + '\n\n';
+        else
+            // custom SP, still generate the permissions
+            sOutput += generateSPPermissions(entity, entity.spDelete, 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
+`;
+    }
+    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
+`;
+    }
+    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.Set('FullTextSearchFunction', functionName);
+            if (!await e.Save())
+                throw new Error(`Could not update the FullTextSearchFunction for entity ${entity.Name}`);
+        }
+        // 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 ID
+                    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';
+    `;
+    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 Entity Generator.
+-- 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 Entity Generator.
+-- This file should NOT be edited by hand.
+-----------------------------------------------------------------
+`;
+}
+exports.generateSingleEntitySQLFileHeader = generateSingleEntitySQLFileHeader;
+async function generateBaseView(ds, entity, entities) {
+    const viewName = entity.BaseView ? entity.BaseView : `vw${entity.CodeName}`;
+    const baseTableFirstChar = entity.BaseTable.charAt(0).toLowerCase();
+    const relatedFieldsString = await generateBaseViewRelatedFieldsString(ds, entity.Fields, entities);
+    const relatedFieldsJoinString = generateBaseViewJoins(entity.Fields);
+    const permissions = generateViewPermissions(entity);
+    return `
+------------------------------------------------------------
+----- BASE VIEW FOR ENTITY:     ${entity.Name}
+-----               BASE TABLE: ${entity.BaseTable}
+------------------------------------------------------------
+IF OBJECT_ID('dbo.${viewName}', 'V') IS NOT NULL
+    DROP VIEW [dbo].[${viewName}]
+GO
+
+CREATE VIEW [dbo].[${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 [dbo].[${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, entities) {
+    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, entities);
+            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;
+                ef._RelatedEntityNameFieldMap = stripID(ef.Name);
+                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);
+                }
+                fieldCount++;
+            }
+        }
+    }
+    return sOutput;
+}
+function getIsNameFieldForSingleEntity(entityName, entities) {
+    const e = entities.find(e => e.Name === entityName);
+    if (e) {
+        const ef = e.NameField;
+        if (e.NameField)
+            return { nameField: ef.Name, nameFieldIsVirtual: ef.IsVirtual };
+    }
+    else
+        console.log(`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;
+}
+var SPType;
+(function (SPType) {
+    SPType[SPType["Create"] = 0] = "Create";
+    SPType[SPType["Update"] = 1] = "Update";
+    SPType[SPType["Delete"] = 2] = "Delete";
+})(SPType || (SPType = {}));
+function generateSPPermissions(entity, spName, type) {
+    let sOutput = '';
+    for (let i = 0; i < entity.Permissions.length; i++) {
+        const ep = entity.Permissions[i];
+        if ((type == SPType.Create && ep.CanCreate) ||
+            (type == SPType.Update && ep.CanUpdate) ||
+            (type == SPType.Delete && ep.CanDelete))
+            sOutput += (sOutput == '' ? `GRANT EXECUTE ON [${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 efString = createEntityFieldsParamString(entity.Fields, false);
+    const permissions = generateSPPermissions(entity, spName, SPType.Create);
+    return `
+------------------------------------------------------------
+----- CREATE PROCEDURE FOR ${entity.BaseTable}
+------------------------------------------------------------
+IF OBJECT_ID('dbo.${spName}', 'P') IS NOT NULL
+    DROP PROCEDURE [dbo].[${spName}]
+GO
+
+CREATE PROCEDURE [dbo].[${spName}]
+    ${efString}
+AS
+BEGIN
+    SET NOCOUNT ON;
+    INSERT INTO 
+    [${entity.SchemaName}].[${entity.BaseTable}]
+        (
+            ${createEntityFieldsInsertString(entity.Fields, '')}
+        )
+    VALUES
+        (
+            ${createEntityFieldsInsertString(entity.Fields, '@')}
+        )
+
+    -- return the new record from the base view, which might have some calculated fields
+    SELECT * FROM ${entity.BaseView} WHERE ID = SCOPE_IDENTITY()
+END
+GO${permissions}
+`;
+}
+function generateSPUpdate(entity) {
+    const spName = entity.spDelete ? entity.spDelete : `spUpdate${entity.ClassName}`;
+    const efParamString = createEntityFieldsParamString(entity.Fields, true);
+    const permissions = generateSPPermissions(entity, spName, SPType.Update);
+    return `
+------------------------------------------------------------
+----- UPDATE PROCEDURE FOR ${entity.BaseTable}  
+------------------------------------------------------------
+IF OBJECT_ID('dbo.${spName}', 'P') IS NOT NULL
+    DROP PROCEDURE [dbo].[${spName}]
+GO
+
+CREATE PROCEDURE [dbo].[${spName}]
+    ${efParamString}
+AS
+BEGIN
+    SET NOCOUNT ON;
+    UPDATE 
+        [${entity.SchemaName}].[${entity.BaseTable}]
+    SET 
+        ${createEntityFieldsUpdateString(entity.Fields)}
+    WHERE 
+        [ID] = @ID
+
+    -- return the updated record so the caller can see the updated values and any calculated fields
+    SELECT * FROM ${entity.BaseView} WHERE ID = @ID
+END
+GO${permissions}
+    `;
+}
+function createEntityFieldsParamString(entityFields, includeID) {
+    let sOutput = '', isFirst = true;
+    for (let i = 0; i < entityFields.length; ++i) {
+        const ef = entityFields[i];
+        if ((ef.AllowUpdateAPI || (ef.Name == 'ID' && includeID)) &&
+            !ef.IsVirtual &&
+            (ef.Name !== 'ID' || includeID) &&
+            ef.Name.toLowerCase().trim() !== 'updatedat' &&
+            ef.Name.toLowerCase().trim() !== 'createdat' &&
+            ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
+            if (!isFirst)
+                sOutput += ',\n    ';
+            else
+                isFirst = false;
+            sOutput += `@${ef.Name} ${ef.SQLFullType}`;
+        }
+    }
+    return sOutput;
+}
+function createEntityFieldsInsertString(entityFields, prefix) {
+    let sOutput = '', isFirst = true;
+    for (let i = 0; i < entityFields.length; ++i) {
+        const ef = entityFields[i];
+        if (ef.Name !== 'ID' &&
+            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 + ef.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 sOutput;
+}
+function createEntityFieldsUpdateString(entityFields) {
+    let sOutput = '', isFirst = true;
+    for (let i = 0; i < entityFields.length; ++i) {
+        const ef = entityFields[i];
+        if (ef.Name !== 'ID' &&
+            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.Name}`;
+        }
+        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, SPType.Delete);
+    return `
+------------------------------------------------------------
+----- DELETE PROCEDURE FOR ${entity.BaseTable}
+------------------------------------------------------------
+IF OBJECT_ID('dbo.${spName}', 'P') IS NOT NULL
+    DROP PROCEDURE [dbo].[${spName}]
+GO
+
+CREATE PROCEDURE [dbo].[${spName}]
+    @ID INT
+AS  
+BEGIN
+    SET NOCOUNT ON;${sCascadeDeletes}
+    DELETE FROM 
+        [${entity.SchemaName}].[${entity.BaseTable}]
+    WHERE 
+        [ID] = @ID
+    SELECT @ID AS ID -- Return the ID 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 
+        [${ef.Name}] = @ID`;
+                    }
+                    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.Name}] = NULL 
+    WHERE 
+        [${ef.Name}] = @ID`;
+                    }
+                    if (sOutput !== '')
+                        sOutput += '\n    ';
+                    sOutput += sql;
+                }
+            }
+        }
+    }
+    return sOutput === '' ? '' : `${sOutput}\n    `;
+}
+//# sourceMappingURL=sql_codegen.js.map