add custom track processing input

package.json

@@ -1,6 +1,6 @@
 {
     "name": "itunes-library-migration-assistant",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "description": "iTunes Library Migration Assistant",
     "keywords": [
         "itunes",

src/api/api-types.ts

@@ -1,3 +1,5 @@
+import {ParsedTrack} from '../migration/reading/parsed-types';
+
 export type ReplacePath = {
     old: string;
     new: string;
@@ -16,13 +18,13 @@ export enum MigrationOutput {
     PlistString = 'plist-string',
 }
 
-export type RunTimeOptions = {
+export interface RunTimeOptions extends Record<string, boolean> {
     validationEnabled: boolean;
     loggingEnabled: boolean;
     checkReplacementPaths: boolean;
     checkFiles: boolean;
     removeRatingComputed: boolean;
-};
+}
 
 export const defaultOptions: RunTimeOptions = {
     validationEnabled: true,
@@ -37,4 +39,5 @@ export type MigrationApiInput<OutputType extends MigrationOutput = MigrationOutp
     replacePaths: Readonly<Readonly<InputPath>[]>;
     outputType?: OutputType;
     options?: Readonly<Partial<RunTimeOptions>>;
+    extraTrackProcessing?: (updatedTrack: Readonly<ParsedTrack>) => Readonly<ParsedTrack>;
 };

src/migration/make-new-library.ts

@@ -1,5 +1,5 @@
 import {existsSync} from 'fs';
-import {InputPath, ReplacePath} from '../api/api-types';
+import {InputPath, MigrationApiInput, ReplacePath} from '../api/api-types';
 import {decodeLocation, encodeLocation} from '../augments/string';
 import {RequiredBy} from '../augments/type';
 import {LibraryMigrationError} from '../errors/library-migration-error';
@@ -13,13 +13,15 @@ export function makeNewLibrary({
     loggingEnabled = true,
     checkFiles = false,
     removeRatingComputed = false,
+    extraTrackProcessing = (track) => track,
 }: Readonly<{
     oldLibrary: Readonly<ParsedLibrary>;
     replacePaths: Readonly<Readonly<InputPath>[]>;
     checkReplacementPaths?: boolean;
     loggingEnabled?: boolean;
     checkFiles?: boolean;
     removeRatingComputed?: boolean;
+    extraTrackProcessing?: MigrationApiInput['extraTrackProcessing'];
 }>): Readonly<ParsedLibrary> {
     const unreplacedPaths = new Set<string>();
     const replacePathUsage = replacePaths.map(() => 0);
@@ -117,7 +119,7 @@ export function makeNewLibrary({
             }
 
             if (!markedForDeletion) {
-                newTracks[trackKey] = rawNewTrack;
+                newTracks[trackKey] = extraTrackProcessing(rawNewTrack);
             }
 
             return newTracks;

src/migration/migrate-library.ts

@@ -9,30 +9,35 @@ export function migrateLibrary({
     replacePaths,
     outputType,
     options: rawOptions,
+    extraTrackProcessing,
 }: MigrationApiInput<MigrationOutput.JsonObject>): ParsedLibrary;
 export function migrateLibrary({
     libraryFilePath,
     replacePaths,
     outputType,
     options: rawOptions,
+    extraTrackProcessing,
 }: MigrationApiInput<MigrationOutput.WriteToFile>): {filePath: string};
 export function migrateLibrary({
     libraryFilePath,
     replacePaths,
     outputType,
     options: rawOptions,
+    extraTrackProcessing,
 }: MigrationApiInput<MigrationOutput.PlistString>): {plist: string};
 export function migrateLibrary({
     libraryFilePath,
     replacePaths,
     outputType,
     options: rawOptions,
+    extraTrackProcessing,
 }: MigrationApiInput): {filePath: string} | {plist: string} | ParsedLibrary;
 export function migrateLibrary({
     libraryFilePath,
     replacePaths,
     outputType = MigrationOutput.WriteToFile,
     options: rawOptions = defaultOptions,
+    extraTrackProcessing,
 }: MigrationApiInput): {filePath: string} | {plist: string} | ParsedLibrary {
     const options = {...defaultOptions, ...rawOptions};
 
@@ -44,6 +49,7 @@ export function migrateLibrary({
     const newLibrary = makeNewLibrary({
         oldLibrary,
         replacePaths,
+        extraTrackProcessing,
         ...options,
     });
 

src/tests/migrate-library.test.ts

@@ -45,9 +45,10 @@ testGroup({
                     outputType: MigrationOutput.PlistString,
                 }).plist;
 
-                const parsedLibraryFile = readLibraryFile({libraryFilePath: libraryFilePath});
                 const reParsedLibrary = readLibraryString({libraryString: outputPlist});
 
+                const parsedLibraryFile = readLibraryFile({libraryFilePath: libraryFilePath});
+
                 return equal(parsedLibraryFile, reParsedLibrary);
             },
         });
@@ -65,9 +66,48 @@ testGroup({
                     outputType: MigrationOutput.JsonObject,
                 });
 
-                const parsedLibraryFile = readLibraryFile({libraryFilePath: libraryFilePath});
+                const reParsedMigratedLibraryFile = readLibraryFile({
+                    libraryFilePath: libraryFilePath,
+                });
 
-                return equal(parsedLibraryFile, outputObject);
+                return equal(reParsedMigratedLibraryFile, outputObject);
+            },
+        });
+
+        runTest({
+            description: 'extra track processing works',
+            expect: true,
+            test: () => {
+                const deletedProperty = 'Play Count';
+
+                const outputObject = migrateLibrary({
+                    libraryFilePath,
+                    replacePaths: [],
+                    options: {
+                        checkReplacementPaths: false,
+                    },
+                    outputType: MigrationOutput.JsonObject,
+                    extraTrackProcessing: (parsedTrack) => {
+                        const outputTrack = {...parsedTrack};
+                        if (!parsedTrack.hasOwnProperty(deletedProperty)) {
+                            throw new Error(
+                                `Original track didn't have ${deletedProperty} anyway, can't test deleting it.`,
+                            );
+                        }
+                        delete outputTrack[deletedProperty];
+                        return outputTrack;
+                    },
+                });
+
+                return Object.keys(outputObject.Tracks).every((trackKey) => {
+                    const track = outputObject.Tracks[trackKey];
+
+                    if (!track) {
+                        throw new Error(`Missing track for ${trackKey}`);
+                    }
+
+                    return !track.hasOwnProperty(deletedProperty);
+                });
             },
         });