@memberjunction/core-entities-server 3.4.0 → 4.1.0

package/dist/custom/QueryEntity.server.js

@@ -1,45 +1,18 @@
-"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadQueryEntityServerSubClass = exports.QueryEntityExtended = void 0;
-const core_1 = require("@memberjunction/core");
-const core_entities_1 = require("@memberjunction/core-entities");
-const global_1 = require("@memberjunction/global");
-const aiengine_1 = require("@memberjunction/aiengine");
-const ai_prompts_1 = require("@memberjunction/ai-prompts");
-const ai_core_plus_1 = require("@memberjunction/ai-core-plus");
-const util_1 = require("./util");
-const node_sql_parser_1 = require("node-sql-parser");
-const nunjucks = __importStar(require("nunjucks"));
-let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.QueryEntity {
+import { BaseEntity, LogError, Metadata } from "@memberjunction/core";
+import { QueryEntity } from "@memberjunction/core-entities";
+import { RegisterClass } from "@memberjunction/global";
+import { AIEngine } from "@memberjunction/aiengine";
+import { AIPromptRunner } from "@memberjunction/ai-prompts";
+import { AIPromptParams } from "@memberjunction/ai-core-plus";
+import { EmbedTextLocalHelper } from "./util.js";
+import { SQLParser } from "./sql-parser.js";
+let QueryEntityExtended = class QueryEntityExtended extends QueryEntity {
     constructor() {
         super(...arguments);
         this._queryEntities = [];
@@ -65,7 +38,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
      * @returns
      */
     async EmbedTextLocal(textToEmbed) {
-        return (0, util_1.EmbedTextLocalHelper)(this, textToEmbed);
+        return EmbedTextLocalHelper(this, textToEmbed);
     }
     async Save(options) {
         try {
@@ -104,7 +77,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             return true;
         }
         catch (e) {
-            (0, core_1.LogError)('Failed to save query:', e);
+            LogError('Failed to save query:', e);
             this.LatestResult?.Errors.push(e);
             return false;
         }
@@ -123,7 +96,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             return true;
         }
         catch (e) {
-            (0, core_1.LogError)('Failed to delete query:', e);
+            LogError('Failed to delete query:', e);
             this.LatestResult?.Errors.push(e);
             return false;
         }
@@ -139,11 +112,11 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             // This is a separate, fast operation that doesn't involve AI
             const updateResult = await super.Save();
             if (!updateResult) {
-                (0, core_1.LogError)('Failed to save query after AI processing completed');
+                LogError('Failed to save query after AI processing completed');
             }
         }
         catch (e) {
-            (0, core_1.LogError)('Error in async AI processing:', e);
+            LogError('Error in async AI processing:', e);
             // Set UsesTemplate to false on error and save
             // This ensures the query is still usable even if AI extraction fails
             this.UsesTemplate = false;
@@ -151,7 +124,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
                 await super.Save();
             }
             catch (saveError) {
-                (0, core_1.LogError)('Failed to save query after AI processing error:', saveError);
+                LogError('Failed to save query after AI processing error:', saveError);
             }
         }
     }
@@ -168,11 +141,11 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             // Save the updated UsesTemplate flag
             const updateResult = await super.Save();
             if (!updateResult) {
-                (0, core_1.LogError)('Failed to save query after cleanup');
+                LogError('Failed to save query after cleanup');
             }
         }
         catch (e) {
-            (0, core_1.LogError)('Error in async cleanup:', e);
+            LogError('Error in async cleanup:', e);
         }
     }
     async extractAndSyncData() {
@@ -182,9 +155,9 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
                 this.SQL.includes('{%') ||
                 this.SQL.includes('{#'));
             // Ensure AIEngine is configured
-            await aiengine_1.AIEngine.Instance.Config(false, this.ContextCurrentUser, this.ProviderToUse);
+            await AIEngine.Instance.Config(false, this.ContextCurrentUser, this.ProviderToUse);
             // Find the SQL Query Parameter Extraction prompt
-            const aiPrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'SQL Query Parameter Extraction' &&
+            const aiPrompt = AIEngine.Instance.Prompts.find(p => p.Name === 'SQL Query Parameter Extraction' &&
                 p.Category === 'MJ: System');
             if (!aiPrompt) {
                 // Prompt not configured, non-fatal, just warn and return
@@ -202,8 +175,8 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
                 entities: entityMetadata
             };
             // Execute the prompt using AIPromptRunner
-            const promptRunner = new ai_prompts_1.AIPromptRunner();
-            const params = new ai_core_plus_1.AIPromptParams();
+            const promptRunner = new AIPromptRunner();
+            const params = new AIPromptParams();
             params.prompt = aiPrompt;
             params.data = promptData;
             params.contextUser = this.ContextCurrentUser;
@@ -248,7 +221,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
         }
         catch (e) {
             // Unexpected error during extraction - log for debugging but don't fail the save
-            (0, core_1.LogError)(`Query "${this.Name}" AI extraction error:`, e);
+            LogError(`Query "${this.Name}" AI extraction error:`, e);
             this.UsesTemplate = false;
         }
     }
@@ -262,69 +235,41 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
         if (!this.SQL)
             return results;
         try {
-            // Pre-process Nunjucks templates to get valid SQL for parsing
-            const processedSQL = this.preProcessNunjucksForParsing(this.SQL);
-            // Parse the SQL using node-sql-parser
-            const parser = new node_sql_parser_1.Parser();
-            let ast;
-            try {
-                ast = parser.astify(processedSQL, { database: 'TransactSQL' });
-            }
-            catch (parseError) {
-                // If parsing fails, fall back to regex-based extraction
-                console.warn(`SQL parsing failed, falling back to regex: ${parseError.message}`);
-                return this.extractEntityMetadataFromSQLRegex();
-            }
-            // Extract table references and column references from AST
-            const tableAliasMap = new Map();
-            const referencedColumns = new Set();
-            // Process AST (handle both single statement and array of statements)
-            const statements = Array.isArray(ast) ? ast : [ast];
-            for (const statement of statements) {
-                this.extractFromAST(statement, tableAliasMap, referencedColumns);
-            }
-            // Build entity metadata with only referenced fields
-            const processedEntities = new Set();
-            for (const [alias, tableInfo] of tableAliasMap) {
-                const schemaName = tableInfo.schemaName || 'dbo';
-                const tableName = tableInfo.tableName;
-                const key = `${schemaName.toLowerCase()}.${tableName.toLowerCase()}`;
-                if (processedEntities.has(key))
-                    continue;
-                processedEntities.add(key);
-                // Find matching entity in metadata
-                const matchingEntity = md.Entities.find(e => (e.BaseView.toLowerCase() === tableName.toLowerCase() ||
-                    e.BaseTable.toLowerCase() === tableName.toLowerCase()) &&
-                    e.SchemaName.toLowerCase() === schemaName.toLowerCase());
+            // Use the shared SQLParser with Nunjucks preprocessing
+            const parseResult = SQLParser.ParseWithTemplatePreprocessing(this.SQL);
+            // Cross-reference parsed tables against entity metadata
+            for (const tableRef of parseResult.Tables) {
+                const matchingEntity = md.Entities.find(e => (e.BaseView.toLowerCase() === tableRef.TableName.toLowerCase() ||
+                    e.BaseTable.toLowerCase() === tableRef.TableName.toLowerCase()) &&
+                    e.SchemaName.toLowerCase() === tableRef.SchemaName.toLowerCase());
                 if (matchingEntity) {
-                    // Get fields from the entity's Fields property
-                    const entityFields = matchingEntity.Fields;
                     // Filter to fields that are actually referenced in the SQL
-                    // Check both the field name directly and with table alias prefix
-                    const relevantFields = entityFields
+                    const relevantFields = matchingEntity.Fields
                         .filter(f => {
                         const fieldLower = f.Name.toLowerCase();
-                        // Check if this field is referenced directly or with any alias
-                        for (const colRef of referencedColumns) {
-                            const colLower = colRef.toLowerCase();
-                            // Match: fieldName, alias.fieldName, tableName.fieldName
-                            if (colLower === fieldLower ||
-                                colLower === `${alias.toLowerCase()}.${fieldLower}` ||
-                                colLower === `${tableName.toLowerCase()}.${fieldLower}` ||
-                                colLower.endsWith(`.${fieldLower}`)) {
+                        for (const colRef of parseResult.Columns) {
+                            const colLower = colRef.ColumnName.toLowerCase();
+                            if (colLower === fieldLower)
                                 return true;
+                            // Check if column qualifier matches table alias or name
+                            if (colRef.TableQualifier) {
+                                const qualLower = colRef.TableQualifier.toLowerCase();
+                                if ((qualLower === tableRef.Alias.toLowerCase() ||
+                                    qualLower === tableRef.TableName.toLowerCase()) &&
+                                    colLower === fieldLower) {
+                                    return true;
+                                }
                             }
                         }
                         // Also include primary keys as they're always useful context
                         return f.IsPrimaryKey;
                     })
-                        .slice(0, 20) // Limit to 20 most relevant fields per entity
+                        .slice(0, 20)
                         .map(f => ({
                         name: f.Name,
                         type: f.Type,
                         isPrimaryKey: f.IsPrimaryKey
                     }));
-                    // Only include entity if we found relevant fields
                     if (relevantFields.length > 0) {
                         results.push({
                             name: matchingEntity.Name,
@@ -338,225 +283,9 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             return results;
         }
         catch (error) {
-            console.warn(`Error in extractEntityMetadataFromSQL: ${error.message}`);
-            return this.extractEntityMetadataFromSQLRegex();
-        }
-    }
-    /**
-     * Pre-processes Nunjucks templates in SQL to create valid SQL for parsing.
-     * Replaces Nunjucks syntax with placeholder values.
-     */
-    preProcessNunjucksForParsing(sql) {
-        // Create a Nunjucks environment that won't throw on undefined
-        const env = new nunjucks.Environment(null, {
-            autoescape: false,
-            throwOnUndefined: false
-        });
-        // Add placeholder filters that return safe SQL values
-        env.addFilter('sqlString', () => "'placeholder'");
-        env.addFilter('sqlNumber', () => '0');
-        env.addFilter('sqlDate', () => "'2000-01-01'");
-        env.addFilter('sqlIn', () => "('placeholder')");
-        env.addFilter('sqlIdentifier', (val) => val || 'placeholder');
-        env.addFilter('sqlNoKeywordsExpression', (val) => val || 'placeholder');
-        env.addFilter('default', (val, defaultVal) => val || defaultVal || 'placeholder');
-        env.addFilter('safe', (val) => val || 'placeholder');
-        env.addFilter('dump', (val) => JSON.stringify(val || {}));
-        try {
-            // Try to render the template with placeholder data
-            // This handles most Nunjucks constructs
-            const rendered = env.renderString(sql, {});
-            return rendered;
-        }
-        catch (e) {
-            // If rendering fails, do manual regex replacement
-            let processed = sql;
-            // Replace {{ variable | filter }} patterns
-            processed = processed.replace(/\{\{\s*[\w.]+\s*\|\s*sqlString\s*\}\}/g, "'placeholder'");
-            processed = processed.replace(/\{\{\s*[\w.]+\s*\|\s*sqlNumber\s*\}\}/g, '0');
-            processed = processed.replace(/\{\{\s*[\w.]+\s*\|\s*sqlDate\s*\}\}/g, "'2000-01-01'");
-            processed = processed.replace(/\{\{\s*[\w.]+\s*\|\s*sqlIn\s*\}\}/g, "('placeholder')");
-            processed = processed.replace(/\{\{\s*[\w.]+\s*\|\s*sqlIdentifier\s*\}\}/g, 'placeholder');
-            processed = processed.replace(/\{\{\s*[\w.]+\s*[^}]*\}\}/g, "'placeholder'");
-            // Remove {% if %}, {% endif %}, {% for %}, {% endfor %} blocks
-            // Keep the content between them
-            processed = processed.replace(/\{%\s*if\s+[^%]+%\}/g, '');
-            processed = processed.replace(/\{%\s*endif\s*%\}/g, '');
-            processed = processed.replace(/\{%\s*else\s*%\}/g, '');
-            processed = processed.replace(/\{%\s*elif\s+[^%]+%\}/g, '');
-            processed = processed.replace(/\{%\s*for\s+[^%]+%\}/g, '');
-            processed = processed.replace(/\{%\s*endfor\s*%\}/g, '');
-            processed = processed.replace(/\{%\s*set\s+[^%]+%\}/g, '');
-            processed = processed.replace(/\{#[^#]*#\}/g, ''); // Comments
-            return processed;
-        }
-    }
-    /**
-     * Recursively extracts table references and column references from SQL AST.
-     */
-    extractFromAST(node, tableAliasMap, referencedColumns) {
-        if (!node || typeof node !== 'object')
-            return;
-        // Handle CTEs (WITH clause) - process these first as they define tables used later
-        if (node.with) {
-            for (const cte of Array.isArray(node.with) ? node.with : [node.with]) {
-                // CTE structure can vary - check multiple possible locations
-                if (cte.stmt) {
-                    // stmt might be the AST directly or contain ast property
-                    const cteAst = cte.stmt.ast || cte.stmt;
-                    this.extractFromAST(cteAst, tableAliasMap, referencedColumns);
-                }
-            }
-        }
-        // Extract FROM clause tables (including JOINs)
-        if (node.from) {
-            for (const fromItem of Array.isArray(node.from) ? node.from : [node.from]) {
-                this.extractTableFromItem(fromItem, tableAliasMap, referencedColumns);
-            }
-        }
-        // Extract column references from SELECT
-        if (node.columns) {
-            for (const col of Array.isArray(node.columns) ? node.columns : [node.columns]) {
-                if (col === '*')
-                    continue;
-                if (col.expr) {
-                    this.extractColumnReferences(col.expr, referencedColumns, tableAliasMap);
-                }
-            }
-        }
-        // Extract column references from WHERE (and tables from subqueries like EXISTS, IN)
-        if (node.where) {
-            this.extractColumnReferences(node.where, referencedColumns, tableAliasMap);
-        }
-        // Extract column references from GROUP BY
-        if (node.groupby) {
-            const groupItems = node.groupby.columns || node.groupby;
-            for (const group of Array.isArray(groupItems) ? groupItems : [groupItems]) {
-                this.extractColumnReferences(group, referencedColumns, tableAliasMap);
-            }
-        }
-        // Extract column references from ORDER BY
-        if (node.orderby) {
-            for (const order of Array.isArray(node.orderby) ? node.orderby : [node.orderby]) {
-                this.extractColumnReferences(order.expr || order, referencedColumns, tableAliasMap);
-            }
-        }
-        // Handle UNION/INTERSECT/EXCEPT - the next query is in _next
-        if (node._next) {
-            this.extractFromAST(node._next, tableAliasMap, referencedColumns);
-        }
-    }
-    /**
-     * Extracts table information from a FROM clause item, handling tables and JOINs.
-     */
-    extractTableFromItem(fromItem, tableAliasMap, referencedColumns) {
-        if (!fromItem)
-            return;
-        // Direct table reference
-        if (fromItem.table) {
-            const alias = fromItem.as || fromItem.table;
-            tableAliasMap.set(alias, {
-                schemaName: fromItem.db || 'dbo',
-                tableName: fromItem.table
-            });
-        }
-        // Handle subqueries in FROM (derived tables)
-        if (fromItem.expr) {
-            // The subquery AST is inside expr.ast
-            const subqueryAst = fromItem.expr.ast || fromItem.expr;
-            this.extractFromAST(subqueryAst, tableAliasMap, referencedColumns);
-        }
-        // Note: In node-sql-parser, JOINs are represented as separate items in the from array
-        // with a 'join' property that's a string (e.g., "INNER JOIN", "LEFT JOIN")
-        // So no need to recurse into join - each table is already in the from array
-        // Extract column references from ON conditions
-        if (fromItem.on) {
-            this.extractColumnReferences(fromItem.on, referencedColumns, tableAliasMap);
-        }
-        // Some parsers use 'using' for join conditions
-        if (fromItem.using) {
-            for (const col of Array.isArray(fromItem.using) ? fromItem.using : [fromItem.using]) {
-                if (typeof col === 'string') {
-                    referencedColumns.add(col);
-                }
-                else if (col.column) {
-                    referencedColumns.add(col.column);
-                }
-            }
-        }
-    }
-    /**
-     * Extracts column references from an expression node.
-     * Also extracts tables from subqueries found in expressions (e.g., EXISTS, IN subqueries).
-     */
-    extractColumnReferences(expr, referencedColumns, tableAliasMap) {
-        if (!expr || typeof expr !== 'object')
-            return;
-        if (expr.type === 'column_ref') {
-            const colName = expr.table ? `${expr.table}.${expr.column}` : expr.column;
-            referencedColumns.add(colName);
-        }
-        // Handle subqueries in expressions (EXISTS, IN, scalar subqueries)
-        if (expr.ast && tableAliasMap) {
-            this.extractFromAST(expr.ast, tableAliasMap, referencedColumns);
-        }
-        // Recursively process nested expressions
-        if (expr.left)
-            this.extractColumnReferences(expr.left, referencedColumns, tableAliasMap);
-        if (expr.right)
-            this.extractColumnReferences(expr.right, referencedColumns, tableAliasMap);
-        if (expr.args) {
-            const args = expr.args.value || expr.args;
-            for (const arg of Array.isArray(args) ? args : [args]) {
-                this.extractColumnReferences(arg, referencedColumns, tableAliasMap);
-            }
-        }
-        if (expr.expr)
-            this.extractColumnReferences(expr.expr, referencedColumns, tableAliasMap);
-    }
-    /**
-     * Fallback regex-based extraction for when SQL parsing fails.
-     */
-    extractEntityMetadataFromSQLRegex() {
-        const md = this.ProviderToUse;
-        const results = [];
-        if (!this.SQL)
+            console.warn(`Error in extractEntityMetadataFromSQL: ${error}`);
             return results;
-        // Simple regex to find schema.table or schema.view references in SQL
-        const tablePattern = /(?:FROM|JOIN|INTO)\s+(?:\[?(\w+)\]?\.)?\[?(\w+)\]?(?:\s+(?:AS\s+)?(\w+))?/gi;
-        const matches = [...this.SQL.matchAll(tablePattern)];
-        const processedViews = new Set();
-        for (const match of matches) {
-            const schemaName = match[1] || 'dbo';
-            const viewOrTable = match[2];
-            const key = `${schemaName.toLowerCase()}.${viewOrTable.toLowerCase()}`;
-            if (processedViews.has(key))
-                continue;
-            processedViews.add(key);
-            const matchingEntity = md.Entities.find(e => (e.BaseView.toLowerCase() === viewOrTable.toLowerCase() ||
-                e.BaseTable.toLowerCase() === viewOrTable.toLowerCase()) &&
-                e.SchemaName.toLowerCase() === schemaName.toLowerCase());
-            if (matchingEntity) {
-                // Get fields from the entity's Fields property
-                const entityFields = matchingEntity.Fields;
-                // Include primary keys and fields ending in ID for fallback
-                const relevantFields = entityFields
-                    .filter(f => f.IsPrimaryKey || f.Name.endsWith('ID'))
-                    .slice(0, 15)
-                    .map(f => ({
-                    name: f.Name,
-                    type: f.Type,
-                    isPrimaryKey: f.IsPrimaryKey
-                }));
-                results.push({
-                    name: matchingEntity.Name,
-                    schemaName: matchingEntity.SchemaName,
-                    baseView: matchingEntity.BaseView,
-                    fields: relevantFields
-                });
-            }
         }
-        return results;
     }
     async syncQueryParameters(extractedParams) {
         // Use the entity's provider instead of creating new Metadata instance
@@ -679,7 +408,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)(`Query "${this.Name}" - Failed to sync parameters:`, e);
+            LogError(`Query "${this.Name}" - Failed to sync parameters:`, e);
             throw e;
         }
     }
@@ -705,7 +434,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)('Failed to remove query parameters:', e);
+            LogError('Failed to remove query parameters:', e);
             throw e; // Re-throw since we're in a transaction
         }
     }
@@ -895,7 +624,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)(`Query "${this.Name}" - Failed to sync fields:`, e);
+            LogError(`Query "${this.Name}" - Failed to sync fields:`, e);
             throw e;
         }
     }
@@ -959,7 +688,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)(`Query "${this.Name}" - Failed to sync entities:`, e);
+            LogError(`Query "${this.Name}" - Failed to sync entities:`, e);
             throw e;
         }
     }
@@ -983,7 +712,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)('Failed to remove query fields:', e);
+            LogError('Failed to remove query fields:', e);
             throw e;
         }
     }
@@ -1007,7 +736,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
             }
         }
         catch (e) {
-            (0, core_1.LogError)('Failed to remove query entities:', e);
+            LogError('Failed to remove query entities:', e);
             throw e;
         }
     }
@@ -1035,7 +764,7 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
     async RefreshRelatedMetadata(refreshFromDB) {
         const md = this.ProviderToUse;
         if (refreshFromDB) {
-            const globalMetadataProvider = core_1.Metadata.Provider;
+            const globalMetadataProvider = Metadata.Provider;
             await globalMetadataProvider.Refresh(md); // we pass in our metadata provider because that is the connection we want to use if we are in the midst of a transaction
             if (globalMetadataProvider !== md) {
                 // If the global metadata provider is different, we need to refresh it
@@ -1048,10 +777,8 @@ let QueryEntityExtended = class QueryEntityExtended extends core_entities_1.Quer
         this._queryParameters = md.QueryParameters.filter(p => p.QueryID === this.ID);
     }
 };
-exports.QueryEntityExtended = QueryEntityExtended;
-exports.QueryEntityExtended = QueryEntityExtended = __decorate([
-    (0, global_1.RegisterClass)(core_1.BaseEntity, 'Queries')
+QueryEntityExtended = __decorate([
+    RegisterClass(BaseEntity, 'Queries')
 ], QueryEntityExtended);
-function LoadQueryEntityServerSubClass() { }
-exports.LoadQueryEntityServerSubClass = LoadQueryEntityServerSubClass;
+export { QueryEntityExtended };
 //# sourceMappingURL=QueryEntity.server.js.map