refactor: make rebuildBackwardRelationshipsForFilteredTypes a pure function

Remove side effects by returning a new object instead of mutating the input.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: toiroakr

packages/sdk/src/cli/apply/index.ts

@@ -198,37 +198,14 @@ export async function apply(options?: ApplyOptions) {
     return;
   }
 
-  // Migration only mode: Apply IdP → Auth → TailorDB (different order for migration scripts)
-  // Migration scripts require machine users, so IdP/Auth must be created first
-  if (migrationOnlyMode) {
-    // Phase 1: Create IdP/Auth first (machine users needed for migration scripts)
-    await applyIdP(client, idp, "create-update");
-    await applyAuth(client, auth, "create-update");
-
-    // Phase 2: TailorDB migration (machine users are now available)
-    await applyTailorDB(client, tailorDB, "create-update");
-
-    // Phase 3: Delete services
-    await applyAuth(client, auth, "delete-services");
-    await applyIdP(client, idp, "delete-services");
-    await applyTailorDB(client, tailorDB, "delete-services");
-
-    logger.success("Successfully applied TailorDB + Auth + IdP changes.");
-    return;
-  }
-
-  // Normal mode: Apply in standard order
   // Phase 2: Create/Update services that Application depends on
   // - Subgraph services (for GraphQL SDL composition): TailorDB, IdP, Auth, Pipeline
   // - StaticWebsite (for CORS and OAuth2 redirect URI resolution)
-
-  // TailorDB: Automatically validates migrations and handles migration flow internally
-  await applyTailorDB(client, tailorDB, "create-update");
-
-  // Other services: Apply after TailorDB migrations complete
-  await applyStaticWebsite(client, staticWebsite, "create-update");
+  // IdP/Auth are applied before TailorDB because migration scripts require machine users
   await applyIdP(client, idp, "create-update");
   await applyAuth(client, auth, "create-update");
+  await applyTailorDB(client, tailorDB, "create-update");
+  await applyStaticWebsite(client, staticWebsite, "create-update");
   await applyPipeline(client, pipeline, "create-update");
 
   // Phase 3: Delete subgraph resources (types, resolvers, etc.) before Application update

packages/sdk/src/cli/apply/services/tailordb/migration.ts

@@ -428,13 +428,11 @@ export async function buildFilteredTypesForVersion(
       }
     }
 
-    filteredTypesByNamespace.set(namespace, filteredTypes);
-  }
-
-  // Rebuild backward relationships after all types are filtered
-  // This ensures backward relationships only reference fields that exist in the filtered state
-  for (const filteredTypes of filteredTypesByNamespace.values()) {
-    rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+    // Rebuild backward relationships to only reference fields that exist in the filtered state
+    filteredTypesByNamespace.set(
+      namespace,
+      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes),
+    );
   }
 
   return filteredTypesByNamespace;

packages/sdk/src/cli/tailordb/migrate/snapshot.test.ts

@@ -1924,13 +1924,13 @@ describe("snapshot", () => {
         },
       );
 
-      const filteredTypes = { Customer: customer, Order: order };
-      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+      const input = { Customer: customer, Order: order };
+      const result = rebuildBackwardRelationshipsForFilteredTypes(input);
 
       // Customer should now have backward relationship to Order
-      expect(filteredTypes.Customer.backwardRelationships.orders).toBeDefined();
-      expect(filteredTypes.Customer.backwardRelationships.orders.targetType).toBe("Order");
-      expect(filteredTypes.Customer.backwardRelationships.orders.targetField).toBe("customerId");
+      expect(result.Customer.backwardRelationships.orders).toBeDefined();
+      expect(result.Customer.backwardRelationships.orders.targetType).toBe("Order");
+      expect(result.Customer.backwardRelationships.orders.targetField).toBe("customerId");
     });
 
     it("does not create backward relationships when forward relationship is filtered out", () => {
@@ -1943,11 +1943,11 @@ describe("snapshot", () => {
         id: { name: "id", config: { type: "uuid", required: true } },
       });
 
-      const filteredTypes = { Customer: customer, Order: order };
-      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+      const input = { Customer: customer, Order: order };
+      const result = rebuildBackwardRelationshipsForFilteredTypes(input);
 
       // Customer should have no backward relationships
-      expect(Object.keys(filteredTypes.Customer.backwardRelationships)).toHaveLength(0);
+      expect(Object.keys(result.Customer.backwardRelationships)).toHaveLength(0);
     });
 
     it("does not create backward relationships when target type does not exist", () => {
@@ -1982,11 +1982,11 @@ describe("snapshot", () => {
       );
 
       // Only Order exists, Customer is not in filtered types
-      const filteredTypes = { Order: order };
-      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+      const input = { Order: order };
+      const result = rebuildBackwardRelationshipsForFilteredTypes(input);
 
       // Order should still have its forward relationship but no backward should be created
-      expect(Object.keys(filteredTypes.Order.backwardRelationships)).toHaveLength(0);
+      expect(Object.keys(result.Order.backwardRelationships)).toHaveLength(0);
     });
 
     it("generates default backward name using inflection when not specified", () => {
@@ -2024,12 +2024,12 @@ describe("snapshot", () => {
         },
       );
 
-      const filteredTypes = { User: user, Profile: profile };
-      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+      const input = { User: user, Profile: profile };
+      const result = rebuildBackwardRelationshipsForFilteredTypes(input);
 
       // Should generate "profiles" (plural of "profile")
-      expect(filteredTypes.User.backwardRelationships.profiles).toBeDefined();
-      expect(filteredTypes.User.backwardRelationships.profiles.isArray).toBe(true);
+      expect(result.User.backwardRelationships.profiles).toBeDefined();
+      expect(result.User.backwardRelationships.profiles.isArray).toBe(true);
     });
 
     it("uses singular form for unique (1-1) relationships", () => {
@@ -2067,12 +2067,12 @@ describe("snapshot", () => {
         },
       );
 
-      const filteredTypes = { User: user, Profile: profile };
-      rebuildBackwardRelationshipsForFilteredTypes(filteredTypes);
+      const input = { User: user, Profile: profile };
+      const result = rebuildBackwardRelationshipsForFilteredTypes(input);
 
       // Should generate "profile" (singular) for 1-1 relationship
-      expect(filteredTypes.User.backwardRelationships.profile).toBeDefined();
-      expect(filteredTypes.User.backwardRelationships.profile.isArray).toBe(false);
+      expect(result.User.backwardRelationships.profile).toBeDefined();
+      expect(result.User.backwardRelationships.profile.isArray).toBe(false);
     });
   });
 });

packages/sdk/src/cli/tailordb/migrate/snapshot.ts

@@ -1212,19 +1212,21 @@ export function filterTypeToSnapshot(type: TailorDBType, snapshotType: SnapshotT
  * This must be called after all types have been filtered via filterTypeToSnapshot
  * to ensure backward relationships only reference fields that exist in the filtered state.
  * @param {Record<string, TailorDBType>} filteredTypes - Filtered types by name
+ * @returns {Record<string, TailorDBType>} New types with rebuilt backward relationships
  */
 export function rebuildBackwardRelationshipsForFilteredTypes(
   filteredTypes: Record<string, TailorDBType>,
-): void {
-  // Clear all backward relationships first (they were set to {} in filterTypeToSnapshot)
-  for (const type of Object.values(filteredTypes)) {
-    type.backwardRelationships = {};
+): Record<string, TailorDBType> {
+  // Create new types with empty backward relationships
+  const result: Record<string, TailorDBType> = {};
+  for (const [name, type] of Object.entries(filteredTypes)) {
+    result[name] = { ...type, backwardRelationships: {} };
   }
 
   // Rebuild backward relationships based on filtered forward relationships
-  for (const [typeName, type] of Object.entries(filteredTypes)) {
+  for (const [typeName, type] of Object.entries(result)) {
     for (const rel of Object.values(type.forwardRelationships)) {
-      const targetType = filteredTypes[rel.targetType];
+      const targetType = result[rel.targetType];
       if (!targetType) continue; // Target type doesn't exist in filtered types
 
       const field = type.fields[rel.targetField];
@@ -1249,6 +1251,8 @@ export function rebuildBackwardRelationshipsForFilteredTypes(
       };
     }
   }
+
+  return result;
 }
 
 // ============================================================================