@memberjunction/server 6.1.4 → 6.1.5

package/src/services/TaskGraphActionRunner.ts

@@ -75,25 +75,26 @@ export class TaskGraphActionRunner implements TaskActionRunner {
     }
 
     /**
-     * Rebuilds the action's parameters from the task's stored payload.
+     * Rebuilds the action's parameters from the task's input, one parameter per key.
      *
-     * **The values here have been through redaction**, because `Task.InputPayload` is persistent,
-     * user-visible storage and nothing writes a raw `ActionParam[]` there. A parameter the binding
-     * marked as not-logged therefore arrives absent rather than secret — the action sees a missing
-     * value, which is the honest consequence of choosing not to persist it, and the reason durable
-     * dispatch is opt-in per binding rather than the default.
+     * For a **durable entity-action** graph the input was written by `RedactParamsToRecord`
+     * (`@memberjunction/actions-base`) at deferral time, so its values have been through redaction:
+     * a parameter the binding marked as not-logged arrives absent rather than secret — the action
+     * sees a missing value, which is the honest consequence of choosing not to persist it, and the
+     * reason durable dispatch is opt-in per binding rather than the default. Every other graph's
+     * input is whatever its spec authored. This method re-applies no redaction rule in either case.
      *
-     * Dependency outputs are merged underneath the task's own input so a node's explicit parameters
-     * always win over an upstream node that happened to emit the same key.
+     * `InputPayload` already carries the dependency outputs: the dispatcher merges them underneath
+     * the task's own input (`mergedPayload`) before calling this runner, so a node's explicit
+     * parameters win and a step with an input mapping gets exactly the parameters it declared.
+     * `DependencyOutputs` is keyed by upstream task ID, not by parameter name, so it is deliberately
+     * not read here — spreading it would hand the action one extra parameter per dependency, named
+     * by a GUID and holding that task's whole output.
      */
     private buildParams(params: TaskActionRunParams): ActionParam[] {
-        const merged: Record<string, unknown> = {};
-        for (const [name, value] of params.DependencyOutputs) {
-            merged[name] = value;
+        if (!params.InputPayload || typeof params.InputPayload !== 'object') {
+            return [];
         }
-        if (params.InputPayload && typeof params.InputPayload === 'object') {
-            Object.assign(merged, params.InputPayload as Record<string, unknown>);
-        }
-        return Object.entries(merged).map(([Name, Value]) => ({ Name, Value, Type: 'Input' }));
+        return Object.entries(params.InputPayload as Record<string, unknown>).map(([Name, Value]) => ({ Name, Value, Type: 'Input' }));
     }
 }

package/dist/resolvers/adhoc-query-helpers.d.ts

@@ -1,27 +0,0 @@
-/**
- * Pure, dependency-free helpers for {@link AdhocQueryResolver}. Kept in their own
- * module (no type-graphql / mssql imports) so the total-row-count boundary logic is
- * unit-testable without standing up the GraphQL resolver or a database.
- */
-/**
- * Determines the exact total row count from the page alone, when it can be known
- * without a separate `COUNT(*)`:
- *
- * - **Not paging** (`maxRows == null`): the query ran uncapped, so every row came
- *   back — the total is just the number returned.
- * - **Short page** (`pageLength < maxRows`): a page shorter than the page size means
- *   there are no rows beyond it, so the total is `startRow + pageLength` exactly.
- * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
- *   signal that a `COUNT(*)` is required to know the true total.
- */
-export declare function exactTotalFromPage(startRow: number, pageLength: number, maxRows: number | null): number | null;
-/**
- * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
- * falling back to `fallback` when the count is absent, non-numeric, or negative — so
- * an unexpected count shape never yields a misleading total. `fallback` should be a
- * safe lower bound (e.g. `startRow + rowsReturned`).
- */
-export declare function resolveAdhocTotalRowCount(countRows: ReadonlyArray<{
-    TotalRowCount?: unknown;
-}> | null | undefined, fallback: number): number;
-//# sourceMappingURL=adhoc-query-helpers.d.ts.map

package/dist/resolvers/adhoc-query-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adhoc-query-helpers.d.ts","sourceRoot":"","sources":["../../src/resolvers/adhoc-query-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,IAAI,GACvB,MAAM,GAAG,IAAI,CAQf;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACrC,SAAS,EAAE,aAAa,CAAC;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EACxE,QAAQ,EAAE,MAAM,GACjB,MAAM,CASR"}

package/dist/resolvers/adhoc-query-helpers.js

@@ -1,42 +0,0 @@
-/**
- * Pure, dependency-free helpers for {@link AdhocQueryResolver}. Kept in their own
- * module (no type-graphql / mssql imports) so the total-row-count boundary logic is
- * unit-testable without standing up the GraphQL resolver or a database.
- */
-/**
- * Determines the exact total row count from the page alone, when it can be known
- * without a separate `COUNT(*)`:
- *
- * - **Not paging** (`maxRows == null`): the query ran uncapped, so every row came
- *   back — the total is just the number returned.
- * - **Short page** (`pageLength < maxRows`): a page shorter than the page size means
- *   there are no rows beyond it, so the total is `startRow + pageLength` exactly.
- * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
- *   signal that a `COUNT(*)` is required to know the true total.
- */
-export function exactTotalFromPage(startRow, pageLength, maxRows) {
-    if (maxRows == null) {
-        return pageLength;
-    }
-    if (pageLength < maxRows) {
-        return startRow + pageLength;
-    }
-    return null;
-}
-/**
- * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
- * falling back to `fallback` when the count is absent, non-numeric, or negative — so
- * an unexpected count shape never yields a misleading total. `fallback` should be a
- * safe lower bound (e.g. `startRow + rowsReturned`).
- */
-export function resolveAdhocTotalRowCount(countRows, fallback) {
-    const raw = countRows?.[0]?.TotalRowCount;
-    if (raw != null) {
-        const n = Number(raw);
-        if (Number.isFinite(n) && n >= 0) {
-            return Math.floor(n);
-        }
-    }
-    return fallback;
-}
-//# sourceMappingURL=adhoc-query-helpers.js.map

package/dist/resolvers/adhoc-query-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"adhoc-query-helpers.js","sourceRoot":"","sources":["../../src/resolvers/adhoc-query-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAC9B,QAAgB,EAChB,UAAkB,EAClB,OAAsB;IAEtB,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,UAAU,CAAC;IACtB,CAAC;IACD,IAAI,UAAU,GAAG,OAAO,EAAE,CAAC;QACvB,OAAO,QAAQ,GAAG,UAAU,CAAC;IACjC,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACrC,SAAwE,EACxE,QAAgB;IAEhB,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC;IAC1C,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QACd,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QACtB,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC"}

package/src/__tests__/adhoc-query-helpers.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { exactTotalFromPage, resolveAdhocTotalRowCount } from '../resolvers/adhoc-query-helpers';
-
-describe('exactTotalFromPage', () => {
-    it('returns the row count when not paging (maxRows null) — the query was uncapped', () => {
-        expect(exactTotalFromPage(0, 47, null)).toBe(47);
-        expect(exactTotalFromPage(0, 0, null)).toBe(0);
-    });
-
-    it('returns startRow + pageLength for a SHORT page (fewer rows than the page size)', () => {
-        expect(exactTotalFromPage(0, 47, 100)).toBe(47);   // page 1, short → exact total
-        expect(exactTotalFromPage(200, 30, 100)).toBe(230); // page 3, short last page
-        expect(exactTotalFromPage(100, 0, 100)).toBe(100);  // empty page past the end
-    });
-
-    it('returns null for a FULL page — a COUNT is required because more rows may exist', () => {
-        expect(exactTotalFromPage(0, 100, 100)).toBeNull();
-        expect(exactTotalFromPage(500, 100, 100)).toBeNull();
-    });
-
-    it('treats an over-full page defensively as "needs count" (should not occur with OFFSET/FETCH)', () => {
-        expect(exactTotalFromPage(0, 150, 100)).toBeNull();
-    });
-});
-
-describe('resolveAdhocTotalRowCount', () => {
-    it('reads TotalRowCount from the count recordset', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 2087 }], 100)).toBe(2087);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 0 }], 100)).toBe(0);
-    });
-
-    it('floors a fractional/stringified count', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: 42.9 }], 0)).toBe(42);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: '2087' as unknown as number }], 0)).toBe(2087);
-    });
-
-    it('falls back when the count is absent, empty, null, or malformed', () => {
-        expect(resolveAdhocTotalRowCount(null, 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount(undefined, 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{}], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: null }], 100)).toBe(100);
-    });
-
-    it('falls back on non-finite or negative counts (never reports a misleading total)', () => {
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: Number.NaN }], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: -5 }], 100)).toBe(100);
-        expect(resolveAdhocTotalRowCount([{ TotalRowCount: Infinity }], 100)).toBe(100);
-    });
-});

package/src/resolvers/adhoc-query-helpers.ts

@@ -1,50 +0,0 @@
-/**
- * Pure, dependency-free helpers for {@link AdhocQueryResolver}. Kept in their own
- * module (no type-graphql / mssql imports) so the total-row-count boundary logic is
- * unit-testable without standing up the GraphQL resolver or a database.
- */
-
-/**
- * Determines the exact total row count from the page alone, when it can be known
- * without a separate `COUNT(*)`:
- *
- * - **Not paging** (`maxRows == null`): the query ran uncapped, so every row came
- *   back — the total is just the number returned.
- * - **Short page** (`pageLength < maxRows`): a page shorter than the page size means
- *   there are no rows beyond it, so the total is `startRow + pageLength` exactly.
- * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
- *   signal that a `COUNT(*)` is required to know the true total.
- */
-export function exactTotalFromPage(
-    startRow: number,
-    pageLength: number,
-    maxRows: number | null,
-): number | null {
-    if (maxRows == null) {
-        return pageLength;
-    }
-    if (pageLength < maxRows) {
-        return startRow + pageLength;
-    }
-    return null;
-}
-
-/**
- * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
- * falling back to `fallback` when the count is absent, non-numeric, or negative — so
- * an unexpected count shape never yields a misleading total. `fallback` should be a
- * safe lower bound (e.g. `startRow + rowsReturned`).
- */
-export function resolveAdhocTotalRowCount(
-    countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
-    fallback: number,
-): number {
-    const raw = countRows?.[0]?.TotalRowCount;
-    if (raw != null) {
-        const n = Number(raw);
-        if (Number.isFinite(n) && n >= 0) {
-            return Math.floor(n);
-        }
-    }
-    return fallback;
-}