@memberjunction/server 2.78.0 → 2.80.0

package/src/resolvers/CreateQueryResolver.ts

@@ -1,11 +1,12 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
-import { AppContext, UserPayload } from '../types.js';
-import { LogError, Metadata, RunView, UserInfo, CompositeKey, EntitySaveOptions } from '@memberjunction/core';
+import { AppContext } from '../types.js';
+import { LogError, Metadata, RunView, UserInfo, CompositeKey } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
-import { QueryCategoryEntity } from '@memberjunction/core-entities';
+import { QueryCategoryEntity, QueryPermissionEntity } from '@memberjunction/core-entities';
 import { QueryResolver } from '../generated/generated.js';
 import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
+import { QueryEntityExtended } from '@memberjunction/core-entities-server';
 
 /**
  * Query status enumeration for GraphQL
@@ -22,6 +23,12 @@ registerEnumType(QueryStatus, {
     description: "Status of a query: Pending, Approved, Rejected, or Expired"
 });
 
+@InputType()
+export class QueryPermissionInputType {
+    @Field(() => String)
+    RoleID!: string;
+}
+
 @InputType()
 export class CreateQuerySystemUserInput {
     @Field(() => String)
@@ -62,6 +69,147 @@ export class CreateQuerySystemUserInput {
 
     @Field(() => Boolean, { nullable: true })
     UsesTemplate?: boolean;
+
+    @Field(() => [QueryPermissionInputType], { nullable: true })
+    Permissions?: QueryPermissionInputType[];
+}
+
+@InputType()
+export class UpdateQuerySystemUserInput {
+    @Field(() => String)
+    ID!: string;
+
+    @Field(() => String, { nullable: true })
+    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 })
+    Status?: QueryStatus;
+
+    @Field(() => Number, { nullable: true })
+    QualityRank?: number;
+
+    @Field(() => Number, { nullable: true })
+    ExecutionCostRank?: number;
+
+    @Field(() => Boolean, { nullable: true })
+    UsesTemplate?: boolean;
+
+    @Field(() => [QueryPermissionInputType], { nullable: true })
+    Permissions?: QueryPermissionInputType[];
+}
+
+@ObjectType()
+export class QueryFieldType {
+    @Field(() => String)
+    ID!: string;
+
+    @Field(() => String)
+    QueryID!: string;
+
+    @Field(() => String)
+    Name!: string;
+
+    @Field(() => String, { nullable: true })
+    Description?: string;
+
+    @Field(() => String, { nullable: true })
+    Type?: string;
+
+    @Field(() => Number)
+    Sequence!: number;
+
+    @Field(() => String, { nullable: true })
+    SQLBaseType?: string;
+
+    @Field(() => String, { nullable: true })
+    SQLFullType?: string;
+
+    @Field(() => Boolean)
+    IsComputed!: boolean;
+
+    @Field(() => String, { nullable: true })
+    ComputationDescription?: string;
+}
+
+@ObjectType()
+export class QueryParameterType {
+    @Field(() => String)
+    ID!: string;
+
+    @Field(() => String)
+    QueryID!: string;
+
+    @Field(() => String)
+    Name!: string;
+
+    @Field(() => String)
+    Type!: string;
+
+    @Field(() => String, { nullable: true })
+    DefaultValue?: string;
+
+    @Field(() => String, { nullable: true })
+    Comments?: string;
+
+    @Field(() => Boolean)
+    IsRequired!: boolean;
+}
+
+@ObjectType()
+export class QueryEntityType {
+    @Field(() => String)
+    ID!: string;
+
+    @Field(() => String)
+    QueryID!: string;
+
+    @Field(() => String)
+    EntityID!: string;
+
+    @Field(() => String, { nullable: true })
+    EntityName?: string;
+
+    @Field(() => Number)
+    Sequence!: number;
+}
+
+@ObjectType()
+export class QueryPermissionType {
+    @Field(() => String)
+    ID!: string;
+
+    @Field(() => String)
+    QueryID!: string;
+
+    @Field(() => String)
+    RoleID!: string;
+
+    @Field(() => String, { nullable: true })
+    RoleName?: string;
 }
 
 @ObjectType()
@@ -74,6 +222,42 @@ export class CreateQueryResultType {
 
     @Field(() => String, { nullable: true })
     QueryData?: string;
+
+    @Field(() => [QueryFieldType], { nullable: true })
+    Fields?: QueryFieldType[];
+
+    @Field(() => [QueryParameterType], { nullable: true })
+    Parameters?: QueryParameterType[];
+
+    @Field(() => [QueryEntityType], { nullable: true })
+    Entities?: QueryEntityType[];
+
+    @Field(() => [QueryPermissionType], { nullable: true })
+    Permissions?: QueryPermissionType[];
+}
+
+@ObjectType()
+export class UpdateQueryResultType {
+    @Field(() => Boolean)
+    Success!: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => String, { nullable: true })
+    QueryData?: string;
+
+    @Field(() => [QueryFieldType], { nullable: true })
+    Fields?: QueryFieldType[];
+
+    @Field(() => [QueryParameterType], { nullable: true })
+    Parameters?: QueryParameterType[];
+
+    @Field(() => [QueryEntityType], { nullable: true })
+    Entities?: QueryEntityType[];
+
+    @Field(() => [QueryPermissionType], { nullable: true })
+    Permissions?: QueryPermissionType[];
 }
 
 @ObjectType()
@@ -108,46 +292,222 @@ export class QueryResolverExtended extends QueryResolver {
             let finalCategoryID = input.CategoryID;
             if (input.CategoryPath) {
                 const md = new Metadata();
-                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord, context.userPayload);
+                finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, md, context.userPayload.userRecord);
             }
-
-            // 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,
+            
+            // Use QueryEntityExtended which handles AI processing
+            const provider = GetReadWriteProvider(context.providers); 
+            const record = await provider.GetEntityObject<QueryEntityExtended>("Queries", context.userPayload.userRecord);
+            
+            // Set the fields from input, handling CategoryPath resolution
+            const fieldsToSet = {
+                ...input,
+                CategoryID: finalCategoryID || input.CategoryID,
                 Status: input.Status || 'Approved',
                 QualityRank: input.QualityRank || 0,
-                ExecutionCostRank: input.ExecutionCostRank,
                 UsesTemplate: input.UsesTemplate || false
             };
+            // Remove Permissions from the fields to set since we handle them separately
+            delete (fieldsToSet as any).Permissions;
             
-            // Use inherited CreateRecord method which bypasses AI processing
-            const provider = GetReadWriteProvider(context.providers);    
-            const createdQuery = await this.CreateRecord('Queries', createInput, provider, context.userPayload, pubSub);
-            
-            if (createdQuery) {
+            record.SetMany(fieldsToSet, true);
+            this.ListenForEntityMessages(record, pubSub, context.userPayload.userRecord);
+
+            // Pass the transactionScopeId from the user payload to the save operation
+            if (await record.Save()) {
+                // save worked, fire the AfterCreate event and then return all the data
+                await this.AfterCreate(provider, input); // fire event
+                const queryID = record.ID;
+                
+                if (input.Permissions && input.Permissions.length > 0) {
+                    await this.createPermissions(input.Permissions, queryID, context.userPayload.userRecord);
+                    await record.RefreshRelatedMetadata(true); // force DB update since we just created new permissions
+                }                
+
                 return {
                     Success: true,
-                    QueryData: JSON.stringify(createdQuery)
+                    QueryData: JSON.stringify(record.GetAll()),
+                    Fields: record.QueryFields,
+                    Parameters: record.QueryParameters,
+                    Entities: record.QueryEntities,
+                    Permissions: record.QueryPermissions
                 };
-            } else {
+            } 
+            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)}`
+            };
+        }
+    }
+
+    protected async createPermissions(permissions: QueryPermissionInputType[], queryID: string, contextUser: UserInfo): Promise<QueryPermissionType[]> {
+        // Create permissions if provided
+        const createdPermissions: QueryPermissionType[] = [];
+        if (permissions && permissions.length > 0) {
+            const md = new Metadata();
+            for (const perm of permissions) {
+                const permissionEntity = await md.GetEntityObject<QueryPermissionEntity>('Query Permissions', contextUser);
+                if (permissionEntity) {
+                    permissionEntity.QueryID = queryID;
+                    permissionEntity.RoleID = perm.RoleID;
+                    
+                    const saveResult = await permissionEntity.Save();
+                    if (saveResult) {
+                        createdPermissions.push({
+                            ID: permissionEntity.ID,
+                            QueryID: permissionEntity.QueryID,
+                            RoleID: permissionEntity.RoleID,
+                            RoleName: permissionEntity.Role // The view includes the Role name
+                        });
+                    }
+                }
+            }
+        }
+        return createdPermissions;
+    }
+
+    /**
+     * Updates an existing query with the provided attributes. This mutation is restricted to system users only.
+     * @param input - UpdateQuerySystemUserInput containing the query ID and fields to update
+     * @param context - Application context containing user information
+     * @returns UpdateQueryResultType with success status and updated query data including related entities
+     */
+    @RequireSystemUser()
+    @Mutation(() => UpdateQueryResultType)
+    async UpdateQuerySystemUser(
+        @Arg('input', () => UpdateQuerySystemUserInput) input: UpdateQuerySystemUserInput,
+        @Ctx() context: AppContext,
+        @PubSub() pubSub: PubSubEngine
+    ): Promise<UpdateQueryResultType> {
+        try {
+            // Load the existing query using QueryEntityExtended
+            const provider = GetReadWriteProvider(context.providers);
+            const queryEntity = await provider.GetEntityObject<QueryEntityExtended>('Queries', context.userPayload.userRecord);
+            if (!queryEntity || !await queryEntity.Load(input.ID)) {
+                return {
+                    Success: false,
+                    ErrorMessage: `Query with ID ${input.ID} not found`
+                };
+            }
+
+            // 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);
+            }
+
+            // Update fields that were provided
+            if (input.Name !== undefined) queryEntity.Name = input.Name;
+            if (finalCategoryID !== undefined) queryEntity.CategoryID = finalCategoryID;
+            if (input.UserQuestion !== undefined) queryEntity.UserQuestion = input.UserQuestion;
+            if (input.Description !== undefined) queryEntity.Description = input.Description;
+            if (input.SQL !== undefined) queryEntity.SQL = input.SQL;
+            if (input.TechnicalDescription !== undefined) queryEntity.TechnicalDescription = input.TechnicalDescription;
+            if (input.OriginalSQL !== undefined) queryEntity.OriginalSQL = input.OriginalSQL;
+            if (input.Feedback !== undefined) queryEntity.Feedback = input.Feedback;
+            if (input.Status !== undefined) queryEntity.Status = input.Status;
+            if (input.QualityRank !== undefined) queryEntity.QualityRank = input.QualityRank;
+            if (input.ExecutionCostRank !== undefined) queryEntity.ExecutionCostRank = input.ExecutionCostRank;
+            if (input.UsesTemplate !== undefined) queryEntity.UsesTemplate = input.UsesTemplate;
+
+            // Save the updated query
+            const saveResult = await queryEntity.Save();
+            if (!saveResult) {
+                return {
+                    Success: false,
+                    ErrorMessage: `Failed to update query: ${queryEntity.LatestResult?.Message || 'Unknown error'}`
+                };
+            }
+
+            const queryID = queryEntity.ID;
+
+            // Handle permissions update if provided
+            if (input.Permissions !== undefined) {
+                // Delete existing permissions
+                const rv = new RunView();
+                const existingPermissions = await rv.RunView<QueryPermissionEntity>({
+                    EntityName: 'Query Permissions',
+                    ExtraFilter: `QueryID='${queryID}'`,
+                    ResultType: 'entity_object'
+                }, context.userPayload.userRecord);
+
+                if (existingPermissions.Success && existingPermissions.Results) {
+                    for (const perm of existingPermissions.Results) {
+                        await perm.Delete();
+                    }
+                }
+
+                // Create new permissions
+                await this.createPermissions(input.Permissions, queryID, context.userPayload.userRecord);
+                
+                // Refresh the metadata to get updated permissions
+                await queryEntity.RefreshRelatedMetadata(true);
+            }
+
+            // Use the properties from QueryEntityExtended instead of manual loading
+            const fields: QueryFieldType[] = queryEntity.QueryFields.map(f => ({
+                ID: f.ID,
+                QueryID: f.QueryID,
+                Name: f.Name,
+                Description: f.Description || undefined,
+                Type: f.SQLBaseType || undefined,
+                Sequence: f.Sequence,
+                SQLBaseType: f.SQLBaseType || undefined,
+                SQLFullType: f.SQLFullType || undefined,
+                IsComputed: f.IsComputed,
+                ComputationEnabled: true, // Default to true as it's not in QueryFieldInfo
+                ComputationDescription: f.ComputationDescription || undefined
+            }));
+            
+            const parameters: QueryParameterType[] = queryEntity.QueryParameters.map(p => ({
+                ID: p.ID,
+                QueryID: p.QueryID,
+                Name: p.Name,
+                Type: p.Type,
+                DefaultValue: p.DefaultValue || undefined,
+                Comments: '', // Not available in QueryParameterInfo
+                IsRequired: p.IsRequired
+            }));
+            
+            const entities: QueryEntityType[] = queryEntity.QueryEntities.map(e => ({
+                ID: e.ID,
+                QueryID: e.QueryID,
+                EntityID: e.EntityID,
+                EntityName: e.Entity || undefined, // Property is called Entity, not EntityName
+                Sequence: e.Sequence || 0
+            }));
+            
+            const permissions: QueryPermissionType[] = queryEntity.QueryPermissions.map(p => ({
+                ID: p.ID,
+                QueryID: p.QueryID,
+                RoleID: p.RoleID,
+                RoleName: p.Role || undefined // Property is called Role, not RoleName
+            }));
+
+            return {
+                Success: true,
+                QueryData: JSON.stringify(queryEntity.GetAll()),
+                Fields: fields,
+                Parameters: parameters,
+                Entities: entities,
+                Permissions: permissions
+            };
 
         } catch (err) {
             LogError(err);
             return {
                 Success: false,
-                ErrorMessage: `QueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
+                ErrorMessage: `QueryResolverExtended::UpdateQuerySystemUser --- Error updating query: ${err instanceof Error ? err.message : String(err)}`
             };
         }
     }
@@ -217,7 +577,7 @@ export class QueryResolverExtended extends QueryResolver {
      * @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, userPayload: UserPayload): Promise<string> {
+    private async findOrCreateCategoryPath(categoryPath: string, md: Metadata, contextUser: UserInfo): Promise<string> {
         if (!categoryPath || categoryPath.trim() === '') {
             throw new Error('CategoryPath cannot be empty');
         }
@@ -240,23 +600,31 @@ export class QueryResolverExtended extends QueryResolver {
                 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'}`);
+                try {
+                    // Create new category
+                    const newCategory = await md.GetEntityObject<QueryCategoryEntity>("Query Categories", contextUser);
+                    if (!newCategory) {
+                        throw new Error(`Failed to create entity object for Query Categories`);
+                    }
+                    
+                    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();
+                } catch (error) {
+                    throw new Error(`Failed to create category '${categoryName}': ${error instanceof Error ? error.message : String(error)}`);
                 }
-
-                currentCategoryID = newCategory.ID;
-                currentParentID = newCategory.ID;
-
-                // Refresh metadata after each category creation to ensure it's available for subsequent lookups
-                await md.Refresh();
             }
         }