Fix playlist writes in client

Author: rickyrombo

packages/common/src/api/tan-query/upload/usePublishCollection.ts

@@ -103,11 +103,13 @@ const getPublishCollectionOptions = (context: PublishCollectionContext) =>
         const metadata = albumMetadataForCreateWithSDK(
           params.collectionMetadata
         )
-        metadata.playlistContents = publishedTracks.map((t) => ({
-          timestamp: Math.round(Date.now() / 1000),
-          trackId: Id.parse(t.trackId),
-          metadataTimestamp: Math.round(Date.now() / 1000)
-        }))
+        metadata.playlistContents = publishedTracks
+          .filter((t) => !!t.trackId)
+          .map((t) => ({
+            timestamp: Math.round(Date.now() / 1000),
+            trackId: t.trackId!,
+            metadataTimestamp: Math.round(Date.now() / 1000)
+          }))
         return await sdk.albums.createAlbum({
           userId: Id.parse(userId),
           imageFile: coverArtFile,
@@ -117,11 +119,13 @@ const getPublishCollectionOptions = (context: PublishCollectionContext) =>
         const metadata = playlistMetadataForCreateWithSDK(
           params.collectionMetadata
         )
-        metadata.playlistContents = publishedTracks.map((t) => ({
-          timestamp: Math.round(Date.now() / 1000),
-          trackId: Id.parse(t.trackId),
-          metadataTimestamp: Math.round(Date.now() / 1000)
-        }))
+        metadata.playlistContents = publishedTracks
+          .filter((t) => !!t.trackId)
+          .map((t) => ({
+            timestamp: Math.round(Date.now() / 1000),
+            trackId: t.trackId!,
+            metadataTimestamp: Math.round(Date.now() / 1000)
+          }))
         return await sdk.playlists.createPlaylist({
           userId: Id.parse(userId),
           imageFile: coverArtFile,

packages/sdk/src/sdk/api/playlists/PlaylistsApi.ts

@@ -90,26 +90,15 @@ export class PlaylistsApi extends GeneratedPlaylistsApi {
     params: EntityManagerCreatePlaylistRequest,
     advancedOptions?: AdvancedOptions
   ) {
-    // Parse inputs
-    const parsedParameters = await parseParams(
-      'createPlaylist',
-      CreatePlaylistSchema
-    )(params)
-
-    // Call createPlaylistInternal with parsed inputs
-    return await this.createPlaylistInternal(parsedParameters, advancedOptions)
+    return await this.createPlaylistInternal(params, advancedOptions)
   }
 
   override async createPlaylist(
     params: CreatePlaylistRequestWithFiles,
     requestInit?: RequestInit
   ) {
     if (this.entityManager) {
-      const { metadata } = params
-      return await this.createPlaylistWithEntityManager({
-        userId: params.userId,
-        metadata
-      })
+      return await this.createPlaylistWithEntityManager(params)
     }
     return super.createPlaylist(params, requestInit)
   }
@@ -175,9 +164,9 @@ export class PlaylistsApi extends GeneratedPlaylistsApi {
         // Transform track metadata (cast: SDK upload schema and API body types align at runtime)
         const trackMetadata = this.combineMetadata(
           this.trackUploadHelper.transformTrackUploadMetadataV2(
-            t as unknown as CreateTrackRequestBody,
+            t as CreateTrackRequestBody,
             userId
-          ) as CreateTrackRequestBody,
+          ),
           playlistMetadata
         )
 
@@ -732,40 +721,37 @@ export class PlaylistsApi extends GeneratedPlaylistsApi {
    * Method to create a playlist with already parsed inputs
    * This is used for both playlists and albums
    */
-  public async createPlaylistInternal<Metadata extends PlaylistMetadata>(
-    {
-      userId,
-      imageFile,
-      metadata,
-      onProgress,
-      trackIds,
-      playlistId: providedPlaylistId
-    }: z.infer<typeof CreatePlaylistSchema> & { metadata: Metadata },
+  public async createPlaylistInternal(
+    params: z.input<typeof CreatePlaylistSchema>,
     advancedOptions?: AdvancedOptions
   ) {
+    const { userId, imageFile, metadata, onProgress } = await parseParams(
+      'createPlaylistInternal',
+      CreatePlaylistSchema
+    )(params)
+
     // Upload cover art to storage node
     const coverArtResponse =
       imageFile &&
       (await this.storage
         .uploadFile({
           file: imageFile,
-          onProgress,
+          onProgress: (event) =>
+            onProgress?.(event.loaded / event.total, {
+              ...event,
+              key: 'image'
+            }),
           metadata: {
             template: 'img_square'
           }
         })
         .start())
 
+    const providedPlaylistId = metadata.playlistId
     const playlistId = providedPlaylistId || (await this.generatePlaylistId())
-    const timestamp = getCurrentTimestamp()
 
-    // Update metadata to include track ids
     const updatedMetadata = {
       ...metadata,
-      playlistContents: (trackIds ?? []).map((trackId) => ({
-        trackId,
-        timestamp
-      })),
       playlistImageSizesMultihash: coverArtResponse?.orig_file_cid
     }
 

packages/sdk/src/sdk/api/playlists/types.ts

@@ -20,6 +20,7 @@ export type PlaylistsApiServicesConfig = {
 
 const CreatePlaylistMetadataSchema = z
   .object({
+    playlistId: z.optional(HashId),
     description: z.optional(z.string().max(1000)),
     playlistName: z.string(),
     isPrivate: z.optional(z.boolean()),
@@ -53,12 +54,24 @@ export type CreatePlaylistMetadata = z.input<
   typeof CreatePlaylistMetadataSchema
 >
 
+export const UploadPlaylistProgressEventSchema = ProgressEventSchema.extend({
+  /**
+   * Index of the track being uploaded in the playlist tracks array, or 'image' if for the image
+   */
+  key: z.number().or(z.literal('image'))
+})
+
+export const UploadPlaylistProgressHandlerSchema = z
+  .function()
+  .args(z.number(), UploadPlaylistProgressEventSchema)
+  .returns(z.void())
+
 export const CreatePlaylistSchema = z
   .object({
     playlistId: z.optional(HashId),
     imageFile: z.optional(ImageFile),
     metadata: CreatePlaylistMetadataSchema,
-    onProgress: z.optional(z.function()),
+    onProgress: UploadPlaylistProgressHandlerSchema.optional(),
     trackIds: z.optional(z.array(HashId)),
     userId: HashId
   })
@@ -101,25 +114,13 @@ const PlaylistTrackMetadataSchema = UploadTrackMetadataSchema.partial({
  */
 export type PlaylistTrackMetadata = z.infer<typeof PlaylistTrackMetadataSchema>
 
-export const UploadPlaylistProgressEventSchema = ProgressEventSchema.extend({
-  /**
-   * Index of the track being uploaded in the playlist tracks array, or 'image' if for the image
-   */
-  key: z.number().or(z.literal('image'))
-})
-
 /**
  * The progress event for updating a playlist
  */
 type UploadPlaylistProgressEvent = z.input<
   typeof UploadPlaylistProgressEventSchema
 >
 
-export const UploadPlaylistProgressHandlerSchema = z
-  .function()
-  .args(z.number(), UploadPlaylistProgressEventSchema)
-  .returns(z.void())
-
 export type UploadPlaylistProgressHandler = (
   /**
    * Overall progress percentage (0-1)
@@ -166,7 +167,7 @@ export const UpdatePlaylistMetadataSchema =
             })
           )
         ),
-        coverArtCid: z.optional(z.string())
+        playlistImageSizesMultihash: z.optional(z.string())
       })
     )
     .strict()