@memberjunction/server 5.27.1 → 5.28.0

package/src/generic/ResolverBase.ts

@@ -153,6 +153,10 @@ export class ResolverBase {
           Key: mapper.ReverseMapFieldName(item.Key),
           Value: item.Value,
         }));
+      } else if (key === 'RestoreContext___') {
+        // Pass through the restore-context blob unchanged — its inner field
+        // names (SourceChangeID, Reason) are not entity-field names.
+        mapped[key] = input[key];
       } else {
         mapped[mapper.ReverseMapFieldName(key)] = input[key];
       }
@@ -160,6 +164,24 @@ export class ResolverBase {
     return mapped;
   }
 
+  /**
+   * Applies an inbound RestoreContext___ blob to a server-side BaseEntity.
+   * Mirrors the OldValues___ pattern — the client-side BaseEntity's
+   * `_restoreContext` doesn't traverse the network, so the server must
+   * reconstruct it from the mutation input before calling Save().
+   *
+   * Returns true when context was applied; false when no context was on the input.
+   */
+  protected applyRestoreContext(
+    entityObject: BaseEntity,
+    input: { RestoreContext___?: { SourceChangeID?: string; Reason?: string | null } | null },
+  ): boolean {
+    const ctx = input?.RestoreContext___;
+    if (!ctx || !ctx.SourceChangeID) return false;
+    entityObject.SetRestoreContext(ctx.SourceChangeID, ctx.Reason ?? null);
+    return true;
+  }
+
   protected async ArrayMapFieldNamesToCodeNames(entityName: string, dataObjectArray: any[], contextUser?: UserInfo): Promise<any[]> {
     // iterate through the array and call MapFieldNamesToCodeNames for each element
     if (dataObjectArray && dataObjectArray.length > 0) {
@@ -1053,7 +1075,17 @@ export class ResolverBase {
       // fire event and proceed if it wasn't cancelled
       const entityObject = await provider.GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
       entityObject.NewRecord();
-      entityObject.SetMany(input);
+      // Strip the RestoreContext___ blob from the field assignments — it's
+      // metadata for the upcoming Save(), not a field on the record.
+      const fieldsForSet: Record<string, unknown> = {};
+      for (const key of Object.keys(input)) {
+        if (key !== 'RestoreContext___') fieldsForSet[key] = input[key];
+      }
+      entityObject.SetMany(fieldsForSet);
+
+      // Reconstruct the client-side restore context, if any, on this server
+      // entity so the data provider writes the lineage columns on Save().
+      this.applyRestoreContext(entityObject, input);
 
       this.ListenForEntityMessages(entityObject, pubSub, userPayload);
 
@@ -1095,10 +1127,11 @@ export class ResolverBase {
       const entityInfo = entityObject.EntityInfo;
       const clientNewValues = {};
       Object.keys(input).forEach((key) => {
-        if (key !== 'OldValues___') {
+        // Skip metadata blobs that aren't actual entity fields.
+        if (key !== 'OldValues___' && key !== 'RestoreContext___') {
           clientNewValues[key] = input[key];
         }
-      }); // grab all the props except for the OldValues property
+      });
 
       if (entityInfo.TrackRecordChanges || !input.OldValues___) {
         // We get here because EITHER the entity tracks record changes OR the client did not provide OldValues, so we need to load the old values from the DB
@@ -1140,8 +1173,12 @@ export class ResolverBase {
         entityObject.SetMany(clientNewValues);
       }
 
+      // Reconstruct the client-side restore context, if any, on this server
+      // entity so the data provider writes the lineage columns on Save().
+      this.applyRestoreContext(entityObject, input);
+
       this.ListenForEntityMessages(entityObject, pubSub, userPayload);
-      
+
       if (await entityObject.Save()) {
         // save worked, fire afterevent and return all the data
         await this.AfterUpdate(provider, input); // fire event

package/src/generic/RestoreContextInput.ts

@@ -0,0 +1,32 @@
+import { Field, InputType } from 'type-graphql';
+
+/**
+ * GraphQL InputType carrying restore-lineage context across the network.
+ *
+ * Set as the `RestoreContext___` reserved field on any entity Create or
+ * Update mutation input when the operation is a restore. The server-side
+ * resolver detects it, calls `BaseEntity.SetRestoreContext()` on the
+ * server-side entity instance before `Save()`, and the data provider then
+ * writes the resulting RecordChange row with `Source='Restore'`,
+ * `RestoredFromID = SourceChangeID`, and `RestoreReason = Reason`.
+ *
+ * Mirrors the pattern used by `OldValues___` (KeyValuePairInput[]) — a
+ * non-field metadata blob carried alongside the regular field values
+ * through the GraphQL mutation input.
+ */
+@InputType()
+export class RestoreContextInput {
+    /**
+     * ID of the historical RecordChange row whose state is being restored.
+     * Persisted to RecordChange.RestoredFromID on the new change row.
+     */
+    @Field(() => String)
+    SourceChangeID: string;
+
+    /**
+     * Optional user-entered explanation for the restore. Persisted to
+     * RecordChange.RestoreReason. NULL when the user did not enter one.
+     */
+    @Field(() => String, { nullable: true })
+    Reason?: string | null;
+}

package/src/index.ts

@@ -104,6 +104,7 @@ export * from './resolvers/TaskResolver.js';
 export * from './generic/KeyValuePairInput.js';
 export * from './generic/KeyInputOutputTypes.js';
 export * from './generic/DeleteOptionsInput.js';
+export * from './generic/RestoreContextInput.js';
 
 export * from './agents/skip-agent.js';
 export * from './agents/skip-sdk.js';
@@ -867,6 +868,13 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
   // Process pending RSU work from pre-restart (entity maps, field maps, sync)
   processRSUPendingWork().catch(err => console.warn(`RSU pending work processing failed: ${err}`));
 
+  // Resume any integration syncs that were orphaned by the previous process restart
+  const resumeUser = UserCache.Instance.GetSystemUser();
+  if (resumeUser) {
+    IntegrationEngine.Instance.ResumeOrphanedSyncs(resumeUser)
+      .catch(err => console.warn(`[IntegrationEngine] Orphaned sync resume failed: ${err}`));
+  }
+
   // Set up graceful shutdown handlers
   const gracefulShutdown = async (signal: string) => {
     console.log(`\n${signal} received, shutting down gracefully...`);
@@ -980,6 +988,11 @@ async function processRSUPendingWork(): Promise<void> {
       const rvPending = new RunView();
       const sourceObjectFields: Record<string, string[] | null> = item.SourceObjectFields ?? {};
 
+      // Introspect schema ONCE for the entire connector, then reuse per object
+      const introspect = connector.IntrospectSchema.bind(connector) as
+        (ci: unknown, u: unknown) => Promise<{ Objects: Array<{ ExternalName: string; Fields: Array<{ Name: string; IsPrimaryKey?: boolean; IsRequired?: boolean }> }> }>;
+      const schema = await introspect(companyIntegration, systemUser);
+
       for (const objName of item.SourceObjectNames) {
         const tableName = objName.replace(/[^A-Za-z0-9_]/g, '_').toLowerCase();
         const entity = md.Entities.find(
@@ -1028,9 +1041,6 @@ async function processRSUPendingWork(): Promise<void> {
 
         // Create field maps — filter by SourceObjectFields (null = all)
         try {
-          const introspect = connector.IntrospectSchema.bind(connector) as
-            (ci: unknown, u: unknown) => Promise<{ Objects: Array<{ ExternalName: string; Fields: Array<{ Name: string }> }> }>;
-          const schema = await introspect(companyIntegration, systemUser);
           const sourceObj = schema.Objects.find(o => o.ExternalName.toLowerCase() === objName.toLowerCase());
 
           const selectedFields = sourceObjectFields[objName]; // null = all, string[] = specific
@@ -1059,6 +1069,9 @@ async function processRSUPendingWork(): Promise<void> {
             fieldMap.EntityMapID = entityMapID;
             fieldMap.SourceFieldName = field.Name;
             fieldMap.DestinationFieldName = field.Name.replace(/[^A-Za-z0-9_]/g, '_');
+            fieldMap.IsKeyField = field.IsPrimaryKey ?? false;
+            fieldMap.IsRequired = field.IsRequired ?? false;
+            fieldMap.Direction = 'SourceToDest';
             fieldMap.Status = 'Active';
             if (await fieldMap.Save()) fieldCount++;
           }
@@ -1075,9 +1088,10 @@ async function processRSUPendingWork(): Promise<void> {
           const syncOptions: IntegrationSyncOptions = {};
           if (item.SyncScope !== 'all' && createdEntityMapIDs.length > 0) syncOptions.EntityMapIDs = createdEntityMapIDs;
           if (item.FullSync) syncOptions.FullSync = true;
+          if (item.SyncDirection) syncOptions.SyncDirection = item.SyncDirection;
           const opts = Object.keys(syncOptions).length > 0 ? syncOptions : undefined;
           IntegrationEngine.Instance.RunSync(item.CompanyIntegrationID, systemUser, 'Manual', undefined, undefined, opts);
-          console.log(`[RSU] Sync started for ${item.CompanyIntegrationID} (EntityMaps: ${createdEntityMapIDs.length}, FullSync: ${!!item.FullSync})`);
+          console.log(`[RSU] Sync started for ${item.CompanyIntegrationID} (EntityMaps: ${createdEntityMapIDs.length}, FullSync: ${!!item.FullSync}, SyncDirection: ${item.SyncDirection ?? 'entity-map default'})`);
         } catch (syncErr) {
           console.warn(`[RSU] Sync start failed: ${syncErr}`);
         }
@@ -1134,7 +1148,9 @@ async function processRSUPendingWork(): Promise<void> {
             job.NewRecord();
             job.JobTypeID = jobTypeResult.Results[0].ID;
             job.OwnerUserID = systemUser.ID;
-            job.Configuration = JSON.stringify({ CompanyIntegrationID: item.CompanyIntegrationID });
+            const schedConfig: Record<string, unknown> = { CompanyIntegrationID: item.CompanyIntegrationID };
+            if (item.ScheduleSyncDirection) schedConfig.SyncDirection = item.ScheduleSyncDirection;
+            job.Configuration = JSON.stringify(schedConfig);
           }
 
           job.Name = `${integrationName} Scheduled Sync`;

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;