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

package/src/resolvers/ConversationRunEventsResolver.ts

@@ -0,0 +1,308 @@
+import { Arg, Ctx, Field, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { RunView } from '@memberjunction/core';
+import { EscapeSQLString } from '@memberjunction/global';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { MJAIAgentRunEntity, MJAIAgentRunStepEntity, MJConversationDetailEntity } from '@memberjunction/core-entities';
+import type { AppContext } from '../types.js';
+import { GetReadOnlyProvider } from '../util.js';
+
+/** The run columns the tail reads. */
+type TailRunRow = Pick<MJAIAgentRunEntity, 'ID' | 'Status' | 'Result'>;
+
+/** The step columns an event carries. The large data columns are never read. */
+type TailStepRow = Pick<
+    MJAIAgentRunStepEntity,
+    'StepNumber' | 'StepType' | 'StepName' | 'Status' | 'Success' | 'ErrorMessage' | 'StartedAt' | 'CompletedAt'
+>;
+
+const RUN_FIELDS: (keyof TailRunRow)[] = ['ID', 'Status', 'Result'];
+const STEP_FIELDS: (keyof TailStepRow)[] = [
+    'StepNumber', 'StepType', 'StepName', 'Status', 'Success', 'ErrorMessage', 'StartedAt', 'CompletedAt',
+];
+
+/**
+ * One step of an agent run, projected for the client's progress view.
+ *
+ * Carries metadata only. `InputData`, `OutputData` and the payload snapshots are
+ * deliberately excluded: they are the largest columns on the row and a run can hold
+ * hundreds of steps, so including them would let a single tail call return tens of
+ * megabytes. The final result is delivered once, via `FinalPayload`, when the run
+ * reaches a terminal state.
+ */
+@ObjectType()
+export class ConversationRunEvent {
+    /** Monotonic position within the run. The cursor a client pages from. */
+    @Field(() => Int)
+    Seq: number;
+
+    @Field(() => String)
+    StepType: string;
+
+    @Field(() => String)
+    StepName: string;
+
+    @Field(() => String)
+    Status: string;
+
+    @Field(() => Boolean, { nullable: true })
+    Success?: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => Date)
+    StartedAt: Date;
+
+    @Field(() => Date, { nullable: true })
+    CompletedAt?: Date;
+}
+
+/** Result of a tail call. */
+@ObjectType()
+export class ConversationRunEventsOutput {
+    @Field(() => Boolean)
+    Success: boolean;
+
+    @Field(() => String)
+    Message: string;
+
+    @Field(() => [ConversationRunEvent])
+    Events: ConversationRunEvent[];
+
+    /**
+     * Highest `Seq` the caller has now seen. Pass it back as `sinceSeq` on the next call.
+     * Echoes the request's `sinceSeq` when nothing new has landed, so a client that polls
+     * a quiet run never rewinds.
+     */
+    @Field(() => Int)
+    LatestSeq: number;
+
+    /**
+     * True while the run is still executing, including a run `Paused` on a workflow that is still
+     * running. False means terminal — stop tailing, and `FinalPayload` / `RunStatus` hold the
+     * outcome. A failed call (`Success` false) reports true, because it knows nothing about the run.
+     */
+    @Field(() => Boolean)
+    IsInFlight: boolean;
+
+    @Field(() => String, { nullable: true })
+    RunID?: string;
+
+    @Field(() => String, { nullable: true })
+    RunStatus?: string;
+
+    /**
+     * The run's answer, returned only once the run is terminal.
+     *
+     * Sourced from `AIAgentRun.Result`, falling back to the conversation detail's message because
+     * `Result` is agent-dependent and null on many successful runs. Still nullable: a caller must
+     * decide a message is finished from {@link IsInFlight} / {@link DetailStatus}, never from the
+     * presence of this field, or it will wait forever on an agent that writes neither.
+     */
+    @Field(() => String, { nullable: true })
+    FinalPayload?: string;
+
+    /** `ConversationDetail.Status` — the value the chat UI renders from. */
+    @Field(() => String, { nullable: true })
+    DetailStatus?: string;
+}
+
+/**
+ * Every read here sets `BypassCache`. This is the last-resort recovery path, and the rows it
+ * judges are written by callers that fire no cache invalidation — `spSweepStaleAIAgentRuns`
+ * force-fails a run with a direct set-based UPDATE. `TrustServerCacheCompletely` defaults on, so
+ * a cached read would keep reporting a swept run as `Running` and recovery would never fire.
+ */
+
+/** Ceiling on events returned per call. A client with a gap larger than this pages. */
+const MAX_EVENTS_PER_TAIL = 200;
+
+/**
+ * Run statuses that mean execution is still in progress. `Paused` is a run parked on a workflow
+ * that is still executing; the orphan reconciler and the process panel treat it the same way.
+ */
+const IN_FLIGHT_STATUSES: MJAIAgentRunEntity['Status'][] = ['Running', 'Paused'];
+
+/**
+ * Durable, resumable read of an agent run's progress (MJ #4222).
+ *
+ * The `statusUpdates` subscription is the only live path a conversation has, and it has no
+ * replay: the server topic is an in-memory PubSub and the client subject is explicitly
+ * unbuffered. Anything published while a socket is half-open is gone, and the client cannot
+ * tell the difference between "nothing happened" and "I missed everything".
+ *
+ * This query is the durable counterpart, mirroring `IntegrationTailRunEvents` — the same
+ * shape the integration subsystem already uses, where the subscription is a latency
+ * optimization over a log rather than the only delivery path. A client keeps the `LatestSeq`
+ * it has seen and re-reads from there after any interruption.
+ *
+ * It is a READ MODEL over tables that already exist. `AIAgentRunStep` rows are inserted when
+ * a step starts and updated when it finishes, so progress is visible mid-run, and
+ * `StepNumber` is already monotonic per run. No new table and no migration.
+ *
+ * Authorization is delegated to `RunView` executed as the calling user, so MJ's existing
+ * row-level security decides what is visible. A caller who cannot read the conversation
+ * detail gets the same answer as one asking about a detail that does not exist.
+ */
+@Resolver()
+export class ConversationRunEventsResolver {
+    @Query(() => ConversationRunEventsOutput)
+    async TailConversationEvents(
+        @Arg('conversationDetailID', () => String) conversationDetailID: string,
+        @Ctx() ctx: AppContext,
+        @Arg('sinceSeq', () => Int, { defaultValue: 0 }) sinceSeq?: number
+    ): Promise<ConversationRunEventsOutput> {
+        const from = Math.max(0, sinceSeq ?? 0);
+        const empty = (message: string): ConversationRunEventsOutput => ({
+            Success: false,
+            Message: message,
+            Events: [],
+            LatestSeq: from,
+            IsInFlight: true,
+        });
+
+        try {
+            const user = ctx.userPayload?.userRecord;
+            if (!user) {
+                return empty('User is not authenticated');
+            }
+
+            const provider = GetReadOnlyProvider(ctx.providers, { allowFallbackToReadWrite: true });
+            const detail = await this.loadDetail(provider, conversationDetailID, user);
+            if (!detail) {
+                // Not found and not authorized are deliberately indistinguishable — answering
+                // "exists but denied" would confirm the id to someone probing for one.
+                return empty(`Conversation detail '${conversationDetailID}' not found`);
+            }
+
+            const run = await this.loadLatestRun(provider, conversationDetailID, user);
+            if (!run) {
+                // The mutation is acknowledged before the run row exists, so this is an
+                // ordinary early-poll result, not an error. Reported as success with nothing
+                // to show so a client does not treat a race as a failure.
+                return {
+                    Success: true,
+                    Message: 'No agent run yet for this conversation detail',
+                    Events: [],
+                    LatestSeq: from,
+                    IsInFlight: false,
+                    DetailStatus: detail.Status ?? undefined,
+                };
+            }
+
+            const isInFlight = IN_FLIGHT_STATUSES.includes(run.Status);
+            const steps = await this.loadSteps(provider, run.ID, from, user);
+            const events = steps.map((s) => this.toEvent(s));
+
+            return {
+                Success: true,
+                Message: `${events.length} event(s)`,
+                Events: events,
+                // Never rewind: a quiet run returns the cursor the caller already held.
+                LatestSeq: events.length > 0 ? events[events.length - 1].Seq : from,
+                IsInFlight: isInFlight,
+                RunID: run.ID,
+                RunStatus: run.Status,
+                // Only meaningful once terminal; sending it mid-run would hand the client a
+                // partial payload it could mistake for the final answer.
+                //
+                // `AIAgentRun.Result` is agent-dependent — it is null on a large share of
+                // genuinely successful runs — so the conversation detail's own message is the
+                // fallback. That is the text the chat renders, so it is the answer a caller
+                // waiting on this field actually wants.
+                FinalPayload: isInFlight ? undefined : (run.Result ?? detail.Message ?? undefined),
+                DetailStatus: detail.Status ?? undefined,
+            };
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            return empty(`TailConversationEvents failed: ${message}`);
+        }
+    }
+
+    /** Loads the conversation detail as the calling user; null when absent or not permitted. */
+    private async loadDetail(
+        provider: IMetadataProvider,
+        conversationDetailID: string,
+        user: UserInfo
+    ): Promise<MJConversationDetailEntity | undefined> {
+        const rv = RunView.FromMetadataProvider(provider);
+        const result = await rv.RunView<MJConversationDetailEntity>(
+            {
+                EntityName: 'MJ: Conversation Details',
+                ExtraFilter: `ID='${this.escape(conversationDetailID)}'`,
+                MaxRows: 1,
+                ResultType: 'entity_object',
+                BypassCache: true,
+            },
+            user
+        );
+        return result.Success ? result.Results?.[0] : undefined;
+    }
+
+    /**
+     * Newest run for the detail. A conversation detail can be retried, and the latest run is
+     * the one the UI is showing.
+     */
+    private async loadLatestRun(
+        provider: IMetadataProvider,
+        conversationDetailID: string,
+        user: UserInfo
+    ): Promise<TailRunRow | undefined> {
+        const rv = RunView.FromMetadataProvider(provider);
+        const result = await rv.RunView<TailRunRow>(
+            {
+                EntityName: 'MJ: AI Agent Runs',
+                ExtraFilter: `ConversationDetailID='${this.escape(conversationDetailID)}'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                Fields: RUN_FIELDS,
+                ResultType: 'simple',
+                BypassCache: true,
+            },
+            user
+        );
+        return result.Success ? result.Results?.[0] : undefined;
+    }
+
+    /** Steps after `sinceSeq`, oldest first, bounded by {@link MAX_EVENTS_PER_TAIL}. */
+    private async loadSteps(
+        provider: IMetadataProvider,
+        agentRunID: string,
+        sinceSeq: number,
+        user: UserInfo
+    ): Promise<TailStepRow[]> {
+        const rv = RunView.FromMetadataProvider(provider);
+        const result = await rv.RunView<TailStepRow>(
+            {
+                EntityName: 'MJ: AI Agent Run Steps',
+                ExtraFilter: `AgentRunID='${this.escape(agentRunID)}' AND StepNumber > ${Math.floor(sinceSeq)}`,
+                OrderBy: 'StepNumber ASC',
+                MaxRows: MAX_EVENTS_PER_TAIL,
+                Fields: STEP_FIELDS,
+                ResultType: 'simple',
+                BypassCache: true,
+            },
+            user
+        );
+        return result.Success ? (result.Results ?? []) : [];
+    }
+
+    /** Projects a plain step row to an event. Plain rows may carry dates as strings. */
+    private toEvent(step: TailStepRow): ConversationRunEvent {
+        return {
+            Seq: step.StepNumber,
+            StepType: step.StepType,
+            StepName: step.StepName,
+            Status: step.Status,
+            Success: step.Success ?? undefined,
+            ErrorMessage: step.ErrorMessage ?? undefined,
+            StartedAt: new Date(step.StartedAt),
+            CompletedAt: step.CompletedAt != null ? new Date(step.CompletedAt) : undefined,
+        };
+    }
+
+    /** Escapes a value for the `ExtraFilter` string. Ids are UUIDs, but never trust the shape. */
+    private escape(value: string): string {
+        return EscapeSQLString(value);
+    }
+}

package/src/resolvers/DuplicateEntryCheckResolver.ts

@@ -0,0 +1,232 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, Float, Int } from 'type-graphql';
+import { AppContext, UserPayload } from '../types.js';
+import { EntityFieldInfo, EntityInfo, IMetadataProvider, LogError, Metadata } from '@memberjunction/core';
+import { DuplicateRecordDetector } from '@memberjunction/ai-vector-dupe';
+import type { DuplicateEntryCheckResult, DuplicateEntryCheckStatus } from '@memberjunction/ai-vector-dupe';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadOnlyProvider } from '../util.js';
+
+/**
+ * The most characters `valuesJSON` may hold. A larger request is refused before it is parsed. The
+ * form sends each field's text cut to 500 characters, so a real entry stays well under it; the
+ * detector then cuts what reaches the template and the decision model on its own.
+ */
+export const DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH = 16 * 1024;
+
+/**
+ * How a `CheckDuplicateEntry` call ended: a detector status, or `NotAuthorized` when the caller may
+ * not run the check (an API key without the scopes, or a user who cannot read the entity). Nothing
+ * ran, and a form stops asking about the entity for the session, as it does on `NotConfigured`.
+ */
+export type DuplicateEntryCheckOutputStatus = DuplicateEntryCheckStatus | 'NotAuthorized';
+
+/** One entered value, as `valuesJSON` may carry it. */
+type EntryValue = string | number | boolean | null;
+
+/** One existing record the entry-time check flags as a possible duplicate. */
+@ObjectType()
+export class DuplicateEntryCandidateOutput {
+    /** The candidate's primary key as a compact URL segment; `CompositeKey.FromURLSegment` reads it back. */
+    @Field()
+    RecordID: string;
+
+    /** The candidate's name, or its key when the caller may not read a name. */
+    @Field()
+    DisplayName: string;
+
+    /** The vector similarity score that surfaced the candidate. */
+    @Field(() => Float)
+    VectorScore: number;
+
+    /** The decision's probability that the candidate is the same entity; null when it gave no answer. */
+    @Field(() => Float, { nullable: true })
+    Probability: number | null;
+}
+
+/**
+ * The result of the `CheckDuplicateEntry` mutation. The mutation never throws to the client: an
+ * authorization denial is `Status: 'NotAuthorized'` and any other failure is `Status: 'Failed'`,
+ * each with an `ErrorMessage`.
+ */
+@ObjectType()
+export class DuplicateEntryCheckOutput {
+    /** `Checked`, `NotConfigured`, `NotAuthorized` or `Failed`. */
+    @Field(() => String)
+    Status: DuplicateEntryCheckOutputStatus;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+
+    /** The flagged candidates, most probable first. Empty unless `Status` is `Checked`. */
+    @Field(() => [DuplicateEntryCandidateOutput])
+    Candidates: DuplicateEntryCandidateOutput[];
+
+    /** How long the check took on the server, in milliseconds. */
+    @Field(() => Int)
+    ElapsedMs: number;
+}
+
+/** What the resolver needs from the detector. `DuplicateRecordDetector` provides it. */
+export type DuplicateEntryChecker = Pick<DuplicateRecordDetector, 'CheckRecordValues'>;
+
+/**
+ * Checks the values a person is entering for a new record against the entity's existing records,
+ * through `DuplicateRecordDetector.CheckRecordValues`, and returns the plausible duplicates to flag.
+ * It only flags: it saves, merges and blocks nothing.
+ */
+@Resolver()
+export class DuplicateEntryCheckResolver extends ResolverBase {
+    /**
+     * Flags existing records that may duplicate a new record being entered.
+     *
+     * Authorization comes before any other work. An API key needs two scopes: `view:run` on the
+     * entity, the scope `RunDynamicView` checks, since the check reads the entity's records; and
+     * `prompt:execute`, the scope `ExecuteSimplePrompt` checks, since each check pays for an embedding
+     * and a decision-model call. A session without an API key skips both. Then the user needs read
+     * permission on the entity. A denial is `NotAuthorized`, and is not logged. The detector then
+     * narrows the candidates to the rows the user can read.
+     *
+     * The detector bounds the check's time on the server (`DUPLICATE_ENTRY_CHECK_SERVER_BUDGET_MS` in
+     * `@memberjunction/ai-vector-dupe`), a little above the form's own budget.
+     *
+     * @param entityName The entity the new record belongs to.
+     * @param valuesJSON The entered values as the JSON of an object, by field name, at most
+     *   {@link DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH} characters. Each value is a string,
+     *   number, boolean or null. Fields the entity does not have, primary keys, read-only fields and
+     *   MJ system fields are ignored.
+     */
+    @Mutation(() => DuplicateEntryCheckOutput)
+    async CheckDuplicateEntry(
+        @Arg('entityName') entityName: string,
+        @Arg('valuesJSON') valuesJSON: string,
+        @Ctx() { userPayload, providers }: AppContext
+    ): Promise<DuplicateEntryCheckOutput> {
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        return this.RunEntryCheck(entityName, valuesJSON, userPayload, provider);
+    }
+
+    /**
+     * The check without the GraphQL plumbing: authorizes, reads the values, and runs the detector.
+     * Never throws.
+     *
+     * @param provider the request's metadata provider; the global one when null
+     */
+    public async RunEntryCheck(
+        entityName: string,
+        valuesJSON: string,
+        userPayload: UserPayload,
+        provider: IMetadataProvider | null
+    ): Promise<DuplicateEntryCheckOutput> {
+        const startTime = Date.now();
+        const entity = (provider ?? new Metadata()).EntityByName(entityName);
+        if (!entity) {
+            return this.failure('Failed', 'Entity not found in metadata', startTime);
+        }
+        const denial = await this.authorizeEntryCheck(entity, userPayload, provider);
+        if (denial) {
+            return this.failure('NotAuthorized', denial, startTime);
+        }
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+            if (!user) {
+                return this.failure('Failed', 'Unable to determine current user', startTime);
+            }
+            const values = this.parseValues(valuesJSON, entity);
+            if ('Error' in values) {
+                return this.failure('Failed', values.Error, startTime);
+            }
+            const result = await this.CreateEntryChecker(provider).CheckRecordValues(entity.Name, values.Values, user);
+            return this.mapResult(result);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            LogError(`CheckDuplicateEntry failed for ${entityName}: ${message}`);
+            return this.failure('Failed', message || 'Unknown error occurred', startTime);
+        }
+    }
+
+    /** The detector a check runs on, bound to the request's provider. */
+    protected CreateEntryChecker(provider: IMetadataProvider | null): DuplicateEntryChecker {
+        return new DuplicateRecordDetector(provider);
+    }
+
+    /**
+     * Why the caller may not run the check, or null when they may: the API-key scopes, then the
+     * user's read permission on the entity. A denial is an answer, not a fault, so nothing is logged.
+     */
+    private async authorizeEntryCheck(
+        entity: EntityInfo,
+        userPayload: UserPayload,
+        provider: IMetadataProvider | null
+    ): Promise<string | null> {
+        try {
+            await this.CheckAPIKeyScopeAuthorization('view:run', entity.Name, userPayload);
+            await this.CheckAPIKeyScopeAuthorization('prompt:execute', '*', userPayload);
+            this.CheckUserReadPermissions(entity.Name, userPayload, provider ?? undefined);
+            return null;
+        } catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+
+    /**
+     * Reads the entered values: the JSON of an object of scalar values, at most
+     * {@link DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH} characters, kept to the fields a person
+     * can enter (matched by name, case-insensitively, and keyed by the field's real name).
+     */
+    private parseValues(valuesJSON: string, entity: EntityInfo): { Values: Record<string, EntryValue> } | { Error: string } {
+        if (valuesJSON.length > DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH) {
+            return { Error: `valuesJSON is ${valuesJSON.length} characters; the limit is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH}` };
+        }
+        let parsed: unknown;
+        try {
+            parsed = JSON.parse(valuesJSON);
+        } catch (e) {
+            return { Error: `valuesJSON is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        if (!this.isPlainObject(parsed)) {
+            return { Error: 'valuesJSON must be the JSON of an object of field values' };
+        }
+        const values: Record<string, EntryValue> = {};
+        for (const [name, value] of Object.entries(parsed)) {
+            if (!this.isEntryValue(value)) {
+                return { Error: `valuesJSON field '${name}' must be a string, number, boolean or null` };
+            }
+            const field = entity.FieldByName(name);
+            if (field && this.isEnterable(field)) {
+                values[field.Name] = value;
+            }
+        }
+        return { Values: values };
+    }
+
+    /** Whether a person can enter the field: not a primary key, not read-only, not an MJ system field. */
+    private isEnterable(field: EntityFieldInfo): boolean {
+        return !field.IsPrimaryKey && !field.ReadOnly && !field.Name.startsWith('__mj_');
+    }
+
+    private isEntryValue(value: unknown): value is EntryValue {
+        return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+    }
+
+    private isPlainObject(value: unknown): value is Record<string, unknown> {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+
+    private mapResult(result: DuplicateEntryCheckResult): DuplicateEntryCheckOutput {
+        return {
+            Status: result.Status,
+            ErrorMessage: result.ErrorMessage,
+            Candidates: result.Candidates.map(c => ({
+                RecordID: c.RecordID,
+                DisplayName: c.DisplayName,
+                VectorScore: c.VectorScore,
+                Probability: c.Probability,
+            })),
+            ElapsedMs: result.ElapsedMs,
+        };
+    }
+
+    private failure(status: DuplicateEntryCheckOutputStatus, errorMessage: string, startTime: number): DuplicateEntryCheckOutput {
+        return { Status: status, ErrorMessage: errorMessage, Candidates: [], ElapsedMs: Date.now() - startTime };
+    }
+}

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,4 +1,4 @@
-import { CompositeKey, DatabaseProviderBase, EntityInfo, LogDebug, UserInfo } from '@memberjunction/core';
+import { CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
@@ -36,20 +36,13 @@ export class EntityRecordNameResult {
  * Resolves a record's display NAME from its primary key — the lookup behind every foreign-key
  * link, breadcrumb and picker label in the UI.
  *
- * **This is a read of entity data and is gated like one.** It historically took no user context
- * at all, which made it an open side channel: a caller denied READ on an entity's name field
- * could still obtain that name here, because the name never travelled through the resolver that
- * strips denied fields. Field-level security turned that latent gap into a live bypass — the
- * form-field FK control falls through to this query precisely WHEN the joined display column is
- * denied, so the one case the fallback exists for was the case that leaked.
+ * Entity-level read permission is checked here ({@link ResolverBase.CheckUserReadPermissions}).
+ * Field- and row-level security are applied by the provider's lookup, for the acting user passed
+ * to it: when any field the name is built from is withheld, it answers with no name.
  *
- * Two gates now apply, matching what the generated single-record resolvers do:
- *   1. entity-level read permission ({@link ResolverBase.CheckUserReadPermissions});
- *   2. field-level read permission on the entity's own name field.
- *
- * A field-level denial answers `Success: false` with no name rather than throwing. Callers
- * already treat "no name" as "show the primary key", which is the intended degradation — and it
- * keeps this query from becoming a probe that distinguishes "restricted" from "missing".
+ * A withheld name answers `Success: false` with the same status as a record that does not exist.
+ * Callers already treat "no name" as "show the primary key", and the identical answer keeps this
+ * query from becoming a probe that distinguishes "restricted" from "missing".
  */
 @Resolver(EntityRecordNameResult)
 export class EntityRecordNameResolver extends ResolverBase {
@@ -91,53 +84,18 @@ export class EntityRecordNameResolver extends ResolverBase {
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {
       const contextUser = userPayload ? this.GetUserFromPayload(userPayload) : undefined;
-      if (this.IsNameFieldDeniedToUser(e, contextUser)) {
-        LogDebug(
-          `[FieldSecurity] Suppressed GetEntityRecordName for '${EntityName}': ` +
-          `the name field is not readable by this user`
-        );
-        return {
-          Success: false,
-          Status: `Name for record, or record ${pk.ToString()} itself not found, could be an access issue`,
-          CompositeKey: pk,
-          EntityName,
-        };
-      }
-      // Pass the acting user through: the provider signature accepts it, and omitting it ran the
-      // underlying lookup with no identity at all — so row-level security had nothing to filter on
-      // either. The field-level gate above is the column half; this is the row half.
+      // The acting user is what field- and row-level security are applied for.
       const recordName = await md.GetEntityRecordName(e.Name, pk, contextUser);
       if (recordName) return { Success: true, Status: 'OK', CompositeKey: pk, RecordName: recordName, EntityName };
       else
         return {
           Success: false,
-          Status: `Name for record, or record ${pk.ToString()} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
+          Status: `Name for record, or record ${pk.ToString()} itself not found, could be an access issue`,
           CompositeKey: pk,
           EntityName,
         };
     } else return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey: pk, EntityName };
   }
-
-  /**
-   * Whether field security withholds this entity's NAME field from the user.
-   *
-   * Resolves the name field the same way the provider's own lookup does — the designated
-   * `IsNameField`, else a field literally called `Name` — so the check cannot drift from the
-   * value it is guarding. Fails OPEN only where field security does not apply at all (flag off,
-   * no user, no name field), matching every other FLS gate.
-   */
-  protected IsNameFieldDeniedToUser(entity: EntityInfo, contextUser?: UserInfo): boolean {
-    if (!entity?.EnableFieldLevelSecurity || !contextUser) {
-      return false;
-    }
-    const nameField =
-      entity.Fields?.find(f => f.IsNameField) ??
-      entity.Fields?.find(f => f.Name?.trim().toLowerCase() === 'name');
-    if (!nameField) {
-      return false;
-    }
-    return entity.GetDeniedReadFields(contextUser).has(nameField.Name.trim().toLowerCase());
-  }
 }
 
 export default EntityRecordNameResolver;

package/src/resolvers/FetchEntityVectorsResolver.ts

@@ -5,6 +5,7 @@ import { MJEntityDocumentEntity, MJVectorIndexEntity, MJVectorDatabaseEntity } f
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetAIAPIKey } from '@memberjunction/ai';
 import { VectorDBBase } from '@memberjunction/ai-vectordb';
+import { AIEngine } from '@memberjunction/aiengine';
 import { EscapeSQLString, MJGlobal, UUIDsEqual } from '@memberjunction/global';
 
 /* ───── GraphQL types ───── */
@@ -99,7 +100,7 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             const metadataFilter: Record<string, unknown> = { Entity: { $eq: entityName } };
 
             const queryResponse = await vectorDBInstance.QueryIndex({
-                id: vectorIndex.Name,  // index name (stripped before Pinecone query)
+                id: AIEngine.Instance.GetProviderIndexName(vectorIndex),
                 vector: uniformVector,
                 topK: limit,
                 includeMetadata: true,

package/src/resolvers/GetDataResolver.ts

@@ -1,4 +1,5 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query } from 'type-graphql';
+import { SQLExpressionValidator } from '@memberjunction/global';
 import { AppContext } from '../types.js';
 import { LogError, LogStatus, LogStatusEx, Metadata } from '@memberjunction/core';
 import { QueryCompositionEngine } from '@memberjunction/generic-database-provider';
@@ -154,6 +155,15 @@ export class GetDataResolver {
                             resolvedSQL = compositionResult.ResolvedSQL;
                         }
 
+                        // Defense-in-depth: even system-token holders get SELECT-only SQL here.
+                        // The read-only pool is the primary control, but if it is ever
+                        // misconfigured to a read-write login this validator still refuses DML/DDL
+                        // (mirrors AdhocQueryResolver).
+                        const validation = SQLExpressionValidator.Instance.validateFullQuery(resolvedSQL);
+                        if (!validation.valid) {
+                            return { result: null, error: validation.error || 'SQL validation failed' };
+                        }
+
                         const request = new sql.Request(readOnlyDataSource);
                         const result = await request.query(resolvedSQL);
                         return { result: result.recordset, error: null };