@memberjunction/server 5.13.0 → 5.15.0

package/dist/resolvers/{CreateQueryResolver.js → QuerySystemUserResolver.js}

@@ -13,7 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
 import { LogError, RunView, CompositeKey, LogStatus } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
-import { MJQueryResolver } from '../generated/generated.js';
+import { MJQueryResolver, MJQuery_ } from '../generated/generated.js';
 import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 /**
@@ -200,310 +200,32 @@ UpdateQuerySystemUserInput = __decorate([
     InputType()
 ], UpdateQuerySystemUserInput);
 export { UpdateQuerySystemUserInput };
-let QueryFieldType = class QueryFieldType {
-};
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "ID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "QueryID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "Name", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "Description", void 0);
-__decorate([
-    Field(() => Number),
-    __metadata("design:type", Number)
-], QueryFieldType.prototype, "Sequence", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SQLBaseType", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SQLFullType", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SourceEntityID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SourceEntity", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SourceFieldName", void 0);
-__decorate([
-    Field(() => Boolean),
-    __metadata("design:type", Boolean)
-], QueryFieldType.prototype, "IsComputed", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "ComputationDescription", void 0);
-__decorate([
-    Field(() => Boolean, { nullable: true }),
-    __metadata("design:type", Boolean)
-], QueryFieldType.prototype, "IsSummary", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryFieldType.prototype, "SummaryDescription", void 0);
-QueryFieldType = __decorate([
-    ObjectType()
-], QueryFieldType);
-export { QueryFieldType };
-let QueryParameterType = class QueryParameterType {
-};
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "ID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "QueryID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "Name", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "Description", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "Type", void 0);
-__decorate([
-    Field(() => Boolean),
-    __metadata("design:type", Boolean)
-], QueryParameterType.prototype, "IsRequired", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "DefaultValue", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "SampleValue", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryParameterType.prototype, "ValidationFilters", void 0);
-QueryParameterType = __decorate([
-    ObjectType()
-], QueryParameterType);
-export { QueryParameterType };
-let MJQueryEntityType = class MJQueryEntityType {
-};
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], MJQueryEntityType.prototype, "ID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], MJQueryEntityType.prototype, "QueryID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], MJQueryEntityType.prototype, "EntityID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], MJQueryEntityType.prototype, "Entity", void 0);
-MJQueryEntityType = __decorate([
-    ObjectType()
-], MJQueryEntityType);
-export { MJQueryEntityType };
-let QueryPermissionType = class QueryPermissionType {
-};
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryPermissionType.prototype, "ID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryPermissionType.prototype, "QueryID", void 0);
-__decorate([
-    Field(() => String),
-    __metadata("design:type", String)
-], QueryPermissionType.prototype, "RoleID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], QueryPermissionType.prototype, "Role", void 0);
-QueryPermissionType = __decorate([
-    ObjectType()
-], QueryPermissionType);
-export { QueryPermissionType };
-let CreateQueryResultType = class CreateQueryResultType {
-};
-__decorate([
-    Field(() => Boolean),
-    __metadata("design:type", Boolean)
-], CreateQueryResultType.prototype, "Success", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "ErrorMessage", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "ID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "Name", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "Description", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "CategoryID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "Category", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "SQL", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "Status", void 0);
-__decorate([
-    Field(() => Number, { nullable: true }),
-    __metadata("design:type", Number)
-], CreateQueryResultType.prototype, "QualityRank", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "EmbeddingVector", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "EmbeddingModelID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "EmbeddingModelName", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], CreateQueryResultType.prototype, "TechnicalDescription", void 0);
-__decorate([
-    Field(() => [QueryFieldType], { nullable: true }),
-    __metadata("design:type", Array)
-], CreateQueryResultType.prototype, "Fields", void 0);
-__decorate([
-    Field(() => [QueryParameterType], { nullable: true }),
-    __metadata("design:type", Array)
-], CreateQueryResultType.prototype, "Parameters", void 0);
-__decorate([
-    Field(() => [MJQueryEntityType], { nullable: true }),
-    __metadata("design:type", Array)
-], CreateQueryResultType.prototype, "Entities", void 0);
-__decorate([
-    Field(() => [QueryPermissionType], { nullable: true }),
-    __metadata("design:type", Array)
-], CreateQueryResultType.prototype, "Permissions", void 0);
-CreateQueryResultType = __decorate([
-    ObjectType()
-], CreateQueryResultType);
-export { CreateQueryResultType };
-let UpdateQueryResultType = class UpdateQueryResultType {
+/**
+ * Consolidated result type for Create and Update query mutations.
+ * Composes the CodeGen-generated MJQuery_ type so that new entity fields
+ * are automatically available in the GraphQL schema without manual sync.
+ *
+ * On success, Query contains the full query data (scalars + related entities).
+ * On failure, Query is null and ErrorMessage describes the problem.
+ */
+let QueryMutationResultType = class QueryMutationResultType {
 };
 __decorate([
     Field(() => Boolean),
     __metadata("design:type", Boolean)
-], UpdateQueryResultType.prototype, "Success", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "ErrorMessage", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "ID", void 0);
+], QueryMutationResultType.prototype, "Success", void 0);
 __decorate([
     Field(() => String, { nullable: true }),
     __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "Name", void 0);
+], QueryMutationResultType.prototype, "ErrorMessage", void 0);
 __decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "Description", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "CategoryID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "Category", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "SQL", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "Status", void 0);
-__decorate([
-    Field(() => Number, { nullable: true }),
-    __metadata("design:type", Number)
-], UpdateQueryResultType.prototype, "QualityRank", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "EmbeddingVector", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "EmbeddingModelID", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "EmbeddingModelName", void 0);
-__decorate([
-    Field(() => String, { nullable: true }),
-    __metadata("design:type", String)
-], UpdateQueryResultType.prototype, "TechnicalDescription", void 0);
-__decorate([
-    Field(() => [QueryFieldType], { nullable: true }),
-    __metadata("design:type", Array)
-], UpdateQueryResultType.prototype, "Fields", void 0);
-__decorate([
-    Field(() => [QueryParameterType], { nullable: true }),
-    __metadata("design:type", Array)
-], UpdateQueryResultType.prototype, "Parameters", void 0);
-__decorate([
-    Field(() => [MJQueryEntityType], { nullable: true }),
-    __metadata("design:type", Array)
-], UpdateQueryResultType.prototype, "Entities", void 0);
-__decorate([
-    Field(() => [QueryPermissionType], { nullable: true }),
-    __metadata("design:type", Array)
-], UpdateQueryResultType.prototype, "Permissions", void 0);
-UpdateQueryResultType = __decorate([
+    Field(() => MJQuery_, { nullable: true }),
+    __metadata("design:type", MJQuery_)
+], QueryMutationResultType.prototype, "Query", void 0);
+QueryMutationResultType = __decorate([
     ObjectType()
-], UpdateQueryResultType);
-export { UpdateQueryResultType };
+], QueryMutationResultType);
+export { QueryMutationResultType };
 let DeleteQueryResultType = class DeleteQueryResultType {
 };
 __decorate([
@@ -568,8 +290,8 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
             }
             // Use MJQueryEntityServer which handles AI processing
             const record = await provider.GetEntityObject("MJ: Queries", context.userPayload.userRecord);
-            // Set the fields from input, handling CategoryPath resolution
-            const fieldsToSet = {
+            // Destructure out non-database fields, keep only fields to persist
+            const { Permissions: _permissions, CategoryPath: _categoryPath, ...fieldsToSet } = {
                 ...input,
                 CategoryID: finalCategoryID || input.CategoryID,
                 Status: input.Status || 'Approved',
@@ -580,9 +302,6 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
                 CacheTTLMinutes: input.CacheTTLMinutes || null,
                 CacheMaxSize: input.CacheMaxSize || null
             };
-            // Remove non-database fields that we handle separately or are input-only
-            delete fieldsToSet.Permissions; // Handled separately via createPermissions
-            delete fieldsToSet.CategoryPath; // Input-only field, resolved to CategoryID
             record.SetMany(fieldsToSet, true);
             this.ListenForEntityMessages(record, pubSub, context.userPayload.userRecord);
             // Attempt to save the query
@@ -598,122 +317,24 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
                 // Refresh metadata cache to include the newly created query
                 // This ensures subsequent operations can find the query without additional DB calls
                 await provider.Refresh();
-                return {
-                    Success: true,
-                    ID: record.ID,
-                    Name: record.Name,
-                    Description: record.Description,
-                    CategoryID: record.CategoryID,
-                    Category: record.Category,
-                    SQL: record.SQL,
-                    Status: record.Status,
-                    QualityRank: record.QualityRank,
-                    EmbeddingVector: record.EmbeddingVector,
-                    EmbeddingModelID: record.EmbeddingModelID,
-                    EmbeddingModelName: record.EmbeddingModel,
-                    TechnicalDescription: record.TechnicalDescription,
-                    Fields: record.QueryFields.map(f => ({
-                        ID: f.ID,
-                        QueryID: f.QueryID,
-                        Name: f.Name,
-                        Description: f.Description,
-                        Sequence: f.Sequence,
-                        SQLBaseType: f.SQLBaseType,
-                        SQLFullType: f.SQLFullType,
-                        SourceEntityID: f.SourceEntityID,
-                        SourceEntity: f.SourceEntity,
-                        SourceFieldName: f.SourceFieldName,
-                        IsComputed: f.IsComputed,
-                        ComputationDescription: f.ComputationDescription,
-                        IsSummary: f.IsSummary,
-                        SummaryDescription: f.SummaryDescription
-                    })),
-                    Parameters: record.QueryParameters.map(p => ({
-                        ID: p.ID,
-                        QueryID: p.QueryID,
-                        Name: p.Name,
-                        Description: p.Description,
-                        Type: p.Type,
-                        IsRequired: p.IsRequired,
-                        DefaultValue: p.DefaultValue,
-                        SampleValue: p.SampleValue,
-                        ValidationFilters: p.ValidationFilters
-                    })),
-                    Entities: record.QueryEntities.map(e => ({
-                        ID: e.ID,
-                        QueryID: e.QueryID,
-                        EntityID: e.EntityID,
-                        Entity: e.Entity
-                    })),
-                    Permissions: record.QueryPermissions.map(p => ({
-                        ID: p.ID,
-                        QueryID: p.QueryID,
-                        RoleID: p.RoleID,
-                        Role: p.Role
-                    }))
-                };
+                return this.buildSuccessResult(record);
             }
             else {
                 // Save failed - check if another request created the same query (race condition)
                 // Always recheck regardless of error type to handle all duplicate scenarios
                 const existingQuery = await this.findExistingQuery(provider, input.Name, finalCategoryID, context.userPayload.userRecord);
                 if (existingQuery) {
-                    // Found the query that was created by another request
-                    // Return it as if we created it (it has the same name/category)
+                    // Found the query that was created by another request — load it as a full entity
+                    // so that related metadata (Fields, Parameters, Entities, Permissions) is populated
                     LogStatus(`[CreateQuery] Unique constraint detected for query '${input.Name}'. Using existing query (ID: ${existingQuery.ID}) created by concurrent request.`);
+                    const existingEntity = await provider.GetEntityObject('MJ: Queries', context.userPayload.userRecord);
+                    if (await existingEntity.Load(existingQuery.ID)) {
+                        return this.buildSuccessResult(existingEntity);
+                    }
+                    // Entity load failed after confirming the row exists — extremely rare
                     return {
-                        Success: true,
-                        ID: existingQuery.ID,
-                        Name: existingQuery.Name,
-                        Description: existingQuery.Description,
-                        CategoryID: existingQuery.CategoryID,
-                        Category: existingQuery.Category,
-                        SQL: existingQuery.SQL,
-                        Status: existingQuery.Status,
-                        QualityRank: existingQuery.QualityRank,
-                        EmbeddingVector: existingQuery.EmbeddingVector,
-                        EmbeddingModelID: existingQuery.EmbeddingModelID,
-                        EmbeddingModelName: existingQuery.EmbeddingModel,
-                        TechnicalDescription: existingQuery.TechnicalDescription,
-                        Fields: existingQuery.Fields?.map((f) => ({
-                            ID: f.ID,
-                            QueryID: f.QueryID,
-                            Name: f.Name,
-                            Description: f.Description,
-                            Sequence: f.Sequence,
-                            SQLBaseType: f.SQLBaseType,
-                            SQLFullType: f.SQLFullType,
-                            SourceEntityID: f.SourceEntityID,
-                            SourceEntity: f.SourceEntity,
-                            SourceFieldName: f.SourceFieldName,
-                            IsComputed: f.IsComputed,
-                            ComputationDescription: f.ComputationDescription,
-                            IsSummary: f.IsSummary,
-                            SummaryDescription: f.SummaryDescription
-                        })) || [],
-                        Parameters: existingQuery.Parameters?.map((p) => ({
-                            ID: p.ID,
-                            QueryID: p.QueryID,
-                            Name: p.Name,
-                            Description: p.Description,
-                            Type: p.Type,
-                            IsRequired: p.IsRequired,
-                            DefaultValue: p.DefaultValue,
-                            SampleValue: p.SampleValue,
-                            ValidationFilters: p.ValidationFilters
-                        })) || [],
-                        Entities: existingQuery.Entities?.map((e) => ({
-                            ID: e.ID,
-                            QueryID: e.QueryID,
-                            EntityID: e.EntityID,
-                            Entity: e.Entity
-                        })) || [],
-                        Permissions: existingQuery.Permissions?.map((p) => ({
-                            ID: p.ID,
-                            QueryID: p.QueryID,
-                            RoleID: p.RoleID,
-                            Role: p.Role
-                        })) || []
+                        Success: false,
+                        ErrorMessage: `Found query '${input.Name}' created by concurrent request (ID: ${existingQuery.ID}) but failed to load it as entity`
                     };
                 }
                 // Genuine failure - couldn't find an existing query with the same name
@@ -732,28 +353,97 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
             };
         }
     }
+    /**
+     * Maps an MJQueryEntityServer (with loaded related metadata) to a QueryMutationResultType.
+     * Uses entity.GetAll() for scalar fields so that new CodeGen-generated fields are included
+     * automatically without manual updates. Related entity arrays are mapped explicitly.
+     */
+    buildSuccessResult(entity) {
+        return {
+            Success: true,
+            Query: {
+                ...entity.GetAll(),
+                MJQueryFields_QueryIDArray: this.mapFields(entity.QueryFields),
+                MJQueryParameters_QueryIDArray: this.mapParameters(entity.QueryParameters),
+                MJQueryEntities_QueryIDArray: this.mapEntities(entity.QueryEntities),
+                MJQueryPermissions_QueryIDArray: this.mapPermissions(entity.QueryPermissions),
+            }
+        };
+    }
+    mapFields(fields) {
+        return fields.map(f => ({
+            ID: f.ID,
+            QueryID: f.QueryID,
+            Name: f.Name,
+            Description: f.Description,
+            Sequence: f.Sequence,
+            SQLBaseType: f.SQLBaseType,
+            SQLFullType: f.SQLFullType,
+            SourceEntityID: f.SourceEntityID,
+            SourceEntity: f.SourceEntity,
+            SourceFieldName: f.SourceFieldName,
+            IsComputed: f.IsComputed,
+            ComputationDescription: f.ComputationDescription,
+            IsSummary: f.IsSummary,
+            SummaryDescription: f.SummaryDescription,
+            _mj__CreatedAt: f.__mj_CreatedAt,
+            _mj__UpdatedAt: f.__mj_UpdatedAt,
+            DetectionMethod: f.DetectionMethod,
+            AutoDetectConfidenceScore: f.AutoDetectConfidenceScore,
+            Query: '',
+        }));
+    }
+    mapParameters(params) {
+        return params.map(p => ({
+            ID: p.ID,
+            QueryID: p.QueryID,
+            Name: p.Name,
+            Description: p.Description,
+            Type: p.Type,
+            IsRequired: p.IsRequired,
+            DefaultValue: p.DefaultValue,
+            SampleValue: p.SampleValue,
+            ValidationFilters: p.ValidationFilters,
+            _mj__CreatedAt: p.__mj_CreatedAt,
+            _mj__UpdatedAt: p.__mj_UpdatedAt,
+            DetectionMethod: p.DetectionMethod,
+            AutoDetectConfidenceScore: p.AutoDetectConfidenceScore,
+            Query: p.Query ?? '',
+        }));
+    }
+    mapEntities(entities) {
+        return entities.map(e => ({
+            ID: e.ID,
+            QueryID: e.QueryID,
+            EntityID: e.EntityID,
+            Entity: e.Entity,
+            _mj__CreatedAt: e.__mj_CreatedAt,
+            _mj__UpdatedAt: e.__mj_UpdatedAt,
+            DetectionMethod: e.DetectionMethod,
+            AutoDetectConfidenceScore: e.AutoDetectConfidenceScore,
+            Query: e.Query ?? '',
+        }));
+    }
+    mapPermissions(permissions) {
+        return permissions.map(p => ({
+            ID: p.ID,
+            QueryID: p.QueryID,
+            RoleID: p.RoleID,
+            Role: p.Role,
+            _mj__CreatedAt: new Date(),
+            _mj__UpdatedAt: new Date(),
+            Query: p.Query ?? '',
+        }));
+    }
     async createPermissions(p, permissions, queryID, contextUser) {
-        // Create permissions if provided
-        const createdPermissions = [];
-        if (permissions && permissions.length > 0) {
-            for (const perm of permissions) {
-                const permissionEntity = await p.GetEntityObject('MJ: 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,
-                            Role: permissionEntity.Role
-                        });
-                    }
-                }
+        for (const perm of permissions) {
+            const permissionEntity = await p.GetEntityObject('MJ: Query Permissions', contextUser);
+            if (permissionEntity) {
+                permissionEntity.QueryID = queryID;
+                permissionEntity.RoleID = perm.RoleID;
+                await permissionEntity.Save();
             }
         }
-        return createdPermissions;
     }
     /**
      * Updates an existing query with the provided attributes. This mutation is restricted to system users only.
@@ -853,60 +543,7 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
                 // Refresh the metadata to get updated permissions
                 await queryEntity.RefreshRelatedMetadata(true);
             }
-            return {
-                Success: true,
-                ID: queryEntity.ID,
-                Name: queryEntity.Name,
-                Description: queryEntity.Description,
-                CategoryID: queryEntity.CategoryID,
-                Category: queryEntity.Category,
-                SQL: queryEntity.SQL,
-                Status: queryEntity.Status,
-                QualityRank: queryEntity.QualityRank,
-                EmbeddingVector: queryEntity.EmbeddingVector,
-                EmbeddingModelID: queryEntity.EmbeddingModelID,
-                EmbeddingModelName: queryEntity.EmbeddingModel,
-                TechnicalDescription: queryEntity.TechnicalDescription,
-                Fields: queryEntity.QueryFields.map(f => ({
-                    ID: f.ID,
-                    QueryID: f.QueryID,
-                    Name: f.Name,
-                    Description: f.Description,
-                    Sequence: f.Sequence,
-                    SQLBaseType: f.SQLBaseType,
-                    SQLFullType: f.SQLFullType,
-                    SourceEntityID: f.SourceEntityID,
-                    SourceEntity: f.SourceEntity,
-                    SourceFieldName: f.SourceFieldName,
-                    IsComputed: f.IsComputed,
-                    ComputationDescription: f.ComputationDescription,
-                    IsSummary: f.IsSummary,
-                    SummaryDescription: f.SummaryDescription
-                })),
-                Parameters: queryEntity.QueryParameters.map(p => ({
-                    ID: p.ID,
-                    QueryID: p.QueryID,
-                    Name: p.Name,
-                    Description: p.Description,
-                    Type: p.Type,
-                    IsRequired: p.IsRequired,
-                    DefaultValue: p.DefaultValue,
-                    SampleValue: p.SampleValue,
-                    ValidationFilters: p.ValidationFilters
-                })),
-                Entities: queryEntity.QueryEntities.map(e => ({
-                    ID: e.ID,
-                    QueryID: e.QueryID,
-                    EntityID: e.EntityID,
-                    Entity: e.Entity
-                })),
-                Permissions: queryEntity.QueryPermissions.map(p => ({
-                    ID: p.ID,
-                    QueryID: p.QueryID,
-                    RoleID: p.RoleID,
-                    Role: p.Role
-                }))
-            };
+            return this.buildSuccessResult(queryEntity);
         }
         catch (err) {
             LogError(err);
@@ -1054,7 +691,7 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
      * @param queryName - Name of the query to find
      * @param categoryID - Category ID (can be null)
      * @param contextUser - User context for database operations
-     * @returns The matching query info or null if not found
+     * @returns The matching query row or null if not found
      */
     async findExistingQuery(provider, queryName, categoryID, contextUser) {
         try {
@@ -1106,7 +743,7 @@ let MJQueryResolverExtended = class MJQueryResolverExtended extends MJQueryResol
 };
 __decorate([
     RequireSystemUser(),
-    Mutation(() => CreateQueryResultType),
+    Mutation(() => QueryMutationResultType),
     __param(0, Arg('input', () => CreateQuerySystemUserInput)),
     __param(1, Ctx()),
     __param(2, PubSub()),
@@ -1116,7 +753,7 @@ __decorate([
 ], MJQueryResolverExtended.prototype, "CreateQuerySystemUser", null);
 __decorate([
     RequireSystemUser(),
-    Mutation(() => UpdateQueryResultType),
+    Mutation(() => QueryMutationResultType),
     __param(0, Arg('input', () => UpdateQuerySystemUserInput)),
     __param(1, Ctx()),
     __param(2, PubSub()),
@@ -1139,4 +776,4 @@ MJQueryResolverExtended = __decorate([
     Resolver()
 ], MJQueryResolverExtended);
 export { MJQueryResolverExtended };
-//# sourceMappingURL=CreateQueryResolver.js.map
+//# sourceMappingURL=QuerySystemUserResolver.js.map