Update users endpoints: round 1 (#9166)

Co-authored-by: Sebastian Klingler <[email protected]>

Author: schottra

packages/common/src/adapters/access.ts

@@ -0,0 +1,36 @@
+import {
+  full,
+  instanceOfFollowGate,
+  instanceOfNftGate,
+  instanceOfTipGate
+} from '@audius/sdk'
+
+import {
+  AccessConditions,
+  AccessConditionsEthNFTCollection,
+  AccessConditionsSolNFTCollection
+} from '~/models'
+
+export const accessConditionsFromSDK = (
+  input: full.AccessGate
+): AccessConditions => {
+  if (instanceOfFollowGate(input)) {
+    return { follow_user_id: input.followUserId }
+  } else if (instanceOfNftGate(input)) {
+    return input.nftCollection.chain === full.NftCollectionChainEnum.Eth
+      ? {
+          nft_collection:
+            input.nftCollection as AccessConditionsEthNFTCollection
+        }
+      : {
+          nft_collection:
+            input.nftCollection as AccessConditionsSolNFTCollection
+        }
+  } else if (full.instanceOfPurchaseGate(input)) {
+    return { usdc_purchase: input.usdcPurchase }
+  } else if (instanceOfTipGate(input)) {
+    return { tip_user_id: input.tipUserId }
+  } else {
+    throw new Error(`Unsupported access gate type: ${input}`)
+  }
+}

packages/common/src/adapters/activity.ts

@@ -0,0 +1,22 @@
+import { full } from '@audius/sdk'
+
+import { userCollectionMetadataFromSDK } from './collection'
+import { userTrackMetadataFromSDK } from './track'
+
+export const repostActivityFromSDK = (input: full.ActivityFull) => {
+  const { timestamp, itemType: item_type, item } = input
+  if (item_type === full.ActivityFullItemTypeEnum.Track) {
+    return {
+      timestamp,
+      item_type,
+      item: userTrackMetadataFromSDK(full.TrackFullFromJSON(item))
+    }
+  } else if (item_type === full.ActivityFullItemTypeEnum.Playlist) {
+    return {
+      timestamp,
+      item_type,
+      item: userCollectionMetadataFromSDK(full.PlaylistFullFromJSON(item))
+    }
+  }
+  return undefined
+}

packages/common/src/adapters/attribution.ts

@@ -0,0 +1,10 @@
+import snakecaseKeys from 'snakecase-keys'
+
+import { ResourceContributor } from '~/models/Track'
+
+// Type from API is Raw, so we'll just convert the keys
+export const resourceContributorFromSDK = (
+  input: object
+): ResourceContributor => {
+  return snakecaseKeys(input) as ResourceContributor
+}

packages/common/src/adapters/collection.ts

@@ -0,0 +1,108 @@
+import { full } from '@audius/sdk'
+import { omit } from 'lodash'
+import snakecaseKeys from 'snakecase-keys'
+
+import {
+  PlaylistTrackId,
+  UserCollectionMetadata,
+  Variant
+} from '~/models/Collection'
+import { Copyright } from '~/models/Track'
+import { decodeHashId } from '~/utils/hashIds'
+
+import { accessConditionsFromSDK } from './access'
+import { resourceContributorFromSDK } from './attribution'
+import { favoriteFromSDK } from './favorite'
+import { coverArtSizesCIDsFromSDK } from './imageSize'
+import { repostFromSDK } from './repost'
+import { userTrackMetadataFromSDK } from './track'
+import { userMetadataFromSDK } from './user'
+import { transformAndCleanList } from './utils'
+
+const addedTimestampToPlaylistTrackId = ({
+  timestamp,
+  trackId,
+  metadataTimestamp
+}: full.PlaylistAddedTimestamp): PlaylistTrackId | null => {
+  const decoded = decodeHashId(trackId)
+  if (decoded) {
+    return {
+      track: decoded,
+      time: timestamp,
+      metadata_time: metadataTimestamp
+    }
+  }
+  return null
+}
+
+export const userCollectionMetadataFromSDK = (
+  input: full.PlaylistFullWithoutTracks
+): UserCollectionMetadata | undefined => {
+  const decodedPlaylistId = decodeHashId(input.id)
+  const decodedOwnerId = decodeHashId(input.userId)
+  const user = userMetadataFromSDK(input.user)
+  if (!decodedPlaylistId || !decodedOwnerId || !user) {
+    return undefined
+  }
+
+  const newCollection: UserCollectionMetadata = {
+    // Fields from API that are omitted in this model
+    ...omit(snakecaseKeys(input), [
+      'id',
+      'user_id',
+      'followee_favorites',
+      'artwork',
+      'favorite_count',
+      'added_timestamps'
+    ]),
+
+    variant: Variant.USER_GENERATED,
+
+    // Nested Transformed Fields
+    artists: input.artists
+      ? transformAndCleanList(input.artists, resourceContributorFromSDK)
+      : null,
+    copyright_line: input.copyrightLine
+      ? (snakecaseKeys(input.copyrightLine) as Copyright)
+      : null,
+    cover_art_cids: input.coverArtCids
+      ? coverArtSizesCIDsFromSDK(input.coverArtCids)
+      : null,
+    followee_reposts: transformAndCleanList(
+      input.followeeReposts,
+      repostFromSDK
+    ),
+    followee_saves: transformAndCleanList(
+      input.followeeFavorites,
+      favoriteFromSDK
+    ),
+    // TODO: Use playlistContents
+    playlist_contents: {
+      track_ids: transformAndCleanList(
+        input.addedTimestamps,
+        addedTimestampToPlaylistTrackId
+      )
+    },
+    playlist_id: decodedPlaylistId,
+    playlist_owner_id: decodedOwnerId,
+    producer_copyright_line: input.producerCopyrightLine
+      ? (snakecaseKeys(input.producerCopyrightLine) as Copyright)
+      : null,
+    stream_conditions: input.streamConditions
+      ? accessConditionsFromSDK(input.streamConditions)
+      : null,
+    tracks: transformAndCleanList(input.tracks, userTrackMetadataFromSDK),
+    user,
+
+    // Retypes / Renames
+    save_count: input.favoriteCount,
+
+    // Nullable fields
+    cover_art: input.coverArt ?? null,
+    cover_art_sizes: input.coverArtSizes ?? null,
+    description: input.description ?? null,
+    release_date: input.releaseDate ?? null
+  }
+
+  return newCollection
+}

packages/common/src/adapters/favorite.ts

@@ -0,0 +1,22 @@
+import { full } from '@audius/sdk'
+import { omit } from 'lodash'
+import snakecaseKeys from 'snakecase-keys'
+
+import { Favorite, FavoriteType } from '~/models/Favorite'
+import { decodeHashId } from '~/utils'
+
+export const favoriteFromSDK = (input: full.Favorite): Favorite | undefined => {
+  const decodedSaveItemId = decodeHashId(input.favoriteItemId)
+  const decodedUserId = decodeHashId(input.userId)
+  if (!decodedSaveItemId || !decodedUserId) {
+    return undefined
+  }
+
+  return {
+    // 'save' is renamed to 'favorite' in the model
+    ...omit(snakecaseKeys(input), ['favorite_item_id', 'favorite_type']),
+    save_item_id: decodedSaveItemId,
+    save_type: input.favoriteType as FavoriteType,
+    user_id: decodedUserId
+  }
+}

packages/common/src/adapters/imageSize.ts

@@ -1,6 +1,7 @@
 import { full } from '@audius/sdk'
 
 import {
+  CoverArtSizesCids,
   CoverPhotoSizesCids,
   ProfilePictureSizesCids,
   SquareSizes,
@@ -16,6 +17,19 @@ export const coverPhotoSizesCIDsFromSDK = (
   }, {})
 }
 
+export const coverArtSizesCIDsFromSDK = (
+  input: full.CoverArt
+): CoverArtSizesCids => {
+  return [
+    SquareSizes.SIZE_1000_BY_1000,
+    SquareSizes.SIZE_150_BY_150,
+    SquareSizes.SIZE_480_BY_480
+  ].reduce((out, size) => {
+    out[size] = input[size] ?? null
+    return out
+  }, {})
+}
+
 export const profilePictureSizesCIDsFromSDK = (
   input: full.ProfilePicture
 ): ProfilePictureSizesCids => {

packages/common/src/adapters/index.ts

@@ -1,3 +1,4 @@
+export * from './activity'
 export * from './grant'
 export * from './imageSize'
 export * from './playlistLibrary'

packages/common/src/adapters/remix.ts

@@ -0,0 +1,21 @@
+import { full } from '@audius/sdk'
+import snakecaseKeys from 'snakecase-keys'
+
+import { Remix } from '~/models/Track'
+import { decodeHashId } from '~/utils/hashIds'
+
+import { userMetadataFromSDK } from './user'
+
+export const remixFromSDK = (input: full.FullRemix): Remix | undefined => {
+  const decodedTrackId = decodeHashId(input.parentTrackId)
+  const user = userMetadataFromSDK(input.user)
+  if (!decodedTrackId || !user) {
+    return undefined
+  }
+
+  return {
+    ...snakecaseKeys(input),
+    parent_track_id: decodedTrackId,
+    user
+  }
+}

packages/common/src/adapters/repost.ts

@@ -0,0 +1,19 @@
+import { full } from '@audius/sdk'
+import snakecaseKeys from 'snakecase-keys'
+
+import { Repost } from '~/models/Repost'
+import { decodeHashId } from '~/utils/hashIds'
+
+export const repostFromSDK = (input: full.Repost): Repost | undefined => {
+  const decodedRepostItemId = decodeHashId(input.repostItemId)
+  const decodedUserId = decodeHashId(input.userId)
+  if (!decodedRepostItemId || !decodedUserId) {
+    return undefined
+  }
+
+  return {
+    ...snakecaseKeys(input),
+    repost_item_id: decodedRepostItemId,
+    user_id: decodedUserId
+  }
+}