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

package/src/__tests__/ConnectionPauseResolver.test.ts

@@ -0,0 +1,166 @@
+/**
+ * everything.txt C6 — "deactivate" has to stop the connection, not just flag it.
+ *
+ * Before this, IsActive=false stopped syncs (the engine checks it) and nothing else. The cron
+ * jobs kept firing, DISCOVERY was never gated at all — so a paused connection went on rescanning
+ * the vendor on a timer — and an in-flight sync ran to the end. Each test below pins one of the
+ * three things that now have to happen, plus the two things that must NOT.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+
+function methodBody(name: string): string {
+  const i = SRC.indexOf(`async ${name}(`);
+  expect(i, `${name} not found`).toBeGreaterThan(-1);
+  const rest = SRC.slice(i);
+  const end = rest.search(/\n    @(Query|Mutation)\(/);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+describe('IntegrationDeactivateConnection — pause means pause', () => {
+  const body = () => methodBody('IntegrationDeactivateConnection');
+
+  it('writes IsActive=false before anything else can fail', () => {
+    // The flag is what every other actor reads. If a later step throws, the connection must
+    // still be paused — a half-done pause that left IsActive true would be the worst outcome.
+    const b = body();
+    const flag = b.indexOf('ci.IsActive = false');
+    const schedules = b.indexOf('findScheduledJobsForConnection');
+    expect(flag).toBeGreaterThan(-1);
+    expect(schedules).toBeGreaterThan(flag);
+  });
+
+  it('pauses the scheduled jobs', () => {
+    expect(body()).toMatch(/DecideSchedulesToPause/);
+    expect(body()).toMatch(/setScheduledJobStatus\([^)]*'Paused'/s);
+  });
+
+  it('records what it paused through the guard that survives a second pause', () => {
+    // DecidePauseWrite is the only thing standing between a re-pause and a lost record.
+    expect(body()).toMatch(/DecidePauseWrite/);
+    expect(body()).toMatch(/WritePausedSchedules/);
+  });
+
+  it('asks an in-flight sync to stop', () => {
+    expect(body()).toMatch(/CancelSyncAsync/);
+  });
+
+  it('reports how far the cancel actually reached instead of assuming', () => {
+    const b = body();
+    expect(b).toMatch(/DescribeCancelScope/);
+    expect(b).toMatch(/IsSyncRunningInThisProcess/);
+    expect(b).toMatch(/CancelScope/);
+  });
+
+  it('NEVER touches entity maps — those are the user\'s table selection, not pause state', () => {
+    const b = body();
+    expect(b).not.toMatch(/DisableUnselectedEntityMaps/);
+    expect(b).not.toMatch(/SetEntityMapEnabled/);
+    expect(b).not.toMatch(/Company Integration Entity Maps/);
+  });
+
+  it('returns the richer type, so a caller can tell a real stop from a hope', () => {
+    expect(SRC).toMatch(/@Mutation\(\(\) => DeactivateConnectionOutput\)\s*\n\s*async IntegrationDeactivateConnection/);
+  });
+});
+
+describe('IntegrationReactivateConnection — restore exactly what pause took', () => {
+  const body = () => methodBody('IntegrationReactivateConnection');
+
+  it('restores through the record, not by activating everything', () => {
+    const b = body();
+    expect(b).toMatch(/DecideSchedulesToResume/);
+    // The tell for the bug this avoids: no unconditional sweep to Active.
+    expect(b).not.toMatch(/jobs\.map\([^)]*'Active'/s);
+  });
+
+  it('consumes the record so the NEXT pause is not treated as a re-pause', () => {
+    // DecidePauseWrite refuses to write when a record is stored. Leaving a consumed record
+    // behind would make every future pause a silent no-op.
+    expect(body()).toMatch(/WritePausedSchedules\(ci\.Configuration, \[\]\)/);
+  });
+
+  it('still does not rescan the source by default', () => {
+    // Resuming a connection and rescanning its schema stay separate decisions.
+    expect(body()).toMatch(/@Arg\("runSchemaRefresh"[^\n]*defaultValue: false/);
+  });
+});
+
+describe('a Save() that returns false is never mistaken for one that worked', () => {
+  // Save() reports a logical failure by returning false, not by throwing. An unchecked save of the
+  // pause record strands the schedules it paused; an unchecked save of the cleared record makes the
+  // next pause record nothing.
+  for (const name of ['IntegrationDeactivateConnection', 'IntegrationReactivateConnection']) {
+    it(`${name} checks every ci.Save()`, () => {
+      const b = methodBody(name);
+      const all = b.match(/ci\.Save\(\)/g) ?? [];
+      const checked = b.match(/if \(!await ci\.Save\(\)\)/g) ?? [];
+      expect(all.length).toBeGreaterThan(1);
+      expect(checked.length).toBe(all.length);
+    });
+  }
+
+  it('pause saves its record BEFORE it moves any job, and moves nothing if that save fails', () => {
+    const b = methodBody('IntegrationDeactivateConnection');
+    const record = b.indexOf('ci.Configuration = WritePausedSchedules(');
+    const recordSave = b.indexOf('if (!await ci.Save())', record);
+    const firstMove = b.indexOf("setScheduledJobStatus(rec.ID, 'Paused'");
+    expect(record).toBeGreaterThan(-1);
+    expect(recordSave).toBeGreaterThan(record);
+    expect(firstMove).toBeGreaterThan(recordSave);
+    expect(b.slice(recordSave, firstMove)).toMatch(/throw new Error/);
+  });
+
+  it('resume says so on every reply when the record will not clear', () => {
+    const b = methodBody('IntegrationReactivateConnection');
+    expect(b).toMatch(/scheduleNote = ' The record of paused schedules could not be cleared/);
+    const carried = (b.match(/\+ scheduleNote/g) ?? []).length + (b.match(/\$\{scheduleNote\}/g) ?? []).length;
+    expect(carried).toBe(4);
+  });
+});
+
+describe('the connection job finder escapes through the shared helpers', () => {
+  it('validates the connection id with sqlUuid and quotes job type ids with EscapeSQLString', () => {
+    const i = SRC.indexOf('private async findScheduledJobsForConnection');
+    const b = SRC.slice(i, SRC.indexOf('private async describeIfPaused'));
+    expect(i).toBeGreaterThan(-1);
+    expect(b).not.toMatch(/\.replace\(\/'\/g/);
+    expect(b).toMatch(/sqlUuid\(companyIntegrationID, 'companyIntegrationID'\)/);
+    expect(b).toMatch(/EscapeSQLString\(id\)/);
+  });
+});
+
+describe('a paused connection is not scanned', () => {
+  it('the detached discovery start refuses', () => {
+    expect(methodBody('IntegrationStartSchemaRefresh')).toMatch(/describeIfPaused/);
+  });
+
+  it('the synchronous refresh refuses', () => {
+    expect(methodBody('IntegrationRefreshConnectorSchema')).toMatch(/describeIfPaused/);
+  });
+
+  it('schema evolution refuses', () => {
+    expect(methodBody('IntegrationSchemaEvolution')).toMatch(/describeIfPaused/);
+  });
+
+  it('both lock-taking paths check BEFORE acquiring the maintenance lock, so a refusal leaks no lock', () => {
+    for (const name of ['IntegrationRefreshConnectorSchema', 'IntegrationSchemaEvolution']) {
+      const b = methodBody(name);
+      const gate = b.indexOf('describeIfPaused');
+      const lock = b.indexOf('AcquireMaintenanceLock');
+      expect(gate, `${name}: gate missing`).toBeGreaterThan(-1);
+      expect(lock, `${name}: lock missing`).toBeGreaterThan(-1);
+      expect(gate, `${name}: gate must precede the lock`).toBeLessThan(lock);
+    }
+  });
+
+  it('the gate fails OPEN — an unreadable connection is not declared paused', () => {
+    const i = SRC.indexOf('private async describeIfPaused');
+    expect(i).toBeGreaterThan(-1);
+    const b = SRC.slice(i, i + 1400);
+    expect(b).toMatch(/catch[\s\S]*return null/);
+  });
+});

package/src/__tests__/ConnectionPauseSave.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Pause and resume, driven through the resolver with a Save() that returns false.
+ *
+ * Save() reports a logical failure by returning false rather than throwing, so the only way to
+ * prove a failed save is handled is to run the mutation against one. ConnectionPauseResolver.test.ts
+ * pins the shape of the code; these pin what happens.
+ */
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, Subscription: noopDecorator,
+        ObjectType: noopDecorator, InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator,
+        Args: noopDecorator, Ctx: noopDecorator, PubSub: noopDecorator, Root: noopDecorator,
+        Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+        createUnionType: () => class {}, registerEnumType: () => undefined,
+        AuthorizationError: class AuthorizationError extends Error {},
+        Float: class {}, Int: class {}, ID: class {},
+    };
+});
+
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+const state = vi.hoisted(() => ({
+    /** Every Save() result in order; anything past the end saves. */
+    saves: [] as boolean[],
+    /** The order things happened in, across the connection row and the jobs. */
+    events: [] as string[],
+    ci: null as null | Record<string, unknown>,
+}));
+
+vi.mock('../util.js', async importOriginal => ({
+    ...(await importOriginal<typeof import('../util.js')>()),
+    GetReadWriteProvider: () => ({
+        GetEntityObject: async () => state.ci,
+    }),
+}));
+
+const { IntegrationDiscoveryResolver } = await import('../resolvers/IntegrationDiscoveryResolver.js');
+const { IntegrationEngine } = await import('@memberjunction/integration-engine');
+const { ReadPausedSchedules, WritePausedSchedules } = await import('../integration/ConnectionPause.js');
+
+type Job = { ID: string; Status: string; Kind: 'sync' | 'discovery' };
+
+function connection(configuration: string | null): Record<string, unknown> {
+    const ci: Record<string, unknown> = {
+        IsActive: true,
+        ScheduleEnabled: true,
+        Configuration: configuration,
+        LatestResult: { Message: 'the database said no' },
+        InnerLoad: async () => true,
+        Save: async () => {
+            const ok = state.saves.length > 0 ? state.saves.shift()! : true;
+            state.events.push(`save:${ok ? 'ok' : 'failed'}:${ReadPausedSchedules(ci.Configuration as string).map(r => r.ID).join(',')}`);
+            return ok;
+        },
+    };
+    return ci;
+}
+
+function resolverWith(jobs: Job[]) {
+    return {
+        getAuthenticatedUser: () => ({ ID: 'user-1' }),
+        findScheduledJobsForConnection: async () => jobs,
+        setScheduledJobStatus: async (id: string, status: string) => {
+            state.events.push(`job:${id}:${status}`);
+            return true;
+        },
+        formatError: (e: unknown) => String(e),
+        startSchemaRefreshPipelineDetached: () => undefined,
+    };
+}
+
+const ctx = { providers: [] } as never;
+
+beforeEach(() => {
+    state.saves = [];
+    state.events = [];
+    vi.spyOn(IntegrationEngine, 'GetSyncProgressAsync').mockResolvedValue(null as never);
+});
+
+describe('IntegrationDeactivateConnection with a failing Save()', () => {
+    const jobs: Job[] = [
+        { ID: 'job-sync', Status: 'Active', Kind: 'sync' },
+        { ID: 'job-disc', Status: 'Active', Kind: 'discovery' },
+    ];
+
+    it('saves the record of what it will pause before it pauses anything', async () => {
+        state.ci = connection(null);
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(true);
+        expect(out.SchedulesPaused).toBe(2);
+        expect(state.events.slice(0, 4)).toEqual([
+            'save:ok:',                      // IsActive = false
+            'save:ok:job-sync,job-disc',     // the record, before any job moves
+            'job:job-sync:Paused',
+            'job:job-disc:Paused',
+        ]);
+    });
+
+    it('pauses nothing, and says so, when the record will not save', async () => {
+        state.ci = connection(null);
+        state.saves = [true, false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(true);
+        expect(out.SchedulesPaused).toBe(0);
+        expect(state.events.filter(e => e.startsWith('job:'))).toEqual([]);
+        expect(out.Message).toContain('Could not pause the schedules');
+    });
+
+    it('stops at the flag when IsActive will not save', async () => {
+        state.ci = connection(null);
+        state.saves = [false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(false);
+        expect(state.events).toEqual(['save:failed:']);
+    });
+});
+
+describe('IntegrationReactivateConnection with a failing Save()', () => {
+    const paused: Job[] = [{ ID: 'job-sync', Status: 'Paused', Kind: 'sync' }];
+    const record = WritePausedSchedules(null, [{ ID: 'job-sync', Kind: 'sync' }]);
+
+    it('restores the recorded jobs and clears the record', async () => {
+        state.ci = connection(record);
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationReactivateConnection.call(resolverWith(paused), 'ci-1', false, false, ctx);
+        expect(out).toEqual({ Success: true, Message: 'Reactivated' });
+        expect(state.events).toEqual(['save:ok:job-sync', 'job:job-sync:Active', 'save:ok:']);
+    });
+
+    it('says so when the record will not clear, instead of reporting a clean resume', async () => {
+        state.ci = connection(record);
+        state.saves = [true, false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationReactivateConnection.call(resolverWith(paused), 'ci-1', false, false, ctx);
+        expect(out.Success).toBe(true);
+        expect(out.Message).toContain('could not be cleared');
+    });
+});

package/src/__tests__/CustomColumnPromoterCompletion.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Completing a promotion after the restart.
+ *
+ * The post-restart consumer calls CompletePromotion with no catalog scope. Unscoped, a connection
+ * with per-connection rows reads as having none, so building its catalog writer threw
+ * PER_CONNECTION_CATALOG_MISSING. CompletePromotion caught that per entity and returned normally,
+ * and the consumer marked the pending work Completed: the columns existed in the database and were
+ * never mapped, with nothing failed anywhere.
+ *
+ * So: the catalog writes run in the connection's own scope, entered per entry; and a failed entry
+ * no longer returns normally — the others still run, then the failure is thrown, so the consumer
+ * fails the pending row instead of completing it.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const h = vi.hoisted(() => ({
+    scopeAtBuild: [] as Array<string | undefined>,
+    savedFields: [] as string[],
+}));
+
+vi.mock('@memberjunction/schema-engine', () => ({
+    RuntimeSchemaManager: { get Instance() { return {}; } },
+}));
+vi.mock('@memberjunction/integration-schema-builder', () => ({ DDLGenerator: class {} }));
+
+// The real scope; only the writer is replaced. It behaves as the real one does for a connection
+// with per-connection rows: outside that connection's scope it cannot tell, and refuses.
+vi.mock('@memberjunction/integration-engine', async (orig) => {
+    const actual = await orig<typeof import('@memberjunction/integration-engine')>();
+    return {
+        ...actual,
+        BuildCatalogWriter: () => {
+            const ci = actual.CurrentCatalogCI();
+            h.scopeAtBuild.push(ci);
+            if (!ci) throw new Error('PER_CONNECTION_CATALOG_MISSING: built outside the connection scope');
+            return {
+                ObjectsInScope: async () => [{ Name: 'Members', ID: 'obj-members' }],
+                FieldsForObject: async () => [],
+                LoadField: async () => null,
+                NewFieldRow: async () => {
+                    const row: Record<string, unknown> = {};
+                    return Object.assign(row, { Save: async () => { h.savedFields.push(String(row.Name)); return true; } });
+                },
+                StampNewField: () => undefined,
+            };
+        },
+    };
+});
+
+import type { UserInfo, IMetadataProvider, EntityInfo } from '@memberjunction/core';
+import { IntegrationEngineBase } from '@memberjunction/integration-engine-base';
+import { WithCatalogScope } from '@memberjunction/integration-engine';
+import { IntegrationCustomColumnPromoter } from '../integration/CustomColumnPromoter.js';
+
+const USER = { ID: 'u-1' } as UserInfo;
+const CONN = 'CCCCCCCC-0000-0000-0000-000000000001';
+const OTHER_CONN = 'CCCCCCCC-0000-0000-0000-000000000002';
+
+type Seams = {
+    createIntegrationObjectFields: (integrationID: string, entityMapID: string, objectName: string, named: unknown[]) => Promise<void>;
+    activeFieldMaps: unknown; createFieldMaps: unknown; spreadAndRebaseline: unknown;
+};
+
+function provider(known: string[]): IMetadataProvider {
+    return {
+        EntityByName: (n: string) => (known.includes(n) ? ({ Name: n } as unknown as EntityInfo) : undefined),
+        PlatformKey: 'sqlserver',
+    } as unknown as IMetadataProvider;
+}
+
+const region = { sourceKey: 'region', columnName: 'region', candidate: { Coverage: 0.5, Inferred: { SchemaFieldType: 'nvarchar', MaxLength: 50 } } };
+
+function entry(entityName: string) {
+    return {
+        EntityName: entityName, EntityMapID: `em-${entityName}`, ExternalObjectName: 'Members', IntegrationID: 'int-1',
+        Columns: [{ SourceKey: 'region', ColumnName: 'region', SchemaFieldType: 'nvarchar', MaxLength: 50, Coverage: 0.5 }],
+    };
+}
+
+beforeEach(() => {
+    h.scopeAtBuild.length = 0;
+    h.savedFields.length = 0;
+    // No catalog entities registered: entering a scope loads nothing and reads nothing.
+    vi.spyOn(IntegrationEngineBase.Instance, 'ProviderToUse', 'get').mockImplementation(() => ({ EntityByName: () => undefined }) as never);
+    vi.spyOn(IntegrationEngineBase.Instance, 'EntityMaps', 'get')
+        .mockReturnValue([{ ID: 'em-Members', CompanyIntegrationID: CONN }] as never);
+    vi.spyOn(IntegrationEngineBase.Instance, 'GetCompanyIntegrationByID')
+        .mockImplementation((id: string) => ({ ID: id }) as never);
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+});
+afterEach(() => { vi.restoreAllMocks(); });
+
+describe('the catalog writes of a promotion run in the connection\'s own scope', () => {
+    it('called with no scope (the post-restart consumer), the writer is built in the connection\'s scope', async () => {
+        const promoter = new IntegrationCustomColumnPromoter(USER, provider([])) as unknown as Seams;
+        await promoter.createIntegrationObjectFields('int-1', 'em-Members', 'Members', [region]);
+        expect(h.scopeAtBuild).toEqual([CONN]);
+        expect(h.savedFields).toEqual(['region']);
+    });
+
+    it('called inside another connection\'s scope, the entry\'s own connection wins', async () => {
+        const promoter = new IntegrationCustomColumnPromoter(USER, provider([])) as unknown as Seams;
+        await WithCatalogScope(OTHER_CONN, () => promoter.createIntegrationObjectFields('int-1', 'em-Members', 'Members', [region]), USER);
+        expect(h.scopeAtBuild).toEqual([CONN]);
+    });
+});
+
+describe('CompletePromotion does not complete over a failed entity', () => {
+    function stub(known: string[], failing: string[] = []) {
+        const promoter = new IntegrationCustomColumnPromoter(USER, provider(known));
+        const p = promoter as unknown as Seams;
+        p.activeFieldMaps = vi.fn().mockResolvedValue(new Map<string, string>());
+        p.createIntegrationObjectFields = vi.fn(async (_i: string, emID: string) => {
+            if (failing.some(f => emID === `em-${f}`)) throw new Error('PER_CONNECTION_CATALOG_MISSING');
+        });
+        const maps = vi.fn().mockResolvedValue(undefined);
+        p.createFieldMaps = maps;
+        p.spreadAndRebaseline = vi.fn().mockResolvedValue(undefined);
+        return { promoter, maps };
+    }
+
+    it('every entry completes: returns the columns and throws nothing', async () => {
+        const { promoter } = stub(['A', 'B']);
+        await expect(promoter.CompletePromotion([entry('A'), entry('B')])).resolves.toEqual([
+            { EntityName: 'A', ColumnName: 'region' },
+            { EntityName: 'B', ColumnName: 'region' },
+        ]);
+    });
+
+    it('one entry fails: the others still complete, then it throws naming the failed one', async () => {
+        const { promoter, maps } = stub(['A', 'B'], ['A']);
+        await expect(promoter.CompletePromotion([entry('A'), entry('B')]))
+            .rejects.toThrow(/PROMOTION_INCOMPLETE: 1 of 2 .*A: PER_CONNECTION_CATALOG_MISSING/);
+        expect(maps).toHaveBeenCalledTimes(1);   // B's field maps were still created
+    });
+
+    it('an entity that is not found after the restart is a failure, not a skip', async () => {
+        const { promoter } = stub(['B']);
+        await expect(promoter.CompletePromotion([entry('A'), entry('B')]))
+            .rejects.toThrow(/PROMOTION_INCOMPLETE: 1 of 2 .*A: entity not found/);
+    });
+});

package/src/__tests__/DeleteConnectionRemovesPerConnectionCatalog.test.ts

@@ -0,0 +1,51 @@
+/**
+ * The per-connection catalog rows carry a plain FK to the connection and nothing cascades, so a
+ * connection that ever ran a discovery on it could not be deleted at all: the CompanyIntegration
+ * delete violated the constraint and the whole cascade rolled back (MJ-CAT-18). The fix deletes
+ * the field rows, then the object rows, inside the same transaction group, before the connection.
+ *
+ * Pinned from source, like PostRestartMapsInCatalogScope: the delete is a transaction over a live
+ * provider, and the fact being pinned is ORDER inside one method body.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+const start = SRC.indexOf('async IntegrationDeleteConnection(');
+const end = SRC.indexOf('// ── SCHEMA EVOLUTION', start);
+const BODY = SRC.slice(start, end);
+
+describe('IntegrationDeleteConnection removes the per-connection catalog before the connection', () => {
+  it('is scoped to the method body', () => {
+    expect(start).toBeGreaterThan(0);
+    expect(end).toBeGreaterThan(start);
+  });
+
+  it('deletes per-connection fields, then objects, then the CompanyIntegration — in that order', () => {
+    const fields = BODY.indexOf("EntityName: 'MJ: Company Integration Object Fields'");
+    const objects = BODY.indexOf("EntityName: 'MJ: Company Integration Objects'");
+    const fieldDelete = BODY.indexOf('field.TransactionGroup = tg;');
+    const objectDelete = BODY.indexOf('object.TransactionGroup = tg;');
+    const ciDelete = BODY.indexOf('ci.TransactionGroup = tg;');
+    expect(objects).toBeGreaterThan(0);
+    expect(fields).toBeGreaterThan(objects);
+    expect(fieldDelete).toBeGreaterThan(fields);
+    expect(objectDelete).toBeGreaterThan(fieldDelete);
+    expect(ciDelete).toBeGreaterThan(objectDelete);
+  });
+
+  it('queues every catalog delete on the same transaction group as the cascade', () => {
+    expect(BODY).toMatch(/field\.TransactionGroup = tg;\s*await field\.Delete\(\);/);
+    expect(BODY).toMatch(/object\.TransactionGroup = tg;\s*await object\.Delete\(\);/);
+  });
+
+  it('is guarded on the catalog entities being registered, so an unmigrated workspace is untouched', () => {
+    expect(BODY).toMatch(/md\.Entities\.some\(e => e\.Name === 'MJ: Company Integration Objects'\)/);
+  });
+
+  it('selects the fields by the objects of THIS connection only', () => {
+    expect(BODY).toMatch(/ExtraFilter: `CompanyIntegrationID='\$\{companyIntegrationID\}'`,\s*ResultType: 'entity_object',\s*\}, sysUser\);\s*const perConnectionObjects/);
+    expect(BODY).toMatch(/ExtraFilter: `CompanyIntegrationObjectID IN \(\$\{objectIDs\}\)`/);
+  });
+});

package/src/__tests__/DetachedDiscoveryStart.test.ts

@@ -0,0 +1,65 @@
+/**
+ * plan.md: "going to a page should NEVER, NEVER trigger such things automatically, it must in a
+ * very clean way tell the user to click a button to start discovery of tables".
+ *
+ * A button needs a call that returns at once. The only discovery entry point that existed was
+ * synchronous - it runs the whole pipeline inline and times out at the gateway on a large catalog -
+ * so both wizards auto-triggered on page entry and adopted whatever run they happened to find.
+ * IntegrationStartSchemaRefresh is the explicit start: it returns a tailable RunID immediately.
+ *
+ * Source-level, for the same reason the sibling default tests are: these are decorator and
+ * argument shapes, and invoking the resolver needs a provider, a connector driver and the RSU
+ * pipeline stood up.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(
+  join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+
+function methodBody(name: string): string {
+  const start = SRC.indexOf(`async ${name}(`);
+  expect(start, `${name} not found`).toBeGreaterThan(-1);
+  const rest = SRC.slice(start);
+  const end = rest.search(/\n    @(Query|Mutation)\(/);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+describe('IntegrationStartSchemaRefresh', () => {
+  it('exists as a mutation', () => {
+    expect(SRC).toMatch(/@Mutation\(\(\) => StartSchemaRefreshOutput\)/);
+    expect(SRC).toMatch(/async IntegrationStartSchemaRefresh\(/);
+  });
+
+  it('launches DETACHED rather than awaiting the pipeline', () => {
+    const body = methodBody('IntegrationStartSchemaRefresh');
+    expect(body).toMatch(/startSchemaRefreshPipelineDetached\(/);
+    // an await on the pipeline would reintroduce the gateway timeout this exists to avoid
+    expect(body).not.toMatch(/await this\.runSchemaRefreshPipeline\(/);
+  });
+
+  it('refuses a second start with the reason, instead of handing back a doomed RunID', () => {
+    const body = methodBody('IntegrationStartSchemaRefresh');
+    expect(body).toMatch(/GetMaintenanceLock\(/);
+    expect(body).toMatch(/RunID: 'not-started'/);
+    expect(body).toMatch(/BlockedBy/);
+  });
+
+  it('probes the lock BEFORE launching, or the refusal is useless', () => {
+    const body = methodBody('IntegrationStartSchemaRefresh');
+    expect(body.indexOf('GetMaintenanceLock('))
+      .toBeLessThan(body.indexOf('startSchemaRefreshPipelineDetached('));
+  });
+
+  it('uses the read-write provider, since the pipeline writes the catalog', () => {
+    expect(methodBody('IntegrationStartSchemaRefresh')).toMatch(/GetReadWriteProvider\(/);
+  });
+
+  it('is a separate mutation, so the synchronous one keeps its real-counts contract', () => {
+    // the synchronous reply promises counts because it waited; a detached launch has only zeros
+    expect(SRC).toMatch(/async IntegrationRefreshConnectorSchema\(/);
+    const detached = methodBody('IntegrationStartSchemaRefresh');
+    expect(detached).not.toMatch(/ObjectsCreated/);
+  });
+});

package/src/__tests__/DurableEntityActionTaskSubmitter.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+const { submitMock } = vi.hoisted(() => ({
+    submitMock: vi.fn(),
+}));
+
+vi.mock('@memberjunction/task-graph', () => ({
+    TaskGraphService: class {
+        public Submit = submitMock;
+    },
+}));
+
+import { DurableEntityActionTaskSubmitter } from '../services/DurableEntityActionTaskSubmitter.js';
+
+describe('DurableEntityActionTaskSubmitter', () => {
+    const contextUser = { ID: 'user-1', Email: 'test@example.com' } as UserInfo;
+
+    beforeEach(() => {
+        submitMock.mockReset();
+        submitMock.mockResolvedValue({ Success: true, ParentTaskID: 'parent-task-1' });
+    });
+
+    it('enlists in request.Provider when supplied instead of minting an isolated provider connection', async () => {
+        const savingProvider = { Name: 'saving-tx-provider', GetEntityObject: vi.fn() } as object as IMetadataProvider;
+        const createProvider = vi.fn();
+        const submitter = new DurableEntityActionTaskSubmitter({ CreateProvider: createProvider }, 'env-1');
+
+        const result = await submitter.Submit({
+            EntityActionID: 'ea-1',
+            ActionID: 'act-1',
+            ActionName: 'Send Order Webhook',
+            EntityID: 'ent-1',
+            EntityName: 'Orders',
+            RecordID: 'ID|ord-1',
+            InvocationType: 'AfterCreate',
+            RedactedParams: { OrderID: 'ord-1' },
+            ContextUser: contextUser,
+            Provider: savingProvider,
+        });
+
+        expect(result).toEqual({ Success: true, ParentTaskID: 'parent-task-1' });
+        expect(createProvider).not.toHaveBeenCalled();
+        expect(submitMock).toHaveBeenCalledTimes(1);
+        expect(submitMock.mock.calls[0][1]).toMatchObject({
+            EnvironmentID: 'env-1',
+            ContextUser: contextUser,
+            Provider: savingProvider,
+        });
+    });
+
+    it('falls back to providerFactory.CreateProvider() when request.Provider is omitted', async () => {
+        const factoryProvider = { Name: 'factory-provider' } as IMetadataProvider;
+        const createProvider = vi.fn().mockResolvedValue(factoryProvider);
+        const submitter = new DurableEntityActionTaskSubmitter({ CreateProvider: createProvider }, 'env-1');
+
+        const result = await submitter.Submit({
+            EntityActionID: 'ea-1',
+            ActionID: 'act-1',
+            ActionName: 'Send Order Webhook',
+            EntityID: 'ent-1',
+            EntityName: 'Orders',
+            RecordID: 'ID|ord-1',
+            InvocationType: 'AfterCreate',
+            RedactedParams: {},
+            ContextUser: contextUser,
+        });
+
+        expect(result).toEqual({ Success: true, ParentTaskID: 'parent-task-1' });
+        expect(createProvider).toHaveBeenCalledTimes(1);
+        expect(submitMock.mock.calls[0][1]).toMatchObject({ Provider: factoryProvider });
+    });
+});