@axinom/mosaic-graphql-common 0.28.0-rc.14 → 0.28.0-rc.16

package/src/plugins/bulk-edit/bulk-edit-async-plugin-factory.ts

@@ -23,6 +23,7 @@ import {
 } from 'graphile-build-pg';
 import { gql as gqlExtended } from 'graphile-utils';
 import GraphQL, {
+  GraphQLBoolean,
   GraphQLInputFieldMap,
   GraphQLInputObjectType,
   GraphQLList,
@@ -95,11 +96,10 @@ export const BulkEditAsyncPluginFactory = (
         );
         const hasForeignKeyRelations = foreignKeyRelations.length > 0;
 
-        const addInputTypeForFKs = hasForeignKeyRelations
-          ? generateInputTypeForFKs(
+        const clearInputTypeForFKs = hasForeignKeyRelations
+          ? generateClearInputTypeForFKs(
               build,
               pgTable,
-              'Add',
               excludedForeignKeyRelations,
             )
           : undefined;
@@ -113,6 +113,15 @@ export const BulkEditAsyncPluginFactory = (
             )
           : undefined;
 
+        const addInputTypeForFKs = hasForeignKeyRelations
+          ? generateInputTypeForFKs(
+              build,
+              pgTable,
+              'Add',
+              excludedForeignKeyRelations,
+            )
+          : undefined;
+
         const BulkEditPayloadType = getBulkEditPayloadType(build);
 
         const args: Record<string, { type: GraphQL.GraphQLInputType }> = {
@@ -124,6 +133,12 @@ export const BulkEditAsyncPluginFactory = (
           },
         };
 
+        if (clearInputTypeForFKs) {
+          args.relatedEntitiesToClear = {
+            type: clearInputTypeForFKs,
+          };
+        }
+
         if (removeInputTypeForFKs) {
           args.relatedEntitiesToRemove = {
             type: removeInputTypeForFKs,
@@ -144,8 +159,9 @@ export const BulkEditAsyncPluginFactory = (
             input: {
               filter: { [key: string]: any };
               set?: { [key: string]: any };
-              relatedEntitiesToRemove?: { [key: string]: [any] };
-              relatedEntitiesToAdd?: { [key: string]: [any] };
+              relatedEntitiesToClear?: { [key: string]: boolean };
+              relatedEntitiesToRemove?: { [key: string]: any[] };
+              relatedEntitiesToAdd?: { [key: string]: any[] };
             },
             context: { [str: string]: unknown },
             resolveInfo: GraphQL.GraphQLResolveInfo,
@@ -159,6 +175,36 @@ export const BulkEditAsyncPluginFactory = (
               storeInboxMessage,
             } = context;
 
+            if (config === undefined) {
+              throw new Error(
+                `The service config [field: config] was unable to be resolved from the GQL context for the Bulk Edit operations.`,
+              );
+            }
+
+            if (jwtToken === undefined) {
+              throw new Error(
+                `The JWT token [field: jwtToken] was unable to be resolved from the GQL context for the Bulk Edit operations.`,
+              );
+            }
+
+            if (subject === undefined) {
+              throw new Error(
+                `The authenticated subject [field: subject] was unable to be resolved from the GQL context for the Bulk Edit operations.`,
+              );
+            }
+
+            if (envOwnerPool === undefined && ownerPool === undefined) {
+              throw new Error(
+                `The DB connection pool [fields: envOwnerPool, ownerPool] was unable to be resolved from the GQL context for the Bulk Edit operations.`,
+              );
+            }
+
+            if (storeInboxMessage === undefined) {
+              throw new Error(
+                `The storeInboxMessage function [field: storeInboxMessage] was unable to be resolved from the GQL context for the Bulk Edit operations. Ensure that the service uses the Transactional Inbox-Outbox implementation.`,
+              );
+            }
+
             const longLivedToken = await getLongLivedToken(
               jwtToken as string,
               config as BasicDBConfig,
@@ -178,12 +224,17 @@ export const BulkEditAsyncPluginFactory = (
               resolveInfo.schema,
             );
 
-            const { set, relatedEntitiesToRemove, relatedEntitiesToAdd } =
-              input;
+            const {
+              set,
+              relatedEntitiesToClear,
+              relatedEntitiesToRemove,
+              relatedEntitiesToAdd,
+            } = input;
 
-            const { removals, additions } = getFkResolverPayload(
+            const { clears, removals, additions } = getFkResolverPayload(
               build,
               pgTable,
+              relatedEntitiesToClear,
               relatedEntitiesToRemove,
               relatedEntitiesToAdd,
               excludedForeignKeyRelations,
@@ -192,6 +243,7 @@ export const BulkEditAsyncPluginFactory = (
             await asyncResolverImplementation(
               {
                 set: getMainResolverPayload(build, pgTable, set),
+                clears,
                 removals,
                 additions,
               },
@@ -276,12 +328,27 @@ interface FkResolverPayload {
   [fKTableName: string]: {
     parentKeyColumnName: string;
     fkGqlFieldNameToColumnNameMap: { [key: string]: string };
-    inputData?: [{ [key: string]: any }];
+    inputData?: { [key: string]: any }[];
   };
 }
 
+/**
+ * Metadata for clearing all entities in a foreign key relation
+ */
+interface FkClearPayload {
+  [fKTableName: string]: {
+    parentKeyColumnName: string;
+    shouldClear: boolean;
+  };
+}
+
+/**
+ * Complete payload for bulk item change operations
+ * Contains metadata for all possible actions: set, clear, remove, and add
+ */
 interface BulkItemChangePayload {
   set: MainResolverPayload;
+  clears: FkClearPayload;
   removals: FkResolverPayload;
   additions: FkResolverPayload;
 }
@@ -304,24 +371,40 @@ function getMainResolverPayload(
   };
 }
 
-// TODO: Can be potentially optimized (i.e. with getAffectedForeignKeyRelations or with asyncResolverImplementation)
+/**
+ * Processes foreign key relation inputs and converts them into structured payloads
+ * for additions, removals, and clears operations.
+ *
+ * @returns Object containing metadata for all FK operations:
+ *  - clears: Boolean flags for clearing all entities in a relation
+ *  - removals: Specific entities to remove from relations
+ *  - additions: Specific entities to add to relations
+ *
+ * TODO: Can be potentially optimized (i.e. with getAffectedForeignKeyRelations or with asyncResolverImplementation)
+ */
 function getFkResolverPayload(
   build: Build,
   pgTable: PgClass,
+  relatedEntitiesToClear:
+    | {
+        [key: string]: boolean;
+      }
+    | undefined,
   relatedEntitiesToRemove:
     | {
-        [key: string]: [any];
+        [key: string]: any[];
       }
     | undefined,
   relatedEntitiesToAdd:
     | {
-        [key: string]: [any];
+        [key: string]: any[];
       }
     | undefined,
   excludedForeignKeyRelations?: string[],
 ): {
-  additions: FkResolverPayload;
+  clears: FkClearPayload;
   removals: FkResolverPayload;
+  additions: FkResolverPayload;
 } {
   const inflection: Inflection = build.inflection;
   const foreignKeyRelations = getAffectedForeignKeyRelations(
@@ -354,35 +437,51 @@ function getFkResolverPayload(
     };
   }
 
-  const additions: FkResolverPayload = {};
+  const clears: FkClearPayload = {};
   const removals: FkResolverPayload = {};
+  const additions: FkResolverPayload = {};
 
   for (const fkProps of Object.keys(fkProcessingMetadata)) {
-    if (relatedEntitiesToAdd) {
-      additions[fkProps] = {
+    if (relatedEntitiesToClear) {
+      const shouldClear =
+        relatedEntitiesToClear[fkProcessingMetadata[fkProps].fkGqlFieldName];
+      if (shouldClear) {
+        clears[fkProps] = {
+          parentKeyColumnName:
+            fkProcessingMetadata[fkProps].parentKeyColumnName,
+          shouldClear: true,
+        };
+      }
+    }
+
+    if (relatedEntitiesToRemove) {
+      removals[fkProps] = {
         parentKeyColumnName: fkProcessingMetadata[fkProps].parentKeyColumnName,
         inputData:
-          relatedEntitiesToAdd[fkProcessingMetadata[fkProps].fkGqlFieldName],
+          relatedEntitiesToRemove[fkProcessingMetadata[fkProps].fkGqlFieldName],
         fkGqlFieldNameToColumnNameMap:
           fkProcessingMetadata[fkProps].fkGqlFieldNameToColumnNameMap,
       };
     }
-
-    if (relatedEntitiesToRemove) {
-      removals[fkProps] = {
+    if (relatedEntitiesToAdd) {
+      additions[fkProps] = {
         parentKeyColumnName: fkProcessingMetadata[fkProps].parentKeyColumnName,
         inputData:
-          relatedEntitiesToRemove[fkProcessingMetadata[fkProps].fkGqlFieldName],
+          relatedEntitiesToAdd[fkProcessingMetadata[fkProps].fkGqlFieldName],
         fkGqlFieldNameToColumnNameMap:
           fkProcessingMetadata[fkProps].fkGqlFieldNameToColumnNameMap,
       };
     }
   }
 
-  return { additions, removals };
+  return { clears, removals, additions };
 }
 
-async function asyncResolverImplementation(
+/**
+ * Exported for testing purposes
+ * @internal
+ */
+export async function asyncResolverImplementation(
   bulkItemChangePayload: BulkItemChangePayload,
   entityIds: string[],
   config: MinimalConfig,
@@ -402,10 +501,14 @@ async function asyncResolverImplementation(
     IsolationLevel.ReadCommitted,
     pgSettings,
     async (txn) => {
-      // Iterate all the entity IDs
+      // Process each entity ID and send messages in this order:
+      // 1. SET_FIELD_VALUES (update main entity fields)
+      // 2. CLEAR_RELATED_ENTITIES (clear all FK relations)
+      // 3. REMOVE_RELATED_ENTITY (remove specific FK entities, skip if cleared)
+      // 4. ADD_RELATED_ENTITY (add new FK entities)
       for (const entity_id of entityIds) {
+        // SET_FIELD_VALUES
         if (bulkItemChangePayload.set.inputData) {
-          // Generate the SET_FIELD_VALUES payload
           const actionSetPayload: PerformItemChangeCommand = {
             table_name: bulkItemChangePayload.set.mainTableName,
             action: 'SET_FIELD_VALUES',
@@ -429,15 +532,52 @@ async function asyncResolverImplementation(
           );
         }
 
+        // CLEAR_RELATED_ENTITIES - Process clears FIRST before any deletions
+        const clearedRelations = new Set<string>();
+        if (bulkItemChangePayload.clears) {
+          const fkTableNames = Object.keys(bulkItemChangePayload.clears);
+
+          for (const fkTableName of fkTableNames) {
+            const fkClearMetadata = bulkItemChangePayload.clears[fkTableName];
+
+            if (fkClearMetadata.shouldClear) {
+              clearedRelations.add(fkTableName); // Track cleared relations
+
+              const clearPayload: PerformItemChangeCommand = {
+                table_name: fkTableName,
+                action: 'CLEAR_RELATED_ENTITIES',
+                stringified_condition: JSON.stringify({
+                  [fkClearMetadata.parentKeyColumnName]: entity_id,
+                }),
+                stringified_payload: JSON.stringify({}),
+              };
+
+              // TODO: Add a DEBUG log for `clearPayload`
+
+              await sendMessage(
+                config,
+                storeInboxMessage,
+                clearPayload,
+                txn,
+                longLivedToken,
+              );
+            }
+          }
+        }
+
+        // REMOVE_RELATED_ENTITY - Skip if relation is being cleared
         if (bulkItemChangePayload.removals) {
           const fkTableNames = Object.keys(bulkItemChangePayload.removals);
 
-          // Iterate each related FK table where entities will be removed
           for (const fkTableName of fkTableNames) {
+            // Skip if this relation is being cleared (optimization)
+            if (clearedRelations.has(fkTableName)) {
+              continue;
+            }
+
             const fkRemovalMetadata =
               bulkItemChangePayload.removals[fkTableName];
             if (fkRemovalMetadata.inputData) {
-              // Generate the REMOVE_RELATED_ENTITY payload per entity of the FK table
               for (const itemToRemove of fkRemovalMetadata.inputData) {
                 const removePayload: PerformItemChangeCommand = {
                   table_name: fkTableName,
@@ -466,17 +606,17 @@ async function asyncResolverImplementation(
           }
         }
 
-        if (Object.keys(bulkItemChangePayload.additions).length > 0) {
-          const fkTables = Object.keys(bulkItemChangePayload.additions);
+        // ADD_RELATED_ENTITY
+        if (bulkItemChangePayload.additions) {
+          const fkTableNames = Object.keys(bulkItemChangePayload.additions);
 
-          // Iterate each related FK table where entities will be added
-          for (const fkTable of fkTables) {
-            const fkAdditionMetadata = bulkItemChangePayload.additions[fkTable];
+          for (const fkTableName of fkTableNames) {
+            const fkAdditionMetadata =
+              bulkItemChangePayload.additions[fkTableName];
             if (fkAdditionMetadata.inputData) {
-              // Generate the ADD_RELATED_ENTITY payload per entity of the FK table
               for (const itemToAdd of fkAdditionMetadata.inputData) {
                 const addPayload: PerformItemChangeCommand = {
-                  table_name: fkTable,
+                  table_name: fkTableName,
                   action: 'ADD_RELATED_ENTITY',
                   stringified_condition: '',
                   stringified_payload: JSON.stringify({
@@ -549,6 +689,41 @@ function mapGqlInputObjectToSqlColumnNames(
   }, {});
 }
 
+// Generate input type for clearing FK relations (boolean flags)
+function generateClearInputTypeForFKs(
+  build: Build,
+  pgTable: PgClass,
+  excludedForeignKeyRelations?: string[],
+): GraphQLInputObjectType {
+  const inflection: Inflection = build.inflection;
+  const clearInputFieldsMap: GraphQL.Thunk<GraphQL.GraphQLInputFieldConfigMap> =
+    {};
+
+  // Filter only the interesting FK relations
+  const foreignKeyRelations = getAffectedForeignKeyRelations(
+    pgTable,
+    excludedForeignKeyRelations,
+  );
+
+  for (const fkConstraint of foreignKeyRelations) {
+    // Add a boolean field for each FK relation
+    clearInputFieldsMap[inflection.allRows(fkConstraint.class)] = {
+      type: GraphQLBoolean,
+    };
+  }
+
+  const ClearInputType = new GraphQLInputObjectType({
+    name: `BulkEditAsync${inflection.tableType(pgTable)}ClearInput`,
+    fields: () => ({
+      ...clearInputFieldsMap,
+    }),
+  });
+
+  build.addType(ClearInputType);
+
+  return ClearInputType;
+}
+
 // TODO: Handle `insertable` | `deletable` GRANTS for FK Relations
 function generateInputTypeForFKs(
   build: Build,