@memberjunction/server 5.27.1 → 5.29.0

package/src/resolvers/FileResolver.ts

@@ -368,9 +368,21 @@ export class FileResolver extends FileResolverBase {
     return { account, provider };
   }
 
+  /**
+   * Legacy file upload path — used by the `<mj-files-file-upload>` Angular component.
+   * Creates a File entity record in the database AND generates a pre-authenticated upload URL.
+   * The client then PUTs the file binary directly to that URL.
+   *
+   * Driver initialization: uses `buildUserContext()` (no storage account). The driver
+   * initializes from environment variables (e.g. STORAGE_AZURE_ACCOUNT_NAME, STORAGE_DROPBOX_ACCESS_TOKEN).
+   *
+   * Input: `ProviderID` identifies which storage provider to use.
+   * Returns: `{ File, UploadUrl, NameExists }` — the persisted File record, upload URL, and duplicate check.
+   *
+   * @see CreatePreAuthUploadUrl for the enterprise storage-account-based path (used by File Browser).
+   */
   @Mutation(() => CreateFilePayload)
   async CreateFile(@Arg('input', () => CreateMJFileInput) input: CreateMJFileInput, @Ctx() context: AppContext, @PubSub() pubSub: PubSubEngine) {
-    // Check to see if there's already an object with that name
     const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
@@ -389,12 +401,15 @@ export class FileResolver extends FileResolverBase {
 
     // Create the upload URL and get the record updates (provider key, content type, etc)
     const userContext = this.buildUserContext(context);
-    const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity, userContext);
+    const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileEntity as unknown as { ID: string; Name: string; ProviderID: string; ContentType?: string; ProviderKey?: string }, userContext);
 
     // Save the file record with the updated input
     const mapper = new FieldMapper();
-    fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }), true, true);
-    await fileEntity.Save();
+    fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }), true, false);
+    const saved = await fileEntity.Save();
+    if (!saved) {
+      console.error('[CreateFile] File save failed:', fileEntity.LatestResult?.CompleteMessage);
+    }
     const File = mapper.MapFields({ ...fileEntity.GetAll() });
 
     return { File, UploadUrl, NameExists };
@@ -534,6 +549,20 @@ export class FileResolver extends FileResolverBase {
     return downloadUrl;
   }
 
+  /**
+   * Enterprise file upload path — used by the File Browser UI.
+   * Generates a pre-authenticated upload URL only (does NOT create a File entity record).
+   * The client handles the upload directly to the storage provider via the returned URL.
+   *
+   * Driver initialization: uses `buildExtendedUserContext()` with a FileStorageAccount entity.
+   * Credentials are loaded from the Credential Engine (encrypted in the database), with
+   * automatic token refresh for OAuth providers like Dropbox and Box.com.
+   *
+   * Input: `AccountID` identifies which storage account (and its linked provider/credentials) to use.
+   * Returns: `{ UploadUrl, ProviderKey }` — the pre-authenticated URL and optional provider key.
+   *
+   * @see CreateFile for the legacy path that also creates a File entity record.
+   */
   @Mutation(() => CreatePreAuthUploadUrlPayload)
   async CreatePreAuthUploadUrl(@Arg('input', () => CreatePreAuthUploadUrlInput) input: CreatePreAuthUploadUrlInput, @Ctx() context: AppContext) {
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -1,5 +1,5 @@
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { CompositeKey, Metadata, RunView, UserInfo, LogError } from "@memberjunction/core";
+import { CompositeKey, LocalCacheManager, Metadata, RunView, UserInfo, LogError } from "@memberjunction/core";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
 import {
     MJCompanyIntegrationEntity,
@@ -24,7 +24,8 @@ import {
     ConnectionTestResult,
     IntegrationEngine,
     IntegrationSyncOptions,
-    SourceSchemaInfo
+    SourceSchemaInfo,
+    IntegrationSchemaSync
 } from "@memberjunction/integration-engine";
 import {
     SchemaBuilder,
@@ -87,6 +88,7 @@ class ApplyAllInput {
     @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;
+    @Field({ nullable: true, defaultValue: 'Pull', description: 'SyncDirection applied to all created entity maps: Pull | Push | Bidirectional. Defaults to Pull.' }) DefaultSyncDirection?: string;
 }
 
 @ObjectType()
@@ -137,6 +139,7 @@ class ApplyAllBatchConnectorInput {
     /** Optional per-connector schedule. Applied on success. */
     @Field({ nullable: true }) CronExpression?: string;
     @Field({ nullable: true }) ScheduleTimezone?: string;
+    @Field({ nullable: true, defaultValue: 'Pull', description: 'SyncDirection applied to all created entity maps for this connector: Pull | Push | Bidirectional. Defaults to Pull.' }) DefaultSyncDirection?: string;
 }
 
 @InputType()
@@ -145,6 +148,8 @@ class ApplyAllBatchInput {
     @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;
+    @Field({ nullable: true, description: 'Override sync direction for the initial sync: Pull | Push | Bidirectional. Defaults to entity map SyncDirection.' }) SyncDirection?: string;
+    @Field({ nullable: true, description: 'Override sync direction stored in the created schedule: Pull | Push | Bidirectional.' }) ScheduleSyncDirection?: string;
 }
 
 @ObjectType()
@@ -508,6 +513,14 @@ class StartSyncOutput {
     @Field({ nullable: true }) RunID?: string;
 }
 
+@ObjectType()
+class WriteRecordOutput {
+    @Field() Success: boolean;
+    @Field() Message: string;
+    @Field({ nullable: true }) ExternalID?: string;
+    @Field({ nullable: true }) StatusCode?: number;
+}
+
 @InputType()
 class CreateScheduleInput {
     @Field() CompanyIntegrationID: string;
@@ -515,6 +528,8 @@ class CreateScheduleInput {
     @Field() CronExpression: string;
     @Field({ nullable: true }) Timezone?: string;
     @Field({ nullable: true }) Description?: string;
+    @Field({ nullable: true }) SyncDirection?: string;
+    @Field({ nullable: true }) FullSync?: boolean;
 }
 
 @ObjectType()
@@ -1008,15 +1023,23 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         // but the connector's GetIntegrationObjects() always has them.
         const connectorDescriptions = this.buildDescriptionLookup(connector);
 
-        return objects.map(obj => {
+        const results: TargetTableConfig[] = [];
+        for (const obj of objects) {
             const sourceObj = sourceSchema.Objects.find(o => o.ExternalName.toLowerCase() === obj.SourceObjectName.toLowerCase());
             const objDescriptions = connectorDescriptions.get(obj.SourceObjectName.toLowerCase());
 
+            // If the object wasn't discovered in IntrospectSchema (e.g. API error), skip it
+            // rather than generating a broken table with no columns and a fallback PK.
+            if (!sourceObj) {
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — not found in source schema (IntrospectSchema may have failed for this object)`);
+                continue;
+            }
+
             // 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 =>
+            const sourceFields = sourceObj.Fields.filter(f =>
                 !selectedFieldSet || selectedFieldSet.has(f.Name.toLowerCase()) || f.IsPrimaryKey
             );
 
@@ -1032,21 +1055,37 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 Description: f.Description ?? objDescriptions?.fields.get(f.Name.toLowerCase()),
             }));
 
-            const primaryKeyFields = (sourceObj?.Fields ?? [])
+            const primaryKeyFields = sourceObj.Fields
                 .filter(f => f.IsPrimaryKey)
                 .map(f => f.Name.replace(/[^A-Za-z0-9_]/g, '_'));
 
-            return {
+            // If no columns were discovered, skip rather than generating a broken table
+            // (DDL with UNIQUE ([ID]) on a non-existent column will always fail).
+            if (columns.length === 0 && primaryKeyFields.length === 0) {
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — 0 fields discovered (live API likely failed and no DB-cached fields available)`);
+                continue;
+            }
+
+            // If columns exist but no PK was found, log diagnostic info and skip rather than
+            // generating broken DDL with UNIQUE ([ID]) on a non-existent column.
+            if (primaryKeyFields.length === 0 && columns.length > 0) {
+                const fieldNames = sourceObj.Fields.map(f => `${f.Name}(pk=${f.IsPrimaryKey})`).join(', ');
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — ${columns.length} columns but NO primary key field found. Fields: [${fieldNames}]`);
+                continue;
+            }
+
+            results.push({
                 SourceObjectName: obj.SourceObjectName,
                 SchemaName: obj.SchemaName,
                 TableName: obj.TableName,
                 EntityName: obj.EntityName,
-                Description: sourceObj?.Description ?? objDescriptions?.objectDescription,
+                Description: sourceObj.Description ?? objDescriptions?.objectDescription,
                 Columns: columns,
-                PrimaryKeyFields: primaryKeyFields.length > 0 ? primaryKeyFields : ['ID'],
+                PrimaryKeyFields: primaryKeyFields,
                 SoftForeignKeys: []
-            };
-        });
+            });
+        }
+        return results;
     }
 
     /** Builds a lookup of object name → { objectDescription, fields: fieldName → description } from the connector's static metadata. */
@@ -1818,9 +1857,73 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
             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
+            // Step 1b: Ensure IntegrationEngine cache is populated so IntrospectSchema's
+            // DB fallback (GetCachedObject/GetCachedFields) can find IntegrationObject records
+            await IntegrationEngine.Instance.Config(false, user);
+
+            // Step 2: Introspect source schema and persist discovered objects/fields
             const sourceSchema = await (connector.IntrospectSchema.bind(connector) as
                 (ci: unknown, u: unknown) => Promise<SourceSchemaInfo>)(companyIntegration, user);
+
+            // Step 2b: Persist discovered objects/fields to IntegrationObject/IntegrationObjectField.
+            // Static records (IsCustom=false) are preserved; new/custom records get IsCustom=true.
+            // This ensures custom objects are available for future sync runs, action generation, etc.
+            try {
+                const persistResult = await IntegrationSchemaSync.PersistDiscoveredSchema({
+                    IntegrationID: companyIntegration.IntegrationID,
+                    SourceSchema: sourceSchema,
+                    ContextUser: user,
+                });
+                if (persistResult.ObjectsCreated > 0 || persistResult.FieldsCreated > 0) {
+                    console.log(
+                        `[IntegrationApplyAll] Persisted discovered schema: ` +
+                        `${persistResult.ObjectsCreated} new objects, ${persistResult.FieldsCreated} new fields, ` +
+                        `${persistResult.ObjectsUpdated} updated objects, ${persistResult.FieldsUpdated} updated fields`
+                    );
+                }
+
+                // Step 2c: Generate CRUD actions for newly discovered custom objects.
+                // Uses the same ActionMetadataGenerator as the offline CLI, persisted via BaseEntity.Save().
+                if (persistResult.ObjectsCreated > 0) {
+                    try {
+                        const engineObjects = IntegrationEngine.Instance
+                            .GetIntegrationObjectsByIntegrationID(companyIntegration.IntegrationID);
+                        const customObjects = sourceSchema.Objects
+                            .filter(o => !engineObjects
+                                .some(ex => ex.Name.toLowerCase() === o.ExternalName.toLowerCase() && !ex.IsCustom))
+                            .map(o => ({
+                                Name: o.ExternalName,
+                                DisplayName: o.ExternalLabel || o.ExternalName,
+                                Description: o.Description,
+                                SupportsWrite: false,
+                                Fields: o.Fields.map(f => ({
+                                    Name: f.Name,
+                                    DisplayName: f.Label || f.Name,
+                                    Description: f.Description || '',
+                                    Type: f.SourceType || 'string',
+                                    IsRequired: f.IsRequired,
+                                    IsReadOnly: false,
+                                    IsPrimaryKey: f.IsPrimaryKey,
+                                })),
+                            }));
+                        await IntegrationSchemaSync.GenerateActionsForCustomObjects({
+                            IntegrationName: companyIntegration.Integration,
+                            CustomObjects: customObjects,
+                            SupportsSearch: connector.SupportsSearch,
+                            SupportsListing: connector.SupportsListing,
+                            ContextUser: user,
+                        });
+                    } catch (actionErr) {
+                        const msg = actionErr instanceof Error ? actionErr.message : String(actionErr);
+                        console.warn(`[IntegrationApplyAll] Action generation warning (non-fatal): ${msg}`);
+                    }
+                }
+            } catch (persistErr) {
+                // Non-fatal: schema persistence failure should not block table creation
+                const msg = persistErr instanceof Error ? persistErr.message : String(persistErr);
+                console.warn(`[IntegrationApplyAll] Schema persistence warning (non-fatal): ${msg}`);
+            }
+
             const objectIDs = input.SourceObjects.map(so => so.SourceObjectID);
             const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
 
@@ -1896,7 +1999,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
             if (skipRestart) {
                 await Metadata.Provider.Refresh();
                 const entityMapsCreated = await this.createEntityAndFieldMaps(
-                    input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user
+                    input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user,
+                    input.DefaultSyncDirection ?? 'Pull'
                 );
                 const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
                 const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
@@ -1978,14 +2082,15 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         connector: BaseIntegrationConnector,
         companyIntegration: MJCompanyIntegrationEntity,
         schemaName: string,
-        user: UserInfo
+        user: UserInfo,
+        defaultSyncDirection: string = 'Pull'
     ): 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
+                companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md, defaultSyncDirection
             );
             if (entityMapResult) {
                 results.push(entityMapResult);
@@ -2002,7 +2107,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         companyIntegration: MJCompanyIntegrationEntity,
         schemaName: string,
         user: UserInfo,
-        md: Metadata
+        md: Metadata,
+        defaultSyncDirection: string = 'Pull'
     ): Promise<ApplyAllEntityMapCreated | null> {
         // Find the entity by schema + table name
         const entityInfo = md.Entities.find(
@@ -2020,8 +2126,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         em.CompanyIntegrationID = companyIntegrationID;
         em.ExternalObjectName = obj.SourceObjectName;
         em.EntityID = entityInfo.ID;
-        em.SyncDirection = 'Pull';
-        em.Priority = 0;
+        em.SyncDirection = isValidSyncDirection(defaultSyncDirection) ? defaultSyncDirection : 'Pull';
+        em.Priority = obj.SourceObjectName.startsWith('assoc_') ? 10 : 0;
         em.Status = 'Active';
         em.SyncEnabled = true;
 
@@ -2183,15 +2289,17 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         @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[],
+        @Arg("syncDirection", () => String, { nullable: true, description: 'Override sync direction: Pull | Push | Bidirectional. If omitted, each entity map\'s own SyncDirection is used.' }) syncDirection: 'Pull' | 'Push' | 'Bidirectional' | undefined,
         @Ctx() ctx: AppContext
     ): Promise<StartSyncOutput> {
         try {
             const user = this.getAuthenticatedUser(ctx);
             await IntegrationEngine.Instance.Config(false, user);
 
-            const syncOptions: { FullSync?: boolean; EntityMapIDs?: string[] } = {};
+            const syncOptions: { FullSync?: boolean; EntityMapIDs?: string[]; SyncDirection?: 'Pull' | 'Push' | 'Bidirectional' } = {};
             if (fullSync) syncOptions.FullSync = true;
             if (entityMapIDs?.length) syncOptions.EntityMapIDs = entityMapIDs;
+            if (syncDirection) syncOptions.SyncDirection = syncDirection;
 
             // Fire and forget — progress is tracked inside IntegrationEngine
             const syncPromise = IntegrationEngine.Instance.RunSync(
@@ -2280,6 +2388,85 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         }
     }
 
+    /**
+     * Writes a single record to an external system via the integration connector.
+     * Supports create, update, and delete operations.
+     */
+    @Mutation(() => WriteRecordOutput)
+    async IntegrationWriteRecord(
+        @Arg("companyIntegrationID") companyIntegrationID: string,
+        @Arg("objectName") objectName: string,
+        @Arg("operation", () => String, { description: 'create, update, or delete' }) operation: string,
+        @Arg("externalID", { nullable: true, description: 'Required for update/delete' }) externalID: string,
+        @Arg("attributes", () => String, { nullable: true, description: 'JSON object of field values for create/update' }) attributesJson: string,
+        @Ctx() ctx: AppContext
+    ): Promise<WriteRecordOutput> {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            await IntegrationEngine.Instance.Config(false, user);
+
+            const rv = new RunView();
+            const ciResult = await rv.RunView<MJCompanyIntegrationEntity>({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: `ID='${companyIntegrationID}'`,
+                MaxRows: 1,
+                ResultType: 'entity_object',
+            }, user);
+
+            if (!ciResult.Success || ciResult.Results.length === 0) {
+                return { Success: false, Message: `Company Integration not found: ${companyIntegrationID}` };
+            }
+
+            const companyIntegration = ciResult.Results[0];
+
+            // Load the Integration entity to get the ClassName for connector resolution
+            const integResult = await rv.RunView<MJIntegrationEntity>({
+                EntityName: 'Integrations',
+                ExtraFilter: `ID='${companyIntegration.IntegrationID}'`,
+                MaxRows: 1,
+                ResultType: 'entity_object',
+            }, user);
+            if (!integResult.Success || integResult.Results.length === 0) {
+                return { Success: false, Message: `Integration not found: ${companyIntegration.IntegrationID}` };
+            }
+            const connector = ConnectorFactory.Resolve(integResult.Results[0]);
+
+            const attributes = attributesJson ? JSON.parse(attributesJson) as Record<string, unknown> : {};
+            const crudBase = { CompanyIntegration: companyIntegration, ObjectName: objectName, ContextUser: user };
+
+            let result: { Success: boolean; ExternalID?: string; ErrorMessage?: string; StatusCode: number };
+
+            switch (operation.toLowerCase()) {
+                case 'create':
+                    if (!connector.SupportsCreate) return { Success: false, Message: 'Connector does not support create' };
+                    result = await connector.CreateRecord({ ...crudBase, Attributes: attributes });
+                    break;
+                case 'update':
+                    if (!connector.SupportsUpdate) return { Success: false, Message: 'Connector does not support update' };
+                    if (!externalID) return { Success: false, Message: 'externalID is required for update' };
+                    result = await connector.UpdateRecord({ ...crudBase, ExternalID: externalID, Attributes: attributes });
+                    break;
+                case 'delete':
+                    if (!connector.SupportsDelete) return { Success: false, Message: 'Connector does not support delete' };
+                    if (!externalID) return { Success: false, Message: 'externalID is required for delete' };
+                    result = await connector.DeleteRecord({ ...crudBase, ExternalID: externalID });
+                    break;
+                default:
+                    return { Success: false, Message: `Invalid operation: ${operation}. Must be create, update, or delete` };
+            }
+
+            return {
+                Success: result.Success,
+                Message: result.Success ? `${operation} succeeded` : (result.ErrorMessage ?? `${operation} failed`),
+                ExternalID: result.ExternalID,
+                StatusCode: result.StatusCode,
+            };
+        } catch (e) {
+            LogError(`IntegrationWriteRecord error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+
     // ── SCHEDULE ────────────────────────────────────────────────────────
 
     @Mutation(() => CreateScheduleOutput)
@@ -2314,7 +2501,10 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
             job.Timezone = input.Timezone || 'UTC';
             job.Status = 'Active';
             job.OwnerUserID = user.ID;
-            job.Configuration = JSON.stringify({ CompanyIntegrationID: input.CompanyIntegrationID });
+            const jobConfig: Record<string, unknown> = { CompanyIntegrationID: input.CompanyIntegrationID };
+            if (input.SyncDirection) jobConfig.SyncDirection = input.SyncDirection;
+            if (input.FullSync) jobConfig.FullSync = input.FullSync;
+            job.Configuration = JSON.stringify(jobConfig);
             job.NextRunAt = CronExpressionHelper.GetNextRunTime(input.CronExpression, input.Timezone || 'UTC');
 
             if (!await job.Save()) return { Success: false, Message: 'Failed to create schedule' };
@@ -2884,6 +3074,17 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
             const user = this.getAuthenticatedUser(ctx);
             const validatedPlatform = this.validatePlatform(platform);
 
+            // Bust RunView caches for integration metadata BEFORE Config(true).
+            // mj sync push writes records via stored procedures which do NOT fire
+            // BaseEntity change events, so the RunView cache is never auto-invalidated.
+            // Explicitly clearing these entries ensures Config(true) re-queries the DB.
+            await LocalCacheManager.Instance.InvalidateEntityCaches('MJ: Integration Objects');
+            await LocalCacheManager.Instance.InvalidateEntityCaches('MJ: Integration Object Fields');
+
+            // Force-refresh integration metadata cache so IntrospectSchema
+            // picks up any IntegrationObject/Field changes made via mj sync push
+            await IntegrationEngine.Instance.Config(true, user);
+
             // Phase 1: Build schema for each connector in parallel
             const buildResults = await Promise.allSettled(
                 input.Connectors.map(async (connInput) => {
@@ -2933,6 +3134,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                         StartSync: input.StartSync,
                         FullSync: input.FullSync ?? false,
                         SyncScope: input.SyncScope ?? 'created',
+                        SyncDirection: input.SyncDirection,
+                        ScheduleSyncDirection: input.ScheduleSyncDirection,
                         CreatedAt: new Date().toISOString(),
                     };
                     rsuInput.PostRestartFiles = [
@@ -3028,7 +3231,8 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                     await Metadata.Provider.Refresh();
                     const entityMapsCreated = await this.createEntityAndFieldMaps(
                         build.connInput.CompanyIntegrationID, build.objects, build.connector,
-                        build.companyIntegration, build.schemaName, user
+                        build.companyIntegration, build.schemaName, user,
+                        build.connInput.DefaultSyncDirection ?? 'Pull'
                     );
                     connResult.EntityMapsCreated = entityMapsCreated;