@memberjunction/server 2.75.0 → 2.76.0

package/src/resolvers/CreateQueryResolver.ts

@@ -1,8 +1,11 @@
-import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
+import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { LogError, Metadata, RunView, UserInfo, CompositeKey } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
-import { QueryEntity, QueryCategoryEntity } from '@memberjunction/core-entities';
+import { QueryCategoryEntity } from '@memberjunction/core-entities';
+import { QueryResolver } from '../generated/generated.js';
+import { GetReadWriteDataSource } from '../util.js';
+import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 
 /**
  * Query status enumeration for GraphQL
@@ -20,7 +23,7 @@ registerEnumType(QueryStatus, {
 });
 
 @InputType()
-export class CreateQueryInputType {
+export class CreateQuerySystemUserInput {
     @Field(() => String)
     Name!: string;
 
@@ -73,88 +76,119 @@ export class CreateQueryResultType {
     QueryData?: string;
 }
 
-export class CreateQueryResolver {
+@ObjectType()
+export class DeleteQueryResultType {
+    @Field(() => Boolean)
+    Success!: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => String, { nullable: true })
+    QueryData?: string;
+}
+
+@Resolver()
+export class QueryResolverExtended extends QueryResolver {
     /**
      * 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 input - CreateQuerySystemUserInput 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
+    async CreateQuerySystemUser(
+        @Arg('input', () => CreateQuerySystemUserInput) input: CreateQuerySystemUserInput,
+        @Ctx() context: AppContext,
+        @PubSub() pubSub: PubSubEngine
     ): 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) {
+                const md = new Metadata();
                 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;
-            }
+            // Create input for the inherited CreateRecord method
+            const createInput = {
+                Name: input.Name,
+                CategoryID: finalCategoryID,
+                UserQuestion: input.UserQuestion,
+                Description: input.Description,
+                SQL: input.SQL,
+                TechnicalDescription: input.TechnicalDescription,
+                OriginalSQL: input.OriginalSQL,
+                Feedback: input.Feedback,
+                Status: input.Status || 'Approved',
+                QualityRank: input.QualityRank || 0,
+                ExecutionCostRank: input.ExecutionCostRank,
+                UsesTemplate: input.UsesTemplate || false
+            };
             
-            if (input.Feedback != null) {
-                newQuery.Feedback = input.Feedback;
-            }
+            // Use inherited CreateRecord method which bypasses AI processing
+            const connPool = GetReadWriteDataSource(context.dataSources);
+            const createdQuery = await this.CreateRecord('Queries', createInput, connPool, context.userPayload, pubSub);
             
-            if (input.Status != null) {
-                newQuery.Status = input.Status;
-            }
-            
-            if (input.QualityRank != null) {
-                newQuery.QualityRank = input.QualityRank;
+            if (createdQuery) {
+                return {
+                    Success: true,
+                    QueryData: JSON.stringify(createdQuery)
+                };
+            } else {
+                return {
+                    Success: false,
+                    ErrorMessage: 'Failed to create query using CreateRecord method'
+                };
             }
+
+        } catch (err) {
+            LogError(err);
+            return {
+                Success: false,
+                ErrorMessage: `QueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+            };
+        }
+    }
+
+    /**
+     * Deletes a query by ID. This mutation is restricted to system users only.
+     * @param ID - The ID of the query to delete
+     * @param options - Delete options controlling action execution
+     * @param context - Application context containing user information
+     * @returns DeleteQueryResultType with success status and deleted query data
+     */
+    @RequireSystemUser()
+    @Mutation(() => DeleteQueryResultType)
+    async DeleteQuerySystemResolver(
+        @Arg('ID', () => String) queryID: string,
+        @Arg('options', () => DeleteOptionsInput, { nullable: true }) options: DeleteOptionsInput | null,
+        @Ctx() context: AppContext,
+        @PubSub() pubSub: PubSubEngine
+    ): Promise<DeleteQueryResultType> {
+        try {
+            const connPool = GetReadWriteDataSource(context.dataSources);
+            const key = new CompositeKey([{FieldName: 'ID', Value: queryID}]);
             
-            if (input.ExecutionCostRank != null) {
-                newQuery.ExecutionCostRank = input.ExecutionCostRank;
-            }
+            // Provide default options if none provided
+            const deleteOptions = options || {
+                SkipEntityAIActions: false,
+                SkipEntityActions: false
+            };
             
-            if (input.UsesTemplate != null) {
-                newQuery.UsesTemplate = input.UsesTemplate;
-            }
-
-            // Save the query
-            const saveResult = await newQuery.Save();
+            // Use inherited DeleteRecord method from ResolverBase
+            const deletedQuery = await this.DeleteRecord('Queries', key, deleteOptions, connPool, context.userPayload, pubSub);
             
-            if (saveResult) {
+            if (deletedQuery) {
                 return {
                     Success: true,
-                    QueryData: JSON.stringify(newQuery.GetAll())
+                    QueryData: JSON.stringify(deletedQuery)
                 };
             } else {
                 return {
                     Success: false,
-                    ErrorMessage: `Failed to save query: ${newQuery.LatestResult?.Message || 'Unknown error'}`
+                    ErrorMessage: 'Failed to delete query using DeleteRecord method'
                 };
             }
 
@@ -162,7 +196,7 @@ export class CreateQueryResolver {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `CreateQueryResolver::CreateQuery --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `QueryResolverExtended::DeleteQuerySystemResolver --- Error deleting query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }

package/src/resolvers/GetDataResolver.ts

@@ -264,6 +264,9 @@ export function isTokenValid(token: string) {
 export function recordTokenUse(token: string, usePayload: any) {
     const t = __accessTokens.find((t) => t.Token === token);
     if (t) {
+        if (!t.TokenUses) {
+            t.TokenUses = [];
+        }
         t.TokenUses.push({ Token: token, UsedAt: new Date(), UsePayload: usePayload });
     }
     else {

package/src/resolvers/QueryResolver.ts

@@ -38,7 +38,7 @@ export class RunQueryResultType {
 
 @Resolver()
 export class RunQueryResolver {
-  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryName?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
+  private async findQuery(QueryID: string, QueryName?: string, CategoryID?: string, CategoryPath?: string, refreshMetadataIfNotFound: boolean = false): Promise<QueryInfo | null> {
     const md = new Metadata();
     
     // Filter queries based on provided criteria
@@ -50,8 +50,8 @@ export class RunQueryResolver {
         if (CategoryID) {
           matches = matches && q.CategoryID?.trim().toLowerCase() === CategoryID.trim().toLowerCase();
         }
-        if (CategoryName) {
-          matches = matches && q.Category?.trim().toLowerCase() === CategoryName.trim().toLowerCase();
+        if (CategoryPath) {
+          matches = matches && q.Category?.trim().toLowerCase() === CategoryPath.trim().toLowerCase();
         }
         return matches;
       }
@@ -62,7 +62,7 @@ export class RunQueryResolver {
       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
+        return this.findQuery(QueryID, QueryName, CategoryID, CategoryPath, false); // change the refresh flag to false so we don't loop infinitely
       } 
       else {
         return null; // No query found and not refreshing metadata
@@ -76,7 +76,7 @@ export class RunQueryResolver {
   async GetQueryData(@Arg('QueryID', () => String) QueryID: string, 
                      @Ctx() context: AppContext,
                      @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                     @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: 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> {
@@ -86,7 +86,7 @@ export class RunQueryResolver {
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -102,7 +102,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -128,7 +128,7 @@ export class RunQueryResolver {
   async GetQueryDataByName(@Arg('QueryName', () => String) QueryName: string, 
                            @Ctx() context: AppContext,
                            @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                           @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                           @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: 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> {
@@ -137,7 +137,7 @@ export class RunQueryResolver {
       { 
         QueryName: QueryName, 
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -162,7 +162,7 @@ export class RunQueryResolver {
   async GetQueryDataSystemUser(@Arg('QueryID', () => String) QueryID: string, 
                                @Ctx() context: AppContext,
                                @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                               @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                               @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: 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> {
@@ -171,7 +171,7 @@ export class RunQueryResolver {
       { 
         QueryID: QueryID,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow
@@ -182,7 +182,7 @@ export class RunQueryResolver {
     let queryName = result.QueryName;
     if (!queryName) {
       try {
-        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryName, true);
+        const queryInfo = await this.findQuery(QueryID, undefined, CategoryID, CategoryPath, true);
         if (queryInfo) {
           queryName = queryInfo.Name;
         }
@@ -209,7 +209,7 @@ export class RunQueryResolver {
   async GetQueryDataByNameSystemUser(@Arg('QueryName', () => String) QueryName: string, 
                                      @Ctx() context: AppContext,
                                      @Arg('CategoryID', () => String, {nullable: true}) CategoryID?: string,
-                                     @Arg('CategoryName', () => String, {nullable: true}) CategoryName?: string,
+                                     @Arg('CategoryPath', () => String, {nullable: true}) CategoryPath?: 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> {
@@ -218,7 +218,7 @@ export class RunQueryResolver {
       { 
         QueryName: QueryName,
         CategoryID: CategoryID,
-        CategoryName: CategoryName,
+        CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow