@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.7

package/src/generic/RunViewResolver.ts

@@ -209,6 +209,13 @@ export class RunViewByIDInput {
   })
   IncludeBinaryFields?: boolean;
 
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'Optional, when true the provider does not run a count to populate TotalRowCount, which then comes back null. Ignored for ResultType count_only.',
+  })
+  SkipTotalRowCount?: boolean;
+
   @Field(() => String, {
     nullable: true,
     description:
@@ -351,6 +358,13 @@ export class RunViewByNameInput {
   })
   IncludeBinaryFields?: boolean;
 
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'Optional, when true the provider does not run a count to populate TotalRowCount, which then comes back null. Ignored for ResultType count_only.',
+  })
+  SkipTotalRowCount?: boolean;
+
   @Field(() => String, {
     nullable: true,
     description:
@@ -479,6 +493,13 @@ export class RunDynamicViewInput {
   })
   IncludeBinaryFields?: boolean;
 
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'Optional, when true the provider does not run a count to populate TotalRowCount, which then comes back null. Ignored for ResultType count_only.',
+  })
+  SkipTotalRowCount?: boolean;
+
   @Field(() => String, {
     nullable: true,
     description:
@@ -629,6 +650,13 @@ export class RunViewGenericInput {
   })
   IncludeBinaryFields?: boolean;
 
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'Optional, when true the provider does not run a count to populate TotalRowCount, which then comes back null. Ignored for ResultType count_only.',
+  })
+  SkipTotalRowCount?: boolean;
+
   @Field(() => String, {
     nullable: true,
     description:
@@ -1328,6 +1356,7 @@ export class RunViewResolver extends ResolverBase {
           DataSource: item.params.DataSource,
           AlternateBaseView: item.params.AlternateBaseView,
           IncludeBinaryFields: item.params.IncludeBinaryFields,
+          SkipTotalRowCount: item.params.SkipTotalRowCount,
           // BypassCache likewise — the input type (RunDynamicViewInput) has always declared it, and its
           // own description promises "the pre-check cache lookup is skipped". Dropping it here left the
           // provider free to answer a deliberate database read from the server cache.
@@ -1346,66 +1375,84 @@ export class RunViewResolver extends ResolverBase {
 
       const response = await sqlProvider.RunViewsWithCacheCheck(coreParams, userPayload.userRecord);
 
-      // Transform results to include processed data rows
-      const transformedResults: RunViewWithCacheCheckResultOutput[] = response.results.map((result, index) => {
-        const inputItem = input[index];
-        const entity = inputItem.params.EntityName ? provider.EntityByName(inputItem.params.EntityName) : undefined;
-
-        // If we have differential data but no entity, that's a configuration error
-        if (result.status === 'differential' && result.differentialData && !entity) {
-          throw new Error(
-            `Entity '${inputItem.params.EntityName}' not found in provider metadata but server returned differential data. ` +
-            `This may indicate a metadata sync issue.`
-          );
+      // Transform results to include processed data rows (applying API encryption policy on copies)
+      const protectRawRows = async (
+        entity: EntityInfo,
+        rows: object[]
+      ): Promise<Record<string, string | number | boolean | Date | Uint8Array | null | undefined>[]> => {
+        type RawRow = Record<string, string | number | boolean | Date | Uint8Array | null | undefined>;
+        const typedRows = rows as RawRow[];
+        if (!typedRows.length || !entity.EncryptedFields.some((field) => !field.AllowDecryptInAPI)) {
+          return typedRows;
         }
+        const shallowCopies: RawRow[] = typedRows.map((row) => ({ ...row }));
+        await this.ArrayFilterEncryptedFieldsForAPI(entity.Name, shallowCopies, user, provider, 'Name');
+        return shallowCopies;
+      };
 
-        if (result.status === 'differential' && result.differentialData && entity) {
-          // Process differential data into GraphQL-compatible format
-          const processedUpdatedRows = this.processRawData(
-            result.differentialData.updatedRows as Record<string, unknown>[],
-            entity.ID,
-            entity
-          );
-          return {
-            viewIndex: result.viewIndex,
-            status: result.status,
-            Results: undefined,
-            differentialData: {
-              updatedRows: processedUpdatedRows,
-              deletedRecordIDs: result.differentialData.deletedRecordIDs,
-            },
-            maxUpdatedAt: result.maxUpdatedAt,
-            rowCount: result.rowCount,
-            errorMessage: result.errorMessage,
-          };
-        }
+      const transformedResults: RunViewWithCacheCheckResultOutput[] = await Promise.all(
+        response.results.map(async (result, index) => {
+          const inputItem = input[index];
+          const entity = inputItem.params.EntityName ? provider.EntityByName(inputItem.params.EntityName) : undefined;
+
+          // If we have differential data but no entity, that's a configuration error
+          if (result.status === 'differential' && result.differentialData && !entity) {
+            throw new Error(
+              `Entity '${inputItem.params.EntityName}' not found in provider metadata but server returned differential data. ` +
+              `This may indicate a metadata sync issue.`
+            );
+          }
+
+          if (result.status === 'differential' && result.differentialData && entity) {
+            // Apply API encryption filtering before serializing differential rows
+            const filteredUpdatedRows = await protectRawRows(entity, result.differentialData.updatedRows as object[]);
+            const processedUpdatedRows = this.processRawData(
+              filteredUpdatedRows,
+              entity.ID,
+              entity
+            );
+            return {
+              viewIndex: result.viewIndex,
+              status: result.status,
+              Results: undefined,
+              differentialData: {
+                updatedRows: processedUpdatedRows,
+                deletedRecordIDs: result.differentialData.deletedRecordIDs,
+              },
+              maxUpdatedAt: result.maxUpdatedAt,
+              rowCount: result.rowCount,
+              errorMessage: result.errorMessage,
+            };
+          }
+
+          if (result.status === 'stale' && result.results && entity) {
+            // Apply API encryption filtering before serializing full refresh rows
+            const filteredRows = await protectRawRows(entity, result.results as object[]);
+            const processedRows = this.processRawData(filteredRows, entity.ID, entity);
+            return {
+              viewIndex: result.viewIndex,
+              status: result.status,
+              Results: processedRows,
+              differentialData: undefined,
+              maxUpdatedAt: result.maxUpdatedAt,
+              rowCount: result.rowCount,
+              errorMessage: result.errorMessage,
+              // Same serializer the regular RunView path uses (value → JSON string).
+              aggregateResults: this.processAggregateResults(result.aggregateResults),
+            };
+          }
 
-        if (result.status === 'stale' && result.results && entity) {
-          // Process raw data into GraphQL-compatible format (full refresh)
-          const processedRows = this.processRawData(result.results as Record<string, unknown>[], entity.ID, entity);
           return {
             viewIndex: result.viewIndex,
             status: result.status,
-            Results: processedRows,
+            Results: undefined,
             differentialData: undefined,
             maxUpdatedAt: result.maxUpdatedAt,
             rowCount: result.rowCount,
             errorMessage: result.errorMessage,
-            // Same serializer the regular RunView path uses (value → JSON string).
-            aggregateResults: this.processAggregateResults(result.aggregateResults),
           };
-        }
-
-        return {
-          viewIndex: result.viewIndex,
-          status: result.status,
-          Results: undefined,
-          differentialData: undefined,
-          maxUpdatedAt: result.maxUpdatedAt,
-          rowCount: result.rowCount,
-          errorMessage: result.errorMessage,
-        };
-      });
+        })
+      );
 
       return {
         success: response.success,