@memberjunction/server 2.73.0 → 2.74.0

package/src/index.ts

@@ -85,13 +85,14 @@ export * from './resolvers/DatasetResolver.js';
 export * from './resolvers/EntityRecordNameResolver.js';
 export * from './resolvers/MergeRecordsResolver.js';
 export * from './resolvers/ReportResolver.js';
+export * from './resolvers/QueryResolver.js';
 export * from './resolvers/SqlLoggingConfigResolver.js';
 export * from './resolvers/SyncRolesUsersResolver.js';
 export * from './resolvers/SyncDataResolver.js';
 export * from './resolvers/GetDataResolver.js';
 export * from './resolvers/GetDataContextDataResolver.js';
 export * from './resolvers/TransactionGroupResolver.js';
-
+export * from './resolvers/CreateQueryResolver.js';
 export { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 
 export * from './generated/generated.js';

package/src/resolvers/AskSkipResolver.ts

@@ -1396,6 +1396,20 @@ cycle.`);
     );
   }
 
+
+  /**
+   * Recursively builds the category path for a query
+   * @param md 
+   * @param categoryID 
+   */
+  protected buildQueryCategoryPath(md: Metadata, categoryID: string): string {
+    const cat = md.QueryCategories.find((c) => c.ID === categoryID);
+    if (!cat) return '';
+    if (!cat.ParentID) return cat.Name; // base case, no parent, just return the name
+    const parentPath = this.buildQueryCategoryPath(md, cat.ParentID); // build the path recursively
+    return parentPath ? `${parentPath}/${cat.Name}` : cat.Name; 
+  }
+
   /**
    * Packages up queries from the metadata based on their status
    * Used to provide Skip with information about available queries
@@ -1412,6 +1426,7 @@ cycle.`);
         name: q.Name,
         description: q.Description,
         category: q.Category,
+        categoryPath: this.buildQueryCategoryPath(md, q.CategoryID),
         sql: q.SQL,
         originalSQL: q.OriginalSQL,
         feedback: q.Feedback,

package/src/resolvers/CreateQueryResolver.ts

@@ -0,0 +1,257 @@
+import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { QueryEntity, QueryCategoryEntity } from '@memberjunction/core-entities';
+
+/**
+ * Query status enumeration for GraphQL
+ */
+export enum QueryStatus {
+    Pending = "Pending",
+    Approved = "Approved", 
+    Rejected = "Rejected",
+    Expired = "Expired"
+}
+
+registerEnumType(QueryStatus, {
+    name: "QueryStatus",
+    description: "Status of a query: Pending, Approved, Rejected, or Expired"
+});
+
+@InputType()
+export class CreateQueryInputType {
+    @Field(() => String)
+    Name!: string;
+
+    @Field(() => String, { nullable: true })
+    CategoryID?: string;
+
+    @Field(() => String, { nullable: true })
+    CategoryPath?: string;
+
+    @Field(() => String, { nullable: true })
+    UserQuestion?: string;
+
+    @Field(() => String, { nullable: true })
+    Description?: string;
+
+    @Field(() => String, { nullable: true })
+    SQL?: string;
+
+    @Field(() => String, { nullable: true })
+    TechnicalDescription?: string;
+
+    @Field(() => String, { nullable: true })
+    OriginalSQL?: string;
+
+    @Field(() => String, { nullable: true })
+    Feedback?: string;
+
+    @Field(() => QueryStatus, { nullable: true, defaultValue: QueryStatus.Pending })
+    Status?: QueryStatus;
+
+    @Field(() => Number, { nullable: true })
+    QualityRank?: number;
+
+    @Field(() => Number, { nullable: true })
+    ExecutionCostRank?: number;
+
+    @Field(() => Boolean, { nullable: true })
+    UsesTemplate?: boolean;
+}
+
+@ObjectType()
+export class CreateQueryResultType {
+    @Field(() => Boolean)
+    Success!: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => String, { nullable: true })
+    QueryData?: string;
+}
+
+export class CreateQueryResolver {
+    /**
+     * Creates a new query with the provided attributes. This mutation is restricted to system users only.
+     * @param input - CreateQueryInputType containing all the query attributes
+     * @param context - Application context containing user information
+     * @returns CreateQueryResultType with success status and query data
+     */
+    @RequireSystemUser()
+    @Mutation(() => CreateQueryResultType)
+    async CreateQuery(
+        @Arg('input', () => CreateQueryInputType) input: CreateQueryInputType,
+        @Ctx() context: AppContext
+    ): Promise<CreateQueryResultType> {
+        try {
+            const md = new Metadata();
+            const newQuery = await md.GetEntityObject<QueryEntity>("Queries", context.userPayload.userRecord);
+
+            // Handle CategoryPath if provided
+            let finalCategoryID = input.CategoryID;
+            if (input.CategoryPath) {
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
+            }
+
+            // Populate the query fields from input
+            newQuery.Name = input.Name;
+            
+            if (finalCategoryID != null) {
+                newQuery.CategoryID = finalCategoryID;
+            }
+            
+            if (input.UserQuestion != null) {
+                newQuery.UserQuestion = input.UserQuestion;
+            }
+            
+            if (input.Description != null) {
+                newQuery.Description = input.Description;
+            }
+            
+            if (input.SQL != null) {
+                newQuery.SQL = input.SQL;
+            }
+            
+            if (input.TechnicalDescription != null) {
+                newQuery.TechnicalDescription = input.TechnicalDescription;
+            }
+            
+            if (input.OriginalSQL != null) {
+                newQuery.OriginalSQL = input.OriginalSQL;
+            }
+            
+            if (input.Feedback != null) {
+                newQuery.Feedback = input.Feedback;
+            }
+            
+            if (input.Status != null) {
+                newQuery.Status = input.Status;
+            }
+            
+            if (input.QualityRank != null) {
+                newQuery.QualityRank = input.QualityRank;
+            }
+            
+            if (input.ExecutionCostRank != null) {
+                newQuery.ExecutionCostRank = input.ExecutionCostRank;
+            }
+            
+            if (input.UsesTemplate != null) {
+                newQuery.UsesTemplate = input.UsesTemplate;
+            }
+
+            // Save the query
+            const saveResult = await newQuery.Save();
+            
+            if (saveResult) {
+                return {
+                    Success: true,
+                    QueryData: JSON.stringify(newQuery.GetAll())
+                };
+            } else {
+                return {
+                    Success: false,
+                    ErrorMessage: `Failed to save query: ${newQuery.LatestResult?.Message || 'Unknown error'}`
+                };
+            }
+
+        } catch (err) {
+            LogError(err);
+            return {
+                Success: false,
+                ErrorMessage: `CreateQueryResolver::CreateQuery --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+            };
+        }
+    }
+
+    /**
+     * Finds or creates a category hierarchy based on the provided path.
+     * Path format: "Parent/Child/Grandchild" - case insensitive lookup and creation.
+     * @param categoryPath - Slash-separated category path
+     * @param md - Metadata instance
+     * @param contextUser - User context for operations
+     * @returns The ID of the final category in the path
+     */
+    private async findOrCreateCategoryPath(categoryPath: string, md: Metadata, contextUser: UserInfo): Promise<string> {
+        if (!categoryPath || categoryPath.trim() === '') {
+            throw new Error('CategoryPath cannot be empty');
+        }
+
+        const pathParts = categoryPath.split('/').map(part => part.trim()).filter(part => part.length > 0);
+        if (pathParts.length === 0) {
+            throw new Error('CategoryPath must contain at least one valid category name');
+        }
+
+        let currentParentID: string | null = null;
+        let currentCategoryID: string | null = null;
+
+        for (let i = 0; i < pathParts.length; i++) {
+            const categoryName = pathParts[i];
+            
+            // Look for existing category at this level
+            const existingCategory = await this.findCategoryByNameAndParent(categoryName, currentParentID, contextUser);
+            
+            if (existingCategory) {
+                currentCategoryID = existingCategory.ID;
+                currentParentID = existingCategory.ID;
+            } else {
+                // Create new category
+                const newCategory = await md.GetEntityObject<QueryCategoryEntity>("Query Categories", contextUser);
+                newCategory.Name = categoryName;
+                newCategory.ParentID = currentParentID;
+                newCategory.UserID = contextUser.ID;
+                newCategory.Description = `Auto-created category from path: ${categoryPath}`;
+
+                const saveResult = await newCategory.Save();
+                if (!saveResult) {
+                    throw new Error(`Failed to create category '${categoryName}': ${newCategory.LatestResult?.Message || 'Unknown error'}`);
+                }
+
+                currentCategoryID = newCategory.ID;
+                currentParentID = newCategory.ID;
+
+                // Refresh metadata after each category creation to ensure it's available for subsequent lookups
+                await md.Refresh();
+            }
+        }
+
+        if (!currentCategoryID) {
+            throw new Error('Failed to determine final category ID');
+        }
+
+        return currentCategoryID;
+    }
+
+    /**
+     * Finds a category by name and parent ID using case-insensitive comparison via RunView.
+     * @param categoryName - Name of the category to find
+     * @param parentID - Parent category ID (null for root level)
+     * @param contextUser - User context for database operations
+     * @returns The matching category entity or null if not found
+     */
+    private async findCategoryByNameAndParent(categoryName: string, parentID: string | null, contextUser: UserInfo): Promise<QueryCategoryEntity | null> {
+        try {
+            const rv = new RunView();
+            const parentFilter = parentID ? `ParentID='${parentID}'` : 'ParentID IS NULL';
+            const nameFilter = `LOWER(Name) = LOWER('${categoryName.replace(/'/g, "''")}')`; // Escape single quotes
+            
+            const result = await rv.RunView<QueryCategoryEntity>({
+                EntityName: 'Query Categories',
+                ExtraFilter: `${nameFilter} AND ${parentFilter}`,
+                ResultType: 'entity_object'
+            }, contextUser);
+
+            if (result.Success && result.Results && result.Results.length > 0) {
+                return result.Results[0];
+            }
+            
+            return null;
+        } catch (error) {
+            LogError(error);
+            return null;
+        }
+    }
+}

package/src/resolvers/QueryResolver.ts

@@ -1,8 +1,10 @@
-// Queries are MemberJunction primitive operations that are used to retrieve data from the server from any stored query
-import { RunQuery } from '@memberjunction/core';
-import { Arg, Ctx, Field, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int } from 'type-graphql';
+import { RunQuery, QueryInfo } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { GraphQLJSONObject } from 'graphql-type-json';
+import { QueryEntity } from '@memberjunction/core-entities';
+import { Metadata } from '@memberjunction/core';
 
 @ObjectType()
 export class RunQueryResultType {
@@ -21,37 +23,104 @@ export class RunQueryResultType {
   @Field()
   RowCount: number;
 
+  @Field()
+  TotalRowCount: number;
+
   @Field()
   ExecutionTime: number;
 
   @Field()
   ErrorMessage: string;
+
+  @Field(() => String, { nullable: true })
+  AppliedParameters?: string;
 }
 
-@Resolver(RunQueryResultType)
-export class ReportResolver {
+@Resolver()
+export class RunQueryResolver {
+  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryName?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
+    const md = new Metadata();
+    
+    // Filter queries based on provided criteria
+    const queries = md.Queries.filter(q => {
+      if (QueryID) {
+        return q.ID.trim().toLowerCase() === QueryID.trim().toLowerCase();
+      } else if (QueryName) {
+        let matches = q.Name.trim().toLowerCase() === QueryName.trim().toLowerCase();
+        if (CategoryID) {
+          matches = matches && q.CategoryID?.trim().toLowerCase() === CategoryID.trim().toLowerCase();
+        }
+        if (CategoryName) {
+          matches = matches && q.Category?.trim().toLowerCase() === CategoryName.trim().toLowerCase();
+        }
+        return matches;
+      }
+      return false;
+    });
+
+    if (queries.length === 0) {
+      if (refreshMetadataIfNotFound) {
+        // If we didn't find the query, refresh metadata and try again
+        await md.Refresh();
+        return this.findQuery(QueryID, QueryName, CategoryID, CategoryName, false); // change the refresh flag to false so we don't loop infinitely
+      } 
+      else {
+        return null; // No query found and not refreshing metadata
+      }
+    }
+    else {
+      return queries[0];
+    }
+  }
   @Query(() => RunQueryResultType)
   async GetQueryData(@Arg('QueryID', () => String) QueryID: string, 
                      @Ctx() context: AppContext,
                      @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string): Promise<RunQueryResultType> {
+                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                     @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
+                     @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
+                     @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
     const runQuery = new RunQuery();
+    console.log('GetQueryData called with:', { QueryID, Parameters, MaxRows, StartRow });
     const result = await runQuery.RunQuery(
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName 
+        CategoryName: CategoryName,
+        Parameters: Parameters,
+        MaxRows: MaxRows,
+        StartRow: StartRow
       }, 
       context.userPayload.userRecord);
+    console.log('RunQuery result:', { 
+      Success: result.Success, 
+      ErrorMessage: result.ErrorMessage,
+      AppliedParameters: result.AppliedParameters 
+    });
+    
+    // If QueryName is not populated by the provider, use efficient lookup
+    let queryName = result.QueryName;
+    if (!queryName) {
+      try {
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        if (queryInfo) {
+          queryName = queryInfo.Name;
+        }
+      } catch (error) {
+        console.error('Error finding query to get name:', error);
+      }
+    }
     
     return {
       QueryID: QueryID,
-      QueryName: result.QueryName,
-      Success: result.Success,
-      Results: JSON.stringify(result.Results),
-      RowCount: result.RowCount,
-      ExecutionTime: result.ExecutionTime,
-      ErrorMessage: result.ErrorMessage,
+      QueryName: queryName || 'Unknown Query',
+      Success: result.Success ?? false,
+      Results: JSON.stringify(result.Results ?? null),
+      RowCount: result.RowCount ?? 0,
+      TotalRowCount: result.TotalRowCount ?? 0,
+      ExecutionTime: result.ExecutionTime ?? 0,
+      ErrorMessage: result.ErrorMessage || '',
+      AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined
     };
   }
 
@@ -59,24 +128,32 @@ export class ReportResolver {
   async GetQueryDataByName(@Arg('QueryName', () => String) QueryName: string, 
                            @Ctx() context: AppContext,
                            @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                           @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string): Promise<RunQueryResultType> {
+                           @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                           @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
+                           @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
+                           @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
     const runQuery = new RunQuery();
     const result = await runQuery.RunQuery(
       { 
         QueryName: QueryName, 
         CategoryID: CategoryID,
-        CategoryName: CategoryName
+        CategoryName: CategoryName,
+        Parameters: Parameters,
+        MaxRows: MaxRows,
+        StartRow: StartRow
       },
       context.userPayload.userRecord);
       
     return {
-      QueryID: result.QueryID,
+      QueryID: result.QueryID || '',
       QueryName: QueryName,
-      Success: result.Success,
-      Results: JSON.stringify(result.Results),
-      RowCount: result.RowCount,
-      ExecutionTime: result.ExecutionTime,
-      ErrorMessage: result.ErrorMessage,
+      Success: result.Success ?? false,
+      Results: JSON.stringify(result.Results ?? null),
+      RowCount: result.RowCount ?? 0,
+      TotalRowCount: result.TotalRowCount ?? 0,
+      ExecutionTime: result.ExecutionTime ?? 0,
+      ErrorMessage: result.ErrorMessage || '',
+      AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined
     };
   }
 
@@ -85,50 +162,45 @@ export class ReportResolver {
   async GetQueryDataSystemUser(@Arg('QueryID', () => String) QueryID: string, 
                                @Ctx() context: AppContext,
                                @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                               @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string): Promise<RunQueryResultType> {
+                               @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                               @Arg('Parameters', () => GraphQLJSONObject, {nullable: true}) Parameters?: Record<string, any>,
+                               @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
+                               @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number): Promise<RunQueryResultType> {
     const runQuery = new RunQuery();
     const result = await runQuery.RunQuery(
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName 
+        CategoryName: CategoryName,
+        Parameters: Parameters,
+        MaxRows: MaxRows,
+        StartRow: StartRow
       }, 
       context.userPayload.userRecord);
     
+    // If QueryName is not populated by the provider, use efficient lookup
+    let queryName = result.QueryName;
+    if (!queryName) {
+      try {
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        if (queryInfo) {
+          queryName = queryInfo.Name;
+        }
+      } catch (error) {
+        console.error('Error finding query to get name:', error);
+      }
+    }
+    
     return {
       QueryID: QueryID,
-      QueryName: result.QueryName,
-      Success: result.Success,
-      Results: JSON.stringify(result.Results),
-      RowCount: result.RowCount,
-      ExecutionTime: result.ExecutionTime,
-      ErrorMessage: result.ErrorMessage,
+      QueryName: queryName || 'Unknown Query',
+      Success: result.Success ?? false,
+      Results: JSON.stringify(result.Results ?? null),
+      RowCount: result.RowCount ?? 0,
+      TotalRowCount: result.TotalRowCount ?? 0,
+      ExecutionTime: result.ExecutionTime ?? 0,
+      ErrorMessage: result.ErrorMessage || '',
+      AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined
     };
   }
-
-  @RequireSystemUser()
-  @Query(() => RunQueryResultType)
-  async GetQueryDataByNameSystemUser(@Arg('QueryName', () => String) QueryName: string, 
-                                     @Ctx() context: AppContext,
-                                     @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string): Promise<RunQueryResultType> {
-    const runQuery = new RunQuery();
-    const result = await runQuery.RunQuery(
-      { 
-        QueryName: QueryName, 
-        CategoryID: CategoryID,
-        CategoryName: CategoryName
-      },
-      context.userPayload.userRecord);
-      
-    return {
-      QueryID: result.QueryID,
-      QueryName: QueryName,
-      Success: result.Success,
-      Results: JSON.stringify(result.Results),
-      RowCount: result.RowCount,
-      ExecutionTime: result.ExecutionTime,
-      ErrorMessage: result.ErrorMessage,
-    };
-  }
-}
+}