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

package/src/resolvers/meetings/meetingTypes.ts

@@ -0,0 +1,238 @@
+import { ObjectType, InputType, Field } from 'type-graphql';
+
+@ObjectType()
+export class MeetingParticipantType {
+  @Field(() => String)
+  ID: string;
+
+  @Field(() => String)
+  MeetingID: string;
+
+  @Field(() => String, { nullable: true })
+  UserID?: string;
+
+  @Field(() => String, { nullable: true })
+  UserName?: string;
+
+  @Field(() => String, { nullable: true })
+  UserEmail?: string;
+
+  @Field(() => String, { nullable: true })
+  AgentID?: string;
+
+  @Field(() => String, { nullable: true })
+  AgentName?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalName?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalEmail?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalPhone?: string;
+
+  @Field(() => String)
+  Role: string;
+
+  @Field(() => String)
+  InviteStatus: string;
+
+  @Field(() => Date, { nullable: true })
+  JoinedAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  LeftAt?: Date;
+}
+
+@ObjectType()
+export class MeetingType {
+  @Field(() => String)
+  ID: string;
+
+  @Field(() => String)
+  Title: string;
+
+  @Field(() => String, { nullable: true })
+  Description?: string;
+
+  @Field(() => String)
+  HostUserID: string;
+
+  @Field(() => String, { nullable: true })
+  HostUserName?: string;
+
+  @Field(() => String)
+  RoomName: string;
+
+  @Field(() => String)
+  Status: string;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledStartAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledEndAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  StartedAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  EndedAt?: Date;
+
+  @Field(() => Boolean)
+  AllowPhoneDialIn: boolean;
+
+  @Field(() => String, { nullable: true })
+  DialInPhoneNumberID?: string;
+
+  @Field(() => String, { nullable: true })
+  DialInPhoneNumber?: string;
+
+  @Field(() => String, { nullable: true })
+  DialInCode?: string;
+
+  @Field(() => String)
+  RecordingPolicy: string;
+
+  @Field(() => String, { nullable: true })
+  ConversationID?: string;
+
+  @Field(() => [MeetingParticipantType], { nullable: true })
+  Participants?: MeetingParticipantType[];
+
+  @Field(() => Date)
+  CreatedAt: Date;
+
+  @Field(() => Date)
+  UpdatedAt: Date;
+}
+
+@ObjectType()
+export class MeetingResult {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+
+  @Field(() => MeetingType, { nullable: true })
+  Meeting?: MeetingType;
+}
+
+@ObjectType()
+export class StartMeetingResult {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+
+  @Field(() => MeetingType, { nullable: true })
+  Meeting?: MeetingType;
+
+  @Field(() => String, { nullable: true })
+  RoomName?: string;
+
+  @Field(() => String, { nullable: true })
+  ClientToken?: string;
+}
+
+@ObjectType()
+export class DialInPhoneNumberType {
+  @Field(() => String)
+  ID: string;
+
+  @Field(() => String)
+  Number: string;
+
+  @Field(() => String, { nullable: true })
+  Label?: string;
+}
+
+@InputType()
+export class MeetingParticipantInput {
+  @Field(() => String, { nullable: true })
+  UserID?: string;
+
+  @Field(() => String, { nullable: true })
+  AgentID?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalName?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalEmail?: string;
+
+  @Field(() => String, { nullable: true })
+  ExternalPhone?: string;
+
+  @Field(() => String, { nullable: true })
+  Role?: string;
+}
+
+@InputType()
+export class CreateMeetingInput {
+  @Field(() => String)
+  Title: string;
+
+  @Field(() => String, { nullable: true })
+  Description?: string;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledStartAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledEndAt?: Date;
+
+  @Field(() => Boolean, { nullable: true })
+  AllowPhoneDialIn?: boolean;
+
+  @Field(() => String, { nullable: true })
+  DialInPhoneNumberID?: string;
+
+  @Field(() => String, { nullable: true })
+  RecordingPolicy?: string;
+
+  @Field(() => [MeetingParticipantInput], { nullable: true })
+  Participants?: MeetingParticipantInput[];
+}
+
+@InputType()
+export class UpdateMeetingInput {
+  @Field(() => String)
+  MeetingID: string;
+
+  @Field(() => String, { nullable: true })
+  Title?: string;
+
+  @Field(() => String, { nullable: true })
+  Description?: string;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledStartAt?: Date;
+
+  @Field(() => Date, { nullable: true })
+  ScheduledEndAt?: Date;
+
+  @Field(() => Boolean, { nullable: true })
+  AllowPhoneDialIn?: boolean;
+
+  @Field(() => String, { nullable: true })
+  DialInPhoneNumberID?: string;
+
+  @Field(() => String, { nullable: true })
+  RecordingPolicy?: string;
+
+  @Field(() => [MeetingParticipantInput], { nullable: true })
+  Participants?: MeetingParticipantInput[];
+}
+
+@InputType()
+export class RSVPMeetingInput {
+  @Field(() => String)
+  MeetingID: string;
+
+  @Field(() => String)
+  InviteStatus: string;
+}

package/src/rest/ViewOperationsHandler.ts

@@ -206,17 +206,20 @@ export class ViewOperationsHandler {
             params.Fields = (params.Fields as string).split(',');
         }
         
-        // Sanitize numeric values
+        // Sanitize numeric values: base-10, integral, and clamped to a sane range so a
+        // negative/garbage value can never reach the SQL layer.
         if (params.MaxRows !== undefined) {
-            params.MaxRows = typeof params.MaxRows === 'string' 
-                ? parseInt(params.MaxRows as string) 
+            const parsed = typeof params.MaxRows === 'string'
+                ? parseInt(params.MaxRows as string, 10)
                 : params.MaxRows;
+            params.MaxRows = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed as number)) : undefined;
         }
         
         if (params.StartRow !== undefined) {
-            params.StartRow = typeof params.StartRow === 'string' 
-                ? parseInt(params.StartRow as string) 
+            const parsed = typeof params.StartRow === 'string'
+                ? parseInt(params.StartRow as string, 10)
                 : params.StartRow;
+            params.StartRow = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed as number)) : undefined;
         }
         
         // Default ResultType if not provided

package/src/services/TaskGraphActionRunner.ts

@@ -35,9 +35,19 @@ export class TaskGraphActionRunner implements TaskActionRunner {
                 Filters: [],
             });
 
+            const output = this.buildOutput(result.Params);
+            const unstorable = this.findUnstorableOutput(output);
+            if (unstorable) {
+                const message =
+                    `Action "${action.Name}" returned output param "${unstorable.Name}", which cannot be stored ` +
+                    `as the step's result: ${unstorable.Reason}. Output params of a durable step must be plain data.`;
+                LogError(`[TaskGraphActionRunner] Task ${params.TaskID}: ${message}`);
+                return { Success: false, ErrorMessage: message, ActionLogID: result.LogEntry?.ID };
+            }
+
             return {
                 Success: result.Success,
-                Output: this.buildOutput(result.Params),
+                Output: output,
                 ErrorMessage: result.Success ? undefined : result.Message,
                 // The engine already wrote the log; this is the only place its id is in hand. Without
                 // carrying it out, a workflow's action step has no path back to its own execution
@@ -51,6 +61,24 @@ export class TaskGraphActionRunner implements TaskActionRunner {
         }
     }
 
+    /**
+     * The first output param that cannot be written to the Task row as JSON, or null.
+     *
+     * Checked here because this is the last place that knows the action's and the param's NAMES: the
+     * dispatcher serializes the whole Output later and, for a live object (an entity, an observable),
+     * fails with a bare "Converting circular structure to JSON" that names neither.
+     */
+    private findUnstorableOutput(output: Record<string, unknown>): { Name: string; Reason: string } | null {
+        for (const [Name, value] of Object.entries(output)) {
+            try {
+                JSON.stringify(value);
+            } catch (e) {
+                return { Name, Reason: e instanceof Error ? e.message.split('\n')[0] : String(e) };
+            }
+        }
+        return null;
+    }
+
     /**
      * Projects the action's parameters onto the flat result a workflow step is expected to produce.
      *

package/src/services/WorkQueueHostService.ts

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Starts the durable work-queue host inside MJServer when `workQueue.enabled` is set.
+ * @module MJServer/services
+ */
+import { randomBytes } from 'node:crypto';
+import { hostname } from 'node:os';
+import sql from 'mssql';
+import { LogError, LogStatus } from '@memberjunction/core';
+import type { DatabaseProviderBase, IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/generic-database-provider';
+import { MJWorkLogger, WorkQueueEngine, WorkQueueHost } from '@memberjunction/work-queue-engine';
+import type { WorkQueueHostConfig, WorkQueueProviderSource } from '@memberjunction/work-queue-engine';
+import { TaskGraphProviderFactory } from './TaskGraphProviderFactory.js';
+import type { WorkQueueConfig } from './workQueueConfig.js';
+
+export const WORK_QUEUE_DISABLE_ENV = 'MJ_DISABLE_WORK_QUEUE_HOST';
+
+/** Matches the width of WorkQueueDelivery.LeaseOwner. */
+const MAX_INSTANCE_ID_LENGTH = 200;
+
+type EnvironmentVariables = Record<string, string | undefined>;
+
+export interface StartableWorkQueueHost {
+    Start(): Promise<void>;
+}
+
+/** Seams for tests; production uses DEFAULT_WORK_QUEUE_HOST_START_DEPENDENCIES. */
+export interface WorkQueueHostStartDependencies {
+    Env: EnvironmentVariables;
+    FindUserByEmail(email: string): UserInfo | undefined;
+    ConfigureEngine(user: UserInfo, provider: DatabaseProviderBase): Promise<WorkQueueEngine>;
+    CreateHost(config: WorkQueueHostConfig, engine: WorkQueueEngine, user: UserInfo, provider: DatabaseProviderBase, providerSource: WorkQueueProviderSource): StartableWorkQueueHost;
+}
+
+export const DEFAULT_WORK_QUEUE_HOST_START_DEPENDENCIES: WorkQueueHostStartDependencies = {
+    Env: process.env,
+    FindUserByEmail: email => UserCache.Users.find(user => user.Email?.trim().toLowerCase() === email.trim().toLowerCase()),
+    ConfigureEngine: async (user, provider) => {
+        await WorkQueueEngine.Instance.Config(false, user, provider);
+        await ReportTopologyIssues(WorkQueueEngine.Instance);
+        return WorkQueueEngine.Instance;
+    },
+    CreateHost: (config, engine, user, provider, providerSource) =>
+        new WorkQueueHost(config, engine, user, provider, new MJWorkLogger(), { ProviderSource: providerSource }),
+};
+
+/**
+ * Topology rows, capability gating, driver bindings and database prerequisites (03 §11) — including SQL Server's
+ * READ_COMMITTED_SNAPSHOT requirement (03 §7). Problems are logged, never thrown: the planner still gates each
+ * subscription, and an operator can read the same list from WorkQueue.ValidateBindings.
+ */
+async function ReportTopologyIssues(engine: WorkQueueEngine): Promise<void> {
+    try {
+        for (const issue of await engine.ValidateTopology()) {
+            const line = `[WorkQueue] ${issue.Severity}: ${issue.Subject} — ${issue.Message}`;
+            if (issue.Severity === 'Error') {
+                LogError(line);
+            } else {
+                LogStatus(line);
+            }
+        }
+    } catch (error) {
+        LogError(`[WorkQueue] Topology validation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+export function IsWorkQueueHostDisabledByEnv(env: EnvironmentVariables): boolean {
+    return env[WORK_QUEUE_DISABLE_ENV] === '1';
+}
+
+/**
+ * Host and pid for humans reading logs; the random suffix for uniqueness — containers routinely share pid 1 and
+ * HOSTNAME is not always exported. A restart is a new instance, so a dead process's leases simply expire.
+ */
+export function CreateWorkQueueInstanceID(env: EnvironmentVariables = process.env): string {
+    const host = env.HOSTNAME ?? hostname();
+    return `${host}-${process.pid}-${randomBytes(4).toString('hex')}`.slice(0, MAX_INSTANCE_ID_LENGTH);
+}
+
+export function BuildWorkQueueHostConfig(config: WorkQueueConfig, instanceID: string): WorkQueueHostConfig {
+    return {
+        InstanceID: instanceID,
+        Subscriptions: config.subscriptions.map(entry => ({ Name: entry.name, Concurrency: entry.concurrency })),
+        IdlePollMinMs: config.idlePollMinMs,
+        IdlePollMaxMs: config.idlePollMaxMs,
+        ShutdownDrainMs: config.shutdownDrainMs,
+        SweeperIntervalMs: config.sweeperEnabled ? config.sweeperIntervalMs : 0,
+        ReconcileIntervalMs: config.reconcileIntervalMs,
+    };
+}
+
+/** A fresh SQL Server provider per delivery over the shared pool; the server provider otherwise. */
+export class MJServerWorkQueueProviderSource implements WorkQueueProviderSource {
+    private readonly factory: TaskGraphProviderFactory | null;
+
+    constructor(pool: sql.ConnectionPool | null, private readonly fallback: IMetadataProvider) {
+        this.factory = pool ? new TaskGraphProviderFactory(pool) : null;
+    }
+
+    public CreateProvider(): Promise<IMetadataProvider> {
+        return this.factory ? this.factory.CreateProvider() : Promise.resolve(this.fallback);
+    }
+}
+
+/** Returns the started host, or null when this instance runs no subscriptions. */
+export async function StartWorkQueueHost(
+    config: WorkQueueConfig,
+    provider: DatabaseProviderBase,
+    providerSource: WorkQueueProviderSource,
+    dependencies: WorkQueueHostStartDependencies = DEFAULT_WORK_QUEUE_HOST_START_DEPENDENCIES,
+): Promise<StartableWorkQueueHost | null> {
+    if (!config.enabled) {
+        return null;
+    }
+    if (IsWorkQueueHostDisabledByEnv(dependencies.Env)) {
+        LogStatus(`[WorkQueue] Host disabled by ${WORK_QUEUE_DISABLE_ENV}=1 — this process publishes but runs no subscriptions.`);
+        return null;
+    }
+    const user = dependencies.FindUserByEmail(config.systemUserEmail);
+    if (!user) {
+        throw new Error(`[WorkQueue] System user not found with email: ${config.systemUserEmail} — set workQueue.systemUserEmail in mj.config.cjs`);
+    }
+    const engine = await dependencies.ConfigureEngine(user, provider);
+    const hostConfig = BuildWorkQueueHostConfig(config, CreateWorkQueueInstanceID(dependencies.Env));
+    const host = dependencies.CreateHost(hostConfig, engine, user, provider, providerSource);
+    await host.Start();
+    LogStatus(`🔄 Work Queue host ${hostConfig.InstanceID}: ${hostConfig.Subscriptions.map(s => `${s.Name}×${s.Concurrency}`).join(', ')}`);
+    return host;
+}

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/types.ts

@@ -121,6 +121,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);
-    });
-});