@memberjunction/sqlserver-dataprovider 0.9.1

package/dist/SQLServerDataProvider.js

@@ -0,0 +1,1293 @@
+"use strict";
+/**************************************************************************************************************
+* The SQLServerDataProvider provides a data provider for the entities framework that uses SQL Server directly
+* In practice - this FILE will NOT exist in the entities library, we need to move to its own separate project
+* so it is only included by the consumer of the entities library if they want to use it.
+**************************************************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLServerDataProvider = exports.SQLServerProviderConfigData = void 0;
+const core_1 = require("@memberjunction/core");
+const SQLServerTransactionGroup_1 = require("./SQLServerTransactionGroup");
+const ai_1 = require("@memberjunction/ai");
+const queue_1 = require("@memberjunction/queue");
+const UserCache_1 = require("./UserCache");
+class SQLServerProviderConfigData extends core_1.ProviderConfigDataBase {
+    get DataSource() { return this.Data.DataSource; }
+    get CurrentUserEmail() { return this.Data.CurrentUserEmail; }
+    get CheckRefreshIntervalSeconds() { return this.Data.CheckRefreshIntervalSeconds; }
+    constructor(dataSource, currentUserEmail, MJCoreSchemaName, checkRefreshIntervalSeconds = 90 /*default to 90 seconds between checks*/, includeSchemas, excludeSchemas) {
+        super({
+            DataSource: dataSource,
+            CurrentUserEmail: currentUserEmail,
+            CheckRefreshIntervalSeconds: checkRefreshIntervalSeconds
+        }, MJCoreSchemaName, includeSchemas, excludeSchemas);
+    }
+}
+exports.SQLServerProviderConfigData = SQLServerProviderConfigData;
+// Implements both the IEntityDataProvider and IMetadataProvider interfaces.
+class SQLServerDataProvider extends core_1.ProviderBase {
+    constructor() {
+        super(...arguments);
+        this._bAllowRefresh = true;
+    }
+    get ConfigData() { return super.ConfigData; }
+    async Config(configData) {
+        try {
+            this._dataSource = configData.DataSource;
+            this._currentUserEmail = configData.CurrentUserEmail;
+            return super.Config(configData); // now parent class can do it's config
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw (e);
+        }
+    }
+    AllowRefresh() {
+        return this._bAllowRefresh;
+    }
+    /**************************************************************************/
+    // START ---- IRunReportProvider
+    /**************************************************************************/
+    async RunReport(params, contextUser) {
+        const ReportID = params.ReportID;
+        // run the sql and return the data
+        const sqlReport = "SELECT ReportSQL FROM vwReports WHERE ID = " + ReportID;
+        const reportInfo = await this.ExecuteSQL(sqlReport);
+        if (reportInfo && reportInfo.length > 0) {
+            const start = new Date().getTime();
+            const sql = reportInfo[0].ReportSQL;
+            const result = await this.ExecuteSQL(sql);
+            const end = new Date().getTime();
+            if (result)
+                return { Success: true, ReportID: ReportID, Results: result, RowCount: result.length, ExecutionTime: end - start, ErrorMessage: '' };
+            else
+                return { Success: false, ReportID: ReportID, Results: [], RowCount: 0, ExecutionTime: end - start, ErrorMessage: 'Error running report SQL' };
+        }
+        else
+            return { Success: false, ReportID: ReportID, Results: [], RowCount: 0, ExecutionTime: 0, ErrorMessage: 'Report not found' };
+    }
+    /**************************************************************************/
+    // END ---- IRunReportProvider
+    /**************************************************************************/
+    /**************************************************************************/
+    // START ---- IRunViewProvider
+    /**************************************************************************/
+    async RunView(params, contextUser) {
+        const startTime = new Date();
+        try {
+            if (params) {
+                const user = contextUser ? contextUser : this.CurrentUser;
+                if (!user)
+                    throw new Error(`User ${this._currentUserEmail} not found in metadata and no contextUser provided to RunView()`);
+                let viewEntity = null, entityInfo = null;
+                if (params.ViewEntity)
+                    viewEntity = params.ViewEntity;
+                else if (params.ViewID && params.ViewID > 0)
+                    viewEntity = await core_1.ViewInfo.GetViewEntity(params.ViewID, contextUser);
+                else if (params.ViewName && params.ViewName.length > 0)
+                    viewEntity = await core_1.ViewInfo.GetViewEntityByName(params.ViewName, contextUser);
+                if (!viewEntity) {
+                    // if we don't have viewEntity, that means it is a dynamic view, so we need EntityName at a minimum
+                    if (!params.EntityName || params.EntityName.length === 0)
+                        throw new Error(`EntityName is required when ViewID or ViewName is not provided`);
+                    entityInfo = this.Entities.find((e) => e.Name === params.EntityName);
+                    if (!entityInfo)
+                        throw new Error(`Entity ${params.EntityName} not found in metadata`);
+                }
+                else {
+                    entityInfo = this.Entities.find((e) => e.ID === viewEntity.EntityID);
+                    if (!entityInfo)
+                        throw new Error(`Entity ID: ${viewEntity.EntityID} not found in metadata`);
+                }
+                // check permissions now, this call will throw an error if the user doesn't have permission
+                this.CheckUserReadPermissions(entityInfo.Name, user);
+                // get other variaables from params
+                const extraFilter = params.ExtraFilter;
+                const userSearchString = params.UserSearchString;
+                const excludeUserViewRunID = params.ExcludeUserViewRunID;
+                const overrideExcludeFilter = params.OverrideExcludeFilter;
+                const saveViewResults = params.SaveViewResults;
+                let topSQL = '';
+                if (params.IgnoreMaxRows === true) {
+                    // do nothing, leave it blank, this structure is here to make the code easier to read
+                }
+                else if (entityInfo.UserViewMaxRows && entityInfo.UserViewMaxRows > 0) {
+                    topSQL = 'TOP ' + entityInfo.UserViewMaxRows;
+                }
+                const fields = this.getRunTimeViewFieldString(params, viewEntity);
+                let viewSQL = `SELECT ${topSQL} ${fields} FROM ${entityInfo.BaseView}`;
+                let countSQL = topSQL && topSQL.length > 0 ? `SELECT COUNT(*) AS TotalRowCount FROM ${entityInfo.BaseView}` : null;
+                let whereSQL = '';
+                let bHasWhere = false;
+                let userViewRunID = 0;
+                // The view may have a where clause that is part of the view definition. If so, we need to add it to the SQL
+                if (viewEntity?.WhereClause && viewEntity?.WhereClause.length > 0) {
+                    whereSQL = `(${viewEntity.WhereClause})`;
+                    bHasWhere = true;
+                }
+                // a developer calling the function can provide an additional Extra Filter which is any valid SQL exprssion that can be added to the WHERE clause
+                if (extraFilter && extraFilter.length > 0) {
+                    // extra filter is simple- we just AND it to the where clause if it exists, or we add it as a where clause if there was no prior WHERE
+                    if (!this.validateUserProvidedSQLClause(extraFilter))
+                        throw new Error(`Invalid Extra Filter: ${extraFilter}, contains one more for forbidden keywords`);
+                    if (bHasWhere) {
+                        whereSQL += ` AND (${extraFilter})`;
+                    }
+                    else {
+                        whereSQL = `(${extraFilter})`;
+                        bHasWhere = true;
+                    }
+                }
+                // check for a user provided search string and generate SQL as needed if provided
+                if (userSearchString && userSearchString.length > 0) {
+                    if (!this.validateUserProvidedSQLClause(userSearchString))
+                        throw new Error(`Invalid User Search SQL clause: ${userSearchString}, contains one more for forbidden keywords`);
+                    const sUserSearchSQL = this.createViewUserSearchSQL(entityInfo, userSearchString);
+                    if (sUserSearchSQL.length > 0) {
+                        if (bHasWhere) {
+                            whereSQL += ` AND (${sUserSearchSQL})`;
+                        }
+                        else {
+                            whereSQL = `(${sUserSearchSQL})`;
+                            bHasWhere = true;
+                        }
+                    }
+                }
+                // now, check for an exclude UserViewRunID, or exclusion of ALL prior runs
+                // if provided, we need to exclude the records that were part of that run (or all prior runs)
+                if ((excludeUserViewRunID && excludeUserViewRunID > 0) ||
+                    (params.ExcludeDataFromAllPriorViewRuns === true)) {
+                    let sExcludeSQL = `ID NOT IN (SELECT RecordID FROM vwUserViewRunDetails WHERE EntityID=${viewEntity.EntityID} AND`;
+                    if (params.ExcludeDataFromAllPriorViewRuns === true)
+                        sExcludeSQL += ` UserViewID=${viewEntity.ID})`; // exclude ALL prior runs for this view, we do NOT need to also add the UserViewRunID even if it was provided because this will automatically filter that out too
+                    else
+                        sExcludeSQL += `UserViewRunID=${excludeUserViewRunID})`; // exclude just the run that was provided
+                    if (overrideExcludeFilter && overrideExcludeFilter.length > 0) {
+                        if (!this.validateUserProvidedSQLClause(overrideExcludeFilter))
+                            throw new Error(`Invalid OverrideExcludeFilter: ${overrideExcludeFilter}, contains one more for forbidden keywords`);
+                        // add in the OVERRIDE filter with an OR statement, this results in those rows that match the Exclude filter to be included
+                        // even if they're in the UserViewRunID that we're excluding
+                        sExcludeSQL += ' OR (' + overrideExcludeFilter + ')';
+                    }
+                    if (bHasWhere) {
+                        whereSQL += ` AND (${sExcludeSQL})`;
+                    }
+                    else {
+                        whereSQL = `(${sExcludeSQL})`;
+                        bHasWhere = true;
+                    }
+                }
+                // NEXT, apply Row Level Security (RLS)  
+                if (!entityInfo.UserExemptFromRowLevelSecurity(user, core_1.EntityPermissionType.Read)) {
+                    // user is NOT exempt from RLS, so we need to apply it
+                    const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, core_1.EntityPermissionType.Read, '');
+                    if (rlsWhereClause && rlsWhereClause.length > 0) {
+                        if (bHasWhere) {
+                            whereSQL += ` AND (${rlsWhereClause})`;
+                        }
+                        else {
+                            whereSQL = `(${rlsWhereClause})`;
+                            bHasWhere = true;
+                        }
+                    }
+                }
+                if (bHasWhere) {
+                    viewSQL += ` WHERE ${whereSQL}`;
+                    if (countSQL)
+                        countSQL += ` WHERE ${whereSQL}`;
+                }
+                // figure out the sorting for the view
+                // first check params.OrderBy, that takes first priority
+                // if that's not provided, then we check the view definition for its SortState
+                // if that's not provided we do NOT sort
+                const orderBy = params.OrderBy ? params.OrderBy : (viewEntity ? viewEntity.OrderByClause : '');
+                // if we're saving the view results, we need to wrap the entire SQL statement
+                if (viewEntity?.ID && viewEntity?.ID > 0 && saveViewResults && user) {
+                    const { executeViewSQL, runID } = await this.executeSQLForUserViewRunLogging(viewEntity.ID, viewEntity.EntityBaseView, whereSQL, orderBy, user);
+                    viewSQL = executeViewSQL;
+                    userViewRunID = runID;
+                }
+                else if (orderBy && orderBy.length > 0) {
+                    // we only add order by if we're not doing run logging. This is becuase the run logging will 
+                    // add the order by to its SELECT query that pulls from the list of records that were returned
+                    // there is no point in ordering the rows as they are saved into an audit list anyway so no order-by above
+                    // just here for final step before we execute it.
+                    if (!this.validateUserProvidedSQLClause(orderBy))
+                        throw new Error(`Invalid Order By clause: ${orderBy}, contains one more for forbidden keywords`);
+                    viewSQL += ` ORDER BY ${orderBy}`;
+                }
+                // now we can run the viewSQL
+                const retData = await this._dataSource.query(viewSQL);
+                // finally, if we have a countSQL, we need to run that first to get the row count
+                // but only do that if the # of rows returned is equal to the max rows, otherwise we know we have all the rows
+                let rowCount = null;
+                if (countSQL && retData.length === entityInfo.UserViewMaxRows) {
+                    const countResult = await this._dataSource.query(countSQL);
+                    if (countResult && countResult.length > 0) {
+                        rowCount = countResult[0].TotalRowCount;
+                    }
+                }
+                const stopTime = new Date();
+                if (params.ForceAuditLog || (viewEntity?.ID && (extraFilter === null || extraFilter.trim().length === 0) && entityInfo.AuditViewRuns)) {
+                    // ONLY LOG TOP LEVEL VIEW EXECUTION - this would be for views with an ID, and don't have ExtraFilter as ExtraFilter
+                    // is only used in the system on a tab or just for ad hoc view execution
+                    // we do NOT want to wait for this, so no await, 
+                    this.createAuditLogRecord(user, 'Run View', 'Run View', 'Success', JSON.stringify({
+                        ViewID: viewEntity?.ID,
+                        ViewName: viewEntity?.Name,
+                        Description: params.AuditLogDescription,
+                        RowCount: retData.length,
+                        SQL: viewSQL
+                    }), entityInfo.ID, null, params.AuditLogDescription);
+                }
+                return {
+                    RowCount: retData.length,
+                    TotalRowCount: rowCount ? rowCount : retData.length,
+                    Results: retData,
+                    UserViewRunID: userViewRunID,
+                    ExecutionTime: stopTime.getTime() - startTime.getTime(),
+                    Success: true,
+                    ErrorMessage: null
+                };
+            }
+            else
+                return null;
+        }
+        catch (e) {
+            const exceptionStopTime = new Date();
+            (0, core_1.LogError)(e);
+            return {
+                RowCount: 0,
+                TotalRowCount: 0,
+                Results: [],
+                UserViewRunID: 0,
+                ExecutionTime: exceptionStopTime.getTime() - startTime.getTime(),
+                Success: false,
+                ErrorMessage: e.message
+            };
+        }
+    }
+    validateUserProvidedSQLClause(clause) {
+        // convert the clause to lower case to make the keyword search case-insensitive
+        const lowerClause = clause.toLowerCase();
+        // check for forbidden keywords and characters
+        const forbiddenPatterns = [
+            'insert',
+            'update',
+            'delete',
+            'exec',
+            'execute',
+            'drop',
+            '--',
+            '/*',
+            '*/',
+            'union',
+            'cast',
+            'xp_',
+            ';'
+        ];
+        for (const pattern of forbiddenPatterns) {
+            if (lowerClause.includes(pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getRunTimeViewFieldString(params, viewEntity) {
+        const fieldList = this.getRunTimeViewFieldArray(params, viewEntity);
+        // pass this back as a comma separated list
+        return fieldList.join(',');
+    }
+    getRunTimeViewFieldArray(params, viewEntity) {
+        const fieldList = [];
+        if (params.Fields) {
+            // fields provided, if ID isn't included, add it first
+            if (params.Fields.find((f) => f.trim().toLowerCase() === 'id') === undefined)
+                fieldList.push('ID');
+            // now add the rest of the param.Fields to fields
+            params.Fields.forEach((f) => {
+                fieldList.push(f);
+            });
+        }
+        else {
+            // fields weren't provided by the caller. So, let's do the following
+            // * if this is a defined view, using a View Name or View ID, we use the fields that are used wtihin the View and always return the ID
+            // * if this is an dynamic view, we return ALL fields in the entity using *
+            if (viewEntity) {
+                // saved view, figure out it's field list
+                viewEntity.Columns.forEach((c) => {
+                    if (!c.hidden) // only return the non-hidden fields
+                        fieldList.push(c.EntityField.Name);
+                });
+                if (fieldList.find((f) => f.trim().toLowerCase() === 'id') === undefined)
+                    fieldList.push('ID'); // this should never happen, all views should always have ID in them, but just in case we do this here to ensure it
+            }
+            else // dynamic view
+                fieldList.push('*'); // no fields provided, include everything 
+        }
+        return fieldList;
+    }
+    async executeSQLForUserViewRunLogging(viewId, entityBaseView, whereSQL, orderBySQL, user) {
+        const sSQL = `
+            DECLARE @ViewIDList TABLE ( ID INT );
+            INSERT INTO @ViewIDList (ID) (SELECT ID FROM ${entityBaseView} WHERE (${whereSQL}))
+            EXEC spCreateUserViewRunWithDetail(${viewId},${user.Email}, @ViewIDLIst)
+            `;
+        const runIDResult = await this._dataSource.query(sSQL);
+        const runID = runIDResult[0].UserViewRunID;
+        const sRetSQL = `SELECT * FROM ${entityBaseView} WHERE ID IN 
+                                    (SELECT RecordID FROM vwUserViewRunDetails WHERE UserViewRunID=${runID})
+                                 ${orderBySQL && orderBySQL.length > 0 ? ' ORDER BY ' + orderBySQL : ''}`;
+        return { executeViewSQL: sRetSQL, runID: runID };
+    }
+    createViewUserSearchSQL(entityInfo, userSearchString) {
+        // we have a user search string. 
+        // if we have full text search, we use that.
+        // Otherwise, we need to manually construct the additional filter associated with this. The user search string is just text from the user
+        // we need to apply it to one or more fields that are part of the entity that support being part of a user search.
+        // we need to get the list of fields that are part of the entity that support being part of a user search.
+        let sUserSearchSQL = '';
+        if (entityInfo.FullTextSearchEnabled) {
+            // we have full text search, so we use that, do as subquery but that gets optimized into JOIN by SQL Server, so we can keep our situation logially simpler
+            // in the context of overall filtering by doing as a SUBQUERY here.
+            // if we have a user search string that includes AND, OR, or NOT, we leave it alone
+            // otherwise, we check to see if the userSearchString is a single word, if so, we also leave it alone
+            // if the userSearchString doesn't have AND OR or NOT in it, and has multiple words, we convert the spaces to
+            // AND so that we can do a full text search on all the words
+            let u = userSearchString;
+            const uUpper = u.toUpperCase();
+            if (uUpper.includes('AND') || uUpper.includes('OR') || uUpper.includes('NOT')) {
+                // do nothing, leave it alone, this structure is here to make the code easier to read
+            }
+            else if (u.includes(' ')) {
+                // we have multiple words, so we need to convert the spaces to AND
+                u = userSearchString.replace(/ /g, ' AND ');
+            }
+            sUserSearchSQL = `ID IN (SELECT ID FROM ${entityInfo.SchemaName}.${entityInfo.FullTextSearchFunction}('${u}'))`;
+        }
+        else {
+            const entityFields = entityInfo.Fields;
+            for (const field of entityFields) {
+                if (field.IncludeInUserSearchAPI) {
+                    let sParam = '';
+                    if (sUserSearchSQL.length > 0)
+                        sUserSearchSQL += ' OR ';
+                    if (field.UserSearchParamFormatAPI && field.UserSearchParamFormatAPI.length > 0)
+                        // we have a search param format. we need to apply it to the user search string
+                        sParam = field.UserSearchParamFormatAPI.replace('{0}', userSearchString);
+                    else
+                        sParam = ` LIKE '%${userSearchString}%'`;
+                    sUserSearchSQL += `(${field.Name} ${sParam})`;
+                }
+            }
+            if (sUserSearchSQL.length > 0)
+                sUserSearchSQL = '(' + sUserSearchSQL + ')'; // wrap the entire search string in parens
+        }
+        return sUserSearchSQL;
+    }
+    async createAuditLogRecord(user, authorizationName, auditLogTypeName, status, details, entityId, recordId, auditLogDescription) {
+        try {
+            const authorization = authorizationName ? this.Authorizations.find((a) => a.Name.trim().toLowerCase() === authorizationName.trim().toLowerCase()) : null;
+            const auditLogType = auditLogTypeName ? this.AuditLogTypes.find((a) => a.Name.trim().toLowerCase() === auditLogTypeName.trim().toLowerCase()) : null;
+            if (!user)
+                throw new Error(`User is a required parameter`);
+            if (!auditLogType)
+                throw new Error(`Audit Log Type ${auditLogTypeName} not found in metadata`);
+            const auditLog = await this.GetEntityObject('Audit Logs', user); // must pass user context on back end as we're not authenticated the same way as the front end
+            auditLog.NewRecord();
+            auditLog.Set('UserID', user.ID);
+            auditLog.Set('AuditLogTypeName', auditLogType.Name);
+            auditLog.Set('Status', status);
+            auditLog.Set('EntityID', entityId);
+            auditLog.Set('RecordID', recordId);
+            if (authorization)
+                auditLog.Set('AuthorizationName', authorization.Name);
+            if (details)
+                auditLog.Set('Details', details);
+            if (auditLogDescription)
+                auditLog.Set('Description', auditLogDescription);
+            if (await auditLog.Save())
+                return auditLog;
+            else
+                throw new Error(`Error saving audit log record`);
+        }
+        catch (err) {
+            (0, core_1.LogError)(err);
+            return null;
+        }
+    }
+    CheckUserReadPermissions(entityName, contextUser) {
+        const entityInfo = this.Entities.find((e) => e.Name === entityName);
+        if (!contextUser)
+            throw new Error(`contextUser is null`);
+        // first check permissions, the logged in user must have read permissions on the entity to run the view
+        if (entityInfo) {
+            const userPermissions = entityInfo.GetUserPermisions(contextUser);
+            if (!userPermissions.CanRead)
+                throw new Error(`User ${contextUser.Email} does not have read permissions on ${entityInfo.Name}`);
+        }
+        else
+            throw new Error(`Entity not found in metadata`);
+    }
+    /**************************************************************************/
+    // END ---- IRunViewProvider
+    /**************************************************************************/
+    /**************************************************************************/
+    // START ---- IEntityDataProvider
+    /**************************************************************************/
+    get ProviderType() {
+        return core_1.EntityDataProviderType.Database;
+    }
+    async GetRecordFavoriteStatus(userId, entityName, recordId) {
+        const id = await this.GetRecordFavoriteID(userId, entityName, recordId);
+        return id !== null;
+    }
+    async GetRecordFavoriteID(userId, entityName, recordId) {
+        try {
+            const sSQL = `SELECT ID FROM vwUserFavorites WHERE UserID = ${userId} AND Entity='${entityName}' AND RecordID=${recordId}`;
+            const result = await this.ExecuteSQL(sSQL);
+            if (result && result.length > 0)
+                return result[0].ID;
+            else
+                return null;
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw (e);
+        }
+    }
+    async SetRecordFavoriteStatus(userId, entityName, recordId, isFavorite, contextUser) {
+        try {
+            const currentFavoriteId = await this.GetRecordFavoriteID(userId, entityName, recordId);
+            if ((currentFavoriteId === null && isFavorite === false) ||
+                (currentFavoriteId !== null && isFavorite === true))
+                return; // no change
+            // if we're here that means we need to invert the status, which either means creating a record or deleting a record
+            const e = this.Entities.find((e) => e.Name === entityName);
+            const ufEntity = await this.GetEntityObject('User Favorites', contextUser || this.CurrentUser);
+            if (currentFavoriteId !== null) {
+                // delete the record since we are setting isFavorite to FALSE
+                await ufEntity.Load(currentFavoriteId);
+                if (await ufEntity.Delete())
+                    return;
+                else
+                    throw new Error(`Error deleting user favorite`);
+            }
+            else {
+                // create the record since we are setting isFavorite to TRUE
+                ufEntity.NewRecord();
+                ufEntity.Set('EntityID', e.ID);
+                ufEntity.Set('RecordID', recordId);
+                ufEntity.Set('UserID', userId);
+                if (await ufEntity.Save())
+                    return;
+                else
+                    throw new Error(`Error saving user favorite`);
+            }
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw (e);
+        }
+    }
+    async GetRecordChanges(entityName, recordId) {
+        try {
+            const sSQL = `SELECT * FROM vwRecordChanges WHERE Entity='${entityName}' AND RecordID=${recordId} ORDER BY ChangedAt DESC`;
+            return this.ExecuteSQL(sSQL);
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw (e);
+        }
+    }
+    GetSaveSQL(entity, bNewRecord, spName, user) {
+        const sSimpleSQL = 'EXEC dbo.' + spName + ' ' + this.generateSPParams(entity, !bNewRecord);
+        const recordChangesEntityInfo = this.Entities.find(e => e.Name === 'Record Changes');
+        let sSQL = '';
+        if (entity.EntityInfo.TrackRecordChanges) {
+            let oldData = null;
+            if (!bNewRecord)
+                oldData = entity.GetAll(true); // get all the OLD values, only do for existing records, for new records, not relevant
+            sSQL = `
+                    DECLARE @ResultTable TABLE (
+                        ${this.getAllEntityColumnsSQL(entity.EntityInfo)}
+                    )
+
+                    INSERT INTO @ResultTable
+                    ${sSimpleSQL}
+
+                    DECLARE @ID INT
+                    SELECT @ID = ID FROM @ResultTable
+                    IF @ID IS NOT NULL AND @ID > 0
+                    BEGIN
+                        DECLARE @ResultChangesTable TABLE (
+                            ${this.getAllEntityColumnsSQL(recordChangesEntityInfo)}                            
+                        )                              
+
+                        INSERT INTO @ResultChangesTable
+                        ${this.GetLogRecordChangeSQL(entity.GetAll(false), oldData, entity.EntityInfo.Name, '@ID', entity.EntityInfo, user)}
+                    END
+
+                    SELECT * FROM @ResultTable`;
+        }
+        else {
+            // not doing track changes for this entity, keep it simple
+            sSQL = sSimpleSQL;
+        }
+        return sSQL;
+    }
+    GetEntityAIActions(entityInfo, before) {
+        return ai_1.AIEngine.EntityAIActions.filter((a) => a.EntityID === entityInfo.ID &&
+            a.TriggerEvent.toLowerCase().trim() === (before ? 'before save' : 'after save'));
+    }
+    async HandleEntityAIActions(entity, before, user) {
+        // Make sure AI Metadata is loaded here...
+        await ai_1.AIEngine.LoadAIMetadata(user);
+        const actions = this.GetEntityAIActions(entity.EntityInfo, before); // get the actions we need to do for this entity
+        if (actions && actions.length > 0) {
+            const ai = new ai_1.AIEngine();
+            for (let i = 0; i < actions.length; i++) {
+                const a = actions[i];
+                const p = {
+                    entityAIActionId: a.ID,
+                    entityRecord: entity,
+                    actionId: a.AIActionID,
+                    modelId: a.AIModelID
+                };
+                if (before) {
+                    // do it with await so we're blocking, as it needs to complete before the record save continues
+                    await ai.ExecuteEntityAIAction(p);
+                }
+                else {
+                    // just add a task and move on, we are doing 'after save' so we don't wait
+                    try {
+                        queue_1.QueueManager.AddTask('Entity AI Action', p, null, user);
+                    }
+                    catch (e) {
+                        (0, core_1.LogError)(e.message);
+                    }
+                }
+            }
+        }
+    }
+    async Save(entity, user, options) {
+        try {
+            if (entity.ID && entity.ID > 0 && !entity.EntityInfo.AllowUpdateAPI) {
+                // existing record and not allowed to update
+                throw new Error(`UPDATE not allowed for entity ${entity.EntityInfo.Name}`);
+            }
+            else if ((!entity.ID || entity.ID <= 0) && !entity.EntityInfo.AllowCreateAPI) {
+                // new record and not allowed to create
+                throw new Error(`CREATE not allowed for entity ${entity.EntityInfo.Name}`);
+            }
+            else {
+                // getting here means we are good to save, now check to see if we're dirty and need to save
+                // REMEMBER - this is the provider and the BaseEntity/subclasses handle user-level permission checking already, we just make sure API was turned on for the operation
+                if (entity.Dirty || (options && options.IgnoreDirtyState)) {
+                    const bNewRecord = (entity.ID && entity.ID > 0) ? false : true;
+                    const spName = bNewRecord ? (entity.EntityInfo.spCreate && entity.EntityInfo.spCreate.length > 0 ? entity.EntityInfo.spCreate : 'spCreate' + entity.EntityInfo.BaseTable) :
+                        (entity.EntityInfo.spUpdate && entity.EntityInfo.spUpdate.length > 0 ? entity.EntityInfo.spUpdate : 'spUpdate' + entity.EntityInfo.BaseTable);
+                    if (!options /*no options set*/ ||
+                        options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/) {
+                        // process any Entity AI actions that are set to trigger BEFORE the save, these are generally a really bad idea to do before save
+                        // but they are supported (for now)
+                        await this.HandleEntityAIActions(entity, true, user);
+                    }
+                    const sSQL = this.GetSaveSQL(entity, bNewRecord, spName, user);
+                    if (entity.TransactionGroup) {
+                        // we have a transaction group, need to play nice and be part of it
+                        return new Promise((resolve, reject) => {
+                            // we are part of a transaction group, so just add our query to the list
+                            // and when the transaction is committed, we will send all the queries at once
+                            this._bAllowRefresh = false; // stop refreshes of metadata while we're doing work
+                            entity.TransactionGroup.AddTransaction(new core_1.TransactionItem(sSQL, null, { dataSource: this._dataSource }, (results, success) => {
+                                // we get here whenever the transaction group does gets around to committing
+                                // our query.  
+                                this._bAllowRefresh = true; // allow refreshes again
+                                if (success && results) {
+                                    // process any Entity AI actions that are set to trigger AFTER the save
+                                    // these are fired off but are NOT part of the transaction group, so if they fail,
+                                    // the transaction group will still commit, but the AI action will not be executed
+                                    if (!options /*no options set*/ ||
+                                        options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/)
+                                        this.HandleEntityAIActions(entity, false, user);
+                                    resolve(results[0]);
+                                }
+                                else
+                                    // the transaction failed, nothing to update, but we need to call Reject so the 
+                                    // promise resolves with a rejection so our outer caller knows
+                                    reject(results);
+                            }));
+                        });
+                    }
+                    else {
+                        // no transaction group, just execute this immediately...
+                        this._bAllowRefresh = false; // stop refreshes of metadata while we're doing work
+                        const result = await this.ExecuteSQL(sSQL);
+                        this._bAllowRefresh = true; // allow refreshes now
+                        if (result && result.length > 0) {
+                            if (!options /*no options set*/ ||
+                                options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/)
+                                this.HandleEntityAIActions(entity, false, user); // fire off any AFTER SAVE AI actions, but don't wait for them
+                            return result[0];
+                        }
+                        else
+                            throw new Error(`SQL Error: No result row returned from SQL: ` + sSQL);
+                    }
+                }
+                else
+                    return entity; // nothing to save, just return the entity
+            }
+        }
+        catch (e) {
+            this._bAllowRefresh = true; // allow refreshes again if we get a failure here
+            (0, core_1.LogError)(e);
+            throw e; // rethrow the error
+        }
+    }
+    getAllEntityColumnsSQL(entityInfo) {
+        let sRet = '', outputCount = 0;
+        for (let i = 0; i < entityInfo.Fields.length; i++) {
+            const f = entityInfo.Fields[i];
+            if (outputCount !== 0)
+                sRet += ',\n';
+            sRet += '[' + f.Name + '] ' + f.SQLFullType + ' ' + (f.AllowsNull ? 'NULL' : 'NOT NULL');
+            outputCount++;
+        }
+        return sRet;
+    }
+    generateSPParams(entity, isUpdate) {
+        let sRet = '', bFirst = true;
+        for (let i = 0; i < entity.EntityInfo.Fields.length; i++) {
+            const f = entity.EntityInfo.Fields[i];
+            if (!f.IsVirtual && f.AllowUpdateAPI) {
+                switch (f.Name.toLowerCase()) {
+                    case 'id':
+                        break;
+                    case 'createdat':
+                    case 'updatedat':
+                        // do nothing
+                        break;
+                    default:
+                        if (f.Type.trim().toLowerCase() !== 'uniqueidentifier' &&
+                            f.AutoIncrement !== true) {
+                            // DO NOT INCLUDE UNIQUEIDENTIFIER FIELDS or Auto Increment Fields
+                            // FOR CREATE/UPDATE, THEY ARE GENERATED BY THE DB
+                            let value = entity.Get(f.Name);
+                            if (f.Type.trim().toLowerCase() === 'datetimeoffset') {
+                                value = new Date(value).toISOString();
+                            }
+                            sRet += this.generateSingleSPParam(f, value, bFirst);
+                            bFirst = false;
+                        }
+                        break;
+                }
+            }
+        }
+        if (isUpdate && bFirst === false) {
+            sRet += ', @ID = ' + entity.ID; // add ID to update SP at end, but only if other fields included
+            bFirst = false;
+        }
+        return sRet;
+    }
+    generateSingleSPParam(f, value, isFirst) {
+        let sRet = '';
+        let quotes = '';
+        let val = value;
+        switch ((0, core_1.TypeScriptTypeFromSQLType)(f.Type).toLowerCase()) {
+            case 'string':
+                quotes = "'";
+                break;
+            case 'date':
+                quotes = "'";
+                if (val !== null && val !== undefined) {
+                    if (typeof val === 'number') {
+                        // we have a timestamp - milliseconds since Unix Epoch
+                        // convert to a date
+                        val = new Date(val);
+                    }
+                    else if (typeof val === 'string') {
+                        // we have a string, attempt to convert it to a date object
+                        val = new Date(val);
+                    }
+                    val = val.toISOString(); // convert the date to ISO format for storage in the DB
+                }
+                break;
+            default:
+                break;
+        }
+        if (!isFirst)
+            sRet += ',\n                ';
+        sRet += `@${f.Name}=${this.packageSPParam(val, quotes)}`;
+        return sRet;
+    }
+    packageSPParam(paramValue, quoteString) {
+        let pVal;
+        if (typeof paramValue === 'string') {
+            if (quoteString == "'")
+                pVal = paramValue.toString().replace(/'/g, "''");
+            else if (quoteString == '"')
+                pVal = paramValue.toString().replace(/"/g, '""');
+            else
+                pVal = paramValue;
+        }
+        else
+            pVal = paramValue;
+        return (paramValue === null || paramValue === undefined) ? null : quoteString + pVal + quoteString;
+    }
+    GetLogRecordChangeSQL(newData, oldData, entityName, recordID, entityInfo, user) {
+        const fullRecordJSON = JSON.stringify(this.escapeQuotesInProperties(newData ? newData : oldData, "'")); // stringify old data if we don't have new - means we are DELETING A RECORD
+        const changes = this.DiffObjects(oldData, newData, entityInfo, "'");
+        const changesKeys = changes ? Object.keys(changes) : [];
+        if (changesKeys.length > 0 || oldData === null /*new record*/ || newData === null /*deleted record*/) {
+            const changesJSON = changes !== null ? JSON.stringify(changes) : '';
+            const sSQL = `EXEC spCreateRecordChange @EntityName='${entityName}', 
+                                                    @RecordID=${recordID}, 
+                                                    @UserID=${user.ID},
+                                                    @ChangesJSON='${changesJSON}', 
+                                                    @ChangesDescription='${oldData && newData ? this.CreateUserDescription(changes) : !oldData ? 'Record Created' : 'Record Deleted'}', 
+                                                    @FullRecordJSON='${fullRecordJSON}', 
+                                                    @Status='Complete', 
+                                                    @Comments=null`;
+            return sSQL;
+        }
+        else
+            return null;
+    }
+    async LogRecordChange(newData, oldData, entityName, recordID, entityInfo, user) {
+        const sSQL = this.GetLogRecordChangeSQL(newData, oldData, entityName, recordID.toString(), entityInfo, user);
+        if (sSQL) {
+            const result = await this.ExecuteSQL(sSQL);
+            return result;
+        }
+    }
+    CreateUserDescription(changesObject, maxValueLength = 200) {
+        let sRet = '';
+        let keys = Object.keys(changesObject);
+        for (let i = 0; i < keys.length; i++) {
+            const change = changesObject[keys[i]];
+            if (sRet.length > 0) {
+                sRet += '\n';
+            }
+            if (change.oldValue && change.newValue) // both old and new values set, show change
+                sRet += `${change.field} changed from ${this.trimString(change.oldValue, maxValueLength, '...')} to ${this.trimString(change.newValue, maxValueLength, '...')}`;
+            else if (change.newValue) // old value was blank, new value isn't
+                sRet += `${change.field} set to ${this.trimString(change.newValue, maxValueLength, '...')}`;
+            else if (change.oldValue) // new value is blank, old value wasn't
+                sRet += `${change.field} cleared from ${this.trimString(change.oldValue, maxValueLength, '...')}`;
+        }
+        return sRet.replace(/'/g, "''");
+    }
+    trimString(value, maxLength, trailingChars) {
+        if (value && typeof value === 'string' && value.length > maxLength) {
+            value = value.substring(0, maxLength) + trailingChars;
+        }
+        return value;
+    }
+    escapeQuotesInProperties(obj, quoteToEscape) {
+        const sRet = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const element = obj[key];
+                if (typeof element === 'string') {
+                    const reg = new RegExp(quoteToEscape, 'g');
+                    sRet[key] = element.replace(reg, quoteToEscape + quoteToEscape);
+                }
+                else
+                    sRet[key] = element;
+            }
+        }
+        return sRet;
+    }
+    DiffObjects(oldData, newData, entityInfo, quoteToEscape) {
+        if (!oldData || !newData)
+            return null;
+        else {
+            const changes = {};
+            for (const key in newData) {
+                const f = entityInfo.Fields.find(f => f.Name.toLowerCase() === key.toLowerCase());
+                let bDiff = false;
+                if ((oldData[key] == undefined || oldData[key] == null) &&
+                    (newData[key] == undefined || newData[key] == null))
+                    bDiff = false; // this branch of logic ensures that undefined and null are treated the same
+                else {
+                    switch (f.TSType) {
+                        case core_1.EntityFieldTSType.String:
+                            bDiff = oldData[key] !== newData[key];
+                            break;
+                        case core_1.EntityFieldTSType.Date:
+                            bDiff = (new Date(oldData[key]).getTime() !== new Date(newData[key]).getTime());
+                            break;
+                        case core_1.EntityFieldTSType.Number:
+                        case core_1.EntityFieldTSType.Boolean:
+                            bDiff = oldData[key] !== newData[key];
+                            break;
+                    }
+                }
+                if (bDiff) {
+                    // make sure we escape things properly
+                    const r = new RegExp(quoteToEscape, 'g');
+                    const o = (oldData[key] && typeof oldData[key] === 'string') ?
+                        oldData[key].replace(r, quoteToEscape + quoteToEscape) : oldData[key];
+                    const n = (newData[key] && typeof newData[key] === 'string') ?
+                        newData[key].replace(r, quoteToEscape + quoteToEscape) : newData[key];
+                    changes[key] = {
+                        field: key,
+                        oldValue: o,
+                        newValue: n
+                    };
+                }
+            }
+            return changes;
+        }
+    }
+    async Load(entity, RecordID, EntityRelationshipsToLoad = null, user) {
+        const sql = `SELECT * FROM ${entity.EntityInfo.BaseView} WHERE ID = ${RecordID}`;
+        const d = await this.ExecuteSQL(sql);
+        if (d && d.length > 0) {
+            // got the record, now process the relationships if there are any
+            const ret = d[0];
+            if (EntityRelationshipsToLoad && EntityRelationshipsToLoad.length > 0) {
+                for (let i = 0; i < EntityRelationshipsToLoad.length; i++) {
+                    const rel = EntityRelationshipsToLoad[i];
+                    const relInfo = entity.EntityInfo.RelatedEntities.find(r => r.RelatedEntity == rel);
+                    if (relInfo) {
+                        let relSql = '';
+                        if (relInfo.Type.trim().toLowerCase() === 'one to many')
+                            // one to many - simple query
+                            relSql = `SELECT * FROM ${relInfo.RelatedEntityBaseView} WHERE ${relInfo.RelatedEntityJoinField} = ${ret.ID}`;
+                        else
+                            // many to many - need to use join table
+                            relSql = `  SELECT 
+                                            _theview.* 
+                                        FROM 
+                                            ${relInfo.RelatedEntityBaseView} _theview 
+                                        INNER JOIN 
+                                            ${relInfo.JoinView} _jv ON _theview.${relInfo.RelatedEntityJoinField} = _jv.${relInfo.JoinEntityInverseJoinField} 
+                                        WHERE 
+                                            _jv.${relInfo.JoinEntityJoinField} = ${ret.ID}`;
+                        const relData = await this.ExecuteSQL(relSql);
+                        if (relData && relData.length > 0) {
+                            ret[rel] = relData;
+                        }
+                    }
+                }
+            }
+            return ret;
+        }
+        // if we get here, something didn't go right
+        return null;
+    }
+    GetDeleteSQL(entity, user) {
+        let sSQL = '';
+        const spName = entity.EntityInfo.spDelete ? entity.EntityInfo.spDelete : `spDelete${entity.EntityInfo.ClassName}`;
+        const sSimpleSQL = 'EXEC ' + spName + ' @ID=' + entity.ID;
+        const recordChangesEntityInfo = this.Entities.find(e => e.Name === 'Record Changes');
+        if (entity.EntityInfo.TrackRecordChanges) {
+            const oldData = entity.GetAll(true); // get all the OLD values
+            sSQL = `
+                    IF OBJECT_ID('tempdb..#ResultTable') IS NOT NULL
+                        DROP TABLE #ResultTable
+
+                    DECLARE @ResultTable TABLE (
+                        ID INT
+                    )
+
+                    INSERT INTO @ResultTable
+                    ${sSimpleSQL}
+
+                    DECLARE @ID INT
+                    SELECT @ID = ID FROM @ResultTable
+                    IF @ID IS NOT NULL AND @ID > 0
+                    BEGIN
+                        DECLARE @ResultChangesTable TABLE (
+                            ${this.getAllEntityColumnsSQL(recordChangesEntityInfo)}                            
+                        )                              
+
+                        INSERT INTO @ResultChangesTable
+                        ${this.GetLogRecordChangeSQL(null /*pass in null for new data for deleted records*/, oldData, entity.EntityInfo.Name, entity.ID.toString(), entity.EntityInfo, user)}
+                    END
+
+                    SELECT @ID AS ID`;
+        }
+        else {
+            // no record change tracking
+            // just delete the record
+            sSQL = sSimpleSQL;
+        }
+        return sSQL;
+    }
+    async Delete(entity, user) {
+        try {
+            if (!entity.ID || entity.ID <= 0)
+                // existing record and not allowed to update
+                throw new Error(`Delete() isn't callable for records that haven't yet been saved - ${entity.EntityInfo.Name}`);
+            if (!entity.EntityInfo.AllowDeleteAPI)
+                // not allowed to delete
+                throw new Error(`Delete() isn't callable for ${entity.EntityInfo.Name} as AllowDeleteAPI is false`);
+            // REMEMBER - this is the provider and the BaseEntity/subclasses handle user-level permission checking already, we just make sure API was turned on for the operation
+            // if we get here we can delete, so build the SQL and then handle appropriately either as part of TransGroup or directly...
+            const sSQL = this.GetDeleteSQL(entity, user);
+            if (entity.TransactionGroup) {
+                // we have a transaction group, need to play nice and be part of it
+                return new Promise((resolve, reject) => {
+                    // we are part of a transaction group, so just add our query to the list
+                    // and when the transaction is committed, we will send all the queries at once
+                    entity.TransactionGroup.AddTransaction(new core_1.TransactionItem(sSQL, null, { dataSource: this._dataSource }, (results, success) => {
+                        // we get here whenever the transaction group does gets around to committing
+                        // our query.  
+                        if (success && results)
+                            resolve(entity.ID === results[0].ID);
+                        else
+                            // the transaction failed, nothing to update, but we need to call Reject so the 
+                            // promise resolves with a rejection so our outer caller knows
+                            reject(results);
+                    }));
+                });
+            }
+            else {
+                return this._dataSource.transaction(async () => {
+                    const d = await this.ExecuteSQL(sSQL);
+                    if (d && d[0] && d[0].ID)
+                        return entity.ID === d[0].ID; // returns the ID of the deleted record if SP is successful
+                    else
+                        return false;
+                });
+            }
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            return false;
+        }
+    }
+    /**************************************************************************/
+    // END ---- IEntityDataProvider
+    /**************************************************************************/
+    /**************************************************************************/
+    // START ---- IMetadataProvider
+    /**************************************************************************/
+    async GetDatasetByName(datasetName, itemFilters) {
+        const sSQL = `SELECT 
+                        d.ID DatasetID,
+                        di.*,
+                        e.BaseView EntityBaseView
+                    FROM 
+                        vwDatasets d 
+                    INNER JOIN 
+                        vwDatasetItems di 
+                    ON
+                        d.Name = di.DatasetName
+                    INNER JOIN 
+                        vwEntities e 
+                    ON
+                        di.EntityID = e.ID
+                    WHERE 
+                        d.Name = @0`;
+        const items = await this.ExecuteSQL(sSQL, [datasetName]);
+        // now we have the dataset and the items, we need to get the update date from the items underlying entities
+        if (items && items.length > 0) {
+            // loop through each of the items and get the data from the underlying entity
+            const results = [];
+            let bSuccess = true;
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                let filterSQL = '';
+                if (itemFilters && itemFilters.length > 0) {
+                    const filter = itemFilters.find(f => f.ItemCode === item.Code);
+                    if (filter)
+                        filterSQL = (item.WhereClause ? ' AND ' : ' WHERE ') + '(' + filter.Filter + ')';
+                }
+                const itemSQL = `SELECT * FROM ${item.EntityBaseView} ${item.WhereClause ? 'WHERE ' + item.WhereClause : ''}${filterSQL}`;
+                const itemData = await this.ExecuteSQL(itemSQL);
+                results.push({
+                    EntityID: item.EntityID,
+                    EntityName: item.Entity,
+                    Code: item.Code,
+                    Results: itemData
+                });
+                if (!itemData || itemData.length === 0)
+                    bSuccess = false;
+            }
+            const status = await this.GetDatasetStatusByName(datasetName);
+            return {
+                DatasetID: items[0].DatasetID,
+                DatasetName: items[0].DatasetName,
+                Success: bSuccess,
+                Status: '',
+                LatestUpdateDate: status.LatestUpdateDate,
+                Results: results
+            };
+        }
+        else {
+            return {
+                DatasetID: 0,
+                DatasetName: '',
+                Success: false,
+                Status: 'No Dataset or Items found for DatasetName: ' + datasetName,
+                LatestUpdateDate: null,
+                Results: null,
+            };
+        }
+    }
+    async GetDatasetStatusByName(datasetName, itemFilters) {
+        const sSQL = `
+            SELECT 
+                d.ID DatasetID,
+                di.*,
+                e.BaseView EntityBaseView 
+            FROM 
+                vwDatasets d 
+            INNER JOIN 
+                vwDatasetItems di 
+            ON
+                d.Name = di.DatasetName
+            INNER JOIN
+                vwEntities e
+            ON
+                di.EntityID = e.ID
+            WHERE 
+                d.Name = @0`;
+        const items = await this.ExecuteSQL(sSQL, [datasetName]);
+        // now we have the dataset and the items, we need to get the update date from the items underlying entities
+        if (items && items.length > 0) {
+            // loop through each of the items and get the update date from the underlying entity
+            const updateDates = [];
+            let latestUpdateDate = new Date(1900, 1, 1);
+            let bSuccess = true;
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                let filterSQL = '';
+                if (itemFilters && itemFilters.length > 0) {
+                    const filter = itemFilters.find(f => f.ItemCode === item.Code);
+                    if (filter)
+                        filterSQL = ' WHERE ' + filter.Filter;
+                }
+                const itemSQL = `SELECT MAX(${item.DateFieldToCheck}) AS UpdateDate FROM ${item.EntityBaseView}${filterSQL}`;
+                const itemUpdateDate = await this.ExecuteSQL(itemSQL);
+                if (itemUpdateDate && itemUpdateDate.length > 0) {
+                    const updateDate = itemUpdateDate[0].UpdateDate;
+                    updateDates.push({
+                        EntityID: item.EntityID,
+                        EntityName: item.Entity,
+                        UpdateDate: updateDate
+                    });
+                    if (updateDate > latestUpdateDate)
+                        latestUpdateDate = updateDate;
+                }
+            }
+            // at the end of the loop we have the latest update date for the dataset, package it up with the individual entity update dates
+            return {
+                DatasetID: items[0].DatasetID,
+                DatasetName: items[0].DatasetName,
+                Success: bSuccess,
+                Status: '',
+                LatestUpdateDate: latestUpdateDate,
+                EntityUpdateDates: updateDates
+            };
+        }
+        else {
+            return {
+                DatasetID: 0,
+                DatasetName: '',
+                Success: false,
+                Status: 'No Dataset or Items found for DatasetName: ' + datasetName,
+                EntityUpdateDates: null,
+                LatestUpdateDate: null
+            };
+        }
+    }
+    async GetApplicationMetadata() {
+        const apps = await this.ExecuteSQL('SELECT * FROM vwApplications', null);
+        const appEntities = await this.ExecuteSQL('SELECT * FROM vwApplicationEntities ORDER BY ApplicationName');
+        const ret = [];
+        for (let i = 0; i < apps.length; i++) {
+            ret.push(new core_1.ApplicationInfo(this, {
+                ...apps[i],
+                ApplicationEntities: appEntities.filter(ae => ae.ApplicationName.trim().toLowerCase() === apps[i].Name.trim().toLowerCase())
+            }));
+        }
+        return ret;
+    }
+    async GetAuditLogTypeMetadata() {
+        const alts = await this.ExecuteSQL('SELECT * FROM vwAuditLogTypes', null);
+        const ret = [];
+        for (let i = 0; i < alts.length; i++) {
+            const alt = new core_1.AuditLogTypeInfo(alts[i]);
+            ret.push(alt);
+        }
+        return ret;
+    }
+    async GetUserMetadata() {
+        const users = await this.ExecuteSQL('SELECT * FROM vwUsers', null);
+        const userRoles = await this.ExecuteSQL('SELECT * FROM vwUserRoles ORDER BY UserID');
+        const ret = [];
+        for (let i = 0; i < users.length; i++) {
+            ret.push(new core_1.UserInfo(this, {
+                ...users[i],
+                UserRoles: userRoles.filter(ur => ur.UserID === users[i].ID)
+            }));
+        }
+        return ret;
+    }
+    async GetAuthorizationMetadata() {
+        const auths = await this.ExecuteSQL('SELECT * FROM vwAuthorizations', null);
+        const authRoles = await this.ExecuteSQL('SELECT * FROM vwAuthorizationRoles ORDER BY AuthorizationName');
+        const ret = [];
+        for (let i = 0; i < auths.length; i++) {
+            ret.push(new core_1.AuthorizationInfo(this, {
+                ...auths[i],
+                AuthorizationRoles: authRoles.filter(ar => ar.AuthorizationName.trim().toLowerCase() === auths[i].Name.trim().toLowerCase())
+            }));
+        }
+        return ret;
+    }
+    async GetCurrentUser() {
+        if (this.CurrentUser)
+            return this.CurrentUser;
+        else if (this._currentUserEmail && this._currentUserEmail.length > 0) {
+            // attempt to lookup current user from email since this.CurrentUser is null for some reason (unexpected)
+            if (UserCache_1.UserCache && UserCache_1.UserCache.Users)
+                return UserCache_1.UserCache.Users.find(u => u.Email.trim().toLowerCase() === this._currentUserEmail.trim().toLowerCase());
+        }
+        // if we get here we can't get the current user
+        return null;
+    }
+    async GetCurrentUserMetadata() {
+        const user = await this.ExecuteSQL(`SELECT * FROM vwUsers WHERE Email='${this._currentUserEmail}'`);
+        if (user && user.length === 1) {
+            const userRoles = await this.ExecuteSQL(`SELECT * FROM vwUserRoles WHERE UserID=${user[0].ID}`);
+            return new core_1.UserInfo(this, {
+                ...user[0],
+                UserRoles: userRoles ? userRoles : []
+            });
+        }
+        else
+            return null;
+    }
+    async GetRoleMetadata() {
+        const roles = await this.ExecuteSQL('SELECT * FROM vwRoles', null);
+        const ret = [];
+        for (let i = 0; i < roles.length; i++) {
+            const ri = new core_1.RoleInfo(roles[i]);
+            ret.push(ri);
+        }
+        return ret;
+    }
+    async GetUserRoleMetadata() {
+        const userRoles = await this.ExecuteSQL('SELECT * FROM vwUserRoles', null);
+        const ret = [];
+        for (let i = 0; i < userRoles.length; i++) {
+            const uri = new core_1.UserRoleInfo(userRoles[i]);
+            ret.push(uri);
+        }
+        return ret;
+    }
+    async GetRowLevelSecurityFilterMetadata() {
+        const filters = await this.ExecuteSQL('SELECT * FROM vwRowLevelSecurityFilters', null);
+        const ret = [];
+        for (let i = 0; i < filters.length; i++) {
+            const rlsfi = new core_1.RowLevelSecurityFilterInfo(filters[i]);
+            ret.push(rlsfi);
+        }
+        return ret;
+    }
+    async ExecuteSQL(query, parameters = null) {
+        try {
+            const data = await this._dataSource.query(query, parameters);
+            return data;
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw e; // force caller to handle
+        }
+    }
+    get LocalStorageProvider() {
+        if (!this._localStorageProvider)
+            this._localStorageProvider = new NodeLocalStorageProvider();
+        return this._localStorageProvider;
+    }
+    async GetEntityRecordNames(info) {
+        const result = [];
+        for (let i = 0; i < info.length; i++) {
+            const r = await this.GetEntityRecordName(info[i].EntityName, info[i].RecordID);
+            result.push({ EntityName: info[i].EntityName, RecordID: info[i].RecordID, RecordName: r, Success: r ? true : false, Status: r ? 'Success' : 'Error' });
+        }
+        return result;
+    }
+    async GetEntityRecordName(entityName, recordId) {
+        try {
+            const sql = this.GetEntityRecordNameSQL(entityName, recordId);
+            if (sql) {
+                const data = await this.ExecuteSQL(sql);
+                if (data && data.length === 1) {
+                    const fields = Object.keys(data[0]);
+                    return data[0][fields[0]]; // return first field
+                }
+                else {
+                    (0, core_1.LogError)(`Entity ${entityName} record ${recordId} not found, returning null`);
+                    return null;
+                }
+            }
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            return null;
+        }
+    }
+    GetEntityRecordNameSQL(entityName, recordId) {
+        const e = this.Entities.find(e => e.Name === entityName);
+        if (!e)
+            throw new Error(`Entity ${entityName} not found`);
+        else {
+            let f = e.Fields.find(f => f.IsNameField);
+            if (!f)
+                f = e.Fields.find(f => f.Name === 'Name');
+            if (!f) {
+                (0, core_1.LogError)(`Entity ${entityName} does not have an IsNameField or a field with the column name of Name, returning null, use recordId`);
+                return null;
+            }
+            else {
+                // got our field, create a SQL Query
+                return `SELECT ${f.Name} FROM ${e.BaseView} WHERE ID=${recordId}`;
+            }
+        }
+    }
+    async CreateTransactionGroup() {
+        return new SQLServerTransactionGroup_1.SQLServerTransactionGroup();
+    }
+    /**************************************************************************/
+    // END ---- IMetadataProvider
+    /**************************************************************************/
+    get Metadata() {
+        return this;
+    }
+}
+exports.SQLServerDataProvider = SQLServerDataProvider;
+// This implementation is purely in memory and doesn't bother to persist to a file. It is fine to load it once per server instance load
+class NodeLocalStorageProvider {
+    constructor() {
+        this._localStorage = {};
+    }
+    async getItem(key) {
+        return new Promise((resolve) => {
+            if (this._localStorage.hasOwnProperty(key))
+                resolve(this._localStorage[key]);
+            else
+                resolve(null);
+        });
+    }
+    async setItem(key, value) {
+        return new Promise((resolve) => {
+            this._localStorage[key] = value;
+            resolve();
+        });
+    }
+    async remove(key) {
+        return new Promise((resolve) => {
+            if (this._localStorage.hasOwnProperty(key))
+                delete this._localStorage[key];
+            resolve();
+        });
+    }
+}
+//# sourceMappingURL=SQLServerDataProvider.js.map