@memberjunction/server 5.27.1 → 5.29.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';
@@ -130,6 +131,7 @@ export * from './resolvers/MCPResolver.js';
 export * from './resolvers/ActionResolver.js';
 export * from './resolvers/CacheStatsResolver.js';
 export * from './resolvers/EntityCommunicationsResolver.js';
+export * from './resolvers/FeedbackResolver.js';
 export * from './resolvers/EntityResolver.js';
 export * from './resolvers/ISAEntityResolver.js';
 export * from './resolvers/ArtifactFileResolver.js';
@@ -867,6 +869,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 +989,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 +1042,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 +1070,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 +1089,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 +1149,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`;