@memberjunction/server 6.2.0-edge.2 → 6.2.0-edge.4

package/src/services/workQueueConfig.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview The `workQueue` configuration section. Kept out of config.ts so it can be tested without
+ * config.ts's module-load database validation.
+ * @module MJServer/services
+ */
+import { z } from 'zod';
+
+export const WorkQueueSubscriptionEntrySchema = z.object({
+  /** A subscription name, or '*' for every MJWorker subscription. */
+  name: z.string().min(1),
+  /** Deliveries this instance processes concurrently for the subscription. */
+  concurrency: z.number().int().positive().optional().default(4),
+});
+
+/**
+ * Durable work-queue host. When enabled, this process runs its share of MJWorker subscriptions. Every claim is atomic
+ * against shared state, so any number of instances may enable it against one database.
+ */
+export const WorkQueueSchema = z
+  .object({
+    enabled: z.boolean().optional().default(false),
+    systemUserEmail: z.string().optional().default('system@memberjunction.org'),
+    subscriptions: z.array(WorkQueueSubscriptionEntrySchema).optional().default([{ name: '*', concurrency: 4 }]),
+    idlePollMinMs: z.number().int().positive().optional().default(250),
+    idlePollMaxMs: z.number().int().positive().optional().default(5000),
+    shutdownDrainMs: z.number().int().nonnegative().optional().default(8000),
+    sweeperEnabled: z.boolean().optional().default(true),
+    sweeperIntervalMs: z.number().int().positive().optional().default(60000),
+    reconcileIntervalMs: z.number().int().nonnegative().optional().default(30000),
+  })
+  .refine(config => config.idlePollMaxMs >= config.idlePollMinMs, {
+    message: 'workQueue.idlePollMaxMs must be >= workQueue.idlePollMinMs',
+    path: ['idlePollMaxMs'],
+  });
+
+export type WorkQueueConfig = z.infer<typeof WorkQueueSchema>;
+
+/**
+ * The merge base for mj.config.cjs. Like scheduledJobs and integrationSyncWorker, the EFFECTIVE default system user
+ * is the placeholder: set workQueue.systemUserEmail explicitly, or StartWorkQueueHost fails fast and says so.
+ */
+export const DEFAULT_WORK_QUEUE_CONFIG: WorkQueueConfig = {
+  enabled: false,
+  systemUserEmail: 'not.set@nowhere.com',
+  subscriptions: [{ name: '*', concurrency: 4 }],
+  idlePollMinMs: 250,
+  idlePollMaxMs: 5000,
+  shutdownDrainMs: 8000,
+  sweeperEnabled: true,
+  sweeperIntervalMs: 60000,
+  reconcileIntervalMs: 30000,
+};

package/src/sharedCache.ts

@@ -0,0 +1,302 @@
+/**
+ * Everything an MJAPI process does with its shared (Redis) connection: which provider to build,
+ * what it publishes, what it does with events from other servers, and which periodic jobs the
+ * connection's leases coordinate.
+ *
+ * Two independent consumers share the one connection and its one subscriber:
+ * {@link WireSharedCacheEvents} for cache invalidation, and {@link WirePushStatusFanOut} for
+ * cross-instance push-status delivery (MJ #4222). Both live here rather than at the call site so
+ * that "what is our Redis used for" has a single answer.
+ *
+ */
+import { BaseEngineSweeper, CacheCategory, LocalCacheManager, LogError, LogStatusEx } from '@memberjunction/core';
+import type { CacheChangedEvent, LocalCacheManagerConfig, ProviderBase } from '@memberjunction/core';
+import type { CacheSettingsConfig } from './config.js';
+import { RedisLocalStorageProvider } from '@memberjunction/redis-provider';
+import type { CachePublishMode } from '@memberjunction/redis-provider';
+import { MJGlobal } from '@memberjunction/global';
+import { PubSubManager } from './generic/PubSubManager.js';
+import { PUSH_STATUS_UPDATES_TOPIC, SetPushStatusPublishHook, ParseReplicatedStatusUpdate } from './generic/PushStatusResolver.js';
+import { CACHE_INVALIDATION_TOPIC } from './generic/CacheInvalidationResolver.js';
+import { UserCache } from '@memberjunction/generic-database-provider';
+
+/**
+ * What an MJAPI process publishes, per category.
+ *
+ * - RunView slots carry their rows: engines on other servers apply them directly.
+ * - Writes without a category (the provider's metadata snapshot, ~2 MB compressed) publish a
+ *   notice only: other servers re-check their metadata against the database and adopt the shared
+ *   snapshot, so the value never needs to travel.
+ * - Everything else (dataset slots, query slots, registry) has no subscriber and publishes nothing.
+ * Category clears are always published.
+ */
+export const MJAPI_PUBLISH_MODES: Readonly<Record<string, CachePublishMode>> = {
+    [CacheCategory.RunViewCache]: 'full',
+    [CacheCategory.Default]: 'notice',
+};
+
+/** Options for {@link CreateSharedCacheProvider}. */
+export interface SharedCacheProviderOptions {
+    Url: string;
+    KeyPrefix: string;
+    DefaultTTLSeconds?: number;
+    EnableLogging: boolean;
+}
+
+/**
+ * Expiry for the shared Redis cache: `REDIS_TTL_SECONDS` when it holds a non-negative integer,
+ * otherwise `cacheSettings.sharedCacheTTLSeconds`, otherwise `undefined` (the provider's default).
+ */
+export function ResolveSharedCacheTTLSeconds(configured: number | undefined, env: NodeJS.ProcessEnv = process.env): number | undefined {
+  const fromEnv = env.REDIS_TTL_SECONDS;
+  if (fromEnv !== undefined && fromEnv.trim() !== '') {
+    const parsed = Number(fromEnv);
+    if (Number.isInteger(parsed) && parsed >= 0) {
+      return parsed;
+    }
+    console.warn(`REDIS_TTL_SECONDS="${fromEnv}" is not a non-negative integer; ignoring it`);
+  }
+  return configured;
+}
+
+/**
+ * The shared cache the environment asks for (`REDIS_URL`, `REDIS_KEY_PREFIX`, `REDIS_TTL_SECONDS`),
+ * or null. Built before the database provider so metadata and startup engines use it from the
+ * first read.
+ */
+export function CreateSharedCacheFromEnvironment(settings: CacheSettingsConfig | undefined, env: NodeJS.ProcessEnv = process.env): RedisLocalStorageProvider | null {
+    if (!env.REDIS_URL) {
+        return null;
+    }
+    return CreateSharedCacheProvider({
+        Url: env.REDIS_URL,
+        KeyPrefix: env.REDIS_KEY_PREFIX || 'mj',
+        DefaultTTLSeconds: ResolveSharedCacheTTLSeconds(settings?.sharedCacheTTLSeconds, env),
+        EnableLogging: settings?.verboseLogging ?? false,
+    });
+}
+
+/**
+ * The warm-up lease MJAPI hands to `StartupManager`, in milliseconds, from
+ * `cacheSettings.startupWarmupLeaseSeconds` (default 30).
+ */
+export function WarmupLeaseMsFromSettings(settings: CacheSettingsConfig | undefined): number {
+    return (settings?.startupWarmupLeaseSeconds ?? 30) * 1000;
+}
+
+/** `LocalCacheManager` settings from `cacheSettings` in mj.config.cjs. */
+export function CacheManagerConfigFromSettings(settings: CacheSettingsConfig | undefined): Partial<LocalCacheManagerConfig> {
+    return {
+        maxSizeBytes: (settings?.maxMemoryMB ?? 150) * 1024 * 1024,
+        maxPercentOfCachePerEntity: settings?.maxPercentOfCachePerEntity ?? 50,
+        defaultTTLMs: (settings?.defaultTTLSeconds ?? 0) * 1000,
+        evictionSweepIntervalMs: (settings?.evictionSweepIntervalSeconds ?? 300) * 1000,
+        verboseLogging: settings?.verboseLogging ?? false,
+    };
+}
+
+/**
+ * Starts the periodic engine-vs-database sweep (plan Phase 3.1) at
+ * `cacheSettings.engineSweepIntervalSeconds` (default 300; 0 leaves it off).
+ * @returns The interval in milliseconds, 0 when disabled.
+ */
+export function StartEngineSweeper(settings: CacheSettingsConfig | undefined): number {
+    const intervalMs = (settings?.engineSweepIntervalSeconds ?? 300) * 1000;
+    BaseEngineSweeper.Instance.Start(intervalMs);
+    return intervalMs;
+}
+
+/** The periodic metadata sweep, so a restart or a config change can replace it. @internal */
+let metadataSweepTimer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Starts the periodic metadata-vs-database sweep at `cacheSettings.metadataSweepIntervalSeconds`
+ * (default 300; 0 leaves it off).
+ *
+ * The sweep asks the database **nothing** unless one of the entities the metadata is built from
+ * declares `TrustServerCacheCompletely = false` — see `ProviderBase.SweepMetadataAgainstDatabase`.
+ * On a stock installation no metadata entity declares it, so the timer ticks and costs nothing. It
+ * exists for installations that write metadata tables directly, where no event is ever raised and
+ * nothing else would notice.
+ *
+ * One process per interval does the work, via a shared lease: a process that refreshes writes a new
+ * snapshot and publishes a notice, which the others act on, so there is no value in each of them
+ * asking the database the same question.
+ *
+ * @returns The interval in milliseconds, 0 when disabled.
+ */
+export function StartMetadataSweep(settings: CacheSettingsConfig | undefined, metadataProvider: () => ProviderBase | undefined): number {
+    if (metadataSweepTimer) {
+        clearInterval(metadataSweepTimer);
+        metadataSweepTimer = null;
+    }
+    const intervalMs = (settings?.metadataSweepIntervalSeconds ?? 300) * 1000;
+    if (intervalMs <= 0) {
+        return 0;
+    }
+    const leaseMs = Math.max(5_000, intervalMs - 5_000);
+    const timer = setInterval(() => void runMetadataSweep(metadataProvider(), leaseMs), intervalMs);
+    if (typeof timer === 'object' && timer !== null && 'unref' in timer) {
+        (timer as { unref(): void }).unref();
+    }
+    metadataSweepTimer = timer;
+    return intervalMs;
+}
+
+/** One sweep: take the fleet lease only when there is something to check. @internal */
+async function runMetadataSweep(provider: ProviderBase | undefined, leaseMs: number): Promise<void> {
+    if (!provider) {
+        return;
+    }
+    try {
+        // The lease is taken only when an entity declares drift, so a stock installation costs no
+        // Redis round trip either — the provider answers from its own membership set.
+        const declared = provider.MetadataMembersDeclaringDrift();
+        if (declared.length === 0) {
+            return;
+        }
+        if (!(await LocalCacheManager.Instance.TryAcquireSharedLease('metadata-sweep', leaseMs))) {
+            return;
+        }
+        const result = await provider.SweepMetadataAgainstDatabase();
+        if (result.Refreshed) {
+            LogStatusEx({ message: `[MJAPI] metadata sweep reloaded metadata; entities declaring drift: ${result.Declared.join(', ')}`, verboseOnly: false });
+        }
+    } catch (e) {
+        LogError(`[MJAPI] metadata sweep failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+
+/**
+ * Starts the periodic user-cache staleness check at `cacheSettings.userCacheCheckIntervalSeconds`
+ * (default 300; 0 leaves it off). The cache refreshes on MJ writes by itself — this covers users
+ * and roles changed outside MJ.
+ * @returns The interval in milliseconds, 0 when disabled.
+ */
+export function StartUserCacheChecks(settings: CacheSettingsConfig | undefined): number {
+    const intervalMs = (settings?.userCacheCheckIntervalSeconds ?? 300) * 1000;
+    UserCache.Instance.StartStalenessChecks(intervalMs);
+    return intervalMs;
+}
+
+/** Builds the Redis provider MJAPI uses as its shared cache. Pub/sub starts with {@link WireSharedCacheEvents}. */
+export function CreateSharedCacheProvider(options: SharedCacheProviderOptions): RedisLocalStorageProvider {
+    // The provider's own config keys stay as the package declares them.
+    return new RedisLocalStorageProvider({
+        url: options.Url,
+        keyPrefix: options.KeyPrefix,
+        defaultTTLSeconds: options.DefaultTTLSeconds,
+        enablePubSub: true,
+        enableLogging: options.EnableLogging,
+        publishModes: MJAPI_PUBLISH_MODES,
+        defaultPublishMode: 'none',
+    });
+}
+
+/**
+ * Subscribes to other servers' cache events and routes them. Called before the database provider
+ * exists (so engines hear peers while they load); `metadataProvider` is resolved per event.
+ * 1. a metadata-snapshot notice → a metadata staleness check on this process's provider, and
+ *    nothing further (a consumed notice returns here);
+ * 2. every other event → `LocalCacheManager.DispatchCacheChange` (engines, the user cache, and
+ *    RunView callbacks);
+ * 3. RunView slot changes → an entity-level invalidation to connected browsers.
+ */
+export async function WireSharedCacheEvents(redis: RedisLocalStorageProvider, metadataProvider: () => ProviderBase | undefined): Promise<void> {
+    await redis.StartListening();
+    redis.OnCacheChanged((event) => RouteSharedCacheEvent(event, metadataProvider()));
+}
+
+/** One incoming event, routed as described on {@link WireSharedCacheEvents}. */
+export function RouteSharedCacheEvent(event: CacheChangedEvent, metadataProvider: ProviderBase | undefined): void {
+    const source = event.SourceServerId ? event.SourceServerId.substring(0, 8) : 'unknown';
+    LogStatusEx({ message: `[MJAPI] shared cache event: ${event.Category}/${event.Action} "${event.CacheKey}" from ${source}`, verboseOnly: true });
+
+    if (metadataProvider?.HandlePeerMetadataNotice(event)) {
+        return;
+    }
+    LocalCacheManager.Instance.DispatchCacheChange(event);
+    relayRunViewChangeToBrowsers(event);
+}
+
+/**
+ * Browsers only care about entity data. A RunView slot key starts with the entity name
+ * (`Entity|Filter|…`); other categories' keys are not entity names and used to reach browsers as
+ * invalidations for "entities" such as `___MJCore_Metadata_AllMetadata`.
+ */
+function relayRunViewChangeToBrowsers(event: CacheChangedEvent): void {
+    if (event.Category !== CacheCategory.RunViewCache || event.Action === 'category_cleared') {
+        return;
+    }
+    const entityName = event.CacheKey ? event.CacheKey.split('|')[0] : '';
+    if (!entityName) {
+        return;
+    }
+    PubSubManager.Instance.Publish(CACHE_INVALIDATION_TOPIC, {
+        entityName,
+        primaryKeyValues: null, // entity-level invalidation
+        action: event.Action,
+        sourceServerId: event.SourceServerId || 'unknown',
+        timestamp: new Date(),
+    });
+}
+
+/** Redis channel carrying replicated push-status updates between server instances. */
+const PUSH_STATUS_FANOUT_CHANNEL = 'push-status-updates';
+
+/**
+ * Replicate push-status updates across server instances over Redis (MJ #4222).
+ *
+ * Outbound: every locally-published update is forwarded on a shared channel. Inbound: a message
+ * from another instance is republished onto THIS instance's local topic, where the normal
+ * subscription filter decides who receives it — so the identity gate (`ownerUserId` vs. the
+ * connection's authenticated user) still applies to a replicated message exactly as it does to a
+ * local one. The replica has no say in who sees what.
+ *
+ * Republishing goes straight to `PubSubManager`, never back through `publishStatusUpdate`, so an
+ * inbound message cannot be re-broadcast and loop. `SourceServerId` guards the remaining case: a
+ * publisher also receives its own message from Redis.
+ *
+ * The channel rides the same connection and subscriber as cache invalidation, and is namespaced
+ * with the provider's key prefix — so replicas configured with different `REDIS_KEY_PREFIX`
+ * values stop replicating to each other, exactly as their caches do.
+ *
+ * @param redis The shared cache provider, already built by {@link CreateSharedCacheFromEnvironment}.
+ */
+export async function WirePushStatusFanOut(redis: RedisLocalStorageProvider): Promise<void> {
+    try {
+        await redis.SubscribeToChannel(PUSH_STATUS_FANOUT_CHANNEL, (raw: string) => {
+            try {
+                const payload = ParseReplicatedStatusUpdate(raw, MJGlobal.Instance.ProcessUUID);
+                if (!payload) {
+                    return;
+                }
+                // Rebuilt as a plain record: the topic's publish signature takes an index-signature
+                // type, and listing the fields keeps the wire shape explicit at the one place it
+                // crosses hosts.
+                PubSubManager.Instance.Publish(PUSH_STATUS_UPDATES_TOPIC, {
+                    sessionId: payload.sessionId,
+                    ownerUserId: payload.ownerUserId,
+                    message: payload.message,
+                    SourceServerId: payload.SourceServerId,
+                });
+            } catch (err) {
+                // A malformed message on a shared channel must not take down the subscriber.
+                LogError('Error processing push-status fan-out message', undefined, err);
+            }
+        });
+
+        SetPushStatusPublishHook((payload) => {
+            redis.PublishMessage(PUSH_STATUS_FANOUT_CHANNEL, JSON.stringify(payload));
+        });
+
+        // Printed unconditionally, not verbose-gated. "Is fan-out actually on?" is the first
+        // question anyone debugging a hung conversation behind a load balancer asks, and a silent
+        // default left no way to answer it.
+        console.log('[MJAPI] Push-status updates: cross-instance fan-out enabled via Redis');
+    } catch (err) {
+        // Single-instance delivery still works, and the durable tail query covers the rest.
+        // Degraded, not broken — so this must not stop the server from starting.
+        console.warn(`Push-status fan-out unavailable: ${(err as Error).message}`);
+    }
+}

package/src/types.ts

@@ -54,6 +54,13 @@ export type AppContext = {
    * Per-request DatabaseProviderBase instances  
    */
   providers: Array<ProviderInfo>;
+
+  /**
+   * The caller's network address as Express resolved it (`req.ip`, which honours the app's
+   * `trust proxy` setting). Present for HTTP requests; absent on WebSocket (subscription) contexts.
+   * Used only to key abuse limits (e.g. realtime verification sends) — never as an identity.
+   */
+  ClientIp?: string;
 };
 
 export class ProviderInfo {
@@ -121,6 +128,11 @@ export type RunViewGenericParams = {
    * Propagated to `RunViewParams.DataSource`.
    */
   dataSource?: 'Live' | 'Materialized';
+  /**
+   * When true, binary fields (`varbinary` / `bytea`, as base64 strings) are returned.
+   * Propagated to `RunViewParams.IncludeBinaryFields`.
+   */
+  includeBinaryFields?: boolean;
 };
 
 

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

@@ -1,33 +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;
-/** @deprecated Use {@link ExactTotalFromPage}. */
-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;
-/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
-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,kDAAkD;AAClD,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,IAAI,GACvB,MAAM,GAAG,IAAI,CAEf;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;AAED,yDAAyD;AACzD,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,CAER"}

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

@@ -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, pageLength, maxRows) {
-    if (maxRows == null) {
-        return pageLength;
-    }
-    if (pageLength < maxRows) {
-        return startRow + pageLength;
-    }
-    return null;
-}
-/** @deprecated Use {@link ExactTotalFromPage}. */
-export function exactTotalFromPage(startRow, pageLength, maxRows) {
-    return ExactTotalFromPage(startRow, pageLength, maxRows);
-}
-/**
- * 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;
-}
-/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
-export function resolveAdhocTotalRowCount(countRows, fallback) {
-    return ResolveAdhocTotalRowCount(countRows, 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,kDAAkD;AAClD,MAAM,UAAU,kBAAkB,CAC9B,QAAgB,EAChB,UAAkB,EAClB,OAAsB;IAEtB,OAAO,kBAAkB,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AAC7D,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;AAED,yDAAyD;AACzD,MAAM,UAAU,yBAAyB,CACrC,SAAwE,EACxE,QAAgB;IAEhB,OAAO,yBAAyB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;AAC1D,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,67 +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;
-}
-
-/** @deprecated Use {@link ExactTotalFromPage}. */
-export function exactTotalFromPage(
-    startRow: number,
-    pageLength: number,
-    maxRows: number | null,
-): number | null {
-    return ExactTotalFromPage(startRow, pageLength, maxRows);
-}
-
-/**
- * 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;
-}
-
-/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
-export function resolveAdhocTotalRowCount(
-    countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
-    fallback: number,
-): number {
-    return ResolveAdhocTotalRowCount(countRows, fallback);
-}