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

package/src/__tests__/ObjectNamesByID.test.ts

@@ -0,0 +1,176 @@
+/**
+ * A table selection's ids resolve against the CONNECTION's catalog, and an apply that resolves
+ * nothing builds nothing.
+ *
+ * Inside a catalog scope, `IntegrationListSourceObjects` hands the picker per-connection
+ * (CompanyIntegrationObject) ids. Every name lookup the apply paths ran read only the shared
+ * `MJ: Integration Objects` catalog, so an id-only selection was dropped with a LogError, the
+ * migration ran with an empty table list, CodeGen and the restart still ran, and the apply reported
+ * Success with 0 tables — 118 picked, 0 built, twice, on a WordPress connection.
+ *
+ * These pin the lookup the four resolver paths now share, and — against the source, because the
+ * resolver needs a provider, a connector and an RSU pipeline to invoke — that the apply refuses an
+ * empty resolution before it builds anything.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { RunView, type UserInfo } from '@memberjunction/core';
+import { IntegrationEngineBase } from '@memberjunction/integration-engine-base';
+import { WithCatalogScope } from '@memberjunction/integration-engine';
+import { LookupObjectNamesByID, OBJECT_ID_LOOKUP_CHUNK } from '../integration/ObjectNamesByID.js';
+
+const USER = { ID: 'user-1' } as UserInfo;
+type RunViewParams = Parameters<RunView['RunView']>[0];
+type RunViewResult = Awaited<ReturnType<RunView['RunView']>>;
+
+/** An engine holding a per-connection catalog: each row is a CIO id, its shared IO id, and a name. */
+function installEngine(rows: Array<{ ID: string; IntegrationObjectID: string | null; Name: string }>, hasCatalog = true) {
+    vi.spyOn(IntegrationEngineBase, 'Instance', 'get').mockReturnValue({
+        HasCompanyIntegrationCatalog: () => hasCatalog,
+        GetCompanyIntegrationObjects: () => rows,
+    } as unknown as IntegrationEngineBase);
+}
+
+describe('LookupObjectNamesByID', () => {
+    let runView: ReturnType<typeof vi.spyOn>;
+    beforeEach(() => {
+        runView = vi.spyOn(RunView.prototype, 'RunView');
+    });
+    afterEach(() => { vi.restoreAllMocks(); });
+
+    it('resolves per-connection ids from the scope\'s catalog with no query, whatever their case', async () => {
+        installEngine([
+            { ID: 'cio-aaa', IntegrationObjectID: 'io-111', Name: 'posts' },
+            { ID: 'cio-bbb', IntegrationObjectID: null, Name: 'pages' },
+        ]);
+
+        const map = await WithCatalogScope('CI-1', () => LookupObjectNamesByID(['CIO-AAA', 'cio-bbb'], USER));
+
+        expect(map.get('CIO-AAA')).toBe('posts');
+        expect(map.get('CIO-BBB')).toBe('pages');
+        expect(runView).not.toHaveBeenCalled();
+    });
+
+    it('also resolves a shared IntegrationObject id through the row that carries it', async () => {
+        installEngine([{ ID: 'cio-aaa', IntegrationObjectID: 'io-111', Name: 'posts' }]);
+
+        const map = await WithCatalogScope('CI-1', () => LookupObjectNamesByID(['IO-111'], USER));
+
+        expect(map.get('IO-111')).toBe('posts');
+        expect(runView).not.toHaveBeenCalled();
+    });
+
+    it('reads a cache miss straight from the connection\'s catalog: one uncached query, scoped to the connection', async () => {
+        installEngine([{ ID: 'cio-aaa', IntegrationObjectID: null, Name: 'posts' }]);
+        runView.mockResolvedValue({ Success: true, Results: [{ ID: 'cio-new', Name: 'comments' }] } as unknown as RunViewResult);
+
+        const map = await WithCatalogScope('CI-1', () => LookupObjectNamesByID(['cio-aaa', 'cio-new'], USER));
+
+        expect(runView).toHaveBeenCalledTimes(1);
+        const params = runView.mock.calls[0][0] as RunViewParams;
+        expect(params.EntityName).toBe('MJ: Company Integration Objects');
+        expect(params.ExtraFilter).toBe("CompanyIntegrationID='CI-1' AND ID IN ('CIO-NEW')");
+        expect(params.BypassCache).toBe(true);
+        expect(params.IgnoreMaxRows).toBe(true);
+        expect(map.get('CIO-NEW')).toBe('comments');
+        expect(map.get('CIO-AAA')).toBe('posts');
+    });
+
+    it(`reads cache misses ${OBJECT_ID_LOOKUP_CHUNK} ids per query`, async () => {
+        installEngine([]);
+        runView.mockResolvedValue({ Success: true, Results: [] } as unknown as RunViewResult);
+        const ids = Array.from({ length: OBJECT_ID_LOOKUP_CHUNK + 1 }, (_, i) => `cio-${i}`);
+
+        await WithCatalogScope('CI-1', () => LookupObjectNamesByID(ids, USER));
+
+        const perConnection = runView.mock.calls.filter(c => (c[0] as RunViewParams).EntityName === 'MJ: Company Integration Objects');
+        expect(perConnection).toHaveLength(2);
+    });
+
+    it('falls through to the shared catalog only for ids neither tier resolved', async () => {
+        installEngine([]);
+        runView
+            .mockResolvedValueOnce({ Success: true, Results: [] } as unknown as RunViewResult)
+            .mockResolvedValueOnce({ Success: true, Results: [{ ID: 'io-9', Name: 'users' }] } as unknown as RunViewResult);
+
+        const map = await WithCatalogScope('CI-1', () => LookupObjectNamesByID(['io-9'], USER));
+
+        expect(runView).toHaveBeenCalledTimes(2);
+        expect((runView.mock.calls[1][0] as RunViewParams).EntityName).toBe('MJ: Integration Objects');
+        expect(map.get('IO-9')).toBe('users');
+    });
+
+    it('outside a catalog scope, queries only the shared catalog — exactly as before', async () => {
+        installEngine([{ ID: 'cio-aaa', IntegrationObjectID: null, Name: 'posts' }]);
+        runView.mockResolvedValue({ Success: true, Results: [{ ID: 'io-1', Name: 'users' }] } as unknown as RunViewResult);
+
+        const map = await LookupObjectNamesByID(['io-1'], USER);
+
+        expect(runView).toHaveBeenCalledTimes(1);
+        const params = runView.mock.calls[0][0] as RunViewParams;
+        expect(params.EntityName).toBe('MJ: Integration Objects');
+        expect(params.ExtraFilter).toBe("ID='IO-1'");
+        expect(map.get('IO-1')).toBe('users');
+    });
+
+    it('quotes ids, so a stray quote cannot break out of the filter', async () => {
+        installEngine([]);
+        runView.mockResolvedValue({ Success: true, Results: [] } as unknown as RunViewResult);
+
+        await LookupObjectNamesByID(["x' OR 1=1 --"], USER);
+
+        expect((runView.mock.calls[0][0] as RunViewParams).ExtraFilter).toBe("ID='X'' OR 1=1 --'");
+    });
+
+    it('escapes ids the way every filter does: a NUL byte never reaches the query', async () => {
+        installEngine([]);
+        runView.mockResolvedValue({ Success: true, Results: [] } as unknown as RunViewResult);
+
+        await LookupObjectNamesByID(['io-1\0'], USER);
+
+        expect((runView.mock.calls[0][0] as RunViewParams).ExtraFilter).toBe("ID='IO-1'");
+    });
+
+    it('asks nothing for an empty selection', async () => {
+        installEngine([]);
+        expect((await LookupObjectNamesByID([], USER)).size).toBe(0);
+        expect(runView).not.toHaveBeenCalled();
+    });
+});
+
+describe('the resolver uses the lookup, and refuses to build an empty resolution', () => {
+    const source = readFileSync(join(__dirname, '../resolvers/IntegrationDiscoveryResolver.ts'), 'utf8');
+    const body = (signature: string): string => {
+        const start = source.indexOf(signature);
+        expect(start, `not found: ${signature}`).toBeGreaterThan(-1);
+        return source.slice(start, source.indexOf('\n    }\n', start));
+    };
+
+    it.each([
+        'private async resolveSelectionPlan(',
+        'private async resolveSourceObjectNames(',
+        'private async resolveSourceObjectsToNames(',
+        'private async resolveObjectInputs(',
+    ])('%s resolves ids through LookupObjectNamesByID, never the shared catalog alone', (signature) => {
+        const fn = body(signature);
+        expect(fn).toContain('LookupObjectNamesByID(');
+        expect(fn).not.toContain("EntityName: 'MJ: Integration Objects'");
+    });
+
+    it('IntegrationApplyAll refuses an empty resolution BEFORE the schema build', () => {
+        const resolve = source.indexOf('const resolved = await this.resolveSourceObjectsToNames(input.SourceObjects, sourceSchema, user);');
+        expect(resolve).toBeGreaterThan(-1);
+        const refusal = source.indexOf('input.SourceObjects.length > 0 && resolvedNames.length === 0', resolve);
+        const build = source.indexOf('this.buildSchemaForConnector(', resolve);
+        expect(refusal).toBeGreaterThan(resolve);
+        expect(refusal).toBeLessThan(build);
+        expect(source.slice(refusal, build)).toContain('Success: false');
+        expect(source.slice(refusal, build)).toContain('Apply refused');
+    });
+
+    it('the batch flow throws on an empty resolution, mirroring the filtered flow', () => {
+        expect(source).toContain('connInput.SourceObjects.length > 0 && resolvedNames.length === 0');
+        expect(source).toContain('No source objects resolved');
+    });
+});

package/src/__tests__/PostRestartMapsInCatalogScope.test.ts

@@ -0,0 +1,146 @@
+/**
+ * The per-connection catalog answers correctly only when a read happens INSIDE a scope naming the
+ * connection; an unscoped read falls back to the shared catalog by design. Every request-time entry
+ * point enters the scope in the resolver. The one entry point that is NOT request-time is the
+ * post-restart consumer in index.ts: after the RSU restarts the process it introspects the connector
+ * to build the entity and field maps, and nothing upstream of it has entered a scope.
+ *
+ * Unscoped, that introspection sees only the declared fields, so every column this connection's own
+ * discovery sampled gets a table column (the RSU built the schema in scope) but no field map, and its
+ * values land in the overflow JSON instead of the column. On the sandbox that was 69 of 556 columns.
+ *
+ * Entering the scope is not enough on its own. In a freshly restarted process nothing has loaded the
+ * connection's catalog, so a synchronous entry reads the shared one; and an async entry loads objects
+ * but not fields, so a connector reading fields gets the connection's objects with none. These run
+ * the real catalog scope from a cold cache, with only the database reads stubbed.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { RunView, type UserInfo } from '@memberjunction/core';
+import {
+    CATALOG_FIELD_COLUMNS,
+    CATALOG_OBJECT_COLUMNS,
+    ENTITY_COMPANY_INTEGRATION_OBJECTS,
+    ENTITY_COMPANY_INTEGRATION_OBJECT_FIELDS,
+    IntegrationEngineBase,
+} from '@memberjunction/integration-engine-base';
+import { CatalogFieldCacheStats, EvictCatalogScope, RunInCatalogScope, WithCatalogScope } from '@memberjunction/integration-engine';
+import { IntrospectInCatalogScope } from '../integration/PostRestartIntrospect.js';
+
+const SRC = readFileSync(join(__dirname, '..', 'index.ts'), 'utf-8');
+
+const INTEGRATION = 'AAAAAAAA-1111-2222-3333-444444444444';
+const CONN = 'CCCCCCCC-0000-0000-0000-000000000001';
+const MEMBERS = 'BBBBBBBB-0000-0000-0000-000000000001';
+const USER = { ID: 'u-1' } as UserInfo;
+type RunViewParams = Parameters<RunView['RunView']>[0];
+type RunViewResult = Awaited<ReturnType<RunView['RunView']>>;
+
+function row(columns: readonly string[], values: Record<string, unknown>) {
+    const all: Record<string, unknown> = {};
+    for (const c of columns) all[c] = null;
+    Object.assign(all, values);
+    return { Fields: Object.keys(all).map(Name => ({ Name })), Get: (c: string) => all[c] };
+}
+const membersRow = row(CATALOG_OBJECT_COLUMNS, {
+    ID: MEMBERS, CompanyIntegrationID: CONN, IntegrationID: INTEGRATION, Name: 'Members', Status: 'Active', Sequence: 1,
+});
+// `region` is the column this connection's discovery sampled; the connector never declared it.
+const memberFields = [
+    row(CATALOG_FIELD_COLUMNS, { ID: 'f0', CompanyIntegrationObjectID: MEMBERS, Name: 'id', Status: 'Active', Sequence: 1 }),
+    row(CATALOG_FIELD_COLUMNS, { ID: 'f1', CompanyIntegrationObjectID: MEMBERS, Name: 'region', Status: 'Active', Sequence: 2 }),
+];
+
+let objectsInDb: ReturnType<typeof row>[] = [];
+let fieldReadFails = false;
+let fieldReads = 0;
+
+function answer(p: RunViewParams): RunViewResult {
+    const ok = (Results: unknown[]) => ({ Success: true, Results } as unknown as RunViewResult);
+    if (p.EntityName === ENTITY_COMPANY_INTEGRATION_OBJECTS) return ok(objectsInDb);
+    if (p.EntityName === ENTITY_COMPANY_INTEGRATION_OBJECT_FIELDS && p.ResultType === 'simple') return ok([]); // the edge set
+    if (p.EntityName === ENTITY_COMPANY_INTEGRATION_OBJECT_FIELDS) {
+        fieldReads++;
+        if (fieldReadFails) return { Success: false, ErrorMessage: 'connection reset', Results: [] } as unknown as RunViewResult;
+        const oid = /CompanyIntegrationObjectID = '([^']+)'/.exec(String(p.ExtraFilter ?? ''))?.[1] ?? '';
+        return ok(oid.toUpperCase() === MEMBERS ? memberFields : []);
+    }
+    return ok([]);
+}
+
+/** What a REST connector's IntrospectSchema reads: the object by integration + name, then its fields. */
+async function introspectMembers(): Promise<string[]> {
+    const base = IntegrationEngineBase.Instance;
+    const obj = base.GetIntegrationObject(INTEGRATION, 'Members');
+    return obj ? base.GetIntegrationObjectFields(obj.ID).map(f => f.Name) : [];
+}
+
+beforeEach(() => {
+    EvictCatalogScope();                     // a freshly restarted process: nothing loaded, nothing warm
+    objectsInDb = [membersRow];
+    fieldReadFails = false;
+    fieldReads = 0;
+    vi.spyOn(RunView.prototype, 'RunView').mockImplementation(async (p: RunViewParams) => answer(p));
+    vi.spyOn(IntegrationEngineBase.Instance, 'ProviderToUse', 'get')
+        .mockImplementation(() => ({ EntityByName: (n: string) => ({ Name: n }) }) as never);
+    IntegrationEngineBase.Instance.SeedForTesting({
+        IntegrationObjects: [], IntegrationObjectFields: [], CompanyIntegrationObjects: [], CompanyIntegrationObjectFields: [],
+    });
+});
+afterEach(() => { vi.restoreAllMocks(); });
+
+describe('post-restart introspection sees the connection\'s own fields from a cold catalog', () => {
+    it('introspects the per-connection fields, sampled column included', async () => {
+        const fields = await IntrospectInCatalogScope(CONN, ['Members'], introspectMembers, USER);
+        expect(fields).toEqual(['id', 'region']);
+    });
+
+    it('releases its pins after the introspection', async () => {
+        await IntrospectInCatalogScope(CONN, ['Members'], introspectMembers, USER);
+        expect(CatalogFieldCacheStats().Pinned).toBe(0);
+    });
+
+    it('releases its pins when the introspection throws, and the error propagates', async () => {
+        await expect(IntrospectInCatalogScope(CONN, ['Members'], async () => { throw new Error('vendor 503'); }, USER))
+            .rejects.toThrow('vendor 503');
+        expect(CatalogFieldCacheStats().Pinned).toBe(0);
+    });
+
+    it('a failed field read throws instead of introspecting an object with no fields', async () => {
+        fieldReadFails = true;
+        const introspect = vi.fn(introspectMembers);
+        await expect(IntrospectInCatalogScope(CONN, ['Members'], introspect, USER)).rejects.toThrow();
+        expect(introspect).not.toHaveBeenCalled();
+    });
+
+    it('a connection with no catalog of its own warms nothing and introspects as before', async () => {
+        objectsInDb = [];
+        const introspect = vi.fn(async () => 'shared');
+        expect(await IntrospectInCatalogScope(CONN, ['Members'], introspect, USER)).toBe('shared');
+        expect(introspect).toHaveBeenCalledOnce();
+        expect(fieldReads).toBe(0);
+    });
+
+    it('why: a synchronous scope on a cold process reads the shared catalog — no object at all', async () => {
+        expect(await RunInCatalogScope(CONN, introspectMembers)).toEqual([]);
+    });
+
+    it('why: an async scope without the warm finds the object but none of its fields', async () => {
+        expect(await WithCatalogScope(CONN, introspectMembers, USER)).toEqual([]);
+    });
+});
+
+describe('index.ts wires the post-restart introspection through it', () => {
+    it('introspects through IntrospectInCatalogScope for the item\'s connection and objects', () => {
+        // Whitespace-tolerant: formatters may wrap the call.
+        expect(SRC).toMatch(
+            /const schema = await IntrospectInCatalogScope\(\s*item\.CompanyIntegrationID\s*,\s*item\.SourceObjectNames\s*,\s*\(\)\s*=>\s*introspect\(\s*companyIntegration\s*,\s*systemUser\s*\)\s*,\s*systemUser\s*,?\s*\)/,
+        );
+    });
+
+    it('has no bare or synchronously scoped post-restart introspect call left', () => {
+        expect(SRC).not.toMatch(/const schema = await introspect\(companyIntegration, systemUser\)/);
+        expect(SRC).not.toMatch(/RunInCatalogScope\(\s*item\.CompanyIntegrationID/);
+    });
+});

package/src/__tests__/QuerySystemUserResolver.childRows.test.ts

@@ -0,0 +1,80 @@
+/**
+ * The child rows `CreateQueryExtended` / `UpdateQueryExtended` return are mapped column by column
+ * from the saved query's rows. A column left out of that mapping reaches the client as `null`
+ * whatever is stored, so every column the GraphQL types carry must be mapped: a field's
+ * nullability, entity-field source and `schema.object` source, a parameter's server-set flag and
+ * a Query Entities row's alternate base view.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('type-graphql', () => {
+    const decoratorFactory = (..._args: unknown[]) => (..._decorated: unknown[]) => undefined;
+    const exportNames = ['Arg', 'Ctx', 'Field', 'InputType', 'Mutation', 'ObjectType', 'Resolver', 'PubSub', 'Int', 'Float'];
+    return { ...Object.fromEntries(exportNames.map((name) => [name, decoratorFactory])), registerEnumType: () => undefined };
+});
+vi.mock('@memberjunction/core-entities-server', () => ({ MJQueryEntityServer: class {} }));
+vi.mock('../generic/DeleteOptionsInput.js', () => ({ DeleteOptionsInput: class {} }));
+vi.mock('../generated/generated.js', () => ({
+    MJQuery_: class {}, MJQueryField_: class {}, MJQueryParameter_: class {}, MJQueryEntity_: class {}, MJQueryPermission_: class {},
+    MJQueryResolver: class {
+        protected async MapFieldNamesToCodeNames(_entityName: string, values: Record<string, unknown>) {
+            return values;
+        }
+    },
+}));
+
+import { MJQueryResolverExtended } from '../resolvers/QuerySystemUserResolver.js';
+
+type MappedRows = { Fields: Record<string, unknown>[]; Parameters: Record<string, unknown>[]; Entities: Record<string, unknown>[] };
+
+const STAMP = new Date('2026-10-28T00:00:00Z');
+
+const FIELD = {
+    ID: 'field-1', QueryID: 'query-1', Query: 'Q', Name: 'UserName', Description: 'The name.', Sequence: 1, SQLBaseType: 'nvarchar', SQLFullType: 'nvarchar(100)',
+    SourceEntityID: 'entity-users', SourceEntity: 'MJ: Users', SourceFieldName: 'Name', SourceEntityFieldID: 'field-users-name', SourceEntityField: 'Name',
+    SourceObjectName: null, IsNullable: false, IsComputed: false, ComputationDescription: null, IsSummary: false, SummaryDescription: null,
+    DetectionMethod: 'Database', AutoDetectConfidenceScore: null, __mj_CreatedAt: STAMP, __mj_UpdatedAt: STAMP,
+};
+
+const OBJECT_FIELD = { ...FIELD, ID: 'field-2', Name: 'Code', SourceEntityID: null, SourceEntity: null, SourceEntityFieldID: null, SourceEntityField: null, SourceFieldName: 'Code', SourceObjectName: 'fixture.Customer', IsNullable: true };
+
+const PARAMETER = {
+    ID: 'parameter-1', QueryID: 'query-1', Query: 'Q', Name: 'OwnerID', Description: null, Type: 'string', IsRequired: true, DefaultValue: null, SampleValue: null,
+    ValidationFilters: null, IsServerSet: true, DetectionMethod: 'Manual', AutoDetectConfidenceScore: null, __mj_CreatedAt: STAMP, __mj_UpdatedAt: STAMP,
+};
+
+const ENTITY = {
+    ID: 'link-1', QueryID: 'query-1', Query: 'Q', EntityID: 'entity-users', Entity: 'MJ: Users', AlternateBaseViewID: 'abv-active', AlternateBaseView: 'Active Users',
+    DetectionMethod: 'Parser', AutoDetectConfidenceScore: 1, __mj_CreatedAt: STAMP, __mj_UpdatedAt: STAMP,
+};
+
+async function mapped(): Promise<MappedRows> {
+    const build = (MJQueryResolverExtended.prototype as unknown as {
+        buildSuccessResult(entity: unknown, user: unknown, provider: unknown): Promise<MappedRows>;
+    }).buildSuccessResult;
+    const entity = { GetAll: () => ({ ID: 'query-1' }), QueryFields: [FIELD, OBJECT_FIELD], QueryParameters: [PARAMETER], QueryEntities: [ENTITY], QueryPermissions: [] };
+    return build.call(new MJQueryResolverExtended(), entity, {}, {});
+}
+
+describe('QuerySystemUserResolver: the saved query\'s child rows are returned with every column', () => {
+    it('returns a field\'s nullability and its entity-field source', async () => {
+        const { Fields } = await mapped();
+        expect(Fields[0]).toMatchObject({ IsNullable: false, SourceEntityFieldID: 'field-users-name', SourceEntityField: 'Name', SourceObjectName: null });
+    });
+
+    it('returns the schema.object source of a field no entity backs', async () => {
+        const { Fields } = await mapped();
+        expect(Fields[1]).toMatchObject({ IsNullable: true, SourceObjectName: 'fixture.Customer', SourceEntityFieldID: null });
+    });
+
+    it('returns a parameter\'s server-set flag', async () => {
+        const { Parameters } = await mapped();
+        expect(Parameters[0]).toMatchObject({ IsServerSet: true });
+    });
+
+    it('returns a Query Entities row\'s alternate base view', async () => {
+        const { Entities } = await mapped();
+        expect(Entities[0]).toMatchObject({ AlternateBaseViewID: 'abv-active', AlternateBaseView: 'Active Users' });
+    });
+});

package/src/__tests__/QuerySystemUserResolver.collision.test.ts

@@ -0,0 +1,200 @@
+/**
+ * #6007: concurrent `CreateQueryExtended` calls with the same name.
+ *
+ * Every request first checks that the name is free, so N requests that arrive together all pass
+ * the check and then race to insert. The database's unique index on (Name, CategoryID) lets one
+ * win. Before the fix, every loser found the winner's row and returned it as its own result, even
+ * with `AutoResolveCollision`, so N callers shared one query. Now:
+ *
+ * - with `AutoResolveCollision`, a loser picks a new unique name and inserts again (bounded), so
+ *   every request gets its own query;
+ * - without it, the existing create-or-get behaviour stays: losers get the query that now exists;
+ * - the existence lookup reads the database, never a cache.
+ *
+ * The provider is a stub whose saves yield before inserting, so concurrent saves interleave the
+ * way they do against a real database, and whose insert enforces the unique name.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { RunViewParams } from '@memberjunction/core';
+
+vi.mock('type-graphql', () => {
+    const decoratorFactory = (..._args: unknown[]) => (..._decorated: unknown[]) => undefined;
+    const exportNames = ['Arg', 'Ctx', 'Field', 'InputType', 'Mutation', 'ObjectType', 'Resolver', 'PubSub', 'Int', 'Float'];
+    return { ...Object.fromEntries(exportNames.map((name) => [name, decoratorFactory])), registerEnumType: () => undefined };
+});
+vi.mock('@memberjunction/core-entities-server', () => ({ MJQueryEntityServer: class {} }));
+vi.mock('../generic/DeleteOptionsInput.js', () => ({ DeleteOptionsInput: class {} }));
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@memberjunction/core')>();
+    return { ...actual, AssertClientInputWritableForUser: () => undefined, LogStatus: () => undefined };
+});
+vi.mock('../generated/generated.js', () => ({
+    MJQuery_: class {}, MJQueryField_: class {}, MJQueryParameter_: class {}, MJQueryEntity_: class {}, MJQueryPermission_: class {},
+    MJQueryResolver: class {
+        protected async CheckAPIKeyScopeAuthorization(): Promise<void> { /* authorized */ }
+        protected async AfterCreate(): Promise<void> { /* no event */ }
+        protected ListenForEntityMessages(): void { /* no pub/sub */ }
+        protected async MapFieldNamesToCodeNames(_entityName: string, values: Record<string, unknown>) { return values; }
+    },
+}));
+
+import { MJQueryResolverExtended, CreateQuerySystemUserInput } from '../resolvers/QuerySystemUserResolver.js';
+import type { AppContext } from '../types.js';
+
+/** One stored query row. */
+interface StoredQuery { ID: string; Name: string; CategoryID: string | null }
+
+const CATEGORY = 'C0000000-0000-0000-0000-000000000001';
+let rows: StoredQuery[];
+let lookups: RunViewParams[];
+/** The child-row reads the resolver made, with every cache bypassed or not. */
+let childReads: RunViewParams[];
+/** The field rows stored per query ID, as the database holds them (the query cache holds none). */
+let storedFields: Map<string, Array<{ ID: string; QueryID: string; Name: string; Sequence: number }>>;
+let nextID: number;
+
+/** A query record as the stub provider hands out: its insert yields first and enforces the unique name. */
+class StubQueryRecord {
+    public ID = '';
+    public Name = '';
+    public CategoryID: string | null = null;
+    public ParameterHints?: Map<string, string>;
+    public EntityInfo = {};
+    public LatestResult: { Message: string; CompleteMessage: string } | null = null;
+    public QueryFields = [];
+    public QueryParameters = [];
+    public QueryEntities = [];
+    public QueryPermissions = [];
+
+    SetMany(values: Record<string, unknown>): void {
+        if (typeof values.Name === 'string') this.Name = values.Name;
+        if (typeof values.CategoryID === 'string') this.CategoryID = values.CategoryID;
+    }
+
+    async Save(): Promise<boolean> {
+        await new Promise(resolve => setTimeout(resolve, 1));
+        if (rows.some(r => r.Name.toLowerCase() === this.Name.toLowerCase() && r.CategoryID === this.CategoryID)) {
+            const message = `Cannot insert duplicate key row in object '__mj.Query' with unique index 'UX_Query_Name_CategoryID'. The duplicate key value is (${this.Name}).`;
+            this.LatestResult = { Message: message, CompleteMessage: message };
+            return false;
+        }
+        this.ID = `Q${++nextID}`;
+        rows.push({ ID: this.ID, Name: this.Name, CategoryID: this.CategoryID });
+        return true;
+    }
+
+    async Load(id: string): Promise<boolean> {
+        const row = rows.find(r => r.ID === id);
+        if (!row) return false;
+        Object.assign(this, row);
+        return true;
+    }
+
+    GetAll(): Record<string, unknown> {
+        return { ID: this.ID, Name: this.Name, CategoryID: this.CategoryID };
+    }
+}
+
+const provider = {
+    async GetEntityObject(): Promise<StubQueryRecord> {
+        return new StubQueryRecord();
+    },
+    async RunViews(params: RunViewParams[]) {
+        childReads.push(...params);
+        return params.map(p => {
+            const queryID = /QueryID='(.*)'/.exec(p.ExtraFilter ?? '')?.[1] ?? '';
+            const results = p.EntityName === 'MJ: Query Fields' ? (storedFields.get(queryID) ?? []) : [];
+            return { Success: true, Results: results, RowCount: results.length, TotalRowCount: results.length, ExecutionTime: 0, ErrorMessage: '', UserViewRunID: '' };
+        });
+    },
+    async RunView(params: RunViewParams) {
+        lookups.push(params);
+        await new Promise(resolve => setTimeout(resolve, 0));
+        const name = /LOWER\(Name\) = LOWER\('(.*)'\)/.exec(params.ExtraFilter ?? '')?.[1]?.replace(/''/g, "'") ?? '';
+        const matches = rows.filter(r => r.Name.toLowerCase() === name.toLowerCase() && r.CategoryID === CATEGORY);
+        return { Success: true, Results: matches, RowCount: matches.length, TotalRowCount: matches.length, ExecutionTime: 0, ErrorMessage: '', UserViewRunID: '' };
+    },
+};
+
+const context = {
+    providers: [{ provider, type: 'Read-Write' }],
+    userPayload: { userRecord: { ID: 'user-1', Email: 'u@example.com', UserRoles: [] } },
+} as unknown as AppContext;
+
+function input(name: string, autoResolve: boolean): CreateQuerySystemUserInput {
+    return Object.assign(new CreateQuerySystemUserInput(), { Name: name, CategoryID: CATEGORY, SQL: 'SELECT 1 AS One', AutoResolveCollision: autoResolve });
+}
+
+async function createConcurrently(count: number, name: string, autoResolve: boolean) {
+    const resolver = new MJQueryResolverExtended();
+    const pubSub = { publish: async () => undefined } as unknown as Parameters<MJQueryResolverExtended['CreateQueryExtended']>[2];
+    return Promise.all(Array.from({ length: count }, () => resolver.CreateQueryExtended(input(name, autoResolve), context, pubSub)));
+}
+
+beforeEach(() => {
+    rows = [];
+    lookups = [];
+    childReads = [];
+    storedFields = new Map();
+    nextID = 0;
+});
+
+describe('CreateQueryExtended — concurrent creates with the same name (#6007)', () => {
+    it('with AutoResolveCollision, gives every concurrent request its own query with its own name', async () => {
+        const results = await createConcurrently(8, 'Revenue By Region', true);
+
+        expect(results.every(r => r.Success)).toBe(true);
+        const ids = new Set(results.map(r => r.Query?.ID));
+        const names = new Set(results.map(r => r.Query?.Name));
+        expect(ids.size).toBe(8);
+        expect(names.size).toBe(8);
+        expect(rows).toHaveLength(8);
+        expect([...names]).toContain('Revenue By Region');
+        expect([...names].filter(n => n !== 'Revenue By Region').every(n => /^Revenue By Region \(\d+\)$/.test(String(n)))).toBe(true);
+    });
+
+    it('without AutoResolveCollision, keeps create-or-get: the requests that lose the race get the query that now exists', async () => {
+        const results = await createConcurrently(5, 'Orders Today', false);
+
+        expect(results.every(r => r.Success)).toBe(true);
+        expect(rows).toHaveLength(1);
+        expect(new Set(results.map(r => r.Query?.ID))).toEqual(new Set([rows[0].ID]));
+    });
+
+    it('without AutoResolveCollision, a request that loses the race gets the other query\'s fields, read from the database', async () => {
+        const saveOnce = StubQueryRecord.prototype.Save;
+        vi.spyOn(StubQueryRecord.prototype, 'Save').mockImplementation(async function (this: StubQueryRecord) {
+            const saved = await saveOnce.call(this);
+            if (saved) storedFields.set(this.ID, [{ ID: `${this.ID}-f1`, QueryID: this.ID, Name: 'One', Sequence: 1 }]);
+            return saved;
+        });
+        const results = await createConcurrently(3, 'With Fields', false);
+
+        const winnerID = rows[0].ID;
+        const losers = results.filter(r => r.Fields?.length === 1);
+        expect(losers).toHaveLength(2);
+        expect(losers.every(r => r.Query?.ID === winnerID && r.Fields?.[0].Name === 'One')).toBe(true);
+        expect(childReads.length).toBeGreaterThan(0);
+        expect(childReads.every(r => r.BypassCache === true)).toBe(true);
+    });
+
+    it('reads every existence check from the database, never a cache', async () => {
+        await createConcurrently(3, 'Uncached', true);
+
+        expect(lookups.length).toBeGreaterThan(0);
+        expect(lookups.every(l => l.BypassCache === true)).toBe(true);
+    });
+
+    it('returns the save failure itself when it is not a name race', async () => {
+        vi.spyOn(StubQueryRecord.prototype, 'Save').mockImplementationOnce(async function (this: StubQueryRecord) {
+            this.LatestResult = { Message: 'Query "Bad" was not saved: MJQ_TAG_IN_STRING_LITERAL', CompleteMessage: 'Query "Bad" was not saved: MJQ_TAG_IN_STRING_LITERAL' };
+            return false;
+        });
+        const [result] = await createConcurrently(1, 'Bad', true);
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('MJQ_TAG_IN_STRING_LITERAL');
+        expect(rows).toHaveLength(0);
+    });
+});