@memberjunction/server 5.15.0 → 5.17.0

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -1,12 +1,29 @@
-import { Resolver, Query, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { Metadata, UserInfo, LogError } from "@memberjunction/core";
-import { MJCompanyIntegrationEntity, MJIntegrationEntity } from "@memberjunction/core-entities";
+import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
+import { CompositeKey, Metadata, RunView, UserInfo, LogError } from "@memberjunction/core";
+import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
+import {
+    MJCompanyIntegrationEntity,
+    MJIntegrationEntity,
+    MJCredentialEntity,
+    MJCompanyIntegrationEntityMapEntity,
+    MJCompanyIntegrationFieldMapEntity,
+    MJCompanyIntegrationRunEntity,
+    MJCompanyIntegrationSyncWatermarkEntity,
+    MJCompanyIntegrationRecordMapEntity,
+    MJScheduledJobEntity,
+    MJScheduledJobTypeEntity,
+    MJScheduledJobRunEntity,
+    MJCompanyIntegrationRunDetailEntity,
+    MJEmployeeCompanyIntegrationEntity
+} from "@memberjunction/core-entities";
 import {
     BaseIntegrationConnector,
     ConnectorFactory,
     ExternalObjectSchema,
     ExternalFieldSchema,
     ConnectionTestResult,
+    IntegrationEngine,
+    IntegrationSyncOptions,
     SourceSchemaInfo
 } from "@memberjunction/integration-engine";
 import {
@@ -14,15 +31,228 @@ import {
     TypeMapper,
     SchemaBuilderInput,
     TargetTableConfig,
-    TargetColumnConfig
+    TargetColumnConfig,
+    ExistingTableInfo,
+    SchemaEvolution
 } from "@memberjunction/integration-schema-builder";
+import { RuntimeSchemaManager, type RSUPipelineStep, type RSUPipelineInput } from "@memberjunction/schema-engine";
+import type { SchemaBuilderOutput } from "@memberjunction/integration-schema-builder";
 import { ResolverBase } from "../generic/ResolverBase.js";
 import { AppContext } from "../types.js";
+import { RequireSystemUser } from "../directives/RequireSystemUser.js";
+import { UserCache } from "@memberjunction/sqlserver-dataprovider";
+
+// ─── RSU Pipeline Output Types ──────────────────────────────────────────────
+
+@ObjectType()
+class RSUStepOutput {
+    @Field() Name: string;
+    @Field() Status: string;
+    @Field() DurationMs: number;
+    @Field() Message: string;
+}
+
+@ObjectType()
+class ApplySchemaOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [RSUStepOutput], { nullable: true }) Steps?: RSUStepOutput[];
+    @Field({ nullable: true }) MigrationFilePath?: string;
+    @Field({ nullable: true }) EntitiesProcessed?: number;
+    @Field({ nullable: true }) GitCommitSuccess?: boolean;
+    @Field({ nullable: true }) APIRestarted?: boolean;
+    @Field(() => [String], { nullable: true }) Warnings?: string[];
+}
+
+@InputType()
+class ApplySchemaBatchItemInput {
+    @Field() CompanyIntegrationID: string;
+    @Field(() => [SchemaPreviewObjectInput]) Objects: SchemaPreviewObjectInput[];
+}
+
+// ─── Apply All Input/Output Types ───────────────────────────────────────────
+
+@InputType()
+class SourceObjectInput {
+    @Field({ description: 'Source object ID (IntegrationObject.ID)' }) SourceObjectID: string;
+    @Field(() => [String], { nullable: true, description: 'Optional field selection. Empty/null = all fields (including any new ones). Only specified fields get field maps.' }) Fields?: string[];
+}
+
+@InputType()
+class ApplyAllInput {
+    @Field() CompanyIntegrationID: string;
+    @Field(() => [SourceObjectInput]) SourceObjects: SourceObjectInput[];
+    @Field({ nullable: true }) CronExpression?: string;
+    @Field({ nullable: true }) ScheduleTimezone?: string;
+    @Field(() => Boolean, { nullable: true, defaultValue: true, description: 'If false, skips the sync step after schema + entity maps are created' }) StartSync?: boolean;
+    @Field(() => Boolean, { nullable: true, defaultValue: false, description: 'If true, ignores watermarks and does a full re-fetch' }) FullSync?: boolean;
+    @Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }) SyncScope?: string;
+}
+
+@ObjectType()
+class ApplyAllEntityMapCreated {
+    @Field() SourceObjectName: string;
+    @Field() EntityName: string;
+    @Field() EntityMapID: string;
+    @Field() FieldMapCount: number;
+}
+
+@ObjectType()
+class ApplyAllOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [RSUStepOutput], { nullable: true }) Steps?: RSUStepOutput[];
+    @Field(() => [ApplyAllEntityMapCreated], { nullable: true }) EntityMapsCreated?: ApplyAllEntityMapCreated[];
+    @Field({ nullable: true }) SyncRunID?: string;
+    @Field({ nullable: true }) ScheduledJobID?: string;
+    @Field({ nullable: true }) GitCommitSuccess?: boolean;
+    @Field({ nullable: true }) APIRestarted?: boolean;
+    @Field(() => [String], { nullable: true }) Warnings?: string[];
+}
+
+@ObjectType()
+class ApplySchemaBatchItemOutput {
+    @Field() CompanyIntegrationID: string;
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [String], { nullable: true }) Warnings?: string[];
+}
+
+@ObjectType()
+class ApplySchemaBatchOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ApplySchemaBatchItemOutput]) Items: ApplySchemaBatchItemOutput[];
+    @Field(() => [RSUStepOutput], { nullable: true }) Steps?: RSUStepOutput[];
+    @Field({ nullable: true }) GitCommitSuccess?: boolean;
+    @Field({ nullable: true }) APIRestarted?: boolean;
+}
+
+// ─── Apply All Batch Input/Output Types ──────────────────────────────────────
+
+@InputType()
+class ApplyAllBatchConnectorInput {
+    @Field() CompanyIntegrationID: string;
+    @Field(() => [SourceObjectInput]) SourceObjects: SourceObjectInput[];
+    /** Optional per-connector schedule. Applied on success. */
+    @Field({ nullable: true }) CronExpression?: string;
+    @Field({ nullable: true }) ScheduleTimezone?: string;
+}
+
+@InputType()
+class ApplyAllBatchInput {
+    @Field(() => [ApplyAllBatchConnectorInput]) Connectors: ApplyAllBatchConnectorInput[];
+    @Field(() => Boolean, { nullable: true, defaultValue: true, description: 'If false, skips sync after schema + entity maps' }) StartSync?: boolean;
+    @Field(() => Boolean, { nullable: true, defaultValue: false, description: 'If true, ignores watermarks and does a full re-fetch' }) FullSync?: boolean;
+    @Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }) SyncScope?: string;
+}
+
+@ObjectType()
+class ApplyAllBatchConnectorResult {
+    @Field() CompanyIntegrationID: string;
+    @Field() IntegrationName: string;
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ApplyAllEntityMapCreated], { nullable: true }) EntityMapsCreated?: ApplyAllEntityMapCreated[];
+    @Field({ nullable: true }) SyncRunID?: string;
+    @Field({ nullable: true }) ScheduledJobID?: string;
+    @Field(() => [String], { nullable: true }) Warnings?: string[];
+}
+
+@ObjectType()
+class ApplyAllBatchOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ApplyAllBatchConnectorResult]) ConnectorResults: ApplyAllBatchConnectorResult[];
+    @Field(() => [RSUStepOutput], { nullable: true }) PipelineSteps?: RSUStepOutput[];
+    @Field({ nullable: true }) GitCommitSuccess?: boolean;
+    @Field({ nullable: true }) APIRestarted?: boolean;
+    @Field() SuccessCount: number;
+    @Field() FailureCount: number;
+}
+
+// ─── Delete Connection Output ────────────────────────────────────────────────
+
+@ObjectType()
+class DeleteConnectionOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) EntityMapsDeleted?: number;
+    @Field({ nullable: true }) FieldMapsDeleted?: number;
+    @Field({ nullable: true }) SchedulesDeleted?: number;
+}
+
+// ─── Schema Evolution Output ─────────────────────────────────────────────────
+
+@ObjectType()
+class SchemaEvolutionOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field() HasChanges: boolean;
+    @Field({ nullable: true }) AddedColumns?: number;
+    @Field({ nullable: true }) ModifiedColumns?: number;
+    @Field(() => [RSUStepOutput], { nullable: true }) Steps?: RSUStepOutput[];
+    @Field({ nullable: true }) GitCommitSuccess?: boolean;
+    @Field({ nullable: true }) APIRestarted?: boolean;
+    @Field(() => [String], { nullable: true }) Warnings?: string[];
+}
+
+// ─── Connector Capabilities Output Type ─────────────────────────────────────
+
+@ObjectType()
+class ConnectorCapabilitiesOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) SupportsGet?: boolean;
+    @Field({ nullable: true }) SupportsCreate?: boolean;
+    @Field({ nullable: true }) SupportsUpdate?: boolean;
+    @Field({ nullable: true }) SupportsDelete?: boolean;
+    @Field({ nullable: true }) SupportsSearch?: boolean;
+}
+
+// --- Connector Discovery Output Types ---
+
+@ObjectType()
+class ConnectorInfoOutput {
+    @Field() IntegrationID: string;
+    @Field() Name: string;
+    @Field({ nullable: true }) Description?: string;
+    @Field({ nullable: true }) ClassName?: string;
+    @Field() IsActive: boolean;
+}
+
+@ObjectType()
+class DiscoverConnectorsOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ConnectorInfoOutput], { nullable: true }) Connectors?: ConnectorInfoOutput[];
+}
+
+// --- Field Map List Output Types ---
+
+@ObjectType()
+class FieldMapSummaryOutput {
+    @Field() ID: string;
+    @Field() EntityMapID: string;
+    @Field({ nullable: true }) SourceFieldName?: string;
+    @Field({ nullable: true }) DestinationFieldName?: string;
+    @Field({ nullable: true }) Status?: string;
+}
+
+@ObjectType()
+class ListFieldMapsOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [FieldMapSummaryOutput], { nullable: true }) FieldMaps?: FieldMapSummaryOutput[];
+}
 
 // --- Output Types ---
 
 @ObjectType()
 class ExternalObjectOutput {
+    @Field({ nullable: true })
+    ID?: string;
+
     @Field()
     Name: string;
 
@@ -117,9 +347,12 @@ class PreviewDataOutput {
 
 @InputType()
 class SchemaPreviewObjectInput {
-    @Field()
+    @Field({ nullable: true, description: 'Source object name. Required if SourceObjectID is not provided.' })
     SourceObjectName: string;
 
+    @Field({ nullable: true, description: 'Source object ID (IntegrationObject.ID). Takes priority over SourceObjectName when provided.' })
+    SourceObjectID?: string;
+
     @Field()
     SchemaName: string;
 
@@ -128,6 +361,9 @@ class SchemaPreviewObjectInput {
 
     @Field()
     EntityName: string;
+
+    @Field(() => [String], { nullable: true, description: 'Optional field selection. If provided, only these source fields are included. Default = all fields.' })
+    Fields?: string[];
 }
 
 @ObjectType()
@@ -204,8 +440,243 @@ class DefaultConfigOutput {
     DefaultObjects?: DefaultObjectConfigOutput[];
 }
 
+// ─── Integration Management Input/Output Types ─────────────────────────────
+
+@InputType()
+class CreateConnectionInput {
+    @Field() IntegrationID: string;
+    @Field() CompanyID: string;
+    @Field() CredentialTypeID: string;
+    @Field() CredentialName: string;
+    @Field() CredentialValues: string;
+    @Field({ nullable: true }) ExternalSystemID?: string;
+    @Field({ nullable: true }) Configuration?: string;
+}
+
+@ObjectType()
+class CreateConnectionOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) CompanyIntegrationID?: string;
+    @Field({ nullable: true }) CredentialID?: string;
+    @Field({ nullable: true }) ConnectionTestSuccess?: boolean;
+    @Field({ nullable: true }) ConnectionTestMessage?: string;
+}
+
+@ObjectType()
+class MutationResultOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+}
+
+@InputType()
+class FieldMapInput {
+    @Field() SourceFieldName: string;
+    @Field() DestinationFieldName: string;
+    @Field({ nullable: true, defaultValue: false }) IsKeyField?: boolean;
+    @Field({ nullable: true, defaultValue: false }) IsRequired?: boolean;
+}
+
+@InputType()
+class EntityMapInput {
+    @Field() ExternalObjectName: string;
+    @Field({ nullable: true }) EntityName?: string;
+    @Field({ nullable: true }) EntityID?: string;
+    @Field({ nullable: true, defaultValue: 'Pull' }) SyncDirection?: string;
+    @Field({ nullable: true, defaultValue: 0 }) Priority?: number;
+    @Field(() => [FieldMapInput], { nullable: true }) FieldMaps?: FieldMapInput[];
+}
+
+@ObjectType()
+class EntityMapCreatedOutput {
+    @Field() EntityMapID: string;
+    @Field() ExternalObjectName: string;
+    @Field() FieldMapCount: number;
+}
+
+@ObjectType()
+class CreateEntityMapsOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [EntityMapCreatedOutput], { nullable: true }) Created?: EntityMapCreatedOutput[];
+}
+
+@ObjectType()
+class StartSyncOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) RunID?: string;
+}
+
+@InputType()
+class CreateScheduleInput {
+    @Field() CompanyIntegrationID: string;
+    @Field() Name: string;
+    @Field() CronExpression: string;
+    @Field({ nullable: true }) Timezone?: string;
+    @Field({ nullable: true }) Description?: string;
+}
+
+@ObjectType()
+class CreateScheduleOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) ScheduledJobID?: string;
+}
+
+@ObjectType()
+class ScheduleSummaryOutput {
+    @Field() ID: string;
+    @Field() Name: string;
+    @Field({ nullable: true }) Status?: string;
+    @Field({ nullable: true }) CronExpression?: string;
+    @Field({ nullable: true }) Timezone?: string;
+    @Field({ nullable: true }) NextRunAt?: string;
+    @Field({ nullable: true }) LastRunAt?: string;
+    @Field({ nullable: true }) RunCount?: number;
+    @Field({ nullable: true }) SuccessCount?: number;
+    @Field({ nullable: true }) FailureCount?: number;
+}
+
+@ObjectType()
+class ListSchedulesOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ScheduleSummaryOutput], { nullable: true }) Schedules?: ScheduleSummaryOutput[];
+}
+
+@InputType()
+class EntityMapUpdateInput {
+    @Field() EntityMapID: string;
+    @Field({ nullable: true }) SyncDirection?: string;
+    @Field({ nullable: true }) Priority?: number;
+    @Field({ nullable: true }) Status?: string;
+}
+
+@ObjectType()
+class EntityMapSummaryOutput {
+    @Field() ID: string;
+    @Field({ nullable: true }) EntityID?: string;
+    @Field({ nullable: true }) Entity?: string;
+    @Field({ nullable: true }) ExternalObjectName?: string;
+    @Field({ nullable: true }) SyncDirection?: string;
+    @Field({ nullable: true }) Priority?: number;
+    @Field({ nullable: true }) Status?: string;
+}
+
+@ObjectType()
+class ListEntityMapsOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [EntityMapSummaryOutput], { nullable: true }) EntityMaps?: EntityMapSummaryOutput[];
+}
+
+@ObjectType()
+class IntegrationStatusOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) IsActive?: boolean;
+    @Field({ nullable: true }) IntegrationName?: string;
+    @Field({ nullable: true }) CompanyIntegrationID?: string;
+    @Field({ nullable: true }) TotalEntityMaps?: number;
+    @Field({ nullable: true }) ActiveEntityMaps?: number;
+    @Field({ nullable: true }) LastRunStatus?: string;
+    @Field({ nullable: true }) LastRunStartedAt?: string;
+    @Field({ nullable: true }) LastRunEndedAt?: string;
+    @Field({ nullable: true }) ScheduleEnabled?: boolean;
+    // RSU pipeline state
+    @Field({ nullable: true }) RSUEnabled?: boolean;
+    @Field({ nullable: true }) RSURunning?: boolean;
+    @Field({ nullable: true }) RSUOutOfSync?: boolean;
+    @Field({ nullable: true }) RSULastRunAt?: string;
+    @Field({ nullable: true }) RSULastRunResult?: string;
+}
+
+@ObjectType()
+class SyncRunEntityDetail {
+    @Field() EntityName: string;
+    @Field() InsertCount: number;
+    @Field() UpdateCount: number;
+    @Field() SkipCount: number;
+    @Field() ErrorCount: number;
+}
+
+@ObjectType()
+class SyncRunSummaryOutput {
+    @Field() ID: string;
+    @Field({ nullable: true }) Status?: string;
+    @Field({ nullable: true }) StartedAt?: string;
+    @Field({ nullable: true }) EndedAt?: string;
+    @Field({ nullable: true }) TotalRecords?: number;
+    @Field({ nullable: true }) RunByUserID?: string;
+    @Field(() => [SyncRunEntityDetail], { nullable: true }) EntityDetails?: SyncRunEntityDetail[];
+}
+
+@ObjectType()
+class SyncHistoryOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [SyncRunSummaryOutput], { nullable: true }) Runs?: SyncRunSummaryOutput[];
+}
+
+@ObjectType()
+class OperationProgressOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) OperationType?: string; // 'sync' | 'rsu' | 'none'
+    @Field({ nullable: true }) IsRunning?: boolean;
+    @Field({ nullable: true }) CurrentEntity?: string;
+    @Field({ nullable: true }) EntityMapsTotal?: number;
+    @Field({ nullable: true }) EntityMapsCompleted?: number;
+    @Field({ nullable: true }) RecordsProcessed?: number;
+    @Field({ nullable: true }) RecordsCreated?: number;
+    @Field({ nullable: true }) RecordsUpdated?: number;
+    @Field({ nullable: true }) RecordsErrored?: number;
+    @Field({ nullable: true }) RSUStep?: string;
+    @Field({ nullable: true }) RSURunning?: boolean;
+    @Field({ nullable: true }) ElapsedMs?: number;
+    @Field({ nullable: true }) StartedAt?: string;
+}
+
+// Sync progress is now tracked inside IntegrationEngine itself via IntegrationEngine.GetSyncProgress()
+
+@ObjectType()
+class ConnectionSummaryOutput {
+    @Field() ID: string;
+    @Field() IntegrationName: string;
+    @Field() IntegrationID: string;
+    @Field() CompanyID: string;
+    @Field({ nullable: true }) Company?: string;
+    @Field() IsActive: boolean;
+    @Field() ScheduleEnabled: boolean;
+    @Field({ nullable: true }) CronExpression?: string;
+    @Field() CreatedAt: string;
+}
+
+@ObjectType()
+class ListConnectionsOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field(() => [ConnectionSummaryOutput], { nullable: true }) Connections?: ConnectionSummaryOutput[];
+}
+
 // --- Resolver ---
 
+// ── Validation helpers for entity map union types ──────────────────────
+const VALID_SYNC_DIRECTIONS = ['Bidirectional', 'Pull', 'Push'] as const;
+type SyncDirection = typeof VALID_SYNC_DIRECTIONS[number];
+
+function isValidSyncDirection(value: string): value is SyncDirection {
+    return (VALID_SYNC_DIRECTIONS as readonly string[]).includes(value);
+}
+
+const VALID_ENTITY_MAP_STATUSES = ['Active', 'Inactive'] as const;
+type EntityMapStatus = typeof VALID_ENTITY_MAP_STATUSES[number];
+
+function isValidEntityMapStatus(value: string): value is EntityMapStatus {
+    return (VALID_ENTITY_MAP_STATUSES as readonly string[]).includes(value);
+}
+
 /**
  * GraphQL resolver for integration discovery operations.
  * Provides endpoints to test connections, discover objects, and discover fields
@@ -214,6 +685,45 @@ class DefaultConfigOutput {
 @Resolver()
 export class IntegrationDiscoveryResolver extends ResolverBase {
 
+    /**
+     * Lists all registered integration connectors (active by default).
+     * Useful for populating connector selection UIs.
+     */
+    @Query(() => DiscoverConnectorsOutput)
+    async IntegrationDiscoverConnectors(
+        @Arg("companyID", { nullable: true }) companyID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<DiscoverConnectorsOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView<MJIntegrationEntity>({
+                EntityName: 'MJ: Integrations',
+                ExtraFilter: '',
+                OrderBy: 'Name',
+                ResultType: 'entity_object'
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+
+            return {
+                Success: true,
+                Message: `${result.Results.length} connectors available`,
+                Connectors: result.Results
+                    .map(r => ({
+                        IntegrationID: r.ID,
+                        Name: r.Name,
+                        Description: r.Description,
+                        ClassName: r.ClassName,
+                        IsActive: true
+                    }))
+            };
+        } catch (e) {
+            LogError(`IntegrationDiscoverConnectors error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
     /**
      * Discovers available objects/tables in the external system.
      */
@@ -236,6 +746,7 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 Success: true,
                 Message: `Discovered ${objects.length} objects`,
                 Objects: objects.map(o => ({
+                    ID: o.ID,
                     Name: o.Name,
                     Label: o.Label,
                     SupportsIncrementalSync: o.SupportsIncrementalSync,
@@ -305,11 +816,10 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 ServerVersion: result.ServerVersion
             };
         } catch (e) {
-            const error = e as Error;
-            LogError(`IntegrationTestConnection error: ${error}`);
+            LogError(`IntegrationTestConnection error: ${this.formatError(e)}`);
             return {
                 Success: false,
-                Message: `Error: ${error.message}`
+                Message: `Error: ${this.formatError(e)}`
             };
         }
     }
@@ -352,11 +862,10 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 }))
             };
         } catch (e) {
-            const error = e as Error;
-            LogError(`IntegrationGetDefaultConfig error: ${error}`);
+            LogError(`IntegrationGetDefaultConfig error: ${this.formatError(e)}`);
             return {
                 Success: false,
-                Message: `Error: ${error.message}`
+                Message: `Error: ${this.formatError(e)}`
             };
         }
     }
@@ -381,26 +890,27 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>;
             const sourceSchema = await introspect(companyIntegration, user);
 
-            // Filter to only requested objects
+            await this.resolveObjectInputs(objects, sourceSchema, user);
+
             const requestedNames = new Set(objects.map(o => o.SourceObjectName));
             const filteredSchema: SourceSchemaInfo = {
                 Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
             };
 
-            // Build target configs from user input + source schema
-            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, platform as 'sqlserver' | 'postgresql');
+            const validatedPlatform = this.validatePlatform(platform);
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
 
             // Run SchemaBuilder
             const input: SchemaBuilderInput = {
                 SourceSchema: filteredSchema,
                 TargetConfigs: targetConfigs,
-                Platform: platform as 'sqlserver' | 'postgresql',
-                MJVersion: '5.7.0',
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
                 SourceType: companyIntegration.Integration,
-                AdditionalSchemaInfoPath: 'additionalSchemaInfo.json',
-                MigrationsDir: 'migrations/v2',
-                MetadataDir: 'metadata',
-                ExistingTables: [],
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: this.buildExistingTables(targetConfigs),
                 EntitySettingsForTargets: {}
             };
 
@@ -432,11 +942,10 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 Warnings: output.Warnings.length > 0 ? output.Warnings : undefined
             };
         } catch (e) {
-            const error = e as Error;
-            LogError(`IntegrationSchemaPreview error: ${error}`);
+            LogError(`IntegrationSchemaPreview error: ${this.formatError(e)}`);
             return {
                 Success: false,
-                Message: `Error: ${error.message}`
+                Message: `Error: ${this.formatError(e)}`
             };
         }
     }
@@ -467,19 +976,19 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 ContextUser: user
             });
 
+            const truncated = result.Records.slice(0, limit);
             return {
                 Success: true,
-                Message: `Fetched ${result.Records.length} preview records`,
-                Records: result.Records.map(r => ({
+                Message: `Fetched ${truncated.length} preview records${result.Records.length > limit ? ` (truncated from ${result.Records.length})` : ''}`,
+                Records: truncated.map(r => ({
                     Data: JSON.stringify(r.Fields)
                 }))
             };
         } catch (e) {
-            const error = e as Error;
-            LogError(`IntegrationPreviewData error: ${error}`);
+            LogError(`IntegrationPreviewData error: ${this.formatError(e)}`);
             return {
                 Success: false,
-                Message: `Error: ${error.message}`
+                Message: `Error: ${this.formatError(e)}`
             };
         }
     }
@@ -489,13 +998,29 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
     private buildTargetConfigs(
         objects: SchemaPreviewObjectInput[],
         sourceSchema: SourceSchemaInfo,
-        platform: 'sqlserver' | 'postgresql'
+        platform: 'sqlserver' | 'postgresql',
+        connector?: BaseIntegrationConnector
     ): TargetTableConfig[] {
         const mapper = new TypeMapper();
 
+        // Build a lookup from the connector's static metadata for descriptions.
+        // DB entities may not have Description populated yet on first run,
+        // but the connector's GetIntegrationObjects() always has them.
+        const connectorDescriptions = this.buildDescriptionLookup(connector);
+
         return objects.map(obj => {
-            const sourceObj = sourceSchema.Objects.find(o => o.ExternalName === obj.SourceObjectName);
-            const columns: TargetColumnConfig[] = (sourceObj?.Fields ?? []).map(f => ({
+            const sourceObj = sourceSchema.Objects.find(o => o.ExternalName.toLowerCase() === obj.SourceObjectName.toLowerCase());
+            const objDescriptions = connectorDescriptions.get(obj.SourceObjectName.toLowerCase());
+
+            // Filter fields if caller specified a subset
+            const selectedFieldSet = obj.Fields?.length
+                ? new Set(obj.Fields.map(f => f.toLowerCase()))
+                : null;
+            const sourceFields = (sourceObj?.Fields ?? []).filter(f =>
+                !selectedFieldSet || selectedFieldSet.has(f.Name.toLowerCase()) || f.IsPrimaryKey
+            );
+
+            const columns: TargetColumnConfig[] = sourceFields.map(f => ({
                 SourceFieldName: f.Name,
                 TargetColumnName: f.Name.replace(/[^A-Za-z0-9_]/g, '_'),
                 TargetSqlType: mapper.MapSourceType(f.SourceType, platform, f),
@@ -503,7 +1028,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 MaxLength: f.MaxLength,
                 Precision: f.Precision,
                 Scale: f.Scale,
-                DefaultValue: f.DefaultValue
+                DefaultValue: f.DefaultValue,
+                Description: f.Description ?? objDescriptions?.fields.get(f.Name.toLowerCase()),
             }));
 
             const primaryKeyFields = (sourceObj?.Fields ?? [])
@@ -515,6 +1041,7 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 SchemaName: obj.SchemaName,
                 TableName: obj.TableName,
                 EntityName: obj.EntityName,
+                Description: sourceObj?.Description ?? objDescriptions?.objectDescription,
                 Columns: columns,
                 PrimaryKeyFields: primaryKeyFields.length > 0 ? primaryKeyFields : ['ID'],
                 SoftForeignKeys: []
@@ -522,6 +1049,122 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         });
     }
 
+    /** Builds a lookup of object name → { objectDescription, fields: fieldName → description } from the connector's static metadata. */
+    /** Build ExistingTableInfo[] from MJ Metadata for tables that already exist in the target schemas. */
+    private buildExistingTables(targetConfigs: TargetTableConfig[]): ExistingTableInfo[] {
+        const md = new Metadata();
+        const result: ExistingTableInfo[] = [];
+        for (const config of targetConfigs) {
+            const entity = md.Entities.find(e =>
+                e.SchemaName.toLowerCase() === config.SchemaName.toLowerCase() &&
+                e.BaseTable.toLowerCase() === config.TableName.toLowerCase()
+            );
+            if (entity) {
+                result.push({
+                    SchemaName: config.SchemaName,
+                    TableName: config.TableName,
+                    Columns: entity.Fields.map(f => ({
+                        Name: f.Name,
+                        SqlType: f.SQLFullType || 'NVARCHAR(MAX)',
+                        IsNullable: f.AllowsNull,
+                        MaxLength: f.MaxLength,
+                        Precision: f.Precision,
+                        Scale: f.Scale,
+                    }))
+                });
+            }
+        }
+        return result;
+    }
+
+    private buildDescriptionLookup(connector?: BaseIntegrationConnector): Map<string, { objectDescription?: string; fields: Map<string, string> }> {
+        const result = new Map<string, { objectDescription?: string; fields: Map<string, string> }>();
+        if (!connector) return result;
+
+        const staticObjects = connector.GetIntegrationObjects();
+        for (const obj of staticObjects) {
+            const fieldMap = new Map<string, string>();
+            for (const f of obj.Fields) {
+                if (f.Description) fieldMap.set(f.Name.toLowerCase(), f.Description);
+            }
+            result.set(obj.Name.toLowerCase(), { objectDescription: obj.Description, fields: fieldMap });
+        }
+        return result;
+    }
+
+    /**
+     * Resolves source object IDs to exact names from the DB, and normalizes names
+     * to match the source schema's ExternalName casing. Call once at each entry point.
+     */
+    private async resolveSourceObjectNames(
+        ids: string[] | undefined,
+        names: string[] | undefined,
+        sourceSchema: SourceSchemaInfo,
+        integrationID: string,
+        user: UserInfo
+    ): Promise<string[]> {
+        // If IDs provided, resolve them to names from IntegrationObject records
+        if (ids && ids.length > 0) {
+            const rv = new RunView();
+            const result = await rv.RunView<{ ID: string; Name: string }>({
+                EntityName: 'MJ: Integration Objects',
+                ExtraFilter: ids.map(id => `ID='${id}'`).join(' OR '),
+                ResultType: 'simple',
+                Fields: ['ID', 'Name'],
+            }, user);
+            if (result.Success) {
+                return result.Results.map(r => r.Name);
+            }
+        }
+
+        // Otherwise normalize provided names against source schema casing
+        if (names && names.length > 0) {
+            const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+            return names.map(n => nameMap.get(n.toLowerCase()) ?? n);
+        }
+
+        return [];
+    }
+
+    /**
+     * Resolves SourceObjectID/SourceObjectName on SchemaPreviewObjectInput array.
+     * Mutates the objects in place — sets SourceObjectName from ID if provided.
+     */
+    private async resolveObjectInputs(
+        objects: SchemaPreviewObjectInput[],
+        sourceSchema: SourceSchemaInfo,
+        user: UserInfo
+    ): Promise<void> {
+        const idsToResolve = objects.filter(o => o.SourceObjectID && !o.SourceObjectName).map(o => o.SourceObjectID!);
+        if (idsToResolve.length > 0) {
+            const rv = new RunView();
+            const result = await rv.RunView<{ ID: string; Name: string }>({
+                EntityName: 'MJ: Integration Objects',
+                ExtraFilter: idsToResolve.map(id => `ID='${id}'`).join(' OR '),
+                ResultType: 'simple',
+                Fields: ['ID', 'Name'],
+            }, user);
+            if (result.Success) {
+                const idToName = new Map(result.Results.map(r => [r.ID.toUpperCase(), r.Name]));
+                for (const obj of objects) {
+                    if (obj.SourceObjectID) {
+                        const resolved = idToName.get(obj.SourceObjectID.toUpperCase());
+                        if (resolved) obj.SourceObjectName = resolved;
+                    }
+                }
+            }
+        }
+
+        // Normalize remaining names to match source schema casing
+        const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+        for (const obj of objects) {
+            if (obj.SourceObjectName) {
+                const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+                if (exact) obj.SourceObjectName = exact;
+            }
+        }
+    }
+
     private getAuthenticatedUser(ctx: AppContext): UserInfo {
         const user = ctx.userPayload.userRecord;
         if (!user) {
@@ -530,6 +1173,13 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         return user;
     }
 
+    /** Get system user for server-side operations that need elevated permissions (cascade deletes, etc.) */
+    private getSystemUser(): UserInfo {
+        const sysUser = UserCache.Instance.GetSystemUser();
+        if (!sysUser) throw new Error('System user not available');
+        return sysUser;
+    }
+
     /**
      * Loads the CompanyIntegration + its parent Integration, then resolves the
      * appropriate connector via ConnectorFactory.
@@ -565,20 +1215,2301 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
             throw new Error(`Integration with ID "${companyIntegration.IntegrationID}" not found`);
         }
 
-        // ConnectorFactory expects its own copy of core-entities types — cast through unknown
-        const connector = ConnectorFactory.Resolve(
-            integration as unknown as Parameters<typeof ConnectorFactory.Resolve>[0]
-        );
+        // ConnectorFactory.Resolve expects MJIntegrationEntity, which is the same type loaded above.
+        // Both this file and ConnectorFactory import from @memberjunction/core-entities.
+        const connector = ConnectorFactory.Resolve(integration);
 
         return { connector, companyIntegration };
     }
 
     private handleDiscoveryError(e: unknown): DiscoverObjectsOutput & DiscoverFieldsOutput {
-        const error = e as Error;
-        LogError(`Integration discovery error: ${error}`);
+        LogError(`Integration discovery error: ${this.formatError(e)}`);
         return {
             Success: false,
-            Message: `Error: ${error.message}`
+            Message: `Error: ${this.formatError(e)}`
         };
     }
+
+    private formatError(e: unknown): string {
+        return e instanceof Error ? e.message : String(e);
+    }
+
+    private static readonly VALID_PLATFORMS = new Set<string>(['sqlserver', 'postgresql']);
+
+    /** Validates and narrows a platform string to the supported union type. */
+    private validatePlatform(platform: string): 'sqlserver' | 'postgresql' {
+        if (!IntegrationDiscoveryResolver.VALID_PLATFORMS.has(platform)) {
+            throw new Error(`Unsupported platform "${platform}". Must be one of: ${[...IntegrationDiscoveryResolver.VALID_PLATFORMS].join(', ')}`);
+        }
+        return platform as 'sqlserver' | 'postgresql';
+    }
+
+    // ── CONNECTION TEST HELPERS ────────────────────────────────────────────
+
+    /**
+     * Tests connectivity for a given CompanyIntegration, reusing the same pattern as IntegrationTestConnection.
+     */
+    private async testConnectionForCI(
+        companyIntegrationID: string,
+        user: UserInfo
+    ): Promise<ConnectionTestResult> {
+        const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+        const testFn = connector.TestConnection.bind(connector) as
+            (ci: unknown, u: unknown) => Promise<ConnectionTestResult>;
+        return testFn(companyIntegration, user);
+    }
+
+    /**
+     * Rolls back a freshly created connection by deleting both the CompanyIntegration and Credential records.
+     */
+    private async rollbackCreatedConnection(
+        ci: MJCompanyIntegrationEntity,
+        credential: MJCredentialEntity
+    ): Promise<void> {
+        try { await ci.Delete(); } catch (e) { LogError(`Rollback: failed to delete CompanyIntegration: ${this.formatError(e)}`); }
+        try { await credential.Delete(); } catch (e) { LogError(`Rollback: failed to delete Credential: ${this.formatError(e)}`); }
+    }
+
+    /**
+     * Snapshots the current credential Values for a given credential ID so they can be restored on rollback.
+     */
+    private async snapshotCredentialValues(
+        credentialID: string | undefined,
+        user: UserInfo
+    ): Promise<string | undefined> {
+        if (!credentialID) return undefined;
+        const md = new Metadata();
+        const credential = await md.GetEntityObject<MJCredentialEntity>('MJ: Credentials', user);
+        const loaded = await credential.InnerLoad(CompositeKey.FromID(credentialID));
+        return loaded ? credential.Values : undefined;
+    }
+
+    /**
+     * Reverts an update to a CompanyIntegration by restoring old configuration, externalSystemID,
+     * and credential values.
+     */
+    private async revertUpdateConnection(
+        ci: MJCompanyIntegrationEntity,
+        oldConfiguration: string | undefined,
+        oldExternalSystemID: string | undefined,
+        oldCredentialValues: string | undefined,
+        user: UserInfo
+    ): Promise<void> {
+        try {
+            // Revert CI fields
+            let dirty = false;
+            if (oldConfiguration !== undefined) { ci.Configuration = oldConfiguration; dirty = true; }
+            if (oldExternalSystemID !== undefined) { ci.ExternalSystemID = oldExternalSystemID; dirty = true; }
+            if (dirty) await ci.Save();
+
+            // Revert credential values
+            if (oldCredentialValues !== undefined && ci.CredentialID) {
+                const md = new Metadata();
+                const credential = await md.GetEntityObject<MJCredentialEntity>('MJ: Credentials', user);
+                const loaded = await credential.InnerLoad(CompositeKey.FromID(ci.CredentialID));
+                if (loaded) {
+                    credential.Values = oldCredentialValues;
+                    await credential.Save();
+                }
+            }
+        } catch (e) {
+            LogError(`Revert update connection failed: ${this.formatError(e)}`);
+        }
+    }
+
+    // ── CONNECTION LIFECYCLE ─────────────────────────────────────────────
+
+    /**
+     * Lists all CompanyIntegrations (optionally filtered by active status).
+     * Returns key fields for dashboard display without requiring a raw RunView call.
+     */
+    @Query(() => ListConnectionsOutput)
+    async IntegrationListConnections(
+        @Arg("activeOnly", { defaultValue: true }) activeOnly: boolean,
+        @Arg("companyID", { nullable: true }) companyID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<ListConnectionsOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const filters: string[] = [];
+            if (activeOnly) filters.push('IsActive=1');
+            if (companyID) filters.push(`CompanyID='${companyID}'`);
+            const filter = filters.join(' AND ');
+            const result = await rv.RunView<MJCompanyIntegrationEntity>({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: filter,
+                OrderBy: 'Integration ASC',
+                ResultType: 'simple',
+                Fields: [
+                    'ID', 'Integration', 'IntegrationID', 'CompanyID', 'Company',
+                    'IsActive', 'ScheduleEnabled', 'CronExpression',
+                    'ExternalSystemID', '__mj_CreatedAt'
+                ]
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+
+            return {
+                Success: true,
+                Message: `${result.Results.length} connections`,
+                Connections: result.Results.map(ci => ({
+                    ID: ci.ID,
+                    IntegrationName: ci.Integration,
+                    IntegrationID: ci.IntegrationID,
+                    CompanyID: ci.CompanyID,
+                    Company: ci.Company,
+                    IsActive: ci.IsActive,
+                    ScheduleEnabled: ci.ScheduleEnabled ?? false,
+                    CronExpression: ci.CronExpression ?? undefined,
+                    CreatedAt: ci.__mj_CreatedAt?.toISOString() ?? '',
+                }))
+            };
+        } catch (e) {
+            LogError(`IntegrationListConnections error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Creates a CompanyIntegration with a linked Credential entity for encrypted credential storage.
+     */
+    @Mutation(() => CreateConnectionOutput)
+    async IntegrationCreateConnection(
+        @Arg("input") input: CreateConnectionInput,
+        @Arg("testConnection", () => Boolean, { defaultValue: false }) testConnection: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<CreateConnectionOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+
+            // 1. Create Credential record with encrypted values
+            const credential = await md.GetEntityObject<MJCredentialEntity>('MJ: Credentials', user);
+            credential.NewRecord();
+            credential.CredentialTypeID = input.CredentialTypeID;
+            credential.Name = input.CredentialName;
+            credential.Values = input.CredentialValues;
+            credential.IsActive = true;
+
+            const credSaved = await credential.Save();
+            if (!credSaved) {
+                const err = credential.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to create Credential: ${err}` };
+            }
+            const credentialID = credential.ID;
+
+            // 2. Create CompanyIntegration linked to the Credential
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            ci.NewRecord();
+            ci.IntegrationID = input.IntegrationID;
+            ci.CompanyID = input.CompanyID;
+            ci.CredentialID = credentialID;
+            ci.IsActive = true;
+            ci.Name = input.CredentialName; // Name is required on CompanyIntegration
+            if (input.ExternalSystemID) ci.ExternalSystemID = input.ExternalSystemID;
+            if (input.Configuration) ci.Configuration = input.Configuration;
+
+            const saved = await ci.Save();
+            if (!saved) {
+                const validationErrors = ci.LatestResult?.Message || 'Unknown validation error';
+                return { Success: false, Message: `Failed to save CompanyIntegration: ${validationErrors}` };
+            }
+
+            // 3. Optionally test the connection; rollback on failure
+            if (testConnection) {
+                const testResult = await this.testConnectionForCI(ci.ID, user);
+                if (!testResult.Success) {
+                    await this.rollbackCreatedConnection(ci, credential);
+                    return {
+                        Success: false,
+                        Message: `Connection test failed: ${testResult.Message}. Connection was not saved.`,
+                        ConnectionTestSuccess: false,
+                        ConnectionTestMessage: testResult.Message
+                    };
+                }
+                return {
+                    Success: true,
+                    Message: 'Connection created and test passed',
+                    CompanyIntegrationID: ci.ID,
+                    CredentialID: credentialID,
+                    ConnectionTestSuccess: true,
+                    ConnectionTestMessage: testResult.Message
+                };
+            }
+
+            return {
+                Success: true,
+                Message: 'Connection created',
+                CompanyIntegrationID: ci.ID,
+                CredentialID: credentialID
+            };
+        } catch (e) {
+            LogError(`IntegrationCreateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Updates credential values and/or configuration on an existing CompanyIntegration.
+     */
+    @Mutation(() => MutationResultOutput)
+    async IntegrationUpdateConnection(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("credentialValues", { nullable: true }) credentialValues: string,
+        @Arg("configuration", { nullable: true }) configuration: string,
+        @Arg("externalSystemID", { nullable: true }) externalSystemID: string,
+        @Arg("testConnection", () => Boolean, { defaultValue: false }) testConnection: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded) return { Success: false, Message: 'CompanyIntegration not found' };
+
+            // Snapshot old values for rollback if testConnection is requested
+            const oldCredentialValues = credentialValues ? await this.snapshotCredentialValues(ci.CredentialID, user) : undefined;
+            const oldConfiguration = ci.Configuration;
+            const oldExternalSystemID = ci.ExternalSystemID;
+
+            // Update linked Credential values if provided
+            if (credentialValues) {
+                const credentialID = ci.CredentialID;
+                if (!credentialID) {
+                    return { Success: false, Message: 'No linked Credential — use IntegrationCreateConnection first' };
+                }
+                const credential = await md.GetEntityObject<MJCredentialEntity>('MJ: Credentials', user);
+                const credLoaded = await credential.InnerLoad(CompositeKey.FromID(credentialID));
+                if (!credLoaded) return { Success: false, Message: 'Linked Credential not found' };
+                credential.Values = credentialValues;
+                if (!await credential.Save()) return { Success: false, Message: 'Failed to update Credential' };
+            }
+
+            let dirty = false;
+            if (configuration !== undefined && configuration !== null) { ci.Configuration = configuration; dirty = true; }
+            if (externalSystemID !== undefined && externalSystemID !== null) { ci.ExternalSystemID = externalSystemID; dirty = true; }
+
+            if (dirty && !await ci.Save()) return { Success: false, Message: 'Failed to save CompanyIntegration' };
+
+            // Optionally test the connection; revert on failure
+            if (testConnection) {
+                const testResult = await this.testConnectionForCI(companyIntegrationID, user);
+                if (!testResult.Success) {
+                    await this.revertUpdateConnection(ci, oldConfiguration, oldExternalSystemID, oldCredentialValues, user);
+                    return { Success: false, Message: `Connection test failed: ${testResult.Message}. Changes have been reverted.` };
+                }
+                return { Success: true, Message: 'Updated and connection test passed' };
+            }
+
+            return { Success: true, Message: 'Updated' };
+        } catch (e) {
+            LogError(`IntegrationUpdateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Soft-deletes a CompanyIntegration by setting IsActive=false.
+     */
+    @Mutation(() => MutationResultOutput)
+    async IntegrationDeactivateConnection(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded) return { Success: false, Message: 'CompanyIntegration not found' };
+            ci.IsActive = false;
+            if (!await ci.Save()) return { Success: false, Message: 'Failed to deactivate' };
+            return { Success: true, Message: 'Deactivated' };
+        } catch (e) {
+            LogError(`IntegrationDeactivateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Reactivates a previously deactivated CompanyIntegration by setting IsActive=true.
+     */
+    @Mutation(() => MutationResultOutput)
+    async IntegrationReactivateConnection(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded) return { Success: false, Message: 'CompanyIntegration not found' };
+            ci.IsActive = true;
+            if (!await ci.Save()) return { Success: false, Message: `Failed to reactivate: ${ci.LatestResult?.Message ?? 'Unknown error'}` };
+            return { Success: true, Message: 'Reactivated' };
+        } catch (e) {
+            LogError(`IntegrationReactivateConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── ENTITY MAPS ─────────────────────────────────────────────────────
+
+    /**
+     * Batch creates entity maps by entity name (resolved by lookup).
+     * Call AFTER the schema pipeline has created the target entities.
+     */
+    @Mutation(() => CreateEntityMapsOutput)
+    async IntegrationCreateEntityMaps(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("entityMaps", () => [EntityMapInput]) entityMaps: EntityMapInput[],
+        @Ctx() ctx: AppContext
+    ): Promise<CreateEntityMapsOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+
+            // Batch resolve entity names → IDs using cached Metadata
+            const namesToResolve = entityMaps.filter(m => m.EntityName && !m.EntityID).map(m => m.EntityName as string);
+            const nameToID = new Map<string, string>();
+
+            if (namesToResolve.length > 0) {
+                const uniqueNames = [...new Set(namesToResolve)];
+                for (const name of uniqueNames) {
+                    const entity = md.EntityByName(name);
+                    if (entity) {
+                        nameToID.set(name, entity.ID);
+                    }
+                }
+                const unresolved = uniqueNames.filter(n => !nameToID.has(n));
+                if (unresolved.length > 0) {
+                    return {
+                        Success: false,
+                        Message: `Entities not found: ${unresolved.join(', ')}. Run the schema pipeline first.`
+                    };
+                }
+            }
+
+            const created: EntityMapCreatedOutput[] = [];
+            for (const mapDef of entityMaps) {
+                const entityID = mapDef.EntityID || nameToID.get(mapDef.EntityName || '');
+                if (!entityID) {
+                    return { Success: false, Message: `No EntityID or EntityName for "${mapDef.ExternalObjectName}"`, Created: created };
+                }
+
+                const em = await md.GetEntityObject<MJCompanyIntegrationEntityMapEntity>('MJ: Company Integration Entity Maps', user);
+                em.NewRecord();
+                em.CompanyIntegrationID = companyIntegrationID;
+                em.ExternalObjectName = mapDef.ExternalObjectName;
+                em.EntityID = entityID;
+                const syncDir = mapDef.SyncDirection || 'Pull';
+                if (!isValidSyncDirection(syncDir)) {
+                    return { Success: false, Message: `Invalid SyncDirection "${syncDir}" for "${mapDef.ExternalObjectName}". Must be one of: ${VALID_SYNC_DIRECTIONS.join(', ')}`, Created: created };
+                }
+                em.SyncDirection = syncDir;
+                em.Priority = mapDef.Priority || 0;
+                em.Status = 'Active';
+
+                if (!await em.Save()) {
+                    return { Success: false, Message: `Failed to create map for ${mapDef.ExternalObjectName}`, Created: created };
+                }
+                const entityMapID = em.ID;
+
+                // Create field maps if provided
+                if (mapDef.FieldMaps) {
+                    for (const fmDef of mapDef.FieldMaps) {
+                        const fm = await md.GetEntityObject<MJCompanyIntegrationFieldMapEntity>('MJ: Company Integration Field Maps', user);
+                        fm.NewRecord();
+                        fm.EntityMapID = entityMapID;
+                        fm.SourceFieldName = fmDef.SourceFieldName;
+                        fm.DestinationFieldName = fmDef.DestinationFieldName;
+                        fm.IsKeyField = fmDef.IsKeyField || false;
+                        fm.IsRequired = fmDef.IsRequired || false;
+                        fm.Status = 'Active';
+                        await fm.Save();
+                    }
+                }
+
+                created.push({
+                    EntityMapID: entityMapID,
+                    ExternalObjectName: mapDef.ExternalObjectName,
+                    FieldMapCount: mapDef.FieldMaps?.length || 0
+                });
+            }
+
+            return { Success: true, Message: `Created ${created.length} entity maps`, Created: created };
+        } catch (e) {
+            LogError(`IntegrationCreateEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── SCHEMA EXECUTION ────────────────────────────────────────────────
+
+    /**
+     * Generates schema artifacts from connector introspection and runs the full
+     * RSU pipeline: write migration file → execute SQL → run CodeGen →
+     * compile TypeScript → restart MJAPI → git commit (if enabled).
+     *
+     * Replaces the old two-step IntegrationSchemaPreview + IntegrationWriteSchemaFiles
+     * pattern. Use IntegrationSchemaPreview to preview generated SQL without applying.
+     */
+    @Mutation(() => ApplySchemaOutput)
+    async IntegrationApplySchema(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("objects", () => [SchemaPreviewObjectInput]) objects: SchemaPreviewObjectInput[],
+        @Arg("platform", { defaultValue: "sqlserver" }) platform: string,
+        @Arg("skipGitCommit", { defaultValue: false }) skipGitCommit: boolean,
+        @Arg("skipRestart", { defaultValue: false }) skipRestart: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<ApplySchemaOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+
+            const introspect = connector.IntrospectSchema.bind(connector) as
+                (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>;
+            const sourceSchema = await introspect(companyIntegration, user);
+
+            await this.resolveObjectInputs(objects, sourceSchema, user);
+
+            const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+            const filteredSchema: SourceSchemaInfo = {
+                Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+            };
+
+            const validatedPlatform = this.validatePlatform(platform);
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
+
+            const input: SchemaBuilderInput = {
+                SourceSchema: filteredSchema,
+                TargetConfigs: targetConfigs,
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+                SourceType: companyIntegration.Integration,
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: this.buildExistingTables(targetConfigs),
+                EntitySettingsForTargets: {}
+            };
+
+            const builder = new SchemaBuilder();
+            const { SchemaOutput, PipelineResult } = await builder.RunSchemaPipeline(input, {
+                SkipGitCommit: skipGitCommit,
+                SkipRestart: skipRestart,
+            });
+
+            return {
+                Success: PipelineResult.Success,
+                Message: PipelineResult.Success
+                    ? `Schema applied — ${PipelineResult.EntitiesProcessed ?? 0} entities processed`
+                    : `Pipeline failed at '${PipelineResult.ErrorStep}': ${PipelineResult.ErrorMessage}`,
+                Steps: PipelineResult.Steps.map((s: RSUPipelineStep) => ({
+                    Name: s.Name,
+                    Status: s.Status,
+                    DurationMs: s.DurationMs,
+                    Message: s.Message,
+                })),
+                MigrationFilePath: PipelineResult.MigrationFilePath,
+                EntitiesProcessed: PipelineResult.EntitiesProcessed,
+                GitCommitSuccess: PipelineResult.GitCommitSuccess,
+                APIRestarted: PipelineResult.APIRestarted,
+                Warnings: SchemaOutput.Warnings.length > 0 ? SchemaOutput.Warnings : undefined,
+            };
+        } catch (e) {
+            LogError(`IntegrationApplySchema error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Batch apply schema for multiple connectors in one RSU pipeline run.
+     * Each item specifies a companyIntegrationID + source objects to create tables for.
+     * All migrations run sequentially, then ONE CodeGen, ONE compile, ONE git PR, ONE restart.
+     */
+    @Mutation(() => ApplySchemaBatchOutput)
+    async IntegrationApplySchemaBatch(
+        @Arg("items", () => [ApplySchemaBatchItemInput]) items: ApplySchemaBatchItemInput[],
+        @Arg("platform", { defaultValue: "sqlserver" }) platform: string,
+        @Arg("skipGitCommit", { defaultValue: false }) skipGitCommit: boolean,
+        @Arg("skipRestart", { defaultValue: false }) skipRestart: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<ApplySchemaBatchOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+            const pipelineInputs: RSUPipelineInput[] = [];
+            const itemResults: ApplySchemaBatchItemOutput[] = [];
+
+            // Phase 1: Build schema artifacts for each connector's objects
+            for (const item of items) {
+                try {
+                    const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(
+                        item.CompanyIntegrationID, item.Objects, validatedPlatform, user, skipGitCommit, skipRestart
+                    );
+                    pipelineInputs.push(rsuInput);
+                    itemResults.push({
+                        CompanyIntegrationID: item.CompanyIntegrationID,
+                        Success: true,
+                        Message: `Schema generated for ${item.Objects.length} object(s)`,
+                        Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                    });
+                } catch (e) {
+                    itemResults.push({
+                        CompanyIntegrationID: item.CompanyIntegrationID,
+                        Success: false,
+                        Message: this.formatError(e),
+                    });
+                }
+            }
+
+            // Phase 2: Run all successful migrations through one pipeline batch
+            if (pipelineInputs.length === 0) {
+                return { Success: false, Message: 'No valid schema inputs to process', Items: itemResults };
+            }
+
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch(pipelineInputs);
+
+            return {
+                Success: batchResult.SuccessCount > 0,
+                Message: `Batch complete: ${batchResult.SuccessCount} succeeded, ${batchResult.FailureCount} failed`,
+                Items: itemResults,
+                Steps: batchResult.Results[0]?.Steps.map((s: RSUPipelineStep) => ({
+                    Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+                })),
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: batchResult.Results[0]?.APIRestarted,
+            };
+        } catch (e) {
+            LogError(`IntegrationApplySchemaBatch error: ${e}`);
+            return { Success: false, Message: this.formatError(e), Items: [] };
+        }
+    }
+
+    // ── APPLY ALL (Full Automatic Flow) ──────────────────────────────────
+
+    /**
+     * Full automatic "Apply All" flow for MJ integrations.
+     * 1. Auto-generates schema/table names from the integration name + source object names
+     * 2. Builds DDL + additionalSchemaInfo
+     * 3. Runs RSU pipeline (migration → CodeGen → compile → git → restart)
+     * 4. Creates CompanyIntegrationEntityMap records for each object
+     * 5. Creates CompanyIntegrationFieldMap records for each field (1:1 mapping)
+     * 6. Starts sync for the integration
+     */
+    @Mutation(() => ApplyAllOutput)
+    async IntegrationApplyAll(
+        @Arg("input") input: ApplyAllInput,
+        @Arg("platform", { defaultValue: "sqlserver" }) platform: string,
+        @Arg("skipGitCommit", { defaultValue: false }) skipGitCommit: boolean,
+        @Arg("skipRestart", { defaultValue: false }) skipRestart: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<ApplyAllOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+
+            // Step 1: Resolve connector and derive schema name
+            const { connector, companyIntegration } = await this.resolveConnector(input.CompanyIntegrationID, user);
+            const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+
+            // Step 2: Resolve object IDs to names, build inputs with per-object Fields
+            const sourceSchema = await (connector.IntrospectSchema.bind(connector) as
+                (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>)(companyIntegration, user);
+            const objectIDs = input.SourceObjects.map(so => so.SourceObjectID);
+            const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
+
+            // Build SchemaPreviewObjectInput with Fields carried from SourceObjectInput
+            const fieldsByID = new Map(input.SourceObjects.map(so => [so.SourceObjectID, so.Fields]));
+            const objects = resolvedNames.map((name, i) => {
+                const obj = new SchemaPreviewObjectInput();
+                obj.SourceObjectName = name;
+                obj.SchemaName = schemaName;
+                obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+                obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+                obj.Fields = fieldsByID.get(objectIDs[i]) ?? undefined;
+                return obj;
+            });
+
+            // Step 3: Build schema and RSU pipeline input
+            const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(
+                input.CompanyIntegrationID, objects, validatedPlatform, user, skipGitCommit, skipRestart
+            );
+
+            // Step 4: Inject integration post-restart payload into RSU input.
+            const { join } = await import('node:path');
+            const rsuWorkDir = process.env.RSU_WORK_DIR || process.cwd();
+            const pendingWorkDir = join(rsuWorkDir, '.rsu_pending');
+            const pendingFilePath = join(pendingWorkDir, `${Date.now()}.json`);
+
+            // Build per-object field map for pending file (null = all fields)
+            const sourceObjectFields: Record<string, string[] | null> = {};
+            for (const so of input.SourceObjects) {
+                const resolvedName = resolvedNames[objectIDs.indexOf(so.SourceObjectID)];
+                if (resolvedName) sourceObjectFields[resolvedName] = so.Fields ?? null;
+            }
+
+            const pendingPayload = {
+                CompanyIntegrationID: input.CompanyIntegrationID,
+                SourceObjectNames: resolvedNames,
+                SourceObjectFields: sourceObjectFields,
+                SchemaName: schemaName,
+                CronExpression: input.CronExpression,
+                ScheduleTimezone: input.ScheduleTimezone,
+                StartSync: input.StartSync,
+                FullSync: input.FullSync ?? false,
+                SyncScope: input.SyncScope ?? 'created',
+                CreatedAt: new Date().toISOString(),
+            };
+            rsuInput.PostRestartFiles = [
+                { Path: pendingFilePath, Content: JSON.stringify(pendingPayload, null, 2) }
+            ];
+
+            // Step 5: Run pipeline (restart kills process at the end)
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+
+            const migrationSucceeded = batchResult.SuccessCount > 0;
+            const pipelineSteps = batchResult.Results[0]?.Steps.map((s: RSUPipelineStep) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
+
+            // If pipeline failed, clean up pending file and return error
+            if (!migrationSucceeded) {
+                try { (await import('node:fs')).unlinkSync(pendingFilePath); } catch { /* may not exist */ }
+                return {
+                    Success: false,
+                    Message: `Pipeline failed: ${batchResult.Results[0]?.ErrorMessage ?? 'unknown error'}`,
+                    Steps: pipelineSteps,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+
+            // If we get here, pipeline succeeded but restart may or may not have happened yet.
+            // If restart happened, this code never executes (process died).
+            // If skipRestart=true, we can do entity maps now.
+            if (skipRestart) {
+                await Metadata.Provider.Refresh();
+                const entityMapsCreated = await this.createEntityAndFieldMaps(
+                    input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user
+                );
+                const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
+                const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
+                const syncRunID = input.StartSync !== false
+                    ? await this.startSyncAfterApply(input.CompanyIntegrationID, user, scopedMapIDs, input.FullSync)
+                    : null;
+
+                // Create schedule if requested
+                let scheduledJobID: string | undefined;
+                if (input.CronExpression) {
+                    try {
+                        scheduledJobID = await this.createScheduleForConnector(
+                            input.CompanyIntegrationID,
+                            companyIntegration.Integration,
+                            input.CronExpression,
+                            input.ScheduleTimezone,
+                            user
+                        ) ?? undefined;
+                    } catch (schedErr) {
+                        console.warn(`[Integration] Schedule creation failed: ${schedErr}`);
+                    }
+                }
+
+                try { (await import('node:fs')).unlinkSync(pendingFilePath); } catch { /* already consumed */ }
+
+                return {
+                    Success: true,
+                    Message: `Applied ${objects.length} object(s) — ${entityMapsCreated.length} entity maps created${syncRunID ? ', sync started' : ''}${scheduledJobID ? ', schedule created' : ''}`,
+                    Steps: pipelineSteps,
+                    EntityMapsCreated: entityMapsCreated,
+                    SyncRunID: syncRunID ?? undefined,
+                    ScheduledJobID: scheduledJobID,
+                    GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                    APIRestarted: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+
+            // If restart is enabled, this return may or may not execute
+            // (depends on whether PM2 kills process before GraphQL response is sent)
+            return {
+                Success: true,
+                Message: `Applied ${objects.length} object(s) — entity maps will be created after restart`,
+                Steps: pipelineSteps,
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: true,
+                Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+            };
+        } catch (e) {
+            LogError(`IntegrationApplyAll error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /** Derives a SQL-safe schema name from the integration name (e.g., "HubSpot" → "hubspot"). */
+    private deriveSchemaName(integrationName: string): string {
+        return (integrationName || 'integration').toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    }
+
+    /** Builds SchemaPreviewObjectInput[] from source object name strings, using auto-derived schema/table names. */
+    private buildObjectInputsFromNames(sourceObjectNames: string[], schemaName: string): SchemaPreviewObjectInput[] {
+        return sourceObjectNames.map(name => {
+            const obj = new SchemaPreviewObjectInput();
+            obj.SourceObjectName = name;
+            obj.SchemaName = schemaName;
+            obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+            obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+            return obj;
+        });
+    }
+
+    /**
+     * After pipeline success, creates CompanyIntegrationEntityMap + CompanyIntegrationFieldMap
+     * records for each source object by matching schema + table name to newly created entities.
+     */
+    private async createEntityAndFieldMaps(
+        companyIntegrationID: string,
+        objects: SchemaPreviewObjectInput[],
+        connector: BaseIntegrationConnector,
+        companyIntegration: MJCompanyIntegrationEntity,
+        schemaName: string,
+        user: UserInfo
+    ): Promise<ApplyAllEntityMapCreated[]> {
+        const md = new Metadata();
+        const results: ApplyAllEntityMapCreated[] = [];
+
+        for (const obj of objects) {
+            const entityMapResult = await this.createSingleEntityMap(
+                companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md
+            );
+            if (entityMapResult) {
+                results.push(entityMapResult);
+            }
+        }
+        return results;
+    }
+
+    /** Creates a single entity map + field maps for one source object. */
+    private async createSingleEntityMap(
+        companyIntegrationID: string,
+        obj: SchemaPreviewObjectInput,
+        connector: BaseIntegrationConnector,
+        companyIntegration: MJCompanyIntegrationEntity,
+        schemaName: string,
+        user: UserInfo,
+        md: Metadata
+    ): Promise<ApplyAllEntityMapCreated | null> {
+        // Find the entity by schema + table name
+        const entityInfo = md.Entities.find(
+            e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
+              && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase()
+        );
+        if (!entityInfo) {
+            LogError(`IntegrationApplyAll: entity not found for ${schemaName}.${obj.TableName}`);
+            return null;
+        }
+
+        // Create entity map
+        const em = await md.GetEntityObject<MJCompanyIntegrationEntityMapEntity>('MJ: Company Integration Entity Maps', user);
+        em.NewRecord();
+        em.CompanyIntegrationID = companyIntegrationID;
+        em.ExternalObjectName = obj.SourceObjectName;
+        em.EntityID = entityInfo.ID;
+        em.SyncDirection = 'Pull';
+        em.Priority = 0;
+        em.Status = 'Active';
+        em.SyncEnabled = true;
+
+        if (!await em.Save()) {
+            LogError(`IntegrationApplyAll: failed to save entity map for ${obj.SourceObjectName}`);
+            return null;
+        }
+
+        // Discover fields from the source and create 1:1 field maps
+        const fieldMapCount = await this.createFieldMapsForEntityMap(
+            em.ID, obj.SourceObjectName, connector, companyIntegration, user, md
+        );
+
+        return {
+            SourceObjectName: obj.SourceObjectName,
+            EntityName: entityInfo.Name,
+            EntityMapID: em.ID,
+            FieldMapCount: fieldMapCount,
+        };
+    }
+
+    /** Discovers fields from the source object and creates 1:1 field maps. */
+    private async createFieldMapsForEntityMap(
+        entityMapID: string,
+        sourceObjectName: string,
+        connector: BaseIntegrationConnector,
+        companyIntegration: MJCompanyIntegrationEntity,
+        user: UserInfo,
+        md: Metadata
+    ): Promise<number> {
+        let fieldCount = 0;
+        try {
+            const discoverFields = connector.DiscoverFields.bind(connector) as
+                (ci: unknown, obj: string, u: unknown) => Promise<ExternalFieldSchema[]>;
+            const fields = await discoverFields(companyIntegration, sourceObjectName, user);
+
+            for (const field of fields) {
+                const fm = await md.GetEntityObject<MJCompanyIntegrationFieldMapEntity>('MJ: Company Integration Field Maps', user);
+                fm.NewRecord();
+                fm.EntityMapID = entityMapID;
+                fm.SourceFieldName = field.Name;
+                fm.DestinationFieldName = field.Name.replace(/[^A-Za-z0-9_]/g, '_');
+                fm.IsKeyField = field.IsUniqueKey;
+                fm.IsRequired = field.IsRequired;
+                fm.Direction = 'SourceToDest';
+                fm.Status = 'Active';
+                fm.Priority = 0;
+
+                if (await fm.Save()) {
+                    fieldCount++;
+                }
+            }
+        } catch (e) {
+            LogError(`IntegrationApplyAll: failed to discover/create field maps for ${sourceObjectName}: ${this.formatError(e)}`);
+        }
+        return fieldCount;
+    }
+
+    /** Starts sync after a successful apply-all pipeline, returning the run ID if available. */
+    private async startSyncAfterApply(companyIntegrationID: string, user: UserInfo, entityMapIDs?: string[], fullSync?: boolean): Promise<string | null> {
+        try {
+            await IntegrationEngine.Instance.Config(false, user);
+            const options: IntegrationSyncOptions = {};
+            if (entityMapIDs?.length) options.EntityMapIDs = entityMapIDs;
+            if (fullSync) options.FullSync = true;
+            const finalOptions = Object.keys(options).length > 0 ? options : undefined;
+            const syncPromise = IntegrationEngine.Instance.RunSync(companyIntegrationID, user, 'Manual', undefined, undefined, finalOptions);
+
+            // Fire and forget — don't block the response
+            syncPromise.catch(err => {
+                LogError(`IntegrationApplyAll: background sync failed for ${companyIntegrationID}: ${err}`);
+            });
+
+            // Small delay to let the run record get created
+            await new Promise(resolve => setTimeout(resolve, 200));
+
+            const rv = new RunView();
+            const runResult = await rv.RunView<{ ID: string }>({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND Status='In Progress'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+
+            return (runResult.Success && runResult.Results.length > 0) ? runResult.Results[0].ID : null;
+        } catch (e) {
+            LogError(`IntegrationApplyAll: sync start failed: ${this.formatError(e)}`);
+            return null;
+        }
+    }
+
+    /**
+     * Build schema artifacts for a single connector's objects.
+     * Shared by IntegrationApplySchema (single) and IntegrationApplySchemaBatch (batch).
+     */
+    private async buildSchemaForConnector(
+        companyIntegrationID: string,
+        objects: SchemaPreviewObjectInput[],
+        platform: 'sqlserver' | 'postgresql',
+        user: UserInfo,
+        skipGitCommit: boolean,
+        skipRestart: boolean
+    ): Promise<{ schemaOutput: SchemaBuilderOutput; rsuInput: RSUPipelineInput }> {
+        const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+
+        const introspect = connector.IntrospectSchema.bind(connector) as
+            (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>;
+        const sourceSchema = await introspect(companyIntegration, user);
+
+        // Normalize names to match source schema casing
+        const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+        for (const obj of objects) {
+            const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+            if (exact) obj.SourceObjectName = exact;
+        }
+
+        const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+        const filteredSchema: SourceSchemaInfo = {
+            Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+        };
+
+        const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, platform, connector);
+
+        const input: SchemaBuilderInput = {
+            SourceSchema: filteredSchema,
+            TargetConfigs: targetConfigs,
+            Platform: platform,
+            MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+            SourceType: companyIntegration.Integration,
+            AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+            MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+            MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+            ExistingTables: this.buildExistingTables(targetConfigs),
+            EntitySettingsForTargets: {}
+        };
+
+        const builder = new SchemaBuilder();
+        const schemaOutput = builder.BuildSchema(input);
+
+        if (schemaOutput.Errors.length > 0) {
+            throw new Error(`Schema generation failed: ${schemaOutput.Errors.join('; ')}`);
+        }
+
+        const rsuInput = builder.BuildRSUInput(schemaOutput, input, { SkipGitCommit: skipGitCommit, SkipRestart: skipRestart });
+        return { schemaOutput, rsuInput };
+    }
+
+    // ── SYNC ────────────────────────────────────────────────────────────
+
+    /**
+     * Starts an async integration sync. Returns immediately with the run ID.
+     * Sends a webhook to the registered callback when complete.
+     */
+    @Mutation(() => StartSyncOutput)
+    async IntegrationStartSync(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("webhookURL", { nullable: true }) webhookURL: string,
+        @Arg("fullSync", () => Boolean, { defaultValue: false, description: 'If true, ignores watermarks and re-fetches all records from the source' }) fullSync: boolean,
+        @Arg("entityMapIDs", () => [String], { nullable: true, description: 'Optional: sync only these entity maps. If omitted, syncs all maps for the connector.' }) entityMapIDs: string[],
+        @Ctx() ctx: AppContext
+    ): Promise<StartSyncOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            await IntegrationEngine.Instance.Config(false, user);
+
+            const syncOptions: { FullSync?: boolean; EntityMapIDs?: string[] } = {};
+            if (fullSync) syncOptions.FullSync = true;
+            if (entityMapIDs?.length) syncOptions.EntityMapIDs = entityMapIDs;
+
+            // Fire and forget — progress is tracked inside IntegrationEngine
+            const syncPromise = IntegrationEngine.Instance.RunSync(
+                companyIntegrationID,
+                user,
+                'Manual',
+                undefined,
+                undefined,
+                Object.keys(syncOptions).length > 0 ? syncOptions : undefined
+            );
+
+            syncPromise
+                .then(async (result) => {
+                    if (webhookURL) {
+                        await this.sendWebhook(webhookURL, {
+                            event: result.Success ? 'sync_complete' : 'sync_failed',
+                            companyIntegrationID,
+                            success: result.Success,
+                            recordsProcessed: result.RecordsProcessed,
+                            recordsCreated: result.RecordsCreated,
+                            recordsUpdated: result.RecordsUpdated,
+                            recordsErrored: result.RecordsErrored,
+                            errorCount: result.Errors.length
+                        });
+                    }
+                })
+                .catch(async (err) => {
+                    console.error(`[Integration] Background sync failed for ${companyIntegrationID}:`, err);
+                    if (webhookURL) {
+                        await this.sendWebhook(webhookURL, {
+                            event: 'sync_failed',
+                            companyIntegrationID,
+                            success: false,
+                            error: err instanceof Error ? err.message : String(err)
+                        });
+                    }
+                });
+
+            // Small delay to let the run record get created
+            await new Promise(resolve => setTimeout(resolve, 200));
+
+            const rv = new RunView();
+            const runResult = await rv.RunView<MJCompanyIntegrationRunEntity>({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND Status='In Progress'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID', 'Status', 'StartedAt']
+            }, user);
+
+            const run = runResult.Success && runResult.Results.length > 0 ? runResult.Results[0] : null;
+
+            return {
+                Success: true,
+                Message: 'Sync started',
+                RunID: run?.ID
+            };
+        } catch (e) {
+            LogError(`IntegrationStartSync error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    /**
+     * Cancels a running sync by marking its status as Cancelled.
+     */
+    @Mutation(() => MutationResultOutput)
+    async IntegrationCancelSync(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            this.getAuthenticatedUser(ctx);
+
+            // Signal the engine to abort the running sync
+            const cancelled = IntegrationEngine.CancelSync(companyIntegrationID);
+            if (!cancelled) {
+                return { Success: false, Message: 'No active sync found for this connector' };
+            }
+
+            return { Success: true, Message: 'Sync cancellation signalled — will stop after current batch completes' };
+        } catch (e) {
+            LogError(`IntegrationCancelSync error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── SCHEDULE ────────────────────────────────────────────────────────
+
+    @Mutation(() => CreateScheduleOutput)
+    async IntegrationCreateSchedule(
+        @Arg("input") input: CreateScheduleInput,
+        @Ctx() ctx: AppContext
+    ): Promise<CreateScheduleOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const rv = new RunView();
+
+            // Find IntegrationSync job type
+            const jobTypeResult = await rv.RunView<MJScheduledJobTypeEntity>({
+                EntityName: 'MJ: Scheduled Job Types',
+                ExtraFilter: `DriverClass='IntegrationSyncScheduledJobDriver'`,
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+            if (!jobTypeResult.Success || jobTypeResult.Results.length === 0) {
+                return { Success: false, Message: 'IntegrationSync scheduled job type not found' };
+            }
+            const jobTypeID = jobTypeResult.Results[0].ID;
+
+            const job = await md.GetEntityObject<MJScheduledJobEntity>('MJ: Scheduled Jobs', user);
+            job.NewRecord();
+            job.JobTypeID = jobTypeID;
+            job.Name = input.Name;
+            if (input.Description) job.Description = input.Description;
+            job.CronExpression = input.CronExpression;
+            job.Timezone = input.Timezone || 'UTC';
+            job.Status = 'Active';
+            job.OwnerUserID = user.ID;
+            job.Configuration = JSON.stringify({ CompanyIntegrationID: input.CompanyIntegrationID });
+            job.NextRunAt = CronExpressionHelper.GetNextRunTime(input.CronExpression, input.Timezone || 'UTC');
+
+            if (!await job.Save()) return { Success: false, Message: 'Failed to create schedule' };
+
+            // Link to CompanyIntegration
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(input.CompanyIntegrationID));
+            if (ciLoaded) {
+                ci.ScheduleEnabled = true;
+                ci.ScheduleType = 'Cron';
+                ci.CronExpression = input.CronExpression;
+                await ci.Save();
+            }
+
+            return { Success: true, Message: 'Schedule created', ScheduledJobID: job.ID };
+        } catch (e) {
+            LogError(`IntegrationCreateSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Mutation(() => MutationResultOutput)
+    async IntegrationUpdateSchedule(
+        @Arg("scheduledJobID") scheduledJobID: string,
+        @Arg("cronExpression", { nullable: true }) cronExpression: string,
+        @Arg("timezone", { nullable: true }) timezone: string,
+        @Arg("name", { nullable: true }) name: string,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const job = await md.GetEntityObject<MJScheduledJobEntity>('MJ: Scheduled Jobs', user);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded) return { Success: false, Message: 'ScheduledJob not found' };
+
+            if (cronExpression) job.CronExpression = cronExpression;
+            if (timezone) job.Timezone = timezone;
+            if (name) job.Name = name;
+            if (cronExpression || timezone) {
+                job.NextRunAt = CronExpressionHelper.GetNextRunTime(job.CronExpression, job.Timezone || 'UTC');
+            }
+
+            if (!await job.Save()) return { Success: false, Message: 'Failed to update' };
+            return { Success: true, Message: 'Updated' };
+        } catch (e) {
+            LogError(`IntegrationUpdateSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Mutation(() => MutationResultOutput)
+    async IntegrationToggleSchedule(
+        @Arg("scheduledJobID") scheduledJobID: string,
+        @Arg("enabled", () => Boolean) enabled: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser();
+            const md = new Metadata();
+            const job = await md.GetEntityObject<MJScheduledJobEntity>('MJ: Scheduled Jobs', sysUser);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded) return { Success: false, Message: 'ScheduledJob not found' };
+            job.Status = enabled ? 'Active' : 'Paused';
+            if (!await job.Save()) {
+                const err = job.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to toggle: ${err}` };
+            }
+            return { Success: true, Message: enabled ? 'Activated' : 'Paused' };
+        } catch (e) {
+            LogError(`IntegrationToggleSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Mutation(() => MutationResultOutput)
+    async IntegrationDeleteSchedule(
+        @Arg("scheduledJobID") scheduledJobID: string,
+        @Arg("companyIntegrationID", { nullable: true }) companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser(); // use system user for delete operations
+            const md = new Metadata();
+
+            // Unlink from CI if provided
+            if (companyIntegrationID) {
+                const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', sysUser);
+                const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+                if (ciLoaded) {
+                    ci.ScheduleEnabled = false;
+                    ci.CronExpression = null;
+                    await ci.Save();
+                }
+            }
+
+            const rv = new RunView();
+
+            // Clear ScheduledJobID on any CompanyIntegration that references this job
+            const ciResult = await rv.RunView<MJCompanyIntegrationEntity>({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: `ScheduledJobID='${scheduledJobID}'`,
+                ResultType: 'entity_object',
+            }, sysUser);
+            if (ciResult.Success) {
+                for (const refCI of ciResult.Results) {
+                    refCI.ScheduledJobID = null;
+                    refCI.ScheduleEnabled = false;
+                    refCI.CronExpression = null;
+                    await refCI.Save();
+                }
+            }
+
+            // Null out ScheduledJobRunID on CompanyIntegrationRuns that reference this job's runs
+            const jobRunsResult = await rv.RunView<MJScheduledJobRunEntity>({
+                EntityName: 'MJ: Scheduled Job Runs',
+                ExtraFilter: `ScheduledJobID='${scheduledJobID}'`,
+                ResultType: 'entity_object',
+            }, sysUser);
+            if (jobRunsResult.Success) {
+                for (const jr of jobRunsResult.Results) {
+                    // Find CompanyIntegrationRuns referencing this job run and null the FK
+                    const ciRunsResult = await rv.RunView<MJCompanyIntegrationRunEntity>({
+                        EntityName: 'MJ: Company Integration Runs',
+                        ExtraFilter: `ScheduledJobRunID='${jr.ID}'`,
+                        ResultType: 'entity_object',
+                    }, sysUser);
+                    if (ciRunsResult.Success) {
+                        for (const ciRun of ciRunsResult.Results) {
+                            ciRun.ScheduledJobRunID = null;
+                            await ciRun.Save();
+                        }
+                    }
+                }
+            }
+
+            // Now delete job runs + job in a transaction
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            if (jobRunsResult.Success) {
+                for (const run of jobRunsResult.Results) {
+                    run.TransactionGroup = tg;
+                    await run.Delete();
+                }
+            }
+
+            const job = await md.GetEntityObject<MJScheduledJobEntity>('MJ: Scheduled Jobs', sysUser);
+            const loaded = await job.InnerLoad(CompositeKey.FromID(scheduledJobID));
+            if (!loaded) return { Success: false, Message: 'ScheduledJob not found' };
+            job.TransactionGroup = tg;
+            await job.Delete();
+            const deleted = await tg.Submit();
+            if (!deleted) {
+                const err = job.LatestResult?.Message || 'Unknown error';
+                return { Success: false, Message: `Failed to delete: ${err}` };
+            }
+            return { Success: true, Message: `Deleted (${jobRunsResult.Results?.length ?? 0} runs removed)` };
+        } catch (e) {
+            LogError(`IntegrationDeleteSchedule error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Query(() => ListSchedulesOutput)
+    async IntegrationListSchedules(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<ListSchedulesOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView<{ ID: string; Name: string; Status: string; CronExpression: string; Timezone: string; NextRunAt: string; LastRunAt: string; RunCount: number; SuccessCount: number; FailureCount: number }>({
+                EntityName: 'MJ: Scheduled Jobs',
+                ExtraFilter: `Configuration LIKE '%"CompanyIntegrationID":"${companyIntegrationID}"%'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                ResultType: 'simple',
+                Fields: ['ID', 'Name', 'Status', 'CronExpression', 'Timezone', 'NextRunAt', 'LastRunAt', 'RunCount', 'SuccessCount', 'FailureCount']
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} schedule(s)`,
+                Schedules: result.Results.map(r => ({
+                    ID: r.ID,
+                    Name: r.Name,
+                    Status: r.Status,
+                    CronExpression: r.CronExpression,
+                    Timezone: r.Timezone,
+                    NextRunAt: r.NextRunAt ?? undefined,
+                    LastRunAt: r.LastRunAt ?? undefined,
+                    RunCount: r.RunCount,
+                    SuccessCount: r.SuccessCount,
+                    FailureCount: r.FailureCount,
+                }))
+            };
+        } catch (e) {
+            LogError(`IntegrationListSchedules error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── ENTITY MAP MANAGEMENT ──────────────────────────────────────────
+
+    @Query(() => ListEntityMapsOutput)
+    async IntegrationListEntityMaps(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<ListEntityMapsOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView<EntityMapSummaryOutput>({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                OrderBy: 'Priority ASC',
+                ResultType: 'simple',
+                Fields: ['ID', 'EntityID', 'Entity', 'ExternalObjectName', 'SyncDirection', 'Priority', 'Status']
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} entity maps`,
+                EntityMaps: result.Results
+            };
+        } catch (e) {
+            LogError(`IntegrationListEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Query(() => ListFieldMapsOutput)
+    async IntegrationListFieldMaps(
+        @Arg("entityMapID") entityMapID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<ListFieldMapsOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView<FieldMapSummaryOutput>({
+                EntityName: 'MJ: Company Integration Field Maps',
+                ExtraFilter: `EntityMapID='${entityMapID}'`,
+                OrderBy: 'SourceFieldName',
+                ResultType: 'simple',
+                Fields: ['ID', 'EntityMapID', 'SourceFieldName', 'DestinationFieldName', 'Status']
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} field maps`,
+                FieldMaps: result.Results
+            };
+        } catch (e) {
+            LogError(`IntegrationListFieldMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Mutation(() => MutationResultOutput)
+    async IntegrationUpdateEntityMaps(
+        @Arg("updates", () => [EntityMapUpdateInput]) updates: EntityMapUpdateInput[],
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const errors: string[] = [];
+
+            for (const update of updates) {
+                const em = await md.GetEntityObject<MJCompanyIntegrationEntityMapEntity>('MJ: Company Integration Entity Maps', user);
+                const loaded = await em.InnerLoad(CompositeKey.FromID(update.EntityMapID));
+                if (!loaded) { errors.push(`${update.EntityMapID}: not found`); continue; }
+
+                if (update.SyncDirection != null) {
+                    if (!isValidSyncDirection(update.SyncDirection)) {
+                        errors.push(`${update.EntityMapID}: invalid SyncDirection "${update.SyncDirection}"`);
+                        continue;
+                    }
+                    em.SyncDirection = update.SyncDirection;
+                }
+                if (update.Priority != null) em.Priority = update.Priority;
+                if (update.Status != null) {
+                    if (!isValidEntityMapStatus(update.Status)) {
+                        errors.push(`${update.EntityMapID}: invalid Status "${update.Status}"`);
+                        continue;
+                    }
+                    em.Status = update.Status;
+                }
+
+                if (!await em.Save()) errors.push(`${update.EntityMapID}: failed to save`);
+            }
+
+            if (errors.length > 0) return { Success: false, Message: `Errors: ${errors.join('; ')}` };
+            return { Success: true, Message: `Updated ${updates.length} entity maps` };
+        } catch (e) {
+            LogError(`IntegrationUpdateEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Mutation(() => MutationResultOutput)
+    async IntegrationDeleteEntityMaps(
+        @Arg("entityMapIDs", () => [String]) entityMapIDs: string[],
+        @Ctx() ctx: AppContext
+    ): Promise<MutationResultOutput> {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const sysUser = this.getSystemUser();
+            const md = new Metadata();
+            const rv = new RunView();
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            const errors: string[] = [];
+
+            for (const entityMapID of entityMapIDs) {
+                const em = await md.GetEntityObject<MJCompanyIntegrationEntityMapEntity>('MJ: Company Integration Entity Maps', sysUser);
+                const loaded = await em.InnerLoad(CompositeKey.FromID(entityMapID));
+                if (!loaded) { errors.push(`${entityMapID}: not found`); continue; }
+
+                // Delete field maps
+                const fmResult = await rv.RunView<MJCompanyIntegrationFieldMapEntity>({
+                    EntityName: 'MJ: Company Integration Field Maps',
+                    ExtraFilter: `EntityMapID='${entityMapID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (fmResult.Success) {
+                    for (const fm of fmResult.Results) { fm.TransactionGroup = tg; await fm.Delete(); }
+                }
+
+                // Delete watermarks
+                const wmResult = await rv.RunView<MJCompanyIntegrationSyncWatermarkEntity>({
+                    EntityName: 'MJ: Company Integration Sync Watermarks',
+                    ExtraFilter: `EntityMapID='${entityMapID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (wmResult.Success) {
+                    for (const wm of wmResult.Results) { wm.TransactionGroup = tg; await wm.Delete(); }
+                }
+
+                // Delete record maps for THIS entity only (filter by CI + EntityID)
+                const rmResult = await rv.RunView<MJCompanyIntegrationRecordMapEntity>({
+                    EntityName: 'MJ: Company Integration Record Maps',
+                    ExtraFilter: `CompanyIntegrationID='${em.CompanyIntegrationID}' AND EntityID='${em.EntityID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (rmResult.Success) {
+                    for (const rm of rmResult.Results) { rm.TransactionGroup = tg; await rm.Delete(); }
+                }
+
+                em.TransactionGroup = tg;
+                await em.Delete();
+            }
+
+            const submitted = await tg.Submit();
+            if (!submitted) return { Success: false, Message: 'Transaction failed — all deletes rolled back' };
+            if (errors.length > 0) return { Success: false, Message: `Partial: ${errors.join('; ')}` };
+            return { Success: true, Message: `Deleted ${entityMapIDs.length} entity maps (with field maps, watermarks, record maps)` };
+        } catch (e) {
+            LogError(`IntegrationDeleteEntityMaps error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── OPERATION PROGRESS (polling) ──────────────────────────────────
+
+    @Query(() => OperationProgressOutput)
+    async IntegrationGetRSUProgress(
+        @Ctx() ctx: AppContext
+    ): Promise<OperationProgressOutput> {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const rsm = RuntimeSchemaManager.Instance;
+            const rsuStatus = rsm.GetStatus();
+            if (rsuStatus.Running) {
+                return {
+                    Success: true,
+                    Message: 'RSU pipeline in progress',
+                    OperationType: 'rsu',
+                    IsRunning: true,
+                    RSURunning: true,
+                    RSUStep: rsuStatus.LastRunResult ?? 'running',
+                    StartedAt: rsuStatus.LastRunAt?.toISOString(),
+                    ElapsedMs: rsuStatus.LastRunAt ? Date.now() - rsuStatus.LastRunAt.getTime() : undefined,
+                };
+            }
+            return { Success: true, Message: 'No RSU pipeline running', OperationType: 'none', IsRunning: false };
+        } catch (e) {
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Query(() => OperationProgressOutput)
+    async IntegrationGetSyncProgress(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<OperationProgressOutput> {
+        try {
+            this.getAuthenticatedUser(ctx);
+            const syncProgress = IntegrationEngine.GetSyncProgress(companyIntegrationID);
+            if (syncProgress) {
+                return {
+                    Success: true,
+                    Message: `Sync in progress (${syncProgress.TriggerType})`,
+                    OperationType: 'sync',
+                    IsRunning: true,
+                    CurrentEntity: syncProgress.CurrentEntity,
+                    EntityMapsTotal: syncProgress.EntityMapsTotal,
+                    EntityMapsCompleted: syncProgress.EntityMapsCompleted,
+                    RecordsProcessed: syncProgress.RecordsProcessed,
+                    RecordsCreated: syncProgress.RecordsCreated,
+                    RecordsUpdated: syncProgress.RecordsUpdated,
+                    RecordsErrored: syncProgress.RecordsErrored,
+                    StartedAt: syncProgress.StartedAt.toISOString(),
+                    ElapsedMs: Date.now() - syncProgress.StartedAt.getTime(),
+                };
+            }
+            return { Success: true, Message: 'No sync running for this connector', OperationType: 'none', IsRunning: false };
+        } catch (e) {
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── STATUS & HISTORY (not polling — for page loads) ─────────────────
+
+    @Query(() => IntegrationStatusOutput)
+    async IntegrationGetStatus(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<IntegrationStatusOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const md = new Metadata();
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const loaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!loaded) return { Success: false, Message: 'Not found' };
+
+            const rv = new RunView();
+            const [mapsResult, runsResult] = await rv.RunViews([
+                {
+                    EntityName: 'MJ: Company Integration Entity Maps',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    ResultType: 'simple',
+                    Fields: ['ID', 'Status']
+                },
+                {
+                    EntityName: 'MJ: Company Integration Runs',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    OrderBy: 'StartedAt DESC',
+                    MaxRows: 1,
+                    ResultType: 'simple',
+                    Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords']
+                }
+            ], user);
+
+            const maps = mapsResult.Success ? mapsResult.Results as Array<{ ID: string; Status: string }> : [];
+            const lastRun = runsResult.Success && runsResult.Results.length > 0
+                ? runsResult.Results[0] as { ID: string; Status: string; StartedAt: string; EndedAt: string; TotalRecords: number }
+                : null;
+
+            // RSU pipeline state
+            const rsuStatus = RuntimeSchemaManager.Instance.GetStatus();
+
+            return {
+                Success: true,
+                Message: 'OK',
+                IsActive: ci.IsActive ?? false,
+                IntegrationName: ci.Integration,
+                CompanyIntegrationID: companyIntegrationID,
+                TotalEntityMaps: maps.length,
+                ActiveEntityMaps: maps.filter(m => m.Status === 'Active').length,
+                LastRunStatus: lastRun?.Status,
+                LastRunStartedAt: lastRun?.StartedAt,
+                LastRunEndedAt: lastRun?.EndedAt,
+                ScheduleEnabled: ci.ScheduleEnabled,
+                RSUEnabled: rsuStatus.Enabled,
+                RSURunning: rsuStatus.Running,
+                RSUOutOfSync: rsuStatus.OutOfSync,
+                RSULastRunAt: rsuStatus.LastRunAt?.toISOString(),
+                RSULastRunResult: rsuStatus.LastRunResult,
+            };
+        } catch (e) {
+            LogError(`IntegrationGetStatus error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    @Query(() => SyncHistoryOutput)
+    async IntegrationGetSyncHistory(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("limit", { defaultValue: 20 }) limit: number,
+        @Ctx() ctx: AppContext
+    ): Promise<SyncHistoryOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const rv = new RunView();
+            const result = await rv.RunView<SyncRunSummaryOutput>({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                OrderBy: 'StartedAt DESC',
+                MaxRows: limit,
+                ResultType: 'simple',
+                Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords', 'RunByUserID']
+            }, user);
+
+            if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
+            return {
+                Success: true,
+                Message: `${result.Results.length} runs`,
+                Runs: result.Results
+            };
+        } catch (e) {
+            LogError(`IntegrationGetSyncHistory error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── CONNECTOR CAPABILITIES ──────────────────────────────────────────
+
+    /**
+     * Returns the CRUD capability flags for the connector bound to a CompanyIntegration.
+     * Use this to determine which operations (Create/Update/Delete/Search) are supported
+     * before attempting point-action calls.
+     */
+    @Query(() => ConnectorCapabilitiesOutput)
+    async IntegrationGetConnectorCapabilities(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Ctx() ctx: AppContext
+    ): Promise<ConnectorCapabilitiesOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const { connector } = await this.resolveConnector(companyIntegrationID, user);
+
+            return {
+                Success: true,
+                Message: 'OK',
+                SupportsGet: connector.SupportsGet,
+                SupportsCreate: connector.SupportsCreate,
+                SupportsUpdate: connector.SupportsUpdate,
+                SupportsDelete: connector.SupportsDelete,
+                SupportsSearch: connector.SupportsSearch,
+            };
+        } catch (e) {
+            LogError(`IntegrationGetConnectorCapabilities error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── APPLY ALL BATCH ─────────────────────────────────────────────────
+
+    /**
+     * Batch "Apply All" for multiple connectors in a single RSU pipeline run.
+     * For each connector: introspect → build schema → collect RSU input.
+     * Then run ONE pipeline batch for all connectors.
+     * Post-pipeline: create entity/field maps and start sync for each success.
+     */
+    @Mutation(() => ApplyAllBatchOutput)
+    async IntegrationApplyAllBatch(
+        @Arg("input") input: ApplyAllBatchInput,
+        @Arg("platform", { defaultValue: "sqlserver" }) platform: string,
+        @Arg("skipGitCommit", { defaultValue: false }) skipGitCommit: boolean,
+        @Arg("skipRestart", { defaultValue: false }) skipRestart: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<ApplyAllBatchOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+
+            // Phase 1: Build schema for each connector in parallel
+            const buildResults = await Promise.allSettled(
+                input.Connectors.map(async (connInput) => {
+                    const { connector, companyIntegration } = await this.resolveConnector(connInput.CompanyIntegrationID, user);
+                    const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+
+                    // Resolve object IDs to names with per-object Fields
+                    const sourceSchema = await (connector.IntrospectSchema.bind(connector) as
+                        (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>)(companyIntegration, user);
+                    const objectIDs = connInput.SourceObjects.map(so => so.SourceObjectID);
+                    const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
+
+                    const fieldsByID = new Map(connInput.SourceObjects.map(so => [so.SourceObjectID, so.Fields]));
+                    const objects = resolvedNames.map((name, i) => {
+                        const obj = new SchemaPreviewObjectInput();
+                        obj.SourceObjectName = name;
+                        obj.SchemaName = schemaName;
+                        obj.TableName = name.replace(/[^A-Za-z0-9_]/g, '_');
+                        obj.EntityName = name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+                        obj.Fields = fieldsByID.get(objectIDs[i]) ?? undefined;
+                        return obj;
+                    });
+
+                    const { schemaOutput, rsuInput } = await this.buildSchemaForConnector(
+                        connInput.CompanyIntegrationID, objects, validatedPlatform, user, skipGitCommit, skipRestart
+                    );
+
+                    // Build per-object field map for pending file
+                    const sourceObjectFields: Record<string, string[] | null> = {};
+                    for (const so of connInput.SourceObjects) {
+                        const resolvedName = resolvedNames[objectIDs.indexOf(so.SourceObjectID)];
+                        if (resolvedName) sourceObjectFields[resolvedName] = so.Fields ?? null;
+                    }
+
+                    // Inject post-restart pending work payload
+                    const { join } = await import('node:path');
+                    const rsuWorkDir = process.env.RSU_WORK_DIR || process.cwd();
+                    const pendingWorkDir = join(rsuWorkDir, '.rsu_pending');
+                    const pendingFilePath = join(pendingWorkDir, `${Date.now()}_${connInput.CompanyIntegrationID}.json`);
+                    const pendingPayload = {
+                        CompanyIntegrationID: connInput.CompanyIntegrationID,
+                        SourceObjectNames: resolvedNames,
+                        SourceObjectFields: sourceObjectFields,
+                        SchemaName: schemaName,
+                        CronExpression: connInput.CronExpression,
+                        ScheduleTimezone: connInput.ScheduleTimezone,
+                        StartSync: input.StartSync,
+                        FullSync: input.FullSync ?? false,
+                        SyncScope: input.SyncScope ?? 'created',
+                        CreatedAt: new Date().toISOString(),
+                    };
+                    rsuInput.PostRestartFiles = [
+                        { Path: pendingFilePath, Content: JSON.stringify(pendingPayload, null, 2) }
+                    ];
+
+                    return {
+                        connInput,
+                        connector,
+                        companyIntegration,
+                        schemaName,
+                        objects,
+                        schemaOutput,
+                        rsuInput,
+                        pendingFilePath,
+                    };
+                })
+            );
+
+            // Separate successes and failures
+            const successfulBuilds: Array<{
+                connInput: ApplyAllBatchConnectorInput;
+                connector: BaseIntegrationConnector;
+                companyIntegration: MJCompanyIntegrationEntity;
+                schemaName: string;
+                objects: SchemaPreviewObjectInput[];
+                schemaOutput: SchemaBuilderOutput;
+                rsuInput: RSUPipelineInput;
+                pendingFilePath: string;
+            }> = [];
+            const connectorResults: ApplyAllBatchConnectorResult[] = [];
+
+            for (let i = 0; i < buildResults.length; i++) {
+                const result = buildResults[i];
+                const connInput = input.Connectors[i];
+                if (result.status === 'fulfilled') {
+                    successfulBuilds.push(result.value);
+                } else {
+                    LogError(`IntegrationApplyAllBatch: build failed for ${connInput.CompanyIntegrationID}: ${result.reason}`);
+                    connectorResults.push({
+                        CompanyIntegrationID: connInput.CompanyIntegrationID,
+                        IntegrationName: 'Unknown',
+                        Success: false,
+                        Message: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                    });
+                }
+            }
+
+            if (successfulBuilds.length === 0) {
+                return {
+                    Success: false,
+                    Message: 'All connectors failed during schema build phase',
+                    ConnectorResults: connectorResults,
+                    SuccessCount: 0,
+                    FailureCount: connectorResults.length,
+                };
+            }
+
+            // Phase 2: Run all successful RSU inputs through one pipeline batch
+            const pipelineInputs = successfulBuilds.map(b => b.rsuInput);
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch(pipelineInputs);
+
+            // Phase 3: Post-pipeline — create entity maps, field maps, schedules for each success
+            for (let i = 0; i < successfulBuilds.length; i++) {
+                const build = successfulBuilds[i];
+                const pipelineResult = batchResult.Results[i];
+                const integrationName = build.companyIntegration.Integration;
+
+                if (!pipelineResult || !pipelineResult.Success) {
+                    connectorResults.push({
+                        CompanyIntegrationID: build.connInput.CompanyIntegrationID,
+                        IntegrationName: integrationName,
+                        Success: false,
+                        Message: pipelineResult?.ErrorMessage ?? 'Pipeline failed',
+                        Warnings: build.schemaOutput.Warnings.length > 0 ? build.schemaOutput.Warnings : undefined,
+                    });
+                    // Clean up pending file on failure
+                    try { (await import('node:fs')).unlinkSync(build.pendingFilePath); } catch { /* may not exist */ }
+                    continue;
+                }
+
+                const connResult: ApplyAllBatchConnectorResult = {
+                    CompanyIntegrationID: build.connInput.CompanyIntegrationID,
+                    IntegrationName: integrationName,
+                    Success: true,
+                    Message: `Applied ${build.objects.length} object(s)`,
+                    Warnings: build.schemaOutput.Warnings.length > 0 ? build.schemaOutput.Warnings : undefined,
+                };
+
+                if (skipRestart) {
+                    // Entity maps, field maps, sync
+                    await Metadata.Provider.Refresh();
+                    const entityMapsCreated = await this.createEntityAndFieldMaps(
+                        build.connInput.CompanyIntegrationID, build.objects, build.connector,
+                        build.companyIntegration, build.schemaName, user
+                    );
+                    connResult.EntityMapsCreated = entityMapsCreated;
+
+                    const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
+                    const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
+                    const syncRunID = input.StartSync !== false
+                        ? await this.startSyncAfterApply(build.connInput.CompanyIntegrationID, user, scopedMapIDs, input.FullSync)
+                        : null;
+                    if (syncRunID) connResult.SyncRunID = syncRunID;
+
+                    // Create schedule if CronExpression provided
+                    if (build.connInput.CronExpression) {
+                        const scheduleResult = await this.createScheduleForConnector(
+                            build.connInput.CompanyIntegrationID, integrationName,
+                            build.connInput.CronExpression, build.connInput.ScheduleTimezone, user
+                        );
+                        if (scheduleResult) connResult.ScheduledJobID = scheduleResult;
+                    }
+
+                    // Clean up pending file
+                    try { (await import('node:fs')).unlinkSync(build.pendingFilePath); } catch { /* already consumed */ }
+
+                    connResult.Message = `Applied ${build.objects.length} object(s) — ${entityMapsCreated.length} entity maps created${syncRunID ? ', sync started' : ''}`;
+                }
+
+                connectorResults.push(connResult);
+            }
+
+            const pipelineSteps = batchResult.Results[0]?.Steps.map((s: RSUPipelineStep) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
+
+            const successCount = connectorResults.filter(r => r.Success).length;
+            const failureCount = connectorResults.filter(r => !r.Success).length;
+
+            return {
+                Success: successCount > 0,
+                Message: `Batch complete: ${successCount} succeeded, ${failureCount} failed`,
+                ConnectorResults: connectorResults,
+                PipelineSteps: pipelineSteps,
+                GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
+                APIRestarted: batchResult.Results[0]?.APIRestarted,
+                SuccessCount: successCount,
+                FailureCount: failureCount,
+            };
+        } catch (e) {
+            LogError(`IntegrationApplyAllBatch error: ${e}`);
+            return {
+                Success: false, Message: this.formatError(e),
+                ConnectorResults: [], SuccessCount: 0, FailureCount: 0,
+            };
+        }
+    }
+
+    /** Helper: creates a schedule for a connector, returns ScheduledJobID or null. */
+    private async createScheduleForConnector(
+        companyIntegrationID: string,
+        integrationName: string,
+        cronExpression: string,
+        timezone: string | undefined,
+        user: UserInfo
+    ): Promise<string | null> {
+        try {
+            const md = new Metadata();
+            const rv = new RunView();
+
+            // Find IntegrationSync job type
+            const jobTypeResult = await rv.RunView<MJScheduledJobTypeEntity>({
+                EntityName: 'MJ: Scheduled Job Types',
+                ExtraFilter: `DriverClass='IntegrationSyncScheduledJobDriver'`,
+                MaxRows: 1,
+                ResultType: 'simple',
+                Fields: ['ID']
+            }, user);
+            if (!jobTypeResult.Success || jobTypeResult.Results.length === 0) {
+                LogError('IntegrationApplyAllBatch: IntegrationSync scheduled job type not found');
+                return null;
+            }
+            const jobTypeID = jobTypeResult.Results[0].ID;
+
+            const job = await md.GetEntityObject<MJScheduledJobEntity>('MJ: Scheduled Jobs', user);
+            job.NewRecord();
+            job.JobTypeID = jobTypeID;
+            job.Name = `${integrationName} Sync`;
+            job.CronExpression = cronExpression;
+            job.Timezone = timezone || 'UTC';
+            job.Status = 'Active';
+            job.OwnerUserID = user.ID;
+            job.Configuration = JSON.stringify({ CompanyIntegrationID: companyIntegrationID });
+
+            if (!await job.Save()) return null;
+
+            // Link to CompanyIntegration
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', user);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (ciLoaded) {
+                ci.ScheduleEnabled = true;
+                ci.ScheduleType = 'Cron';
+                ci.CronExpression = cronExpression;
+                await ci.Save();
+            }
+
+            return job.ID;
+        } catch (e) {
+            LogError(`IntegrationApplyAllBatch: schedule creation failed: ${this.formatError(e)}`);
+            return null;
+        }
+    }
+
+    // ── DELETE CONNECTION ────────────────────────────────────────────────
+
+    /**
+     * Hard-deletes a CompanyIntegration and all associated entity maps, field maps,
+     * and scheduled jobs. Does NOT drop database tables (flagged for future).
+     */
+    @Mutation(() => DeleteConnectionOutput)
+    async IntegrationDeleteConnection(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("deleteData", { defaultValue: false }) deleteData: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<DeleteConnectionOutput> {
+        try {
+            this.getAuthenticatedUser(ctx); // verify caller is authenticated
+            const sysUser = this.getSystemUser(); // use system user for cascade delete
+            const md = new Metadata();
+            const rv = new RunView();
+
+            // Step 1: Load CompanyIntegration
+            const ci = await md.GetEntityObject<MJCompanyIntegrationEntity>('MJ: Company Integrations', sysUser);
+            const ciLoaded = await ci.InnerLoad(CompositeKey.FromID(companyIntegrationID));
+            if (!ciLoaded) return { Success: false, Message: 'CompanyIntegration not found' };
+
+            // Cascade delete in FK-safe order using TransactionGroup
+            const tg = await Metadata.Provider.CreateTransactionGroup();
+            let fieldMapsDeleted = 0;
+            let entityMapsDeleted = 0;
+            let schedulesDeleted = 0;
+
+            // Step 2: Null out ScheduledJobRunID on CompanyIntegrationRuns (break FK before deleting job runs)
+            const ciRunsResult = await rv.RunView<MJCompanyIntegrationRunEntity>({
+                EntityName: 'MJ: Company Integration Runs',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (ciRunsResult.Success) {
+                for (const ciRun of ciRunsResult.Results) {
+                    if (ciRun.ScheduledJobRunID) {
+                        ciRun.ScheduledJobRunID = null;
+                        await ciRun.Save();
+                    }
+                }
+            }
+
+            // Step 3: Delete scheduled job runs + jobs (reference CI via Configuration JSON)
+            const jobsResult = await rv.RunView<MJScheduledJobEntity>({
+                EntityName: 'MJ: Scheduled Jobs',
+                ExtraFilter: `Configuration LIKE '%${companyIntegrationID}%'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (jobsResult.Success) {
+                for (const job of jobsResult.Results) {
+                    try {
+                        const config = JSON.parse(job.Configuration || '{}') as Record<string, unknown>;
+                        if (config.CompanyIntegrationID === companyIntegrationID) {
+                            const jobRunsResult = await rv.RunView<MJScheduledJobRunEntity>({
+                                EntityName: 'MJ: Scheduled Job Runs',
+                                ExtraFilter: `ScheduledJobID='${job.ID}'`,
+                                ResultType: 'entity_object'
+                            }, sysUser);
+                            if (jobRunsResult.Success) {
+                                for (const jr of jobRunsResult.Results) {
+                                    jr.TransactionGroup = tg;
+                                    await jr.Delete();
+                                }
+                            }
+                            job.TransactionGroup = tg;
+                            await job.Delete();
+                            schedulesDeleted++;
+                        }
+                    } catch { /* skip invalid config */ }
+                }
+            }
+
+            // Step 4: Delete run details then runs (reuse ciRunsResult from Step 2)
+            if (ciRunsResult.Success) {
+                for (const run of ciRunsResult.Results) {
+                    // Delete run details first
+                    const detailsResult = await rv.RunView<MJCompanyIntegrationRunDetailEntity>({
+                        EntityName: 'MJ: Company Integration Run Details',
+                        ExtraFilter: `CompanyIntegrationRunID='${run.ID}'`,
+                        ResultType: 'entity_object'
+                    }, sysUser);
+                    if (detailsResult.Success) {
+                        for (const detail of detailsResult.Results) {
+                            detail.TransactionGroup = tg;
+                            await detail.Delete();
+                        }
+                    }
+                    run.TransactionGroup = tg;
+                    await run.Delete();
+                }
+            }
+
+            // Step 4: Delete entity map children (field maps, watermarks, record maps)
+            const entityMapsResult = await rv.RunView<MJCompanyIntegrationEntityMapEntity>({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            const entityMaps = entityMapsResult.Success ? entityMapsResult.Results : [];
+
+            for (const em of entityMaps) {
+                const fmResult = await rv.RunView<MJCompanyIntegrationFieldMapEntity>({
+                    EntityName: 'MJ: Company Integration Field Maps',
+                    ExtraFilter: `EntityMapID='${em.ID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (fmResult.Success) {
+                    for (const fm of fmResult.Results) {
+                        fm.TransactionGroup = tg;
+                        if (await fm.Delete()) fieldMapsDeleted++;
+                    }
+                }
+
+                const wmResult = await rv.RunView<MJCompanyIntegrationSyncWatermarkEntity>({
+                    EntityName: 'MJ: Company Integration Sync Watermarks',
+                    ExtraFilter: `EntityMapID='${em.ID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (wmResult.Success) {
+                    for (const wm of wmResult.Results) {
+                        wm.TransactionGroup = tg;
+                        await wm.Delete();
+                    }
+                }
+
+                const rmResult = await rv.RunView<MJCompanyIntegrationRecordMapEntity>({
+                    EntityName: 'MJ: Company Integration Record Maps',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                    ResultType: 'entity_object'
+                }, sysUser);
+                if (rmResult.Success) {
+                    for (const rm of rmResult.Results) {
+                        rm.TransactionGroup = tg;
+                        await rm.Delete();
+                    }
+                }
+            }
+
+            // Step 5: Delete entity maps
+            for (const em of entityMaps) {
+                em.TransactionGroup = tg;
+                if (await em.Delete()) entityMapsDeleted++;
+            }
+
+            // Step 6: Delete employee-company integration links
+            const empResult = await rv.RunView<MJEmployeeCompanyIntegrationEntity>({
+                EntityName: 'MJ: Employee Company Integrations',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'entity_object'
+            }, sysUser);
+            if (empResult.Success) {
+                for (const emp of empResult.Results) {
+                    emp.TransactionGroup = tg;
+                    await emp.Delete();
+                }
+            }
+
+            // Step 7: Delete the CompanyIntegration itself
+            ci.TransactionGroup = tg;
+            await ci.Delete();
+
+            // Submit the transaction
+            const submitted = await tg.Submit();
+            if (!submitted) {
+                return { Success: false, Message: 'Transaction failed — all deletes rolled back' };
+            }
+
+            if (deleteData) {
+                LogError(`IntegrationDeleteConnection: deleteData=true requested but table deletion not yet implemented for ${companyIntegrationID}`);
+            }
+
+            return {
+                Success: true,
+                Message: `Deleted connection and all associated records`,
+                EntityMapsDeleted: entityMapsDeleted,
+                FieldMapsDeleted: fieldMapsDeleted,
+                SchedulesDeleted: schedulesDeleted,
+            };
+        } catch (e) {
+            LogError(`IntegrationDeleteConnection error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
+    // ── SCHEMA EVOLUTION ────────────────────────────────────────────────
+
+    /**
+     * Detects schema changes (new/modified columns) in the external system and
+     * applies ALTER TABLE migrations via the RSU pipeline.
+     * Compares the current connector introspection against existing MJ entities.
+     */
+    @Mutation(() => SchemaEvolutionOutput)
+    async IntegrationSchemaEvolution(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("platform", { defaultValue: "sqlserver" }) platform: string,
+        @Arg("skipGitCommit", { defaultValue: false }) skipGitCommit: boolean,
+        @Arg("skipRestart", { defaultValue: false }) skipRestart: boolean,
+        @Ctx() ctx: AppContext
+    ): Promise<SchemaEvolutionOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const validatedPlatform = this.validatePlatform(platform);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user);
+            const schemaName = this.deriveSchemaName(companyIntegration.Integration);
+            const md = new Metadata();
+            const rv = new RunView();
+
+            // Step 1: Get existing entity maps for this CompanyIntegration
+            const entityMapsResult = await rv.RunView<MJCompanyIntegrationEntityMapEntity>({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+                ResultType: 'simple',
+                Fields: ['ID', 'ExternalObjectName', 'EntityID']
+            }, user);
+
+            if (!entityMapsResult.Success || entityMapsResult.Results.length === 0) {
+                return {
+                    Success: false, Message: 'No entity maps found — nothing to evolve',
+                    HasChanges: false,
+                };
+            }
+
+            const sourceObjectNames = entityMapsResult.Results.map(em => em.ExternalObjectName);
+            const objects = this.buildObjectInputsFromNames(sourceObjectNames, schemaName);
+
+            // Step 2: Build ExistingTables from Metadata.Entities matching the schema
+            const existingTables: ExistingTableInfo[] = [];
+            for (const obj of objects) {
+                const entityInfo = md.Entities.find(
+                    e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
+                      && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase()
+                );
+                if (entityInfo) {
+                    existingTables.push({
+                        SchemaName: entityInfo.SchemaName,
+                        TableName: entityInfo.BaseTable,
+                        Columns: entityInfo.Fields.map(f => ({
+                            Name: f.Name,
+                            SqlType: f.SQLFullType || f.Type,
+                            IsNullable: f.AllowsNull,
+                            MaxLength: f.MaxLength > 0 ? f.MaxLength : null,
+                            Precision: f.Precision > 0 ? f.Precision : null,
+                            Scale: f.Scale > 0 ? f.Scale : null,
+                        })),
+                    });
+                }
+            }
+
+            // Step 3: Introspect current schema from connector
+            const introspect = connector.IntrospectSchema.bind(connector) as
+                (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>;
+            const sourceSchema = await introspect(companyIntegration, user);
+
+            // Normalize names to match source schema casing
+            const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
+            const normalizedNames = sourceObjectNames.map(n => nameMap.get(n.toLowerCase()) ?? n);
+            // Also normalize the objects array SourceObjectName
+            for (const obj of objects) {
+                const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
+                if (exact) obj.SourceObjectName = exact;
+            }
+
+            const requestedNames = new Set(normalizedNames);
+            const filteredSchema: SourceSchemaInfo = {
+                Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
+            };
+
+            // Step 4: Build target configs and SchemaBuilder input with ExistingTables
+            const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
+
+            const schemaInput: SchemaBuilderInput = {
+                SourceSchema: filteredSchema,
+                TargetConfigs: targetConfigs,
+                Platform: validatedPlatform,
+                MJVersion: process.env.MJ_VERSION ?? '5.11.0',
+                SourceType: companyIntegration.Integration,
+                AdditionalSchemaInfoPath: process.env.RSU_ADDITIONAL_SCHEMA_INFO_PATH ?? 'additionalSchemaInfo.json',
+                MigrationsDir: process.env.RSU_MIGRATIONS_PATH ?? 'migrations/rsu',
+                MetadataDir: process.env.RSU_METADATA_DIR ?? 'metadata',
+                ExistingTables: existingTables,
+                EntitySettingsForTargets: {}
+            };
+
+            // Step 5: Build schema — SchemaBuilder handles evolution (ALTER TABLE) internally
+            const builder = new SchemaBuilder();
+            const schemaOutput = builder.BuildSchema(schemaInput);
+
+            if (schemaOutput.Errors.length > 0) {
+                return {
+                    Success: false,
+                    Message: `Schema evolution failed: ${schemaOutput.Errors.join('; ')}`,
+                    HasChanges: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+
+            // Step 6: Check if any migration SQL was generated
+            if (schemaOutput.MigrationFiles.length === 0) {
+                return {
+                    Success: true,
+                    Message: 'No schema changes detected',
+                    HasChanges: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+
+            // Step 7: Count added/modified columns by re-diffing
+            let addedColumns = 0;
+            let modifiedColumns = 0;
+            const evolution = new SchemaEvolution();
+            for (const existing of existingTables) {
+                const config = targetConfigs.find(
+                    c => c.SchemaName.toLowerCase() === existing.SchemaName.toLowerCase()
+                      && c.TableName.toLowerCase() === existing.TableName.toLowerCase()
+                );
+                if (!config) continue;
+                const sourceObj = filteredSchema.Objects.find(o => o.ExternalName.toLowerCase() === config.SourceObjectName.toLowerCase());
+                if (!sourceObj) continue;
+                const diff = evolution.DiffSchema(sourceObj, config, existing, validatedPlatform);
+                addedColumns += diff.AddedColumns.length;
+                modifiedColumns += diff.ModifiedColumns.length;
+            }
+
+            // Step 8: Run RSU pipeline
+            const rsuInput = builder.BuildRSUInput(schemaOutput, schemaInput, {
+                SkipGitCommit: skipGitCommit,
+                SkipRestart: skipRestart,
+            });
+
+            const rsm = RuntimeSchemaManager.Instance;
+            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+
+            const pipelineResult = batchResult.Results[0];
+            const pipelineSteps = pipelineResult?.Steps.map((s: RSUPipelineStep) => ({
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+            }));
+
+            return {
+                Success: pipelineResult?.Success ?? false,
+                Message: pipelineResult?.Success
+                    ? `Schema evolution applied — ${addedColumns} column(s) added, ${modifiedColumns} column(s) modified`
+                    : `Pipeline failed: ${pipelineResult?.ErrorMessage ?? 'unknown error'}`,
+                HasChanges: true,
+                AddedColumns: addedColumns,
+                ModifiedColumns: modifiedColumns,
+                Steps: pipelineSteps,
+                GitCommitSuccess: pipelineResult?.GitCommitSuccess,
+                APIRestarted: pipelineResult?.APIRestarted,
+                Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+            };
+        } catch (e) {
+            LogError(`IntegrationSchemaEvolution error: ${e}`);
+            return { Success: false, Message: this.formatError(e), HasChanges: false };
+        }
+    }
+
+    // ── WEBHOOK HELPER ──────────────────────────────────────────────────
+
+    private async sendWebhook(url: string, payload: Record<string, unknown>): Promise<void> {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok) {
+                console.error(`[Integration] Webhook POST to ${url} returned ${response.status}`);
+            }
+        } catch (e) {
+            console.error(`[Integration] Webhook POST to ${url} failed:`, e);
+        }
+    }
 }