text:
GET request playerHeroStatistics.getByPlayerId returns 500

Using the following example code with my own playerId, I get a 500 response without an identifiable error message:
   const heroStats = await omeda.playerHeroStatistics.getByPlayerId({
        playerId: "<player-id",
        params: {
           hero_ids: ["1", "2"]
        }
   });

node version: Node.js v20.11.0
npm version: 10.2.4
omedacity-js version: 0.6.3
Error message (massive):
file:///Users/cnixon_dev/code/omedaJS/node_modules/axios/lib/core/settle.js:19
    reject(new AxiosError(
           ^
AxiosError: Request failed with status code 500
    at settle (file:///Users/cnixon_dev/code/omedaJS/node_modules/axios/lib/core/settle.js:19:12)
    at IncomingMessage.handleStreamEnd (file:///Users/cnixon_dev/code/omedaJS/node_modules/axios/lib/adapters/http.js:589:11)
    at IncomingMessage.emit (node:events:530:35)
    at endReadableNT (node:internal/streams/readable:1696:12)
    at process.processTicksAndRejections (node:internal/process/task_queues:82:21) {
  code: 'ERR_BAD_RESPONSE',
  config: {
    transitional: {
      silentJSONParsing: true,
      forcedJSONParsing: true,
      clarifyTimeoutError: false
    },
    adapter: [ 'xhr', 'http' ],
    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',
      'x-origin-sdk': 'omedacity-js@0.6.3',
      'User-Agent': 'axios/1.6.5',
      'Accept-Encoding': 'gzip, compress, deflate, br'
    },
    baseURL: 'https://omeda.city',
    method: 'get',
    url: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
    data: undefined
  },
  request: <ref *4> 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: undefined,
        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: 'omeda.city',
      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: 'omeda.city',
      _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)]: [Function: bound onFinish]
      },
      allowHalfOpen: false,
      _maxListeners: undefined,
      _sockname: null,
      _pendingData: null,
      _pendingEncoding: '',
      server: undefined,
      _server: null,
      ssl: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
      },
      _requestCert: true,
      _rejectUnauthorized: true,
      timeout: 5000,
      parser: null,
      _httpMessage: null,
      autoSelectFamilyAttemptedAddresses: [ '2606:4700:3033::6815:5f03:443' ],
      [Symbol(alpncallback)]: null,
      [Symbol(res)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
      },
      [Symbol(verified)]: true,
      [Symbol(pendingSession)]: null,
      [Symbol(async_id_symbol)]: -1,
      [Symbol(kHandle)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
      },
      [Symbol(lastWriteQueueSize)]: 0,
      [Symbol(timeout)]: <ref *3> Timeout {
        _idleTimeout: 5000,
        _idlePrev: TimersList {
          _idleNext: [Circular *3],
          _idlePrev: [Circular *3],
          expiry: 5143,
          id: -9007199254740991,
          msecs: 5000,
          priorityQueuePosition: 1
        },
        _idleNext: TimersList {
          _idleNext: [Circular *3],
          _idlePrev: [Circular *3],
          expiry: 5143,
          id: -9007199254740991,
          msecs: 5000,
          priorityQueuePosition: 1
        },
        _idleStart: 2133,
        _onTimeout: [Function: bound ],
        _timerArgs: undefined,
        _repeat: null,
        _destroyed: false,
        [Symbol(refed)]: false,
        [Symbol(kHasPrimitive)]: false,
        [Symbol(asyncId)]: 543,
        [Symbol(triggerId)]: 541
      },
      [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,
        maxRedirects: 21,
        maxBodyLength: Infinity,
        protocol: 'https:',
        path: null,
        method: 'GET',
        headers: [Object: null prototype] {
          Accept: 'application/json, text/plain, */*',
          'Content-Type': 'application/json',
          'x-origin-sdk': 'omedacity-js@0.6.3',
          'User-Agent': 'axios/1.6.5',
          'Accept-Encoding': 'gzip, compress, deflate, br'
        },
        agents: { http: undefined, https: undefined },
        auth: undefined,
        family: undefined,
        beforeRedirect: [Function: dispatchBeforeRedirect],
        beforeRedirects: { proxy: [Function: beforeRedirect] },
        hostname: 'omeda.city',
        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: __node_internal_],
            validateHeaderValue: [Function: __node_internal_],
            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: '/heroes.json',
        _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] {
            'omeda.city: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: 'omeda.city',
        keepAlive: true,
        scheduling: 'lifo',
        timeout: 5000,
        noDelay: true,
        servername: 'omeda.city',
        _agentKey: 'omeda.city:443:::::::::::::::::::::',
        encoding: null,
        keepAliveInitialDelay: 1000
      }
    },
    _header: 'GET /players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2 HTTP/1.1\r\n' +
      'Accept: application/json, text/plain, */*\r\n' +
      'Content-Type: application/json\r\n' +
      'x-origin-sdk: omedacity-js@0.6.3\r\n' +
      'User-Agent: axios/1.6.5\r\n' +
      'Accept-Encoding: gzip, compress, deflate, br\r\n' +
      'Host: omeda.city\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] {
        'omeda.city:443:::::::::::::::::::::': [
          <ref *1> TLSSocket {
            _tlsOptions: [Object],
            _secureEstablished: true,
            _securePending: false,
            _newSessionPending: false,
            _controlReleased: true,
            secureConnecting: false,
            _SNICallback: null,
            servername: 'omeda.city',
            alpnProtocol: false,
            authorized: true,
            authorizationError: null,
            encrypted: true,
            _events: [Object: null prototype],
            _eventsCount: 9,
            connecting: false,
            _hadError: false,
            _parent: null,
            _host: 'omeda.city',
            _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: {
          'omeda.city:443:::::::::::::::::::::': Buffer(1762) [Uint8Array] [
             48, 130,   6, 222,   2,   1,   1,   2,   2,   3,   4,   4,
              2,  19,   2,   4,  32, 145, 182, 127, 109, 173, 156,  20,
             78,  72, 122, 122, 251,  65,  69, 119,   4, 176, 152, 101,
             72, 192, 107, 117,  46, 226, 140,  98,  99,  33, 197, 249,
             11,   4,  48,  54,  47,  74,  88, 255, 119,  99, 133,  34,
            205,  89,  14,  74,  61,  15, 103,  36,  92, 198,  33, 153,
            111, 110, 209, 164, 157,  57, 144, 124, 172, 215, 171, 246,
             66, 209, 199,  41, 142,  37, 221,  95, 178, 237, 219, 157,
             97, 238, 125, 161,
            ... 1662 more items
          ]
        },
        list: [ 'omeda.city:443:::::::::::::::::::::' ]
      },
      [Symbol(shapeMode)]: false,
      [Symbol(kCapture)]: false
    },
    socketPath: undefined,
    method: 'GET',
    maxHeaderSize: undefined,
    insecureHTTPParser: undefined,
    joinDuplicateHeaders: undefined,
    path: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
    _ended: true,
    res: IncomingMessage {
      _events: {
        close: undefined,
        error: [Function: handleStreamError],
        data: [Function: handleStreamData],
        end: [ [Function: responseOnEnd], [Function: handleStreamEnd] ],
        readable: undefined,
        finish: undefined,
        aborted: [Function: handlerStreamAborted]
      },
      _readableState: ReadableState {
        highWaterMark: 16384,
        buffer: [],
        bufferIndex: 0,
        length: 0,
        pipes: [],
        awaitDrainWriters: null,
        [Symbol(kState)]: 194779004
      },
      _maxListeners: undefined,
      socket: null,
      httpVersionMajor: 1,
      httpVersionMinor: 1,
      httpVersion: '1.1',
      complete: true,
      rawHeaders: [
        'Date',
        'Fri, 26 Jan 2024 17:34:11 GMT',
        'Content-Type',
        'application/json; charset=UTF-8',
        'Content-Length',
        '46',
        'Connection',
        'keep-alive',
        'vary',
        'Origin',
        'x-request-id',
        '809997b8-1c4b-465d-8860-eb406ccf3bcc',
        'x-runtime',
        '0.016154',
        'CF-Cache-Status',
        'DYNAMIC',
        'Report-To',
        '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=oY027imPsu1gAC11LcNq2iOez6%2FltkGW8k5FMW2icdlU0pDeTV9XXOmetMIGNFS7MeoJ9tkPh0eMLSnQE%2FSEwoFXXkCI5r6A4BtEfAzuLeAaD7McNKGAJWTKmtIUe8ASQZFRSYMwj%2Fr7"}],"group":"cf-nel","max_age":604800}',
        'NEL',
        '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}',
        'Server',
        'cloudflare',
        'CF-RAY',
        '84ba815a9a97c390-SEA',
        'alt-svc',
        'h3=":443"; ma=86400'
      ],
      rawTrailers: [],
      joinDuplicateHeaders: undefined,
      aborted: false,
      upgrade: false,
      url: '',
      method: null,
      statusCode: 500,
      statusMessage: 'Internal Server Error',
      client: <ref *1> TLSSocket {
        _tlsOptions: {
          allowHalfOpen: undefined,
          pipe: false,
          secureContext: SecureContext { context: SecureContext {} },
          isServer: false,
          requestCert: true,
          rejectUnauthorized: true,
          session: undefined,
          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: 'omeda.city',
        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: 'omeda.city',
        _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)]: [Function: bound onFinish]
        },
        allowHalfOpen: false,
        _maxListeners: undefined,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: undefined,
        _server: null,
        ssl: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        _requestCert: true,
        _rejectUnauthorized: true,
        timeout: 5000,
        parser: null,
        _httpMessage: null,
        autoSelectFamilyAttemptedAddresses: [ '2606:4700:3033::6815:5f03:443' ],
        [Symbol(alpncallback)]: null,
        [Symbol(res)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        [Symbol(verified)]: true,
        [Symbol(pendingSession)]: null,
        [Symbol(async_id_symbol)]: -1,
        [Symbol(kHandle)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        [Symbol(lastWriteQueueSize)]: 0,
        [Symbol(timeout)]: <ref *3> Timeout {
          _idleTimeout: 5000,
          _idlePrev: TimersList {
            _idleNext: [Circular *3],
            _idlePrev: [Circular *3],
            expiry: 5143,
            id: -9007199254740991,
            msecs: 5000,
            priorityQueuePosition: 1
          },
          _idleNext: TimersList {
            _idleNext: [Circular *3],
            _idlePrev: [Circular *3],
            expiry: 5143,
            id: -9007199254740991,
            msecs: 5000,
            priorityQueuePosition: 1
          },
          _idleStart: 2133,
          _onTimeout: [Function: bound ],
          _timerArgs: undefined,
          _repeat: null,
          _destroyed: false,
          [Symbol(refed)]: false,
          [Symbol(kHasPrimitive)]: false,
          [Symbol(asyncId)]: 543,
          [Symbol(triggerId)]: 541
        },
        [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,
          maxRedirects: 21,
          maxBodyLength: Infinity,
          protocol: 'https:',
          path: null,
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            'x-origin-sdk': 'omedacity-js@0.6.3',
            'User-Agent': 'axios/1.6.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'omeda.city',
          port: 443,
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/heroes.json',
          _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: 'omeda.city',
          keepAlive: true,
          scheduling: 'lifo',
          timeout: 5000,
          noDelay: true,
          servername: 'omeda.city',
          _agentKey: 'omeda.city:443:::::::::::::::::::::',
          encoding: null,
          keepAliveInitialDelay: 1000
        }
      },
      _consuming: false,
      _dumped: false,
      req: [Circular *4],
      _eventsCount: 4,
      responseUrl: 'https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
      redirects: [],
      [Symbol(shapeMode)]: true,
      [Symbol(kCapture)]: false,
      [Symbol(kHeaders)]: {
        date: 'Fri, 26 Jan 2024 17:34:11 GMT',
        'content-type': 'application/json; charset=UTF-8',
        'content-length': '46',
        connection: 'keep-alive',
        vary: 'Origin',
        'x-request-id': '809997b8-1c4b-465d-8860-eb406ccf3bcc',
        'x-runtime': '0.016154',
        'cf-cache-status': 'DYNAMIC',
        'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=oY027imPsu1gAC11LcNq2iOez6%2FltkGW8k5FMW2icdlU0pDeTV9XXOmetMIGNFS7MeoJ9tkPh0eMLSnQE%2FSEwoFXXkCI5r6A4BtEfAzuLeAaD7McNKGAJWTKmtIUe8ASQZFRSYMwj%2Fr7"}],"group":"cf-nel","max_age":604800}',
        nel: '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}',
        server: 'cloudflare',
        'cf-ray': '84ba815a9a97c390-SEA',
        'alt-svc': 'h3=":443"; ma=86400'
      },
      [Symbol(kHeadersCount)]: 26,
      [Symbol(kTrailers)]: null,
      [Symbol(kTrailersCount)]: 0
    },
    aborted: false,
    timeoutCb: null,
    upgradeOrConnect: false,
    parser: null,
    maxHeadersCount: null,
    reusedSocket: true,
    host: 'omeda.city',
    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: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
        method: 'GET',
        headers: [Object: null prototype] {
          Accept: 'application/json, text/plain, */*',
          'Content-Type': 'application/json',
          'x-origin-sdk': 'omedacity-js@0.6.3',
          'User-Agent': 'axios/1.6.5',
          'Accept-Encoding': 'gzip, compress, deflate, br'
        },
        agents: { http: undefined, https: undefined },
        auth: undefined,
        family: undefined,
        beforeRedirect: [Function: dispatchBeforeRedirect],
        beforeRedirects: { proxy: [Function: beforeRedirect] },
        hostname: 'omeda.city',
        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: __node_internal_],
            validateHeaderValue: [Function: __node_internal_],
            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: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json',
        search: '?hero_ids[0]=2'
      },
      _ended: true,
      _ending: true,
      _redirectCount: 0,
      _redirects: [],
      _requestBodyLength: 0,
      _requestBodyBuffers: [],
      _eventsCount: 3,
      _onNativeResponse: [Function (anonymous)],
      _currentRequest: [Circular *4],
      _currentUrl: 'https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
      [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' ],
      'x-origin-sdk': [ 'x-origin-sdk', 'omedacity-js@0.6.3' ],
      'user-agent': [ 'User-Agent', 'axios/1.6.5' ],
      'accept-encoding': [ 'Accept-Encoding', 'gzip, compress, deflate, br' ],
      host: [ 'Host', 'omeda.city' ]
    },
    [Symbol(errored)]: null,
    [Symbol(kHighWaterMark)]: 16384,
    [Symbol(kRejectNonStandardBodyWrites)]: false,
    [Symbol(kUniqueHeaders)]: null
  },
  response: {
    status: 500,
    statusText: 'Internal Server Error',
    headers: Object [AxiosHeaders] {
      date: 'Fri, 26 Jan 2024 17:34:11 GMT',
      'content-type': 'application/json; charset=UTF-8',
      'content-length': '46',
      connection: 'keep-alive',
      vary: 'Origin',
      'x-request-id': '809997b8-1c4b-465d-8860-eb406ccf3bcc',
      'x-runtime': '0.016154',
      'cf-cache-status': 'DYNAMIC',
      'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=oY027imPsu1gAC11LcNq2iOez6%2FltkGW8k5FMW2icdlU0pDeTV9XXOmetMIGNFS7MeoJ9tkPh0eMLSnQE%2FSEwoFXXkCI5r6A4BtEfAzuLeAaD7McNKGAJWTKmtIUe8ASQZFRSYMwj%2Fr7"}],"group":"cf-nel","max_age":604800}',
      nel: '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}',
      server: 'cloudflare',
      'cf-ray': '84ba815a9a97c390-SEA',
      'alt-svc': 'h3=":443"; ma=86400'
    },
    config: {
      transitional: {
        silentJSONParsing: true,
        forcedJSONParsing: true,
        clarifyTimeoutError: false
      },
      adapter: [ 'xhr', 'http' ],
      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',
        'x-origin-sdk': 'omedacity-js@0.6.3',
        'User-Agent': 'axios/1.6.5',
        'Accept-Encoding': 'gzip, compress, deflate, br'
      },
      baseURL: 'https://omeda.city',
      method: 'get',
      url: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
      data: undefined
    },
    request: <ref *4> 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: undefined,
          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: 'omeda.city',
        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: 'omeda.city',
        _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)]: [Function: bound onFinish]
        },
        allowHalfOpen: false,
        _maxListeners: undefined,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: undefined,
        _server: null,
        ssl: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        _requestCert: true,
        _rejectUnauthorized: true,
        timeout: 5000,
        parser: null,
        _httpMessage: null,
        autoSelectFamilyAttemptedAddresses: [ '2606:4700:3033::6815:5f03:443' ],
        [Symbol(alpncallback)]: null,
        [Symbol(res)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        [Symbol(verified)]: true,
        [Symbol(pendingSession)]: null,
        [Symbol(async_id_symbol)]: -1,
        [Symbol(kHandle)]: <ref *2> 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(resource_symbol)]: ReusedHandle { type: 57, handle: [Circular *2] }
        },
        [Symbol(lastWriteQueueSize)]: 0,
        [Symbol(timeout)]: <ref *3> Timeout {
          _idleTimeout: 5000,
          _idlePrev: TimersList {
            _idleNext: [Circular *3],
            _idlePrev: [Circular *3],
            expiry: 5143,
            id: -9007199254740991,
            msecs: 5000,
            priorityQueuePosition: 1
          },
          _idleNext: TimersList {
            _idleNext: [Circular *3],
            _idlePrev: [Circular *3],
            expiry: 5143,
            id: -9007199254740991,
            msecs: 5000,
            priorityQueuePosition: 1
          },
          _idleStart: 2133,
          _onTimeout: [Function: bound ],
          _timerArgs: undefined,
          _repeat: null,
          _destroyed: false,
          [Symbol(refed)]: false,
          [Symbol(kHasPrimitive)]: false,
          [Symbol(asyncId)]: 543,
          [Symbol(triggerId)]: 541
        },
        [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,
          maxRedirects: 21,
          maxBodyLength: Infinity,
          protocol: 'https:',
          path: null,
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            'x-origin-sdk': 'omedacity-js@0.6.3',
            'User-Agent': 'axios/1.6.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'omeda.city',
          port: 443,
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/heroes.json',
          _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: 'omeda.city',
          keepAlive: true,
          scheduling: 'lifo',
          timeout: 5000,
          noDelay: true,
          servername: 'omeda.city',
          _agentKey: 'omeda.city:443:::::::::::::::::::::',
          encoding: null,
          keepAliveInitialDelay: 1000
        }
      },
      _header: 'GET /players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2 HTTP/1.1\r\n' +
        'Accept: application/json, text/plain, */*\r\n' +
        'Content-Type: application/json\r\n' +
        'x-origin-sdk: omedacity-js@0.6.3\r\n' +
        'User-Agent: axios/1.6.5\r\n' +
        'Accept-Encoding: gzip, compress, deflate, br\r\n' +
        'Host: omeda.city\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] {
          'omeda.city:443:::::::::::::::::::::': [ [TLSSocket] ]
        },
        keepAliveMsecs: 1000,
        keepAlive: true,
        maxSockets: Infinity,
        maxFreeSockets: 256,
        scheduling: 'lifo',
        maxTotalSockets: Infinity,
        totalSocketCount: 1,
        maxCachedSessions: 100,
        _sessionCache: {
          map: {
            'omeda.city:443:::::::::::::::::::::': [Buffer [Uint8Array]]
          },
          list: [ 'omeda.city:443:::::::::::::::::::::' ]
        },
        [Symbol(shapeMode)]: false,
        [Symbol(kCapture)]: false
      },
      socketPath: undefined,
      method: 'GET',
      maxHeaderSize: undefined,
      insecureHTTPParser: undefined,
      joinDuplicateHeaders: undefined,
      path: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
      _ended: true,
      res: IncomingMessage {
        _events: {
          close: undefined,
          error: [Function: handleStreamError],
          data: [Function: handleStreamData],
          end: [ [Function: responseOnEnd], [Function: handleStreamEnd] ],
          readable: undefined,
          finish: undefined,
          aborted: [Function: handlerStreamAborted]
        },
        _readableState: ReadableState {
          highWaterMark: 16384,
          buffer: [],
          bufferIndex: 0,
          length: 0,
          pipes: [],
          awaitDrainWriters: null,
          [Symbol(kState)]: 194779004
        },
        _maxListeners: undefined,
        socket: null,
        httpVersionMajor: 1,
        httpVersionMinor: 1,
        httpVersion: '1.1',
        complete: true,
        rawHeaders: [
          'Date',
          'Fri, 26 Jan 2024 17:34:11 GMT',
          'Content-Type',
          'application/json; charset=UTF-8',
          'Content-Length',
          '46',
          'Connection',
          'keep-alive',
          'vary',
          'Origin',
          'x-request-id',
          '809997b8-1c4b-465d-8860-eb406ccf3bcc',
          'x-runtime',
          '0.016154',
          'CF-Cache-Status',
          'DYNAMIC',
          'Report-To',
          '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=oY027imPsu1gAC11LcNq2iOez6%2FltkGW8k5FMW2icdlU0pDeTV9XXOmetMIGNFS7MeoJ9tkPh0eMLSnQE%2FSEwoFXXkCI5r6A4BtEfAzuLeAaD7McNKGAJWTKmtIUe8ASQZFRSYMwj%2Fr7"}],"group":"cf-nel","max_age":604800}',
          'NEL',
          '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}',
          'Server',
          'cloudflare',
          'CF-RAY',
          '84ba815a9a97c390-SEA',
          'alt-svc',
          'h3=":443"; ma=86400'
        ],
        rawTrailers: [],
        joinDuplicateHeaders: undefined,
        aborted: false,
        upgrade: false,
        url: '',
        method: null,
        statusCode: 500,
        statusMessage: 'Internal Server Error',
        client: <ref *1> TLSSocket {
          _tlsOptions: {
            allowHalfOpen: undefined,
            pipe: false,
            secureContext: [SecureContext],
            isServer: false,
            requestCert: true,
            rejectUnauthorized: true,
            session: undefined,
            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: 'omeda.city',
          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: 'omeda.city',
          _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)]: [Function: bound onFinish]
          },
          allowHalfOpen: false,
          _maxListeners: undefined,
          _sockname: null,
          _pendingData: null,
          _pendingEncoding: '',
          server: undefined,
          _server: null,
          ssl: <ref *2> 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(resource_symbol)]: [ReusedHandle]
          },
          _requestCert: true,
          _rejectUnauthorized: true,
          timeout: 5000,
          parser: null,
          _httpMessage: null,
          autoSelectFamilyAttemptedAddresses: [ '2606:4700:3033::6815:5f03:443' ],
          [Symbol(alpncallback)]: null,
          [Symbol(res)]: <ref *2> 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(resource_symbol)]: [ReusedHandle]
          },
          [Symbol(verified)]: true,
          [Symbol(pendingSession)]: null,
          [Symbol(async_id_symbol)]: -1,
          [Symbol(kHandle)]: <ref *2> 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(resource_symbol)]: [ReusedHandle]
          },
          [Symbol(lastWriteQueueSize)]: 0,
          [Symbol(timeout)]: <ref *3> Timeout {
            _idleTimeout: 5000,
            _idlePrev: [TimersList],
            _idleNext: [TimersList],
            _idleStart: 2133,
            _onTimeout: [Function: bound ],
            _timerArgs: undefined,
            _repeat: null,
            _destroyed: false,
            [Symbol(refed)]: false,
            [Symbol(kHasPrimitive)]: false,
            [Symbol(asyncId)]: 543,
            [Symbol(triggerId)]: 541
          },
          [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,
            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: 'omeda.city',
            port: 443,
            agent: undefined,
            nativeProtocols: [Object],
            pathname: '/heroes.json',
            _defaultAgent: [Agent],
            host: 'omeda.city',
            keepAlive: true,
            scheduling: 'lifo',
            timeout: 5000,
            noDelay: true,
            servername: 'omeda.city',
            _agentKey: 'omeda.city:443:::::::::::::::::::::',
            encoding: null,
            keepAliveInitialDelay: 1000
          }
        },
        _consuming: false,
        _dumped: false,
        req: [Circular *4],
        _eventsCount: 4,
        responseUrl: 'https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
        redirects: [],
        [Symbol(shapeMode)]: true,
        [Symbol(kCapture)]: false,
        [Symbol(kHeaders)]: {
          date: 'Fri, 26 Jan 2024 17:34:11 GMT',
          'content-type': 'application/json; charset=UTF-8',
          'content-length': '46',
          connection: 'keep-alive',
          vary: 'Origin',
          'x-request-id': '809997b8-1c4b-465d-8860-eb406ccf3bcc',
          'x-runtime': '0.016154',
          'cf-cache-status': 'DYNAMIC',
          'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=oY027imPsu1gAC11LcNq2iOez6%2FltkGW8k5FMW2icdlU0pDeTV9XXOmetMIGNFS7MeoJ9tkPh0eMLSnQE%2FSEwoFXXkCI5r6A4BtEfAzuLeAaD7McNKGAJWTKmtIUe8ASQZFRSYMwj%2Fr7"}],"group":"cf-nel","max_age":604800}',
          nel: '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}',
          server: 'cloudflare',
          'cf-ray': '84ba815a9a97c390-SEA',
          'alt-svc': 'h3=":443"; ma=86400'
        },
        [Symbol(kHeadersCount)]: 26,
        [Symbol(kTrailers)]: null,
        [Symbol(kTrailersCount)]: 0
      },
      aborted: false,
      timeoutCb: null,
      upgradeOrConnect: false,
      parser: null,
      maxHeadersCount: null,
      reusedSocket: true,
      host: 'omeda.city',
      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: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
          method: 'GET',
          headers: [Object: null prototype] {
            Accept: 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            'x-origin-sdk': 'omedacity-js@0.6.3',
            'User-Agent': 'axios/1.6.5',
            'Accept-Encoding': 'gzip, compress, deflate, br'
          },
          agents: { http: undefined, https: undefined },
          auth: undefined,
          family: undefined,
          beforeRedirect: [Function: dispatchBeforeRedirect],
          beforeRedirects: { proxy: [Function: beforeRedirect] },
          hostname: 'omeda.city',
          port: '',
          agent: undefined,
          nativeProtocols: { 'http:': [Object], 'https:': [Object] },
          pathname: '/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json',
          search: '?hero_ids[0]=2'
        },
        _ended: true,
        _ending: true,
        _redirectCount: 0,
        _redirects: [],
        _requestBodyLength: 0,
        _requestBodyBuffers: [],
        _eventsCount: 3,
        _onNativeResponse: [Function (anonymous)],
        _currentRequest: [Circular *4],
        _currentUrl: 'https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2',
        [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' ],
        'x-origin-sdk': [ 'x-origin-sdk', 'omedacity-js@0.6.3' ],
        'user-agent': [ 'User-Agent', 'axios/1.6.5' ],
        'accept-encoding': [ 'Accept-Encoding', 'gzip, compress, deflate, br' ],
        host: [ 'Host', 'omeda.city' ]
      },
      [Symbol(errored)]: null,
      [Symbol(kHighWaterMark)]: 16384,
      [Symbol(kRejectNonStandardBodyWrites)]: false,
      [Symbol(kUniqueHeaders)]: null
    },
    data: { status: 500, error: 'Internal Server Error' }
  }
}

I tried with a single hero_id in the list to see if there was an issue there, but alas, no difference in error messaging.

Making the request without the params object returns a valid response with all heroes' statistics for the player

@Nixoncole The problem is the query. Sent
https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids[0]=2
and it should
https://omeda.city/players/f7291c56-a6d6-4610-a8b6-628816c9677b/hero_statistics.json?hero_ids=["2"]

Forgive my naivety here, but is this an open source project I could open pull requests against for changes like this?(Obviously with your/your team's permission and reviews)

@dewald-els @Nixoncole
it is necessary to adjust the function of forming request parameters
https://github.com/dewald-els/omedacity-js/blob/main/src/api/index.ts
export const createQueryParams = <T>(params?: T): string => {
  if (!params) return "";

  const query: string[] = [];
  for (const key in params) {
    const param = params[key];

    if (Array.isArray(param)) {
      query.push(key + "=" + encodeURIComponent(JSON.stringify(param)));
    } else if (typeof param === "string" || typeof param === "number") {
      query.push(key + "=" + encodeURIComponent(param));
    } else {
      for (const pKey in param) {
        if (param[pKey] === false) {
          continue;
        }

        if (query.length === 0) {
          query.push("?" + key + "[" + pKey + "]" + "=" + encodeURIComponent(param[pKey]));
        } else {
          query.push(key + "[" + pKey + "]" + "=" + encodeURIComponent(param[pKey]));
        }
      }
    }
  }
  return query.join("&") ?? "";
};```

Forgive my naivety here, but is this an open source project I could open pull requests against for changes like this? (Obviously with your/your team's permission and reviews)

@bslie @dewald-els Please pardon my assumptions; I tried to cut a branch and make a change myself to help, but of course do not have the permissions to push.
Here are the changes I made that made my project work:
/src/api/index.ts:
export const createQueryParams = <T>(params?: T): string => {
  if (!params) return "";

  const query: string[] = [];
  for (const key in params) {
    const param = params[key];

    if (Array.isArray(param)) {
      if (query.length === 0) {
          query.push("?" + key + "=" + JSON.stringify(param));
      } else {
          query.push(key + "=" + JSON.stringify(param));
      }
    } else if (typeof param === "string" || typeof param === "number" || typeof param === "boolean") {
      // TODO: There should be a better way to handle params set to false.
      if (param === false) {
        continue;
      }
      if (query.length === 0) {
          query.push("?" + key + "=" + param);
      } else {
          query.push(key + "=" + param);
      }
    } else {
      for (const pKey in param) {
          if (typeof param[pKey] === "string" || typeof param[pKey] === "number" || typeof param[pKey] === "boolean") {
            // TODO: There should be a better way to handle params set to false.
            if (param[pKey] === false) {
              continue;
            }
            if (query.length === 0) {
                query.push("?" + key + "[" + pKey + "]" + "=" + param[pKey]);
            } else {
                query.push(key + "[" + pKey + "]" + "=" + param[pKey]);
            }
          }
      }
    }
  }
  return query.join("&") ?? "";
};

Summary of this change:

Account for arrays such that they land under a single element of the query parameter
There was inconsistencies in how booleans were handled depending on if they were top level or nested one level down, I simply duplicated the current behavior of adding true query parameters at both levels. (old behavior incorrectly flattened nested booleans into the 'key' of the nested parameter)

I also added the following tests to __tests__/createQueryParams.test.js, with no changes to existing tests necessary:
it("should create a list of strings param", () => {
 const params = createQueryParams({
   ids: ["1", "2", "3"]
 });

 expect(params).toBe("?ids=[\"1\",\"2\",\"3\"]");
});

it("does not add deeply nested objects as parameters", () => {
 const params = createQueryParams({
   filter: {
     include_inactive: 0,
     test_request: true,
     name: "test",
     nestedArray: ["don't", "send"],
     nestedObject: {
       interalBool: true,
       internalString: "shouldn't see"
     }
   }
 });

 expect(params).toBe('?filter[include_inactive]=0&filter[test_request]=true&filter[name]=test');
});

it("do not add 'false' booleans at any level as parameters", () => {
 const params = createQueryParams({
   include: false,
   filter: {
     include_inactive: 0,
     test_request: false
   }
 });

 expect(params).toBe("?filter[include_inactive]=0");
});

it("add 'true' booleans at any level as parameters", () => {
 const params = createQueryParams({
   include: true,
   filter: {
     include_inactive: 0,
     test_request: true
   }
 });

 expect(params).toBe("?include=true&filter[include_inactive]=0&filter[test_request]=true");
});

Summary of added tests:

Test for new functionality of handling arrays as parameters
'Negative test' confirming the behavior of only adding nested parameter values if they are string, boolean, or number
Test confirming createQueryParams does not add false as a query parameter, and instead omit the field (For what it's worth, sending false as a query parameter appears to work the same as not including it, so either way works)
Test confirming createQueryParams correctly adds true values as a query parameter at both levels

I hope this is helpful! Please take or leave any functionality you want, and if you decide to make this more open sourced (or desire contributors) please let me know! I'm happy to help

Thanks for this! @bslie has been kind enough to make a PR. I posted a review with some small changes. Will let you know when it's ready :)

@Nixoncole @bslie 's PR has been merged. The published version 0.6.4 should be available on NPM in the next 15 - 30 mins. Feel free to close the issue once you've confirmed it has been resolved 👍

Awesome, thanks y'all! 🙏
@dewald-els > Yeah! Of course, if you find any issues log it here, and make a PR if you can. You can assign yourself to the issue then
I think the repo is locked down such that I can't cut a branch or contribute in that more traditional sense:
$     git push --set-upstream origin nixoncole/createQueryParams-fix-arrays-and-booleans

remote: Permission to dewald-els/omedacity-js.git denied to Nixoncole.
fatal: unable to access 'https://github.com/dewald-els/omedacity-js.git/': The requested URL returned error: 403

If you're comfortable opening this up to be more public, or extending permissions such that I can contribute I'm really happy to help where I can!

i think if you fork the repo and then submit a Pull Request it should work 🤔 @Nixoncole

authors: Nixoncole bslie dewald-els

repo: dewald-els/omedacity-js


text:
Request

Tambah dashboard admin mas, untuk mengontrol isi dari database-nya 🙏

Bolehh mas, terima kasih untuk sarannya

Bolehh mas, terima kasih untuk sarannya

🙏🙏

source: gharchive/issue

authors: dewanakl eabdalmufid

repo: dewanakl/undangan-api

license: MIT

license_type: permissive

license_source: github-api


text:
Server side rendering & tooling

Nice, je bent aan de slag gegaan met tooling. Je gebruikt verschillende tools en schrijft ook je eigen build scripts.
Alleen werken de build scripts nog niet helemaal nadat er meer dan 1x wordt gebuild? Er wordt niks naar mijn dist folder geschreven als ik npm run build draai ;o?
npm start hoort eigenlijk ook de app in de dist te starten en niet je app in je root (dev omgeving)?
Als tip voor server side rendering zou ik je routing, applicatie logica en domein logica apart schrijven. Ik doe dat met routes, controllers en services.

Feedback verwerkt en toegepast.
Op dit moment als de build script word opgeroepen zal het de dist folder compleet overschrijven waardoor het lijkt dat er niks gebeurt.
Indien de routing complexer gaat worden zal ik deze ook opsplitsen.

authors: dewarian ofahchouch-gh


text:
Risk: missing success-critical stakeholders

#5 Issue by smattingly,
Project success = satisfying the win conditions of all success-critical stakeholders.
Therefore, failure to include one or more success-critical stakeholders creates severe risk of project failure.
Success-critical stakeholders are individuals or groups whose approval is needed for the project to move forward. This includes, but is not limited to, the users, customers, developers, investors, administrators, and those with management, financial, legal, or policy interests.
All such viewpoints must be actively represented by someone who represents the stakeholder, has the knowledge to make decisions, the authority to make commitments, and the time and interest to participate.

Reviewed this date.

Hasn't Changed

reviewed

reviewed

reviewed

reviewed

repo: dewv/project-management-pomodoro


text:
InvalidStateError when Attempting to Update Message Read Status in Dexie 3.2.4

Issue Description
I'm encountering an InvalidStateError with Dexie version 3.2.4 when trying to update the read status of a message in my application's database. The error message suggests an attempt to execute an operation on an objectStore of an IDBTransaction that has already finished. This occurs in a seemingly straightforward operation where I first check if a message exists and then attempt to update its readed status.
Steps to Reproduce
Initialize the database with tables for messages, contacts, and entities. Ensure messages have a unique index on msgId.
Attempt to update a message's readed status by first retrieving the message by its ID and then calling the update method on the tgMessages table.
The error occurs upon executing the update operation, despite the message existing in the database.
Expected Behavior
The message's readed status should be updated without any errors, and the operation should complete successfully within the context of an active transaction.
Actual Behavior
The operation fails with the following error:
InvalidStateError: Failed to execute 'objectStore' on 'IDBTransaction': The transaction has finished.
export class ChatMessageDatabase extends Dexie {
    tgMessages: Dexie.Table<TgMessage, number> = null as any;
    constructor(userId: number) {
        super(`ChatMessageDatabase_userId_${userId}`);

        this.version(1).stores({
            tgMessages: '++id,&msgId,contactId,senderId,receiverId',
        });
        this.tgMessages = this.table('tgMessages');

async updateMessageReaded(message: TgMessage) {
    try {
        await this.transaction('rw', this.tgMessages, async () => {
            const msg = await this.tgMessages.get(message.id);
            if (msg) {
                await this.tgMessages.update(message.id, { readed: true });
                console.log('Successfully updated message read status', message);
            } else {
                console.log('Message not found');
            }
        });
    } catch (err) {
        console.error('Failed to update message read status', err);
    }
}

Additional Context
Dexie version: 3.2.4
Browser: [Include browser name and version]
The issue occurs consistently when attempting to update any message's readed status.
The database initialization and update operation are part of an application managing chat messages.
I have tried several approaches to ensure the operation executes within an active transaction context, including wrapping the operation in a this.transaction call, but the error persists.
I use the following code which works fine:
async updateMessageReadedDirectly(message: TgMessage) {
        return new Promise((resolve, reject) => {
            const request = indexedDB.open(this.name);
            request.onerror = function (event) {
                reject('Database open error');
            };
            request.onsuccess = function (event) {
                //@ts-ignore
                const db = event.target.result;
                const transaction = db.transaction(['tgMessages'], 'readwrite');
                const store = transaction.objectStore('tgMessages');
                const getRequest = store.get(message.id);

                getRequest.onsuccess = function () {
                    const data = getRequest.result;
                    data.readed = message.readed;
                    const updateRequest = store.put(data);
                    updateRequest.onsuccess = function () {
                        resolve('Update success');
                    };
                    updateRequest.onerror = function (event: any) {
                        reject('Update failed');
                    };
                };

                getRequest.onerror = function (event: any) {
                    reject('Get failed');
                };
            };
        });
    }

Any insights or suggestions on how to resolve this error would be greatly appreciated.

Is the error happening on a real browser or in a unit test? What browser engine and version are you using? Reason I ask is because unit tests usually use fakeIndexedDB or indexedDBShim which cannot survive transactions between awaits, just like browsers had problem with for a while ago.

If the case is an old browser, fakeIndexedDB or indexedDBShim, one solution is to transpile the code to ES2016 (before await was introduced).

authors: asuradoll dfahlander


text:
Export just a DataFrame - not just the whole notebook

Really useful package. It works well for me. One thing I would be interested in doing is exporting just the Dataframe - not the entire notebook. Is that a potential option or is that way outside the scope of this project?
Thanks again for the package.

That's definitely in scope and something I've been meaning to add to it. I have a pretty big update coming with the next release of this package.
I could probably add it using the register api. Let me experiment and update what I come up with here.

Just added this functionality and it will be in the next release. Great idea! And thanks for tuning me into pandas accessor API.
Here's the link for anyone who randomly stumbles upon this issue - https://pandas.pydata.org/docs/reference/api/pandas.api.extensions.register_dataframe_accessor.html


text:
Кондиционер

Приветствую,
Яндекс видит кондиционер как термостат, это можно как-то изменить?
Спасибо

Да. Прописать тип devices.types.thermostat.ac в ямле: https://docs.yaha-cloud.ru/v0.6.x/config/entity/#type


text:
Bow crashing when used

panic: interface conversion: world.Item is nil, not item.Arrow [recovered]
        panic: interface conversion: world.Item is nil, not item.Arrow

goroutine 28 [running]:
github.com/df-mc/dragonfly/server/session.(*Session).handlePackets.func1()
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/session.go:303 +0x74
panic({0x1178c60, 0xc00511e330})
        C:/Program Files/Go/src/runtime/panic.go:884 +0x212
github.com/df-mc/dragonfly/server/item.Bow.Release({}, {0x1391558, 0xc0019482c0}, 0x51c2ac58, 0xc0046fa0b0)
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/item/bow.go:60 +0xbe5
github.com/df-mc/dragonfly/server/player.(*Player).ReleaseItem(0xc0019482c0)
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/player/player.go:1400 +0x2a2
github.com/df-mc/dragonfly/server/session.(*InventoryTransactionHandler).handleReleaseItemTransaction(...)
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/handler_inventory_transaction.go:154
github.com/df-mc/dragonfly/server/session.(*InventoryTransactionHandler).Handle(0x116d3e0?, {0x1382bb0?, 0xc004690fa0?}, 0xc0004d0600)
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/handler_inventory_transaction.go:46 +0x1b3
github.com/df-mc/dragonfly/server/session.(*Session).handlePacket(0xc0004d0600, {0x1382bb0, 0xc004690fa0})
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/session.go:424 +0x9b
github.com/df-mc/dragonfly/server/session.(*Session).handlePackets(0xc0004d0600)
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/session.go:312 +0xef
created by github.com/df-mc/dragonfly/server/session.(*Session).Start
        C:/Users/jonat/go/pkg/mod/github.com/df-mc/dragonfly@v0.8.11-0.20221222044455-cc384fc61224/server/session/session.go:217 +0xa5
exit status 2

Did some more testing and this only occurs when you are in creative and you dont have a arrow in your inventory

repo: df-mc/dragonfly


text:
dexie-cloud: cloud  sync flickering

Hi, i'm implementing treeview base on dexie as a model;
locally all fine.
but in cloud mode there is some issues with  tree duplication
and with multi select nodes;
code:
duplicateTree = async (treeId: string) => {
    return await this.transaction("rw", this.trees, this.treesItems, async () => {
      if (!await this._canAddTree()) return;
      // check if exist
      const currentTree = await treesDB.trees.get(treeId);
      if (!currentTree) return;
      // create new Tree with no treeItems
      const { treeName } = currentTree;
      const newTreeId = await this.createNewTree(`${treeName}-copy`, false, currentTree);
      if (!newTreeId) return false;

      // get all items from current tree
      const coll = await this.getAllTreeItemsCollection(treeId);
      const idsMap: any = {};

      // iterate over them and add each with the new treeId
      await coll.each(async (item) => {
        const newNodeId = await this.treesItems.add({ ...item, treeId: newTreeId, id: undefined as any });
        idsMap[item.id] = newNodeId;
      });

      const newTreeColl = await this.getAllTreeItemsCollection(newTreeId);
      await newTreeColl.modify((item, ref) => {
        const { parentPath } = item;
        // fix parrentPath with new ids
        const newParentPath = parentPath.split("/").map(_ => idsMap[_]).join("/")
        const newItem = { ...item, parentPath: newParentPath };
        ref.value = newItem;
      })
    })
  }

sorry about the mess with github etidor;
her is my repo:
https://github.com/maor700/trees-creator
and this is the app online:
https://trees-creator.vercel.app/
thanx

Thanks for a nice sample. I could successfully use your deployed app and create trees and duplicate them. However, I didn't find a way to reproduce the issue. Not sure if I understand how the bug manifest itself. Maybe need a way to trigger db.cloud.login() to reproduce the issue?
I've fixed a lot of issues in the latest versions of dexie@next (3.2.0-beta.2) and dexie-cloud-addon@latest (1.0.0-beta.3) that was published last night. Try yarn add dexie@next dexie-cloud-addon@latest dexie-react-hooks@latest to make sure you have the latest versions.
Would it be possible to deploy a new version of the app that can be used to reproduce the issue (with a login button or similar)?
Kind regards
David

Thank you David.
I really appreciate your efforts to help me these days ...
You're right, the issues only appear in "logged-in" mode so I added the login btn again.
Anyway, I upgraded the packages as you recommended.
You can try again on the same page:
https://trees-creator.vercel.app/
List of issues:

Duplication does not work.
Multi-select flickering when you select everything and deselects a specific node and tries to re-select everything.
Synchronization of two clients works, but very quickly does not

Thanks! This is a good repro. I will troubleshoot it and come back. Might take some time as I will be traveling this week. Probably able to trace it down until some time next week.

I was able to find an issue with request queueing that was hit when duplicating a tree on a synced table. I am not able to verify if this solves this issue in whole right now (just took the chance to look at it during morning coffee at a hotel) but the issue that was solved was definitely a bug so if we're lucky this could take us one step further. Will continue looking at it next week. The issue I found is resolved in dexie-cloud@1.0.0-beta.5.

Wow! Don't sucrefice you vication for that.
When beta 5 will be released?

I'm too curious to find out what it could be. Found a bug and released beta 5 this morning so you could try it. But I don't know if it fixed the issues as there might be more bugs around the case that happens in your .each() callback - it needs to queue up the requests and that part was obviously not tested before. Either this was fixed on its whole with beta.5 or there are other issues to solve there. If still issue to duplicate trees with beta.5 you could also work around this bug by using toArray() instead of each () and then do a bulkAdd() instead from the result (after mapping it). This would avoid forcing the framework to queue up requests.

This morning I was able to debug the "flickering" issue as well, which turned out to be a bug on the server for comparing array keys. I've published an updated cloud service with the issue fixed. It seems also that dexie-cloud-addon 1.0.0-beta.5 did fix the tree duplication issue. So it seems both bugs are gone now. Please confirm when you have a chance.

I updated the version, and as you said it did solve the issues.
Thank you so much for this wonderful product.
An unrelated question, when two clients on the same user become offline and make local changes when they go back online how does the cloud decide what to do with the different versions? Unite them? Taking the latest? What happens when there is conflict? This is a serious problem.

license_source: bigquery


text:
fix(agent): Check subnet canister ranges

Description
We were missing checks that ensured that responses were signed by the correct subnet.
In detail, when the user reads the state of a canister C, the IC returns a state tree in a response Resp. To ensure the integrity of the Resp, the state tree must be signed. It can be signed directly by the root key of the IC, or by a different key (in particular, a subnet key) that is certified by the IC root key through a (possibly nested) delegation. Such delegations are scoped, and valid only for certain canister ranges. For Resp to be valid, C has to be included in the ranges of all the delegations, but this check was missing. See:
https://internetcomputer.org/docs/current/references/ic-interface-spec/#certification
https://internetcomputer.org/docs/current/references/ic-interface-spec/#http-read-state
https://internetcomputer.org/docs/current/references/ic-interface-spec/#canister-signatures
Fixes SDK-315
How Has This Been Tested?
Unit tests
Checklist:

[X] My changes follow the guidelines in CONTRIBUTING.md.
[X] The title of this PR complies with Conventional Commits.
[X] I have edited the CHANGELOG accordingly.
[X] I have made corresponding changes to the documentation.

Note that the same check is missing in agent-rs.

The check was added to agent-rs in https://github.com/dfinity/agent-rs/pull/312

One note as I'm starting to review this - while I agree that this change should go out under 0.12.0, our release process for this project is to defer bumping package.json versions until we initiate the release, handling that in a dedicate PR.
I'll go ahead and clean that up, which should also remove some overhead in the changed files view

source: gharchive/pull-request

authors: krpeacock oggy-dfin

repo: dfinity/agent-js


text:
Machine readable info

First off, thank you for a useful project.
I used to use wasm-nm (src) to get the symbol table from a Wasm file.  It's basically the UNIX nm but for Wasms.  Unfortunately wasm-nm is unmaintained and doesn't work on recent Wasm files that have new instructions.
Thankfully ic-wasm info also provides the list of exported functions and it works with recent wasms, so that is great.  My only minor gripe is that the output is not very machine readable.  I have to parse it with sed and if ever you change the format, those sed scripts might well break.
Would you be open to providing a machine readable output?  For example, ic-wasm info --json so that the output can be parsed with jq?
If so, I would be happy to provide a PR to do this.  I would propose to gather all the info collected here into a struct.  On that struct I would have a to_string() method that provides output identical to the current output.  I would then add the option of serializing that struct as JSON instead.
What do you think?

Sounds good to me. The current output is for human only, so we don't even need to keep the current format. Feel free to adjust the format as you see fit.

authors: bitdivine chenyan-dfinity

repo: dfinity/ic-wasm


text:
fix: add missing chars for code block in pocket-ic.md

Thank you for your contribution to the IC Developer Portal.
Before submitting your Pull Request, please make sure that:

[ ] You have updated the .github/CODEOWNERS file according to your changes.
[ ] You have registered new documents to /sidebars.js if any.

Dear @ravibazz,
In order to potentially merge your code in this open-source repository and therefore proceed with your contribution, we need to have your approval on DFINITY's CLA.
If you decide to agree with it, please visit this issue and read the instructions there. Once you have signed it, re-trigger the workflow on this PR to see if your code can be merged.
— The DFINITY Foundation

thank you for the contribution @ravibazz !

repo: dfinity/portal


text:
fix: ci issues

Description
CI failed on audit:ubuntu and build_dfx:ubuntu jobs, as in these runs:

https://github.com/dfinity/sdk/actions/runs/3621249143/jobs/6105685766
https://github.com/dfinity/sdk/actions/runs/3621249142/jobs/6105659892

How Has This Been Tested?
CI

Mirrored in #2804

repo: dfinity/sdk


text:
Function autocorr.integrated_time() missing "window" keyword argument

It looks like when the autocorr.integrated_time() function was updated recently, the "window" keyword was removed. However, this function is still called with "window=50" as an argument in both ensemble.py and mh.py.
The keyword error was triggered for me using the example script quickstart.py.

This should be fixed in v2.2.1 that was just pushed. Sorry about that!

authors: dfm turnerm

repo: dfm/emcee

license: mit


text:
ttttttt to 0.0.1

Promote ttttttt to version 0.0.1

[APPROVALNOTIFIER] This PR is NOT APPROVED
This pull-request has been approved by:
To fully approve this pull request, please assign additional approvers.
We suggest the following additional approvers:
If they are not already assigned, you can assign the PR to them by writing /assign  in a comment when ready.
The full list of commands accepted by this bot can be found here.
The pull request process is described here

Needs approval from an approver in each of these files:

OWNERS

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

repo: dg-bee/environment-painterember-staging


text:
Version number formatting > yy/mm/dd

@dgibbs64 Little tweak and low priority : Thought instead of formatting version numbers dd/mm/yy, could be yy/mm/dd , that way the number would be incremental, which would make more sense.
If you think it sucks, just close, otherwise, please assign yourself or me to it.

Never thought about it. There is no requirement to do this yet as the version numbers are only for reference currently so doesn't currently matter. However if required in the future we can change it.


text:
Image and binary difference/change support

it should eventually give you something like

with

via https://www.pyimagesearch.com/2017/06/19/image-difference-with-opencv-and-python/

[x] fetch binary/images without error
[x] basic test for fetching binary and detect when it changes
[x] check the saving mechanism is saving the binary correctly
[x] implement the actual image diff engine
[x] implement a way to select different files in the 'history' diff/preview tab
[ ] add a unit test that ensures the diff generated
[ ] even more pytest tests
[ ] make the layout nice

Is there a plan for when this PR will be merged? Or is there something I can help with?

Hi, Is there any update on this PR? This would be very helpful!


text:
Fix Feed URL

Refer - http://dharmit.github.io/atom.xml
At present its use default example.com which breaks my feedly :(
<entry>
<title>
Using Ansible conditionals to avoid repetitive downloads
</title>
<link href="http://example.com/blog/2016/04/08/ansible-register-when-avoid-downloads.html"/>
<updated>2016-04-08T00:00:00+00:00</updated>
<id>
http://example.com/blog/2016/04/08/ansible-register-when-avoid-downloads
</id>

@MiteshShah Many thanks for this! :+1:

authors: MiteshShah dharmit


text:
various changes (see 1st comment)

Here are the changes I'd like to submit:

RFC7283 to informative reference (was obsoleted by 8415, can't keep it as normative, as idnits treats it as an error)
added list of deprecated mechanisms in 8415 (there is a similar list for 8415bis)
typo (gleaming => gleaning)
added text what to do if IA_TA is received (ignore option, continue message processing)

Updated the IA_TA processing as discussed over mail (MUST => SHOULD).

license: Unlicense


text:
V0.9.7

Hi dheijl,
I install and try your new release.. And when I changed LOG level or Input Source, I can't see a Restart Button.
Another thing, I do not see the usefulness of the SSDP discovery at regular and adjustable interval, I think that in a classic use, it would be more useful to just put a button to restart the SSDP discovery. When I use swyh-rs on a renderer that is already active and that I turn on my tv for example, it is easier for me to manually search for my tv rather than wait for automatic discovery.. Anyway it works well, but if I start swyh-rs, ssdp discovery find my Harmann I start th stream, then after a moment I start my TV, the GUI give me :

Sorry but always GUI bug.. But nothung serious..
Have a nice day..

Ah yes also a little thing that I wanted to tell you, it is to make an automatic return to line in the info window so as not to have to do a side translation to see all the info..   ;-)

Yes, resizing is not handled properly because there is currently no way that I can see in fltk-rs to handle resizing. The restart button is to the right of the window and thus invisible in your screenshot. I will have to think about the resizing problem, and the gui layout in general for that matter.

In fullscreen mode I haven't restart button..

And at the minimal size.. ;-)

It has "fallen off" the window and is not visible. Has to do with screen resolution and a windows font size > 100 %...

My screen resolution is 1280X800 at maximum .. I did not quite understand what to do as a modification in the display settings ?

The restart button is now replaced with a pop-up.
You do not have to do anything, the problem is in the fltk-rs library, it does not expose the native fltk screen_scale() and screen_dpi() functions, and that makes GUI layout difficult for different screen sizes and screen resolutions (dpi).

Resizing is a little bit better now, but I don't see how to get it right with the current FLTK version (widgets get resized vertically too, no anchors, no layouts...).

Hi, I try V1 but at minimal size I have :

and at fullscreen

It's not really better for me, sorry.. FLTK seems quite restrictive indeed.

Thanks to @MoAlyousef resizing is now much better (V1.0.1), but you can still lose the horizontal scrollbar at the bottom ...

repo: dheijl/swyh-rs


text:
GraphQL to RDF-OWL?

Have you considered reversing the process and converting GraphQL (SDL) to RDF-S or OWL? (Would need Subclassing to handle GraphQL Type inheritance)

Hi @peterdresslar
I'm considering it right now :)
I believe it would be easier to convert from GraphQL than the inverse.
We could start by loading the schema into memory then handle the javascript objects to create the classes and subclasses.
rdfs:subClassOf would then be needed indeed for the GraphQL implements keywords.
Cheers,

@dherault I think it would be quite useful in a number of cases. For my particular use case I am hoping to migrate from SDL to OWL specifically, but it is easy to imagine working from GraphQL objects or even an introspection result. I'd be happy to help out.

If you happen to write a documentation on the subject please put it here and/or PR a README.md update or a GRAPHQL_TO_OWL.md file with a link on the readme.
Thanks,

Will do a new file--there seem to be two major approaches that could be taken, and that choice will drastically affect the README

Deeply WIP, but also very interesting to think about:
https://github.com/peterdresslar/semantic-graphql/blob/GraphQL-to-Semantic/GRAPHQL_TO_OWL_NOTES.md

authors: dherault peterdresslar

repo: dherault/semantic-graphql


text:
Check TODO: items in source

some questions, some suggested changes... some for discussion

TODO:do some valid keywords have only one part, or should we ignore them as invalid
If a keyword only have one part, it is still valid, it just means that it doesn't have a corresponding English translation in the document.

one questions like this are answered, feel free to remove the corresponding TODO at your convenience

// TODO: if just installed, how can there be triggers in local storage?

https://github.com/dhowe/ChinaEye/pull/31/commits/f370d7880978661f664f7972f8d374fb16ad7ced

// TODO: make sure that our style tag is not being added multiple times on the same page

https://github.com/dhowe/ChinaEye/pull/31/commits/f7fad0580fef36b862c8e02fe0e6ba0dd0bae0e4
all done, please check.

repo: dhowe/ChinaEye


text:
Feature/add staged files selection

I have added a multi-selection feature that allows users to choose which files to commit when they don't want to stage all of them. This change gives users more control over the staging process and makes it easier to manage commits. 🚀💻👨💻

done @di-sukharev

@vladickweb bro, let's merge it when you agree with the changes ;)

@vladickweb bro, let's merge it when you agree with the changes ;)

done! @di-sukharev

authors: di-sukharev vladickweb

repo: di-sukharev/opencommit


text:
Add Windows Support

We should support Windows!

[ ] Add DirectShow webcam driver to camera package
[ ] Ensure ansi package works with common Windows terminals
[ ] Compile for windows and distribute binaries
[ ] Update Makefile and install.sh with Windows support

I don't have a PC so I can't finish this one. Hoping someone else can take this on.

repo: dialup-inc/ascii


text:
Enable redirecting http traffic to secured upstream servers

Currently only http upstream servers can be used. This will require to also change the external interface configuration form in MI's cloud views and atmosphere's REST API to convey the additional attribute saying if the upstream server is secured with https.

With @dharezlak we performed test where https->proxy->https->vm communication was established.
Redirus is ready for such change. Options capability can be used to distinguish if http or https should be used in proxy_pass directive. The only thing needed here is to change templates.
Atmosphere on the other hand need to be changed to support this feature. Boolean value should be added into Port Mapping Template (e.g. upstream_https) and this value should be converted into option while sending request into Redirus.

@nowakowski, @tbartynski this task priority should be increased. In plgrid we have a situation where https->https communication should be established.
Another solution of the problem would be to:

remove https/https PortMappingTemplate type, only http OR https
redirus will establish http->http or https->https communication.

What is your opinion?

Can we establish https->https without triggering a MIM-type situation?

Yeap, I was able to establish such connection before creating this issue. To be 100% sure we can recreate such situation on Monday :smile:

That's good news. I like the idea of removing HTTP and HTTPS; IMHO this option never made much sense. :)

I have mixed filings about it. On one hand you are right, for user it is quite strange that https->http connections are created. On the other hand https->http is much faster than https->https and we can treat inter tenant communication as "safe".

@mkasztelnik I fully agree; what I was trying to say is that it's weird to have both an HTTP and an HTTPS redirection to an application service (you'll typically want one or the other); hence this menu option is confusing and could be removed.

authors: dharezlak mkasztelnik nowakowski

repo: dice-cyfronet/atmosphere


text:
Fix for #191

This pull request also does the following:

Fix the same issue with the countLines method, although it's a quite simple fix for that method.

For this I've added the getLineEnding method, which returns the used line separator of a file.

Add better tests.

please resolve conflicts

Please request an review from @Clueliss  when ready.

Conflicts have to be resolved and the documentation now needs checked and maybe updated now, because the behaviour of the FileSeparatorQuerySource has been changed.

[ ] update documentation
[ ] resolve conflicts

I had a short look at some of the failing tests. They seem to be due to leading/trailing whitespaces/new line characters in tests that were removed before but are kept now.

authors: bigerl nck-mlcnv

repo: dice-group/IGUANA