Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Migration fails on startup - albumIds is empty #426

Open
AlexGustafsson opened this issue Aug 24, 2024 · 8 comments
Open

Migration fails on startup - albumIds is empty #426

AlexGustafsson opened this issue Aug 24, 2024 · 8 comments

Comments

@AlexGustafsson
Copy link

Describe the bug

Using version 1.10.1, on the line referenced below, the API logs that there are no albumIds, yet albums are fetched from the Spotify API. This causes the API to respond with 400 bad request, which in turn seems to crash the migration - resulting in the your Spotify API never starting.

logger.info(`Fixing missing albums (${albumIds.join(",")})`);

Expected behavior

When there are no albumIds found to be missing, no requests should be made to the Spotify API. The migration should complete.

My guess is that the root cause is something different, though, as there is already a check that allTracks contains at least one track, before extracting the albumIds. So why that would turn out empty is anyone's guess.

Additional context

$ node ./lib/migrations.js
[info]  Trying to connect to database at mongodb://mongo.your-spotify.svc.cluster.local:27017/your_spotify
[info]  Connected to database !
[debug]  Locking DB_LongWriteLock
[info]  Checking database for missing track data...
[info]  Fixing missing albums ()
[error]  Retrying crashed promise, 1/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 2/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 3/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 4/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 5/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 6/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 7/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 8/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 9/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 10/10

node:internal/process/promises:289
            triggerUncaughtException(err, true /* fromPromise */);
            ^
AxiosError: Request failed with status code 400
    at settle (/app/node_modules/axios/dist/node/axios.cjs:1967:12)
    at Unzip.handleStreamEnd (/app/node_modules/axios/dist/node/axios.cjs:3066:11)
    at Unzip.emit (node:events:530:35)
    at endReadableNT (node:internal/streams/readable:1696:12)
    at process.processTicksAndRejections (node:internal/process/task_queues:82:21)
    at Axios.request (/app/node_modules/axios/dist/node/axios.cjs:3877:41)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5) {
  code: 'ERR_BAD_REQUEST',

Full logs (tokens and IPs redacted) are attached.

logs.txt

Screenshots

N/A

Shared link

I can't login as the API service fails to start.

@Yooooomi
Copy link
Owner

Hello! Weird to see this happening. There is litterally an if statement checking if there are more than 0 elements to fetch. I feel like there are "missing" album ids equal to "". Checking this. Also, I fear that if I fix this condition, the UI might start panicking because there is one song that does not have an album, which is uncommon. It would be very helpful if you had the id of the track.

For the moment I'll just add the ids of the tracks whose album is missing, so that we can debug this more easily.

@AlexGustafsson
Copy link
Author

Weirdly enough none of these queries return anything.

db.tracks.find({album: ""})
db.albums.find({id: ""})

Do you have suggestions on queries to run?

@Yooooomi
Copy link
Owner

I have no idea why this happens honestly.
1.11.0 brings more debug to this, let's check with this once it's published to dockerhub

@AlexGustafsson
Copy link
Author

Thanks for the quick look! I've tried the new release and attached the findings below.

Logs:

[info]  Trying to connect to database at mongodb://mongo.your-spotify.svc.cluster.local:27017/your_spotify
[info]  Connected to database !
[debug]  Locking DB_LongWriteLock
[info]  Checking database for missing track data...
[info]  Fixing missing albums for tracks 5nf0T9pVhJPXlgYGSXJhpc ()
[info]  Refreshed token for 116136123
[error]  Retrying crashed promise, 1/10, retrying in 30 seconds...

Checking the entry for the track with missing album:

db.tracks.find({id: "5nf0T9pVhJPXlgYGSXJhpc"})
[
  {
    _id: ObjectId('6697f14aaa47a0e30b21d6cc'),
    album: null,
    artists: [ '6zpub6jbY6CdrcqQsDq8P4' ],
    available_markets: [
      'AR', 'AU', 'AT', 'BE', 'BO', 'BR', 'BG', 'CA', 'CL', 'CO', 'CR', 'CY',
      'CZ', 'DK', 'DO', 'DE', 'EC', 'EE', 'SV', 'FI', 'GR', 'GT', 'HN', 'HK',
      'HU', 'IS', 'IE', 'IT', 'LV', 'LT', 'LU', 'MY', 'MT', 'MX', 'NL', 'NZ',
      'NI', 'NO', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'SG', 'SK', 'ES', 'SE',
      'CH', 'TW', 'TR', 'UY', 'US', 'GB', 'AD', 'LI', 'MC', 'ID', 'JP', 'TH',
      'VN', 'RO', 'IL', 'ZA', 'SA', 'AE', 'BH', 'QA', 'OM', 'KW', 'EG', 'MA',
      'DZ', 'TN', 'LB', 'JO', 'PS', 'IN', 'BY', 'KZ', 'MD', 'UA', 'AL', 'BA',
      'HR', 'ME', 'MK', 'RS', 'SI', 'KR', 'BD', 'PK', 'LK', 'GH', 'KE', 'NG',
      'TZ', 'UG', 'AG', 'AM', 'BS', 'BB', 'BZ', 'BT', 'BW', 'BF', 'CV', 'CW',
      'DM', 'FJ', 'GM', 'GE', 'GD', 'GW', 'GY', 'HT', 'JM', 'KI', 'LS', 'LR',
      'MW', 'MV', 'ML', 'MH', 'FM', 'NA', 'NR', 'NE', 'PW', 'PG', 'WS', 'SM',
      'ST', 'SN', 'SC', 'SL', 'SB', 'KN', 'LC', 'VC', 'SR', 'TL', 'TO', 'TT',
      'TV', 'VU', 'AZ', 'BN', 'BI', 'KH', 'CM', 'TD', 'KM', 'GQ', 'SZ', 'GA',
      'GN', 'KG', 'LA', 'MO', 'MR', 'MN', 'NP', 'RW', 'TG', 'UZ', 'ZW', 'BJ',
      'MG', 'MU', 'MZ', 'AO', 'CI', 'DJ', 'ZM', 'CD', 'CG', 'IQ', 'LY', 'TJ',
      'VE', 'ET', 'XK'
    ],
    disc_number: 1,
    duration_ms: 168693,
    explicit: false,
    external_ids: { isrc: 'SEAYD7402030' },
    external_urls: {
      spotify: 'https://open.spotify.com/track/5nf0T9pVhJPXlgYGSXJhpc'
    },
    href: 'https://api.spotify.com/v1/tracks/5nf0T9pVhJPXlgYGSXJhpc',
    id: '5nf0T9pVhJPXlgYGSXJhpc',
    is_local: false,
    name: 'Öppna din himmel',
    popularity: 34,
    preview_url: 'https://p.scdn.co/mp3-preview/67c30a8a29cb40d8500c345f937c5a1fa55d5ac6?cid=968eaeeb405f4715a69f9f7575a3717a',
    track_number: 2,
    type: 'track',
    uri: 'spotify:track:5nf0T9pVhJPXlgYGSXJhpc',
    __v: 0
  }
]

Apparently the issue is a null album as opposed to one with an empty string. I checked the database for other null entries, but this was the only one.

I'm guessing the album id should be 3jDOyKSwbE7YNQorSVfvxy (the id I get when trying to share the album through Spotify). I cannot find any album entry in the database for that id using db.albums.find({id: "3jDOyKSwbE7YNQorSVfvxy"}).

@Yooooomi
Copy link
Owner

Interesting, so this seems fixable. I feel like there should be a step where it finds tracks with null albums and fetch the id from the Spotify api.

@AlexGustafsson
Copy link
Author

As it was just the one album, I decided to patch the database. Everything's working fine now.

Tell me if there's a fix you want me to try out. I could just remove the album entry I created and set the album back to null to verify.

@Yooooomi
Copy link
Owner

Goat move right there. I can try implementing the fix I stated above next time I work on this.

@rissson
Copy link

rissson commented Sep 9, 2024

I've had this issue on 1.8.0 as well. I just upgraded to 1.11.0, here are some additional information that may help:

Initial error
yarn run v1.22.22
warning Skipping preferred cache folder "/.cache/yarn" because it is not writable.
warning Selected the next writable cache folder in the list, will be "/tmp/.yarn-cache-1674".
$ node ./lib/migrations.js
warning Cannot find a suitable global folder. Tried these: "/usr/local, /.yarn"
[info]  Trying to connect to database at mongodb://mongodb:27017/your_spotify
[info]  Connected to database !
[debug]  Locking DB_LongWriteLock
[info]  Checking database for missing track data...
[info]  Fixing missing albums for tracks 7v9Q0dAb9t7h8gJOkcJHay ()
[error]  Retrying crashed promise, 1/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 2/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 3/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 4/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 5/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 6/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 7/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 8/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 9/10, retrying in 30 seconds...
[error]  Retrying crashed promise, 10/10

node:internal/process/promises:391
    triggerUncaughtException(err, true /* fromPromise */);
    ^
AxiosError: Request failed with status code 400
    at settle (/app/node_modules/axios/dist/node/axios.cjs:2019:12)
    at Unzip.handleStreamEnd (/app/node_modules/axios/dist/node/axios.cjs:3135:11)
    at Unzip.emit (node:events:531:35)
    at endReadableNT (node:internal/streams/readable:1696:12)
    at process.processTicksAndRejections (node:internal/process/task_queues:82:21)
    at Axios.request (/app/node_modules/axios/dist/node/axios.cjs:4269:41)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5) {
  code: 'ERR_BAD_REQUEST',
  config: {
    transitional: {
      silentJSONParsing: true,
      forcedJSONParsing: true,
      clarifyTimeoutError: false
    },
    adapter: [ 'xhr', 'http', 'fetch' ],
    transformRequest: [ [Function: transformRequest] ],
    transformResponse: [ [Function: transformResponse] ],
    timeout: 0,
    xsrfCookieName: 'XSRF-TOKEN',
    xsrfHeaderName: 'X-XSRF-TOKEN',
    maxContentLength: -1,
    maxBodyLength: -1,
    env: {
      FormData: [Function: FormData] {
        LINE_BREAK: '\r\n',
        DEFAULT_CONTENT_TYPE: 'application/octet-stream'
      },
      Blob: [class Blob]
    },
    validateStatus: [Function: validateStatus],
    headers: Object [AxiosHeaders] {
      Accept: 'application/json, text/plain, */*',
      'Content-Type': 'application/json',
      Authorization: 'Bearer no',
      'User-Agent': 'axios/1.7.5',
      'Accept-Encoding': 'gzip, compress, deflate, br'
    },
    baseURL: 'https://api.spotify.com/v1',
    method: 'get',
    url: 'https://api.spotify.com/v1/albums?ids=',
    data: undefined
  },
  request: <ref *3> ClientRequest {
    _events: [Object: null prototype] {
      abort: [Function (anonymous)],
      aborted: [Function (anonymous)],
      connect: [Function (anonymous)],
      error: [Function (anonymous)],
      socket: [Function (anonymous)],
      timeout: [Function (anonymous)],
      finish: [Function: requestOnFinish]
    },
    _eventsCount: 7,
    _maxListeners: undefined,
    outputData: [],
    outputSize: 0,
    writable: true,
    destroyed: true,
    _last: true,
    chunkedEncoding: false,
    shouldKeepAlive: true,
    maxRequestsOnConnectionReached: false,
    _defaultKeepAlive: true,
    useChunkedEncodingByDefault: false,
    sendDate: false,
    _removedConnection: false,
    _removedContLen: false,
    _removedTE: false,
    strictContentLength: false,
    _contentLength: 0,
    _hasBody: true,
    _trailer: '',
    finished: true,
    _headerSent: true,
    _closed: true,
    socket: <ref *1> TLSSocket {
      _tlsOptions: {
        allowHalfOpen: undefined,
        pipe: false,
        secureContext: SecureContext { context: SecureContext {} },
        isServer: false,
        requestCert: true,
        rejectUnauthorized: true,
        session: Buffer(2127) [Uint8Array] [...],
        ALPNProtocols: undefined,
        requestOCSP: undefined,
        enableTrace: undefined,
        pskCallback: undefined,
        highWaterMark: undefined,
        onread: undefined,
        signal: undefined
      },
      _secureEstablished: true,
      _securePending: false,
      _newSessionPending: false,
      _controlReleased: true,
      secureConnecting: false,
      _SNICallback: null,
      servername: 'api.spotify.com',
      alpnProtocol: false,
      authorized: true,
      authorizationError: null,
      encrypted: true,
      _events: [Object: null prototype] {
        close: [
          [Function: onSocketCloseDestroySSL],
          [Function: bound onceWrapper] {
            listener: [Function (anonymous)]
          },
          [Function: onClose]
        ],
        end: [Function: onReadableStreamEnd],
        error: [Function: bound onceWrapper] {
          listener: [Function: freeSocketErrorListener]
        },
        newListener: [Function: keylogNewListener],
        connect: undefined,
        secure: [Function: onConnectSecure],
        session: [Function (anonymous)],
        free: [Function: onFree],
        timeout: [Function: onTimeout],
        agentRemove: [Function: onRemove],
        data: undefined,
        drain: undefined
      },
      _eventsCount: 9,
      connecting: false,
      _hadError: false,
      _parent: null,
      _host: 'api.spotify.com',
      _closeAfterHandlingError: false,
      _readableState: ReadableState {
        highWaterMark: 16384,
        buffer: [],
        bufferIndex: 0,
        length: 0,
        pipes: [],
        awaitDrainWriters: null,
        [Symbol(kState)]: 60303620
      },
      _writableState: WritableState {
        highWaterMark: 16384,
        length: 0,
        corked: 0,
        onwrite: [Function: bound onwrite],
        writelen: 0,
        bufferedIndex: 0,
        pendingcb: 0,
        [Symbol(kState)]: 17563908,
        [Symbol(kBufferedValue)]: null,
        [Symbol(kWriteCbValue)]: null
      },
      allowHalfOpen: false,
      _maxListeners: undefined,
      _sockname: null,
      _pendingData: null,
      _pendingEncoding: '',
      server: undefined,
      _server: null,
      ssl: TLSWrap {
        _parent: TCP {
          reading: [Getter/Setter],
          onconnection: null,
          [Symbol(owner_symbol)]: [Circular *1]
        },
        _parentWrap: null,
        _secureContext: SecureContext { context: SecureContext {} },
        reading: true,
        onkeylog: [Function: onkeylog],
        onhandshakestart: {},
        onhandshakedone: [Function (anonymous)],
        onocspresponse: [Function: onocspresponse],
        onnewsession: [Function: onnewsessionclient],
        onerror: [Function: onerror],
        [Symbol(owner_symbol)]: [Circular *1]
      },
      _requestCert: true,
      _rejectUnauthorized: true,
      timeout: 5000,
      parser: null,
      _httpMessage: null,
      autoSelectFamilyAttemptedAddresses: [ '2600:1901:1:7c5:::443' ],
      [Symbol(alpncallback)]: null,
      [Symbol(res)]: TLSWrap {
        _parent: TCP {
          reading: [Getter/Setter],
          onconnection: null,
          [Symbol(owner_symbol)]: [Circular *1]
        },
        _parentWrap: null,
        _secureContext: SecureContext { context: SecureContext {} },
        reading: true,
        onkeylog: [Function: onkeylog],
        onhandshakestart: {},
        onhandshakedone: [Function (anonymous)],
        onocspresponse: [Function: onocspresponse],
        onnewsession: [Function: onnewsessionclient],
        onerror: [Function: onerror],
        [Symbol(owner_symbol)]: [Circular *1]
      },
      [Symbol(verified)]: true,
      [Symbol(pendingSession)]: null,
      [Symbol(async_id_symbol)]: -1,
      [Symbol(kHandle)]: TLSWrap {
        _parent: TCP {
          reading: [Getter/Setter],
          onconnection: null,
          [Symbol(owner_symbol)]: [Circular *1]
        },
        _parentWrap: null,
        _secureContext: SecureContext { context: SecureContext {} },
        reading: true,
        onkeylog: [Function: onkeylog],
        onhandshakestart: {},
        onhandshakedone: [Function (anonymous)],
        onocspresponse: [Function: onocspresponse],
        onnewsession: [Function: onnewsessionclient],
        onerror: [Function: onerror],
        [Symbol(owner_symbol)]: [Circular *1]
      },
      [Symbol(lastWriteQueueSize)]: 0,
      [Symbol(timeout)]: <ref *2> Timeout {
        _idleTimeout: 5000,
        _idlePrev: TimersList {
          _idleNext: [Circular *2],
          _idlePrev: [Circular *2],
          expiry: 294110,
          id: -9007199254740845,
          msecs: 5000,
          priorityQueuePosition: 3
        },
        _idleNext: TimersList {
          _idleNext: [Circular *2],
          _idlePrev: [Circular *2],
          expiry: 294110,
          id: -9007199254740845,
          msecs: 5000,
          priorityQueuePosition: 3
        },
        _idleStart: 289190,
        _onTimeout: [Function: bound ],
        _timerArgs: undefined,
        _repeat: null,
        _destroyed: false,
        [Symbol(refed)]: false,
        [Symbol(kHasPrimitive)]: false,
        [Symbol(asyncId)]: 924,
        [Symbol(triggerId)]: 922
      },
      [Symbol(kBuffer)]: null,
      [Symbol(kBufferCb)]: null,
      [Symbol(kBufferGen)]: null,
      [Symbol(shapeMode)]: true,
      [Symbol(kCapture)]: false,
      [Symbol(kSetNoDelay)]: false,
      [Symbol(kSetKeepAlive)]: true,
      [Symbol(kSetKeepAliveInitialDelay)]: 1,
      [Symbol(kBytesRead)]: 0,
      [Symbol(kBytesWritten)]: 0,
      [Symbol(connect-options)]: {
        rejectUnauthorized: true,
        ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
        checkServerIdentity: [Function: checkServerIdentity],
        minDHSize: 1024,
        session: Buffer(2127) [Uint8Array] [...],
        maxRedirects: 21,
        maxBodyLength: Infinity,
        protocol: 'https:',
        path: null,
        method: 'GET',
        headers: [Object: null prototype] {
          Accept: 'application/json, text/plain, */*',
          'Content-Type': 'application/json',
          Authorization: 'Bearer no',
          'User-Agent': 'axios/1.7.5',
          'Accept-Encoding': 'gzip, compress, deflate, br'
        },
        agents: { http: undefined, https: undefined },
        auth: undefined,
        family: undefined,
        beforeRedirect: [Function: dispatchBeforeRedirect],
        beforeRedirects: { proxy: [Function: beforeRedirect] },
        hostname: 'api.spotify.com',
        port: 443,
        agent: undefined,
        nativeProtocols: {
          'http:': {
            _connectionListener: [Function: connectionListener],
            METHODS: [Array],
            STATUS_CODES: [Object],
            Agent: [Function],
            ClientRequest: [Function: ClientRequest],
            IncomingMessage: [Function: IncomingMessage],
            OutgoingMessage: [Function: OutgoingMessage],
            Server: [Function: Server],
            ServerResponse: [Function: ServerResponse],
            createServer: [Function: createServer],
            validateHeaderName: [Function],
            validateHeaderValue: [Function],
            get: [Function: get],
            request: [Function: request],
            setMaxIdleHTTPParsers: [Function: setMaxIdleHTTPParsers],
            maxHeaderSize: [Getter],
            globalAgent: [Getter/Setter]
          },
          'https:': {
            Agent: [Function: Agent],
            globalAgent: [Agent],
            Server: [Function: Server],
            createServer: [Function: createServer],
            get: [Function: get],
            request: [Function: request]
          }
        },
        pathname: '/v1/albums',
        search: '?ids=',
        _defaultAgent: Agent {
          _events: [Object: null prototype] {
            free: [Function (anonymous)],
            newListener: [Function: maybeEnableKeylog]
          },
          _eventsCount: 2,
          _maxListeners: undefined,
          defaultPort: 443,
          protocol: 'https:',
          options: [Object: null prototype] {
            keepAlive: true,
            scheduling: 'lifo',
            timeout: 5000,
            noDelay: true,
            path: null
          },
          requests: [Object: null prototype] {},
          sockets: [Object: null prototype] {},
          freeSockets: [Object: null prototype] {
            'api.spotify.com:443:::::::::::::::::::::': [Array]
          },
          keepAliveMsecs: 1000,
          keepAlive: true,
          maxSockets: Infinity,
          maxFreeSockets: 256,
          scheduling: 'lifo',
          maxTotalSockets: Infinity,
          totalSocketCount: 1,
          maxCachedSessions: 100,
          _sessionCache: { map: [Object], list: [Array] },
          [Symbol(shapeMode)]: false,
          [Symbol(kCapture)]: false
        },
        host: 'api.spotify.com',
        keepAlive: true,
        scheduling: 'lifo',
        timeout: 5000,
        noDelay: true,
        servername: 'api.spotify.com',
        _agentKey: 'api.spotify.com:443:::::::::::::::::::::',
        encoding: null,
        keepAliveInitialDelay: 1000
      }
    },
    _header: 'GET /v1/albums?ids= HTTP/1.1\r\n' +
      'Accept: application/json, text/plain, */*\r\n' +
      'Content-Type: application/json\r\n' +
      'Authorization: Bearer no\r\n' +
      'User-Agent: axios/1.7.5\r\n' +
      'Accept-Encoding: gzip, compress, deflate, br\r\n' +
      'Host: api.spotify.com\r\n' +
      'Connection: keep-alive\r\n' +
      '\r\n',
    _keepAliveTimeout: 0,
    _onPendingData: [Function: nop],
    agent: Agent {
      _events: [Object: null prototype] {
        free: [Function (anonymous)],
        newListener: [Function: maybeEnableKeylog]
      },
      _eventsCount: 2,
      _maxListeners: undefined,
      defaultPort: 443,
      protocol: 'https:',
      options: [Object: null prototype] {
        keepAlive: true,
        scheduling: 'lifo',
        timeout: 5000,
        noDelay: true,
        path: null
      },
      requests: [Object: null prototype] {},
      sockets: [Object: null prototype] {},
      freeSockets: [Object: null prototype] {
        'api.spotify.com:443:::::::::::::::::::::': [
          <ref *1> TLSSocket {
            _tlsOptions: [Object],
            _secureEstablished: true,
            _securePending: false,
            _newSessionPending: false,
            _controlReleased: true,
            secureConnecting: false,
            _SNICallback: null,
            servername: 'api.spotify.com',
            alpnProtocol: false,
            authorized: true,
            authorizationError: null,
            encrypted: true,
            _events: [Object: null prototype],
            _eventsCount: 9,
            connecting: false,
            _hadError: false,
            _parent: null,
            _host: 'api.spotify.com',
            _closeAfterHandlingError: false,
            _readableState: [ReadableState],
            _writableState: [WritableState],
            allowHalfOpen: false,
            _maxListeners: undefined,
            _sockname: null,
            _pendingData: null,
            _pendingEncoding: '',
            server: undefined,
            _server: null,
            ssl: [TLSWrap],
            _requestCert: true,
            _rejectUnauthorized: true,
            timeout: 5000,
            parser: null,
            _httpMessage: null,
            autoSelectFamilyAttemptedAddresses: [Array],
            [Symbol(alpncallback)]: null,
            [Symbol(res)]: [TLSWrap],
            [Symbol(verified)]: true,
            [Symbol(pendingSession)]: null,
            [Symbol(async_id_symbol)]: -1,
            [Symbol(kHandle)]: [TLSWrap],
            [Symbol(lastWriteQueueSize)]: 0,
            [Symbol(timeout)]: [Timeout],
            [Symbol(kBuffer)]: null,
            [Symbol(kBufferCb)]: null,
            [Symbol(kBufferGen)]: null,
            [Symbol(shapeMode)]: true,
            [Symbol(kCapture)]: false,
            [Symbol(kSetNoDelay)]: false,
            [Symbol(kSetKeepAlive)]: true,
            [Symbol(kSetKeepAliveInitialDelay)]: 1,
            [Symbol(kBytesRead)]: 0,
            [Symbol(kBytesWritten)]: 0,
            [Symbol(connect-options)]: [Object]
          }
        ]
      },
      keepAliveMsecs: 1000,
      keepAlive: true,
      maxSockets: Infinity,
      maxFreeSockets: 256,
      scheduling: 'lifo',
      maxTotalSockets: Infinity,
      totalSocketCount: 1,
      maxCachedSessions: 100,
      _sessionCache: {
        map: {
          'api.spotify.com:443:::::::::::::::::::::': Buffer(2128) [Uint8Array] [...]
        },
        list: [ 'api.spotify.com:443:::::::::::::::::::::' ]
      },
      [Symbol(shapeMode)]: false,
      [Symbol(kCapture)]: false
    },
    socketPath: undefined,
    method: 'GET',
    maxHeaderSize: undefined,
    insecureHTTPParser: undefined,
    joinDuplicateHeaders: undefined,
    path: '/v1/albums?ids=',
    _ended: true,
    res: IncomingMessage {
      _events: {
        close: [
          [Function (anonymous)],
          [Function: onclose],
          [Function: onclose]
        ],
        error: [
          [Function: onerror],
          [Function: onError],
          [Function: onerror]
        ],
        data: undefined,
        end: [
          [Function: responseOnEnd],
          [Function: onend],
          [Function: onend]
        ],
        readable: undefined,
        finish: [ [Function: onfinish], [Function: onfinish] ]
      },
      _readableState: ReadableState {
        highWaterMark: 16384,
        buffer: [],
        bufferIndex: 0,
        length: 0,
        pipes: [],
        awaitDrainWriters: null,
        [Symbol(kState)]: 110892924
      },
      _maxListeners: undefined,
      socket: null,
      httpVersionMajor: 1,
      httpVersionMinor: 1,
      httpVersion: '1.1',
      complete: true,
      rawHeaders: [
        'content-type',
        'application/json; charset=utf-8',
        'cache-control',
        'private, max-age=0',
        'access-control-allow-origin',
        '*',
        'access-control-allow-headers',
        'Accept, App-Platform, Authorization, Content-Type, Origin, Retry-After, Spotify-App-Version, X-Cloud-Trace-Context, client-token, content-access-token',
        'access-control-allow-methods',
        'GET, POST, OPTIONS, PUT, DELETE, PATCH',
        'access-control-allow-credentials',
        'true',
        'access-control-max-age',
        '604800',
        'content-encoding',
        'gzip',
        'strict-transport-security',
        'max-age=31536000',
        'x-content-type-options',
        'nosniff',
        'date',
        'Mon, 09 Sep 2024 11:50:53 GMT',
        'server',
        'envoy',
        'Via',
        'HTTP/2 edgeproxy, 1.1 google',
        'Alt-Svc',
        'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
        'Transfer-Encoding',
        'chunked'
      ],
      rawTrailers: [],
      joinDuplicateHeaders: undefined,
      aborted: false,
      upgrade: false,
      url: '',
      method: null,
      statusCode: 400,
      statusMessage: 'Bad Request',
      client: <ref *1> TLSSocket {
        _tlsOptions: {
          allowHalfOpen: undefined,
          pipe: false,
          secureContext: SecureContext { context: SecureContext {} },
          isServer: false,
          requestCert: true,
          rejectUnauthorized: true,
          session: Buffer(2127) [Uint8Array] [...],
          ALPNProtocols: undefined,
          requestOCSP: undefined,
          enableTrace: undefined,
          pskCallback: undefined,
          highWaterMark: undefined,
          onread: undefined,
          signal: undefined
        },
        _secureEstablished: true,
        _securePending: false,
        _newSessionPending: false,
        _controlReleased: true,
        secureConnecting: false,
        _SNICallback: null,
        servername: 'api.spotify.com',
        alpnProtocol: false,
        authorized: true,
        authorizationError: null,
        encrypted: true,
        _events: [Object: null prototype] {
          close: [
            [Function: onSocketCloseDestroySSL],
            [Function],
            [Function: onClose]
          ],
          end: [Function: onReadableStreamEnd],
          error: [Function: bound onceWrapper] {
            listener: [Function: freeSocketErrorListener]
          },
          newListener: [Function: keylogNewListener],
          connect: undefined,
          secure: [Function: onConnectSecure],
          session: [Function (anonymous)],
          free: [Function: onFree],
          timeout: [Function: onTimeout],
          agentRemove: [Function: onRemove],
          data: undefined,
          drain: undefined
        },
        _eventsCount: 9,
        connecting: false,
        _hadError: false,
        _parent: null,
        _host: 'api.spotify.com',
        _closeAfterHandlingError: false,
        _readableState: ReadableState {
          highWaterMark: 16384,
          buffer: [],
          bufferIndex: 0,
          length: 0,
          pipes: [],
          awaitDrainWriters: null,
          [Symbol(kState)]: 60303620
        },
        _writableState: WritableState {
          highWaterMark: 16384,
          length: 0,
          corked: 0,
          onwrite: [Function: bound onwrite],
          writelen: 0,
          bufferedIndex: 0,
          pendingcb: 0,
          [Symbol(kState)]: 17563908,
          [Symbol(kBufferedValue)]: null,
          [Symbol(kWriteCbValue)]: null
        },
        allowHalfOpen: false,
        _maxListeners: undefined,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: undefined,
        _server: null,
        ssl: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        _requestCert: true,
        _rejectUnauthorized: true,
        timeout: 5000,
        parser: null,
        _httpMessage: null,
        autoSelectFamilyAttemptedAddresses: [ '2600:1901:1:7c5:::443' ],
        [Symbol(alpncallback)]: null,
        [Symbol(res)]: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        [Symbol(verified)]: true,
        [Symbol(pendingSession)]: null,
        [Symbol(async_id_symbol)]: -1,
        [Symbol(kHandle)]: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        [Symbol(lastWriteQueueSize)]: 0,
        [Symbol(timeout)]: <ref *2> Timeout {
          _idleTimeout: 5000,
          _idlePrev: TimersList {
            _idleNext: [Circular *2],
            _idlePrev: [Circular *2],
            expiry: 294110,
            id: -9007199254740845,
            msecs: 5000,
            priorityQueuePosition: 3
          },
          _idleNext: TimersList {
            _idleNext: [Circular *2],
            _idlePrev: [Circular *2],
            expiry: 294110,
            id: -9007199254740845,
            msecs: 5000,
            priorityQueuePosition: 3
          },
          _idleStart: 289190,
          _onTimeout: [Function: bound ],
          _timerArgs: undefined,
          _repeat: null,
          _destroyed: false,
          [Symbol(refed)]: false,
          [Symbol(kHasPrimitive)]: false,
          [Symbol(asyncId)]: 924,
          [Symbol(triggerId)]: 922
        },
        [Symbol(kBuffer)]: null,
        [Symbol(kBufferCb)]: null,
        [Symbol(kBufferGen)]: null,
        [Symbol(shapeMode)]: true,
        [Symbol(kCapture)]: false,
        [Symbol(kSetNoDelay)]: false,
        [Symbol(kSetKeepAlive)]: true,
        [Symbol(kSetKeepAliveInitialDelay)]: 1,
        [Symbol(kBytesRead)]: 0,
        [Symbol(kBytesWritten)]: 0,
        [Symbol(connect-options)]: {
          rejectUnauthorized: true,
          ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
          checkServerIdentity: [Function: checkServerIdentity],
          minDHSize: 1024,
          session: Buffer(2127) [Uint8Array] [...],
          maxRedirects: 21,
          maxBodyLength: Infinity,
          protocol: 'https:',
          path: null,
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            Authorization: 'Bearer no',
            'User-Agent': 'axios/1.7.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'api.spotify.com',
          port: 443,
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/v1/albums',
          search: '?ids=',
          _defaultAgent: Agent {
            _events: [Object: null prototype],
            _eventsCount: 2,
            _maxListeners: undefined,
            defaultPort: 443,
            protocol: 'https:',
            options: [Object: null prototype],
            requests: [Object: null prototype] {},
            sockets: [Object: null prototype] {},
            freeSockets: [Object: null prototype],
            keepAliveMsecs: 1000,
            keepAlive: true,
            maxSockets: Infinity,
            maxFreeSockets: 256,
            scheduling: 'lifo',
            maxTotalSockets: Infinity,
            totalSocketCount: 1,
            maxCachedSessions: 100,
            _sessionCache: [Object],
            [Symbol(shapeMode)]: false,
            [Symbol(kCapture)]: false
          },
          host: 'api.spotify.com',
          keepAlive: true,
          scheduling: 'lifo',
          timeout: 5000,
          noDelay: true,
          servername: 'api.spotify.com',
          _agentKey: 'api.spotify.com:443:::::::::::::::::::::',
          encoding: null,
          keepAliveInitialDelay: 1000
        }
      },
      _consuming: false,
      _dumped: false,
      req: [Circular *3],
      _eventsCount: 4,
      responseUrl: 'https://api.spotify.com/v1/albums?ids=',
      redirects: [],
      [Symbol(shapeMode)]: true,
      [Symbol(kCapture)]: false,
      [Symbol(kHeaders)]: {
        'content-type': 'application/json; charset=utf-8',
        'cache-control': 'private, max-age=0',
        'access-control-allow-origin': '*',
        'access-control-allow-headers': 'Accept, App-Platform, Authorization, Content-Type, Origin, Retry-After, Spotify-App-Version, X-Cloud-Trace-Context, client-token, content-access-token',
        'access-control-allow-methods': 'GET, POST, OPTIONS, PUT, DELETE, PATCH',
        'access-control-allow-credentials': 'true',
        'access-control-max-age': '604800',
        'strict-transport-security': 'max-age=31536000',
        'x-content-type-options': 'nosniff',
        date: 'Mon, 09 Sep 2024 11:50:53 GMT',
        server: 'envoy',
        via: 'HTTP/2 edgeproxy, 1.1 google',
        'alt-svc': 'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
        'transfer-encoding': 'chunked'
      },
      [Symbol(kHeadersCount)]: 30,
      [Symbol(kTrailers)]: null,
      [Symbol(kTrailersCount)]: 0
    },
    aborted: false,
    timeoutCb: null,
    upgradeOrConnect: false,
    parser: null,
    maxHeadersCount: null,
    reusedSocket: false,
    host: 'api.spotify.com',
    protocol: 'https:',
    _redirectable: Writable {
      _events: {
        close: undefined,
        error: [Function: handleRequestError],
        prefinish: undefined,
        finish: undefined,
        drain: undefined,
        response: [Function: handleResponse],
        socket: [Function: handleRequestSocket]
      },
      _writableState: WritableState {
        highWaterMark: 16384,
        length: 0,
        corked: 0,
        onwrite: [Function: bound onwrite],
        writelen: 0,
        bufferedIndex: 0,
        pendingcb: 0,
        [Symbol(kState)]: 17580812,
        [Symbol(kBufferedValue)]: null
      },
      _maxListeners: undefined,
      _options: {
        maxRedirects: 21,
        maxBodyLength: Infinity,
        protocol: 'https:',
        path: '/v1/albums?ids=',
        method: 'GET',
        headers: [Object: null prototype] {
          Accept: 'application/json, text/plain, */*',
          'Content-Type': 'application/json',
          Authorization: 'Bearer no',
          'User-Agent': 'axios/1.7.5',
          'Accept-Encoding': 'gzip, compress, deflate, br'
        },
        agents: { http: undefined, https: undefined },
        auth: undefined,
        family: undefined,
        beforeRedirect: [Function: dispatchBeforeRedirect],
        beforeRedirects: { proxy: [Function: beforeRedirect] },
        hostname: 'api.spotify.com',
        port: '',
        agent: undefined,
        nativeProtocols: {
          'http:': {
            _connectionListener: [Function: connectionListener],
            METHODS: [Array],
            STATUS_CODES: [Object],
            Agent: [Function],
            ClientRequest: [Function: ClientRequest],
            IncomingMessage: [Function: IncomingMessage],
            OutgoingMessage: [Function: OutgoingMessage],
            Server: [Function: Server],
            ServerResponse: [Function: ServerResponse],
            createServer: [Function: createServer],
            validateHeaderName: [Function],
            validateHeaderValue: [Function],
            get: [Function: get],
            request: [Function: request],
            setMaxIdleHTTPParsers: [Function: setMaxIdleHTTPParsers],
            maxHeaderSize: [Getter],
            globalAgent: [Getter/Setter]
          },
          'https:': {
            Agent: [Function: Agent],
            globalAgent: [Agent],
            Server: [Function: Server],
            createServer: [Function: createServer],
            get: [Function: get],
            request: [Function: request]
          }
        },
        pathname: '/v1/albums',
        search: '?ids='
      },
      _ended: true,
      _ending: true,
      _redirectCount: 0,
      _redirects: [],
      _requestBodyLength: 0,
      _requestBodyBuffers: [],
      _eventsCount: 3,
      _onNativeResponse: [Function (anonymous)],
      _currentRequest: [Circular *3],
      _currentUrl: 'https://api.spotify.com/v1/albums?ids=',
      [Symbol(shapeMode)]: true,
      [Symbol(kCapture)]: false
    },
    [Symbol(shapeMode)]: false,
    [Symbol(kCapture)]: false,
    [Symbol(kBytesWritten)]: 0,
    [Symbol(kNeedDrain)]: false,
    [Symbol(corked)]: 0,
    [Symbol(kOutHeaders)]: [Object: null prototype] {
      accept: [ 'Accept', 'application/json, text/plain, */*' ],
      'content-type': [ 'Content-Type', 'application/json' ],
      authorization: [
        'Authorization',
        'Bearer no'
      ],
      'user-agent': [ 'User-Agent', 'axios/1.7.5' ],
      'accept-encoding': [ 'Accept-Encoding', 'gzip, compress, deflate, br' ],
      host: [ 'Host', 'api.spotify.com' ]
    },
    [Symbol(errored)]: null,
    [Symbol(kHighWaterMark)]: 16384,
    [Symbol(kRejectNonStandardBodyWrites)]: false,
    [Symbol(kUniqueHeaders)]: null
  },
  response: {
    status: 400,
    statusText: 'Bad Request',
    headers: Object [AxiosHeaders] {
      'content-type': 'application/json; charset=utf-8',
      'cache-control': 'private, max-age=0',
      'access-control-allow-origin': '*',
      'access-control-allow-headers': 'Accept, App-Platform, Authorization, Content-Type, Origin, Retry-After, Spotify-App-Version, X-Cloud-Trace-Context, client-token, content-access-token',
      'access-control-allow-methods': 'GET, POST, OPTIONS, PUT, DELETE, PATCH',
      'access-control-allow-credentials': 'true',
      'access-control-max-age': '604800',
      'strict-transport-security': 'max-age=31536000',
      'x-content-type-options': 'nosniff',
      date: 'Mon, 09 Sep 2024 11:50:53 GMT',
      server: 'envoy',
      via: 'HTTP/2 edgeproxy, 1.1 google',
      'alt-svc': 'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
      'transfer-encoding': 'chunked'
    },
    config: {
      transitional: {
        silentJSONParsing: true,
        forcedJSONParsing: true,
        clarifyTimeoutError: false
      },
      adapter: [ 'xhr', 'http', 'fetch' ],
      transformRequest: [ [Function: transformRequest] ],
      transformResponse: [ [Function: transformResponse] ],
      timeout: 0,
      xsrfCookieName: 'XSRF-TOKEN',
      xsrfHeaderName: 'X-XSRF-TOKEN',
      maxContentLength: -1,
      maxBodyLength: -1,
      env: {
        FormData: [Function: FormData] {
          LINE_BREAK: '\r\n',
          DEFAULT_CONTENT_TYPE: 'application/octet-stream'
        },
        Blob: [class Blob]
      },
      validateStatus: [Function: validateStatus],
      headers: Object [AxiosHeaders] {
        Accept: 'application/json, text/plain, */*',
        'Content-Type': 'application/json',
        Authorization: 'Bearer no',
        'User-Agent': 'axios/1.7.5',
        'Accept-Encoding': 'gzip, compress, deflate, br'
      },
      baseURL: 'https://api.spotify.com/v1',
      method: 'get',
      url: 'https://api.spotify.com/v1/albums?ids=',
      data: undefined
    },
    request: <ref *3> ClientRequest {
      _events: [Object: null prototype] {
        abort: [Function (anonymous)],
        aborted: [Function (anonymous)],
        connect: [Function (anonymous)],
        error: [Function (anonymous)],
        socket: [Function (anonymous)],
        timeout: [Function (anonymous)],
        finish: [Function: requestOnFinish]
      },
      _eventsCount: 7,
      _maxListeners: undefined,
      outputData: [],
      outputSize: 0,
      writable: true,
      destroyed: true,
      _last: true,
      chunkedEncoding: false,
      shouldKeepAlive: true,
      maxRequestsOnConnectionReached: false,
      _defaultKeepAlive: true,
      useChunkedEncodingByDefault: false,
      sendDate: false,
      _removedConnection: false,
      _removedContLen: false,
      _removedTE: false,
      strictContentLength: false,
      _contentLength: 0,
      _hasBody: true,
      _trailer: '',
      finished: true,
      _headerSent: true,
      _closed: true,
      socket: <ref *1> TLSSocket {
        _tlsOptions: {
          allowHalfOpen: undefined,
          pipe: false,
          secureContext: SecureContext { context: SecureContext {} },
          isServer: false,
          requestCert: true,
          rejectUnauthorized: true,
          session: Buffer(2127) [Uint8Array] [...],
          ALPNProtocols: undefined,
          requestOCSP: undefined,
          enableTrace: undefined,
          pskCallback: undefined,
          highWaterMark: undefined,
          onread: undefined,
          signal: undefined
        },
        _secureEstablished: true,
        _securePending: false,
        _newSessionPending: false,
        _controlReleased: true,
        secureConnecting: false,
        _SNICallback: null,
        servername: 'api.spotify.com',
        alpnProtocol: false,
        authorized: true,
        authorizationError: null,
        encrypted: true,
        _events: [Object: null prototype] {
          close: [
            [Function: onSocketCloseDestroySSL],
            [Function],
            [Function: onClose]
          ],
          end: [Function: onReadableStreamEnd],
          error: [Function: bound onceWrapper] {
            listener: [Function: freeSocketErrorListener]
          },
          newListener: [Function: keylogNewListener],
          connect: undefined,
          secure: [Function: onConnectSecure],
          session: [Function (anonymous)],
          free: [Function: onFree],
          timeout: [Function: onTimeout],
          agentRemove: [Function: onRemove],
          data: undefined,
          drain: undefined
        },
        _eventsCount: 9,
        connecting: false,
        _hadError: false,
        _parent: null,
        _host: 'api.spotify.com',
        _closeAfterHandlingError: false,
        _readableState: ReadableState {
          highWaterMark: 16384,
          buffer: [],
          bufferIndex: 0,
          length: 0,
          pipes: [],
          awaitDrainWriters: null,
          [Symbol(kState)]: 60303620
        },
        _writableState: WritableState {
          highWaterMark: 16384,
          length: 0,
          corked: 0,
          onwrite: [Function: bound onwrite],
          writelen: 0,
          bufferedIndex: 0,
          pendingcb: 0,
          [Symbol(kState)]: 17563908,
          [Symbol(kBufferedValue)]: null,
          [Symbol(kWriteCbValue)]: null
        },
        allowHalfOpen: false,
        _maxListeners: undefined,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: undefined,
        _server: null,
        ssl: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        _requestCert: true,
        _rejectUnauthorized: true,
        timeout: 5000,
        parser: null,
        _httpMessage: null,
        autoSelectFamilyAttemptedAddresses: [ '2600:1901:1:7c5:::443' ],
        [Symbol(alpncallback)]: null,
        [Symbol(res)]: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        [Symbol(verified)]: true,
        [Symbol(pendingSession)]: null,
        [Symbol(async_id_symbol)]: -1,
        [Symbol(kHandle)]: TLSWrap {
          _parent: TCP {
            reading: [Getter/Setter],
            onconnection: null,
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _parentWrap: null,
          _secureContext: SecureContext { context: SecureContext {} },
          reading: true,
          onkeylog: [Function: onkeylog],
          onhandshakestart: {},
          onhandshakedone: [Function (anonymous)],
          onocspresponse: [Function: onocspresponse],
          onnewsession: [Function: onnewsessionclient],
          onerror: [Function: onerror],
          [Symbol(owner_symbol)]: [Circular *1]
        },
        [Symbol(lastWriteQueueSize)]: 0,
        [Symbol(timeout)]: <ref *2> Timeout {
          _idleTimeout: 5000,
          _idlePrev: TimersList {
            _idleNext: [Circular *2],
            _idlePrev: [Circular *2],
            expiry: 294110,
            id: -9007199254740845,
            msecs: 5000,
            priorityQueuePosition: 3
          },
          _idleNext: TimersList {
            _idleNext: [Circular *2],
            _idlePrev: [Circular *2],
            expiry: 294110,
            id: -9007199254740845,
            msecs: 5000,
            priorityQueuePosition: 3
          },
          _idleStart: 289190,
          _onTimeout: [Function: bound ],
          _timerArgs: undefined,
          _repeat: null,
          _destroyed: false,
          [Symbol(refed)]: false,
          [Symbol(kHasPrimitive)]: false,
          [Symbol(asyncId)]: 924,
          [Symbol(triggerId)]: 922
        },
        [Symbol(kBuffer)]: null,
        [Symbol(kBufferCb)]: null,
        [Symbol(kBufferGen)]: null,
        [Symbol(shapeMode)]: true,
        [Symbol(kCapture)]: false,
        [Symbol(kSetNoDelay)]: false,
        [Symbol(kSetKeepAlive)]: true,
        [Symbol(kSetKeepAliveInitialDelay)]: 1,
        [Symbol(kBytesRead)]: 0,
        [Symbol(kBytesWritten)]: 0,
        [Symbol(connect-options)]: {
          rejectUnauthorized: true,
          ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
          checkServerIdentity: [Function: checkServerIdentity],
          minDHSize: 1024,
          session: Buffer(2127) [Uint8Array] [...],
          maxRedirects: 21,
          maxBodyLength: Infinity,
          protocol: 'https:',
          path: null,
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            Authorization: 'Bearer no',
            'User-Agent': 'axios/1.7.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'api.spotify.com',
          port: 443,
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/v1/albums',
          search: '?ids=',
          _defaultAgent: Agent {
            _events: [Object: null prototype],
            _eventsCount: 2,
            _maxListeners: undefined,
            defaultPort: 443,
            protocol: 'https:',
            options: [Object: null prototype],
            requests: [Object: null prototype] {},
            sockets: [Object: null prototype] {},
            freeSockets: [Object: null prototype],
            keepAliveMsecs: 1000,
            keepAlive: true,
            maxSockets: Infinity,
            maxFreeSockets: 256,
            scheduling: 'lifo',
            maxTotalSockets: Infinity,
            totalSocketCount: 1,
            maxCachedSessions: 100,
            _sessionCache: [Object],
            [Symbol(shapeMode)]: false,
            [Symbol(kCapture)]: false
          },
          host: 'api.spotify.com',
          keepAlive: true,
          scheduling: 'lifo',
          timeout: 5000,
          noDelay: true,
          servername: 'api.spotify.com',
          _agentKey: 'api.spotify.com:443:::::::::::::::::::::',
          encoding: null,
          keepAliveInitialDelay: 1000
        }
      },
      _header: 'GET /v1/albums?ids= HTTP/1.1\r\n' +
        'Accept: application/json, text/plain, */*\r\n' +
        'Content-Type: application/json\r\n' +
        'Authorization: Bearer no\r\n' +
        'User-Agent: axios/1.7.5\r\n' +
        'Accept-Encoding: gzip, compress, deflate, br\r\n' +
        'Host: api.spotify.com\r\n' +
        'Connection: keep-alive\r\n' +
        '\r\n',
      _keepAliveTimeout: 0,
      _onPendingData: [Function: nop],
      agent: Agent {
        _events: [Object: null prototype] {
          free: [Function (anonymous)],
          newListener: [Function: maybeEnableKeylog]
        },
        _eventsCount: 2,
        _maxListeners: undefined,
        defaultPort: 443,
        protocol: 'https:',
        options: [Object: null prototype] {
          keepAlive: true,
          scheduling: 'lifo',
          timeout: 5000,
          noDelay: true,
          path: null
        },
        requests: [Object: null prototype] {},
        sockets: [Object: null prototype] {},
        freeSockets: [Object: null prototype] {
          'api.spotify.com:443:::::::::::::::::::::': [ [TLSSocket] ]
        },
        keepAliveMsecs: 1000,
        keepAlive: true,
        maxSockets: Infinity,
        maxFreeSockets: 256,
        scheduling: 'lifo',
        maxTotalSockets: Infinity,
        totalSocketCount: 1,
        maxCachedSessions: 100,
        _sessionCache: {
          map: {
            'api.spotify.com:443:::::::::::::::::::::': [Buffer [Uint8Array]]
          },
          list: [ 'api.spotify.com:443:::::::::::::::::::::' ]
        },
        [Symbol(shapeMode)]: false,
        [Symbol(kCapture)]: false
      },
      socketPath: undefined,
      method: 'GET',
      maxHeaderSize: undefined,
      insecureHTTPParser: undefined,
      joinDuplicateHeaders: undefined,
      path: '/v1/albums?ids=',
      _ended: true,
      res: IncomingMessage {
        _events: {
          close: [
            [Function (anonymous)],
            [Function: onclose],
            [Function: onclose]
          ],
          error: [
            [Function: onerror],
            [Function: onError],
            [Function: onerror]
          ],
          data: undefined,
          end: [
            [Function: responseOnEnd],
            [Function: onend],
            [Function: onend]
          ],
          readable: undefined,
          finish: [ [Function: onfinish], [Function: onfinish] ]
        },
        _readableState: ReadableState {
          highWaterMark: 16384,
          buffer: [],
          bufferIndex: 0,
          length: 0,
          pipes: [],
          awaitDrainWriters: null,
          [Symbol(kState)]: 110892924
        },
        _maxListeners: undefined,
        socket: null,
        httpVersionMajor: 1,
        httpVersionMinor: 1,
        httpVersion: '1.1',
        complete: true,
        rawHeaders: [
          'content-type',
          'application/json; charset=utf-8',
          'cache-control',
          'private, max-age=0',
          'access-control-allow-origin',
          '*',
          'access-control-allow-headers',
          'Accept, App-Platform, Authorization, Content-Type, Origin, Retry-After, Spotify-App-Version, X-Cloud-Trace-Context, client-token, content-access-token',
          'access-control-allow-methods',
          'GET, POST, OPTIONS, PUT, DELETE, PATCH',
          'access-control-allow-credentials',
          'true',
          'access-control-max-age',
          '604800',
          'content-encoding',
          'gzip',
          'strict-transport-security',
          'max-age=31536000',
          'x-content-type-options',
          'nosniff',
          'date',
          'Mon, 09 Sep 2024 11:50:53 GMT',
          'server',
          'envoy',
          'Via',
          'HTTP/2 edgeproxy, 1.1 google',
          'Alt-Svc',
          'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
          'Transfer-Encoding',
          'chunked'
        ],
        rawTrailers: [],
        joinDuplicateHeaders: undefined,
        aborted: false,
        upgrade: false,
        url: '',
        method: null,
        statusCode: 400,
        statusMessage: 'Bad Request',
        client: <ref *1> TLSSocket {
          _tlsOptions: {
            allowHalfOpen: undefined,
            pipe: false,
            secureContext: [SecureContext],
            isServer: false,
            requestCert: true,
            rejectUnauthorized: true,
            session: [Buffer [Uint8Array]],
            ALPNProtocols: undefined,
            requestOCSP: undefined,
            enableTrace: undefined,
            pskCallback: undefined,
            highWaterMark: undefined,
            onread: undefined,
            signal: undefined
          },
          _secureEstablished: true,
          _securePending: false,
          _newSessionPending: false,
          _controlReleased: true,
          secureConnecting: false,
          _SNICallback: null,
          servername: 'api.spotify.com',
          alpnProtocol: false,
          authorized: true,
          authorizationError: null,
          encrypted: true,
          _events: [Object: null prototype] {
            close: [Array],
            end: [Function: onReadableStreamEnd],
            error: [Function],
            newListener: [Function: keylogNewListener],
            connect: undefined,
            secure: [Function: onConnectSecure],
            session: [Function (anonymous)],
            free: [Function: onFree],
            timeout: [Function: onTimeout],
            agentRemove: [Function: onRemove],
            data: undefined,
            drain: undefined
          },
          _eventsCount: 9,
          connecting: false,
          _hadError: false,
          _parent: null,
          _host: 'api.spotify.com',
          _closeAfterHandlingError: false,
          _readableState: ReadableState {
            highWaterMark: 16384,
            buffer: [],
            bufferIndex: 0,
            length: 0,
            pipes: [],
            awaitDrainWriters: null,
            [Symbol(kState)]: 60303620
          },
          _writableState: WritableState {
            highWaterMark: 16384,
            length: 0,
            corked: 0,
            onwrite: [Function: bound onwrite],
            writelen: 0,
            bufferedIndex: 0,
            pendingcb: 0,
            [Symbol(kState)]: 17563908,
            [Symbol(kBufferedValue)]: null,
            [Symbol(kWriteCbValue)]: null
          },
          allowHalfOpen: false,
          _maxListeners: undefined,
          _sockname: null,
          _pendingData: null,
          _pendingEncoding: '',
          server: undefined,
          _server: null,
          ssl: TLSWrap {
            _parent: [TCP],
            _parentWrap: null,
            _secureContext: [SecureContext],
            reading: true,
            onkeylog: [Function: onkeylog],
            onhandshakestart: {},
            onhandshakedone: [Function (anonymous)],
            onocspresponse: [Function: onocspresponse],
            onnewsession: [Function: onnewsessionclient],
            onerror: [Function: onerror],
            [Symbol(owner_symbol)]: [Circular *1]
          },
          _requestCert: true,
          _rejectUnauthorized: true,
          timeout: 5000,
          parser: null,
          _httpMessage: null,
          autoSelectFamilyAttemptedAddresses: [ '2600:1901:1:7c5:::443' ],
          [Symbol(alpncallback)]: null,
          [Symbol(res)]: TLSWrap {
            _parent: [TCP],
            _parentWrap: null,
            _secureContext: [SecureContext],
            reading: true,
            onkeylog: [Function: onkeylog],
            onhandshakestart: {},
            onhandshakedone: [Function (anonymous)],
            onocspresponse: [Function: onocspresponse],
            onnewsession: [Function: onnewsessionclient],
            onerror: [Function: onerror],
            [Symbol(owner_symbol)]: [Circular *1]
          },
          [Symbol(verified)]: true,
          [Symbol(pendingSession)]: null,
          [Symbol(async_id_symbol)]: -1,
          [Symbol(kHandle)]: TLSWrap {
            _parent: [TCP],
            _parentWrap: null,
            _secureContext: [SecureContext],
            reading: true,
            onkeylog: [Function: onkeylog],
            onhandshakestart: {},
            onhandshakedone: [Function (anonymous)],
            onocspresponse: [Function: onocspresponse],
            onnewsession: [Function: onnewsessionclient],
            onerror: [Function: onerror],
            [Symbol(owner_symbol)]: [Circular *1]
          },
          [Symbol(lastWriteQueueSize)]: 0,
          [Symbol(timeout)]: <ref *2> Timeout {
            _idleTimeout: 5000,
            _idlePrev: [TimersList],
            _idleNext: [TimersList],
            _idleStart: 289190,
            _onTimeout: [Function: bound ],
            _timerArgs: undefined,
            _repeat: null,
            _destroyed: false,
            [Symbol(refed)]: false,
            [Symbol(kHasPrimitive)]: false,
            [Symbol(asyncId)]: 924,
            [Symbol(triggerId)]: 922
          },
          [Symbol(kBuffer)]: null,
          [Symbol(kBufferCb)]: null,
          [Symbol(kBufferGen)]: null,
          [Symbol(shapeMode)]: true,
          [Symbol(kCapture)]: false,
          [Symbol(kSetNoDelay)]: false,
          [Symbol(kSetKeepAlive)]: true,
          [Symbol(kSetKeepAliveInitialDelay)]: 1,
          [Symbol(kBytesRead)]: 0,
          [Symbol(kBytesWritten)]: 0,
          [Symbol(connect-options)]: {
            rejectUnauthorized: true,
            ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
            checkServerIdentity: [Function: checkServerIdentity],
            minDHSize: 1024,
            session: [Buffer [Uint8Array]],
            maxRedirects: 21,
            maxBodyLength: Infinity,
            protocol: 'https:',
            path: null,
            method: 'GET',
            headers: [Object: null prototype],
            agents: [Object],
            auth: undefined,
            family: undefined,
            beforeRedirect: [Function: dispatchBeforeRedirect],
            beforeRedirects: [Object],
            hostname: 'api.spotify.com',
            port: 443,
            agent: undefined,
            nativeProtocols: [Object],
            pathname: '/v1/albums',
            search: '?ids=',
            _defaultAgent: [Agent],
            host: 'api.spotify.com',
            keepAlive: true,
            scheduling: 'lifo',
            timeout: 5000,
            noDelay: true,
            servername: 'api.spotify.com',
            _agentKey: 'api.spotify.com:443:::::::::::::::::::::',
            encoding: null,
            keepAliveInitialDelay: 1000
          }
        },
        _consuming: false,
        _dumped: false,
        req: [Circular *3],
        _eventsCount: 4,
        responseUrl: 'https://api.spotify.com/v1/albums?ids=',
        redirects: [],
        [Symbol(shapeMode)]: true,
        [Symbol(kCapture)]: false,
        [Symbol(kHeaders)]: {
          'content-type': 'application/json; charset=utf-8',
          'cache-control': 'private, max-age=0',
          'access-control-allow-origin': '*',
          'access-control-allow-headers': 'Accept, App-Platform, Authorization, Content-Type, Origin, Retry-After, Spotify-App-Version, X-Cloud-Trace-Context, client-token, content-access-token',
          'access-control-allow-methods': 'GET, POST, OPTIONS, PUT, DELETE, PATCH',
          'access-control-allow-credentials': 'true',
          'access-control-max-age': '604800',
          'strict-transport-security': 'max-age=31536000',
          'x-content-type-options': 'nosniff',
          date: 'Mon, 09 Sep 2024 11:50:53 GMT',
          server: 'envoy',
          via: 'HTTP/2 edgeproxy, 1.1 google',
          'alt-svc': 'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000',
          'transfer-encoding': 'chunked'
        },
        [Symbol(kHeadersCount)]: 30,
        [Symbol(kTrailers)]: null,
        [Symbol(kTrailersCount)]: 0
      },
      aborted: false,
      timeoutCb: null,
      upgradeOrConnect: false,
      parser: null,
      maxHeadersCount: null,
      reusedSocket: false,
      host: 'api.spotify.com',
      protocol: 'https:',
      _redirectable: Writable {
        _events: {
          close: undefined,
          error: [Function: handleRequestError],
          prefinish: undefined,
          finish: undefined,
          drain: undefined,
          response: [Function: handleResponse],
          socket: [Function: handleRequestSocket]
        },
        _writableState: WritableState {
          highWaterMark: 16384,
          length: 0,
          corked: 0,
          onwrite: [Function: bound onwrite],
          writelen: 0,
          bufferedIndex: 0,
          pendingcb: 0,
          [Symbol(kState)]: 17580812,
          [Symbol(kBufferedValue)]: null
        },
        _maxListeners: undefined,
        _options: {
          maxRedirects: 21,
          maxBodyLength: Infinity,
          protocol: 'https:',
          path: '/v1/albums?ids=',
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            Authorization: 'Bearer no',
            'User-Agent': 'axios/1.7.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'api.spotify.com',
          port: '',
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/v1/albums',
          search: '?ids='
        },
        _ended: true,
        _ending: true,
        _redirectCount: 0,
        _redirects: [],
        _requestBodyLength: 0,
        _requestBodyBuffers: [],
        _eventsCount: 3,
        _onNativeResponse: [Function (anonymous)],
        _currentRequest: [Circular *3],
        _currentUrl: 'https://api.spotify.com/v1/albums?ids=',
        [Symbol(shapeMode)]: true,
        [Symbol(kCapture)]: false
      },
      [Symbol(shapeMode)]: false,
      [Symbol(kCapture)]: false,
      [Symbol(kBytesWritten)]: 0,
      [Symbol(kNeedDrain)]: false,
      [Symbol(corked)]: 0,
      [Symbol(kOutHeaders)]: [Object: null prototype] {
        accept: [ 'Accept', 'application/json, text/plain, */*' ],
        'content-type': [ 'Content-Type', 'application/json' ],
        authorization: [
          'Authorization',
          'Bearer no'
        ],
        'user-agent': [ 'User-Agent', 'axios/1.7.5' ],
        'accept-encoding': [ 'Accept-Encoding', 'gzip, compress, deflate, br' ],
        host: [ 'Host', 'api.spotify.com' ]
      },
      [Symbol(errored)]: null,
      [Symbol(kHighWaterMark)]: 16384,
      [Symbol(kRejectNonStandardBodyWrites)]: false,
      [Symbol(kUniqueHeaders)]: null
    },
    data: { error: { status: 400, message: 'Missing required field: ids' } }
  },
  status: 400
}

Node.js v20.17.0
error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
`db.tracks.find({id: "7v9Q0dAb9t7h8gJOkcJHay"})`
your_spotify> db.tracks.find({id: "7v9Q0dAb9t7h8gJOkcJHay"})
[
  {
    _id: ObjectId("66794fb2eff24269a8e700e4"),
    album: null,
    artists: [ '4tZwfgrHOc3mvqYlEYSvVi' ],
    available_markets: [
      'AR', 'AU', 'AT', 'BE', 'BO', 'BR', 'BG', 'CA', 'CL', 'CO', 'CR', 'CY',
      'CZ', 'DK', 'DO', 'DE', 'EC', 'EE', 'SV', 'FI', 'FR', 'GR', 'GT', 'HN',
      'HK', 'HU', 'IS', 'IE', 'IT', 'LV', 'LT', 'LU', 'MY', 'MT', 'MX', 'NL',
      'NZ', 'NI', 'NO', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'SG', 'SK', 'ES',
      'SE', 'CH', 'TW', 'TR', 'UY', 'US', 'GB', 'AD', 'LI', 'MC', 'ID', 'JP',
      'TH', 'VN', 'RO', 'IL', 'ZA', 'SA', 'AE', 'BH', 'QA', 'OM', 'KW', 'EG',
      'MA', 'DZ', 'TN', 'LB', 'JO', 'PS', 'IN', 'BY', 'KZ', 'MD', 'UA', 'AL',
      'BA', 'HR', 'ME', 'MK', 'RS', 'SI', 'KR', 'BD', 'PK', 'LK', 'GH', 'KE',
      'NG', 'TZ', 'UG', 'AG', 'AM', 'BS', 'BB', 'BZ', 'BT', 'BW', 'BF', 'CV',
      'CW', 'DM', 'FJ', 'GM', 'GE', 'GD', 'GW', 'GY', 'HT', 'JM', 'KI', 'LS',
      'LR', 'MW', 'MV', 'ML', 'MH', 'FM', 'NA', 'NR', 'NE', 'PW', 'PG', 'PR',
      'WS', 'SM', 'ST', 'SN', 'SC', 'SL', 'SB', 'KN', 'LC', 'VC', 'SR', 'TL',
      'TO', 'TT', 'TV', 'VU', 'AZ', 'BN', 'BI', 'KH', 'CM', 'TD', 'KM', 'GQ',
      'SZ', 'GA', 'GN', 'KG', 'LA', 'MO', 'MR', 'MN', 'NP', 'RW', 'TG', 'UZ',
      'ZW', 'BJ', 'MG', 'MU', 'MZ', 'AO', 'CI', 'DJ', 'ZM', 'CD', 'CG', 'IQ',
      'LY', 'TJ', 'VE', 'ET', 'XK'
    ],
    disc_number: 1,
    duration_ms: 240173,
    explicit: false,
    external_ids: { isrc: 'GBDUW0000068' },
    external_urls: {
      spotify: 'https://open.spotify.com/track/7v9Q0dAb9t7h8gJOkcJHay'
    },
    href: 'https://api.spotify.com/v1/tracks/7v9Q0dAb9t7h8gJOkcJHay',
    id: '7v9Q0dAb9t7h8gJOkcJHay',
    is_local: false,
    name: 'Face to Face',
    popularity: 58,
    preview_url: 'https://p.scdn.co/mp3-preview/1e1ac914d240a6b0c3e0b53febdbe3f1267f53af?cid=1cf2e40cbe3543bba3a58b889e5ee76f',
    track_number: 13,
    type: 'track',
    uri: 'spotify:track:7v9Q0dAb9t7h8gJOkcJHay',
    __v: 0
  }
]

Running db.tracks.remove({id: "7v9Q0dAb9t7h8gJOkcJHay"}) allowed the API to start again.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

3 participants