feat: add support for building social links from legacy fields and reverse dual-write (#3407)

Author: idoshamun

.claude/settings.json

@@ -52,6 +52,7 @@
       "Bash(docker-compose:*)",
       "WebFetch(domain:*.daily.dev)",
       "mcp__github__*",
+      "mcp__plugin_linear_linear__*",
       "Read",
       "Glob",
       "Grep",

__tests__/updateUserInfo.ts

@@ -84,6 +84,7 @@ describe('mutation updateUserInfo', () => {
         twitter
         github
         hashnode
+        linkedin
         createdAt
         infoConfirmed
         timezone
@@ -97,6 +98,10 @@ describe('mutation updateUserInfo', () => {
           city
         }
         hideExperience
+        socialLinks {
+          platform
+          url
+        }
       }
     }
   `;
@@ -712,4 +717,47 @@ describe('mutation updateUserInfo', () => {
     const updatedUser = await repo.findOneBy({ id: loggedUser });
     expect(updatedUser?.hideExperience).toBe(false);
   });
+
+  describe('socialLinks', () => {
+    it('should reverse dual-write: update socialLinks when legacy fields are provided', async () => {
+      loggedUser = '1';
+      const repo = con.getRepository(User);
+      const user = await repo.findOneBy({ id: loggedUser });
+
+      // Use legacy format (individual fields like the client currently sends)
+      const res = await client.mutate(MUTATION, {
+        variables: {
+          data: {
+            name: user?.name,
+            username: 'testuser',
+            github: 'idoshamun',
+            linkedin: 'ido-shamun',
+            twitter: 'idoshamun',
+            portfolio: 'https://shamun.dev',
+            youtube: null,
+            stackoverflow: null,
+          },
+        },
+      });
+
+      expect(res.errors).toBeFalsy();
+
+      // Verify legacy columns are updated
+      expect(res.data.updateUserInfo.github).toBe('idoshamun');
+      expect(res.data.updateUserInfo.linkedin).toBe('ido-shamun');
+      expect(res.data.updateUserInfo.twitter).toBe('idoshamun');
+
+      // Verify socialLinks JSONB is also populated with full URLs (order may vary)
+      const updated = await repo.findOneBy({ id: loggedUser });
+      expect(updated?.socialLinks).toHaveLength(4);
+      expect(updated?.socialLinks).toEqual(
+        expect.arrayContaining([
+          { platform: 'github', url: 'https://github.com/idoshamun' },
+          { platform: 'linkedin', url: 'https://linkedin.com/in/ido-shamun' },
+          { platform: 'twitter', url: 'https://x.com/idoshamun' },
+          { platform: 'portfolio', url: 'https://shamun.dev' },
+        ]),
+      );
+    });
+  });
 });

__tests__/users.ts

@@ -4304,6 +4304,31 @@ describe('mutation updateUserProfile', () => {
     const updated = await con.getRepository(User).findOneBy({ id: loggedUser });
     expect(updated?.socialLinks).toEqual([]);
   });
+
+  it('should reverse dual-write: update socialLinks when legacy fields are provided', async () => {
+    loggedUser = '1';
+
+    // Use legacy format (individual fields)
+    const res = await client.mutate(MUTATION, {
+      variables: {
+        data: {
+          github: 'myhandle',
+          linkedin: 'myprofile',
+        },
+      },
+    });
+
+    expect(res.errors).toBeFalsy();
+
+    // Verify socialLinks JSONB is populated with full URLs
+    const updated = await con.getRepository(User).findOneBy({ id: loggedUser });
+    expect(updated?.socialLinks).toEqual(
+      expect.arrayContaining([
+        { platform: 'github', url: 'https://github.com/myhandle' },
+        { platform: 'linkedin', url: 'https://linkedin.com/in/myprofile' },
+      ]),
+    );
+  });
 });
 
 describe('mutation deleteUser', () => {

src/schema/users.ts

@@ -1716,6 +1716,107 @@ export const clearImagePreset = async ({
   }
 };
 
+/**
+ * Platform URL templates for building URLs from handles
+ */
+const PLATFORM_URL_TEMPLATES: Record<string, (handle: string) => string> = {
+  twitter: (handle) => `https://x.com/${handle}`,
+  github: (handle) => `https://github.com/${handle}`,
+  linkedin: (handle) => `https://linkedin.com/in/${handle}`,
+  threads: (handle) => `https://threads.net/@${handle}`,
+  roadmap: (handle) => `https://roadmap.sh/u/${handle}`,
+  codepen: (handle) => `https://codepen.io/${handle}`,
+  reddit: (handle) => `https://reddit.com/u/${handle}`,
+  stackoverflow: (handle) => `https://stackoverflow.com/users/${handle}`,
+  youtube: (handle) => `https://youtube.com/@${handle}`,
+  bluesky: (handle) => `https://bsky.app/profile/${handle}`,
+  hashnode: (handle) => `https://hashnode.com/@${handle}`,
+  // These platforms store full URLs, not handles
+  mastodon: (url) => url,
+  portfolio: (url) => url,
+};
+
+/**
+ * Build URL from handle for a given platform
+ */
+function buildUrlFromHandle(
+  handle: string | null | undefined,
+  platform: string,
+): string | null {
+  if (!handle) return null;
+  const template = PLATFORM_URL_TEMPLATES[platform];
+  if (!template) return null;
+  return template(handle);
+}
+
+/**
+ * Build socialLinks array from legacy column values
+ * Used for reverse dual-write when legacy fields are updated
+ */
+function buildSocialLinksFromLegacyFields(
+  data: Partial<GQLUpdateUserInput>,
+  existingUser: User,
+): UserSocialLink[] {
+  const legacyPlatforms = [
+    'twitter',
+    'github',
+    'linkedin',
+    'threads',
+    'roadmap',
+    'codepen',
+    'reddit',
+    'stackoverflow',
+    'youtube',
+    'bluesky',
+    'mastodon',
+    'hashnode',
+    'portfolio',
+  ] as const;
+
+  const socialLinks: UserSocialLink[] = [];
+
+  for (const platform of legacyPlatforms) {
+    // Use the new value from data if provided, otherwise use existing user value
+    const handle =
+      platform in data
+        ? (data[platform as keyof GQLUpdateUserInput] as string | null)
+        : (existingUser[platform] as string | null);
+
+    if (handle) {
+      const url = buildUrlFromHandle(handle, platform);
+      if (url) {
+        socialLinks.push({ platform, url });
+      }
+    }
+  }
+
+  return socialLinks;
+}
+
+/**
+ * Check if any legacy social fields are being updated
+ */
+function hasLegacySocialFieldsUpdate(
+  data: Partial<GQLUpdateUserInput>,
+): boolean {
+  const legacyPlatforms = [
+    'twitter',
+    'github',
+    'linkedin',
+    'threads',
+    'roadmap',
+    'codepen',
+    'reddit',
+    'stackoverflow',
+    'youtube',
+    'bluesky',
+    'mastodon',
+    'hashnode',
+    'portfolio',
+  ];
+  return legacyPlatforms.some((platform) => platform in data);
+}
+
 /**
  * Extract handle/value from URL for legacy column storage
  */
@@ -1761,8 +1862,8 @@ function extractHandleFromUrl(url: string, platform: string): string | null {
         // Full URL is stored for mastodon
         return url;
       case 'hashnode':
-        // Full URL is stored for hashnode
-        return url;
+        // https://hashnode.com/@username
+        return pathname.replace(/^\/@?/, '') || null;
       case 'portfolio':
         // Full URL is stored for portfolio
         return url;
@@ -2583,13 +2684,21 @@ export const resolvers: IResolvers<unknown, BaseContext> = traceResolvers<
           : data.image || user.image;
 
       try {
-        // Process socialLinks for dual-write if provided
+        // Process socialLinks for dual-write
         let socialLinksData: {
           socialLinks?: UserSocialLink[];
           legacyColumns?: Record<string, string | null>;
         } = {};
+
         if (data.socialLinks) {
+          // New format: socialLinks array provided -> write to both socialLinks and legacy columns
           socialLinksData = processSocialLinksForDualWrite(data.socialLinks);
+        } else if (hasLegacySocialFieldsUpdate(data)) {
+          // Legacy format: individual fields provided -> build socialLinks from merged values
+          socialLinksData.socialLinks = buildSocialLinksFromLegacyFields(
+            data,
+            user,
+          );
         }
 
         const updatedUser = {
@@ -2733,13 +2842,21 @@ export const resolvers: IResolvers<unknown, BaseContext> = traceResolvers<
       try {
         delete data.externalLocationId;
 
-        // Process socialLinks for dual-write if provided
+        // Process socialLinks for dual-write
         let socialLinksData: {
           socialLinks?: UserSocialLink[];
           legacyColumns?: Record<string, string | null>;
         } = {};
+
         if (data.socialLinks) {
+          // New format: socialLinks array provided -> write to both socialLinks and legacy columns
           socialLinksData = processSocialLinksForDualWrite(data.socialLinks);
+        } else if (hasLegacySocialFieldsUpdate(data)) {
+          // Legacy format: individual fields provided -> build socialLinks from merged values
+          socialLinksData.socialLinks = buildSocialLinksFromLegacyFields(
+            data,
+            user,
+          );
         }
 
         const updatedUser = {