S3.GetObject no longer returns the result as a string #1877

igilham · 2021-01-06T09:50:13Z

Describe the bug
I'm using the GetObjectCommand with an S3Client to pull a file down from S3. In v2 of the SDK I can write response.Body.toString('utf-8') to turn the response into a string. In v3 of the SDK response.Body is a complex object that does not seem to expose the result of reading from the socket.

It's not clear if the SDK's current behaviour is intentional, but the change in behaviour since v2 is significant and undocumented.

SDK version number
3.1.0

Is the issue in the browser/Node.js/ReactNative?
Node.js

Details of the browser/Node.js/ReactNative version
v12.18.0

To Reproduce (observed behavior)

import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';

export async function getFile() {
  const client = new S3Client({ region: 'eu-west-1' });
  const cmd = new GetObjectCommand({
    Bucket: 'my-bucket',
    Key: '/readme.txt',
  });
  const data = await client.send(cmd);

  console.log(data.Body.toString('utf-8'));
}

Expected behavior
It should print the text of the file.

Additional context

data.Body is a complex object with circular references. Object.keys(data.Body) returns the following:

[
  "_readableState",
  "readable",
  "_events",
  "_eventsCount",
  "_maxListeners",
  "socket",
  "connection",
  "httpVersionMajor",
  "httpVersionMinor",
  "httpVersion",
  "complete",
  "headers",
  "rawHeaders",
  "trailers",
  "rawTrailers",
  "aborted",
  "upgrade",
  "url",
  "method",
  "statusCode",
  "statusMessage",
  "client",
  "_consuming",
  "_dumped",
  "req"
]

The text was updated successfully, but these errors were encountered:

trivikr · 2021-01-06T16:01:32Z

This happens as data.Body is now of type Readable | ReadableStream | Blob

aws-sdk-js-v3/clients/client-s3/models/models_0.ts

Line 6560 in 25cb359

Body?: Readable | ReadableStream | Blob;

For your specific example, you can write a streamToString function to convert ReadableStream to a string.

const { S3Client, GetObjectCommand } = require("@aws-sdk/client-s3");

(async () => {
  const region = "us-west-2";
  const client = new S3Client({ region });

  const streamToString = (stream) =>
    new Promise((resolve, reject) => {
      const chunks = [];
      stream.on("data", (chunk) => chunks.push(chunk));
      stream.on("error", reject);
      stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
    });

  const command = new GetObjectCommand({
    Bucket: "test-aws-sdk-js-1877",
    Key: "readme.txt",
  });

  const { Body } = await client.send(command);
  const bodyContents = await streamToString(Body);
  console.log(bodyContents);
})();

@igilham Does this resolve your query?

igilham · 2021-01-06T17:05:18Z

Thanks, @trivikr. This works in my application but raises a few concerns about the library that are worth sharing:

There is no documentation for clients and the GetObjectCommand is not documented in the user guide or sample code. The project Readme file implies I could expect the same behaviour as SDKv2.
My IDE can't tell me what the type of response.Body is. It tells me that it's any. Perhaps the library configuration could be improved to export the correct type information.
It's nice to have options for data processing, but I shouldn't be forced to write boilerplate I/O code for the most common use case.
As noted below, I can't find an export of ReadableStream and Blob so it appears to be impossible to make this code type-safe.

For reference, I've rewritten the streamToString with the missing types added back in to comply with my team's linter settings.

import { Readable } from 'stream';

// Apparently the stream parameter should be of type Readable|ReadableStream|Blob
// The latter 2 don't seem to exist anywhere.
async function streamToString (stream: Readable): Promise<string> {
  return await new Promise((resolve, reject) => {
    const chunks: Uint8Array[] = [];
    stream.on('data', (chunk) => chunks.push(chunk));
    stream.on('error', reject);
    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
  });
}

trivikr · 2021-01-06T17:21:27Z

There is no documentation for clients and the GetObjectCommand is not documented in the user guide or sample code. The project Readme file implies I could expect the same behaviour as SDKv2.

Documentation for getObject operation lists that GetObjectOutput.Body is Readable | ReadableStream | Blob
API Reference: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-s3/classes/s3.html#getobject

Screenshot

My IDE can't tell me what the type of response.Body is. It tells me that it's any. Perhaps the library configuration could be improved to export the correct type information.

I'm using Visual Studio Code, and it shows type of response.Body as internal.Readable | ReadableStream<any> | Blob on hover.

Please create a new issue with details of your IDE and code if problem persists.

Screenshot

trivikr · 2021-01-06T17:33:43Z

As noted below, I can't find an export of ReadableStream and Blob so it appears to be impossible to make this code type-safe.

For reference, I've rewritten the streamToString with the missing types added back in to comply with my team's linter settings.

import { Readable } from 'stream';

// Apparently the stream parameter should be of type Readable|ReadableStream|Blob
// The latter 2 don't seem to exist anywhere.
async function streamToString (stream: Readable): Promise<string> {
  return await new Promise((resolve, reject) => {
    const chunks: Uint8Array[] = [];
    stream.on('data', (chunk) => chunks.push(chunk));
    stream.on('error', reject);
    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
  });
}

As this code is run on Node.js, you can pass Body as Readable as follows:

const bodyContents = await streamToString(Body as Readable);

igilham · 2021-01-06T17:39:05Z

Thanks for following up.

I didn't realise the methods and types were documented. I took the description on the client landing page (go to the README) to mean it was a dead-end. Perhaps improving the wording should be a separate issue.

I can't explain the IDE issue. I'm also on VSCode and it says it's an any. I find the IDE quite unstable though, so maybe it's just me.

trivikr · 2021-01-06T17:54:26Z

I didn't realise the methods and types were documented. I took the description on the client landing page (go to the README) to mean it was a dead-end. Perhaps improving the wording should be a separate issue.

I've created documentation update request at #1878

igilham · 2021-01-07T09:49:42Z

Thanks. I think that covers my remaining frustrations. I appreciate that it can take time for documentation elsewhere to catch up when a major version is released.

leimd · 2021-01-21T06:07:36Z

The codesnippet works in Node.js environment, in the browser, you would have a ReadableStream instead of Readable.

Here is my implementation of handling the ReadableStream:

const streamToString = (stream) => {
  return new Promise((resolve, reject) => {
    if (stream instanceof ReadableStream === false) {
      reject(
        "Expected stream to be instance of ReadableStream, but got " +
          typeof stream
      );
    }
    let text = "";
    const decoder = new TextDecoder("utf-8");

    const reader = stream.getReader();
    const processRead = ({ done, value }) => {
      if (done) {
        // resolve promise with chunks
        console.log("done");
        // resolve(Buffer.concat(chunks).toString("utf8"));
        resolve(text);
        return;
      }

      text += decoder.decode(value);

      // Not done, keep reading
      reader.read().then(processRead);
    };

    // start read
    reader.read().then(processRead);
  });
};

ffxsam · 2021-01-28T23:56:13Z

@trivikr Thanks for that link to the docs! I didn't even know they existed till just now.

lambrospetrou · 2021-02-09T19:33:17Z

The codesnippet works in Node.js environment, in the browser, you would have a ReadableStream instead of Readable.

Here is my implementation of handling the ReadableStream:

const streamToString = (stream) => {
  return new Promise((resolve, reject) => {
    if (stream instanceof ReadableStream === false) {
      reject(
        "Expected stream to be instance of ReadableStream, but got " +
          typeof stream
      );
    }
    let text = "";
    const decoder = new TextDecoder("utf-8");

    const reader = stream.getReader();
    const processRead = ({ done, value }) => {
      if (done) {
        // resolve promise with chunks
        console.log("done");
        // resolve(Buffer.concat(chunks).toString("utf8"));
        resolve(text);
        return;
      }

      text += decoder.decode(value);

      // Not done, keep reading
      reader.read().then(processRead);
    };

    // start read
    reader.read().then(processRead);
  });
};

I also wasted lots of time on GetObject and the trifecta of its types. Also, the fact that ReadableStream | Blob is only Browser, and Readable only Node made it extremely annoying :)

The streamToString solution posted above works for Node.
For the browser, I found that using the Response object from fetch seems a shorter solution:

new Response(response!.body, {});

This will return a Response object which will then allow us to use any of the helper methods it has to convert to String, Buffer, Json, etc. See more at https://developer.mozilla.org/en-US/docs/Web/API/Response#methods.

Full example:

const s3 = new S3({
  region: "us-east-1",
  credentials: {
    accessKeyId: "replace-it",
    secretAccessKey: "replace-it",
  },
});
const resp = await s3.getObject({
  Bucket: "your-bucket",
  Key: "your-object-key",
});
console.info(await new Response(resp.Body, {}).text())

It's quite unfortunate that everybody has to go through these hoops to get the content out of the response though. Especially considering that we have to do type checking with things like if (resp.Body instanceof Readable), or declare special interfaces to avoid differences between browser/Node.

smiccoli · 2021-02-10T12:55:02Z

The codesnippet works in Node.js environment, in the browser, you would have a ReadableStream instead of Readable.
Here is my implementation of handling the ReadableStream:
const streamToString = (stream) => {
  return new Promise((resolve, reject) => {
    if (stream instanceof ReadableStream === false) {
      reject(
        "Expected stream to be instance of ReadableStream, but got " +
          typeof stream
      );
    }
    let text = "";
    const decoder = new TextDecoder("utf-8");

    const reader = stream.getReader();
    const processRead = ({ done, value }) => {
      if (done) {
        // resolve promise with chunks
        console.log("done");
        // resolve(Buffer.concat(chunks).toString("utf8"));
        resolve(text);
        return;
      }

      text += decoder.decode(value);

      // Not done, keep reading
      reader.read().then(processRead);
    };

    // start read
    reader.read().then(processRead);
  });
};
I also wasted lots of time on GetObject and the trifecta of its types. Also, the fact that ReadableStream | Blob is only Browser, and Readable only Node made it extremely annoying :)

The streamToString solution posted above works for Node.
For the browser, I found that using the Response object from fetch seems a shorter solution:
new Response(response!.body, {});
This will return a Response object which will then allow us to use any of the helper methods it has to convert to String, Buffer, Json, etc. See more at https://developer.mozilla.org/en-US/docs/Web/API/Response#methods.

Full example:
const s3 = new S3({
  region: "us-east-1",
  credentials: {
    accessKeyId: "replace-it",
    secretAccessKey: "replace-it",
  },
});
const resp = await s3.getObject({
  Bucket: "your-bucket",
  Key: "your-object-key",
});
console.info(await new Response(resp.Body, {}).text())
It's quite unfortunate that everybody has to go through these hoops to get the content out of the response though. Especially considering that we have to do type checking with things like if (resp.Body instanceof Readable), or declare special interfaces to avoid differences between browser/Node.

the use of Response looks as the neatest solution right now, for json and text payloads.

ffxsam · 2021-02-10T15:56:54Z

I've been running into these pain points as well, including Lambda invocation. The payload returned is now a Uint8Array, so it takes a few hoops to get it into a usable format:

const payload = JSON.parse(Buffer.from(data.Payload).toString());

Whereas in the previous JS SDK, it was simply:

const payload = JSON.parse(data.Payload);

I don't understand this new direction with the SDK. I can't say I'm a fan. Maybe @trivikr can weigh in.

trivikr · 2021-02-10T16:37:17Z

Reopening as lot of customers have raised questions.
Tagging @AllanZhengYP for comment.

moltar · 2021-03-06T16:18:59Z

export interface GetObjectOutput {
    /**
     * <p>Object data.</p>
     */
    Body?: Readable | ReadableStream | Blob;

  // ... snip
}

This is throwing an error in a NodeJS app, because TS config does not load DOM libs.

This results in the Body being set to any.

kennu · 2021-03-08T19:51:32Z

I'm also very confused about how to read S3 Body responses with SDK v3. The SDK documentation for GetObjectCommand does not describe how to do it, and the SDK examples are also missing it (awsdocs/aws-doc-sdk-examples#1677).

I would ask the AWS SDK team to include in the SDK a simple way to read S3 Body responses. We don't want to re-implement complicated event handlers and helper functions for this simple purpose every time we use GetObject in a project.

In v2 we could just say something like JSON.parse(response.Body?.toString()). Please make it as simple in v3. Stream-based processing is also important, but it should be only an alternative for the simple case for parsing small JSON objects.

For reference, I was able to do this in Node.js by utilizing node-fetch. I would like something like this be included in AWS SDK.

npm install node-fetch
npm install --save-dev @types/node-fetch

import { Response } from 'node-fetch'

const response = new Response(s3Response.Body)
const data = await response.json()

m-radzikowski · 2021-03-15T19:35:18Z

A one-line alternative is to use get-stream package, as posted here: #1096 (comment)

I understand the reason for returning a ReadableStream, but a built-in helper method would be nice. Reading the whole body into string in memory is probably good for 99% of cases.

If some helper method would be a part of the SDK we could just call it as readStream(response.Body) and everyone would be happy not having to add another dependency or 10 lines of boilerplate code to every new project.

kuhe · 2022-10-21T17:45:55Z

This is now documented in the root readme with an example: https://github.com/kuhe/aws-sdk-js-v3/tree/main#streams

You do not need to import sdkStreamMixin explicitly. As of that version It is applied to stream objects in command outputs.

import { S3 } from "@aws-sdk/client-s3";

const client = new S3({});

const getObjectResult = await client.getObject({
  Bucket: "...",
  Key: "...",
});

// env-specific stream with added mixin methods.
const bodyStream = getObjectResult.Body; 

// one-time transform.
const bodyAsString = await bodyStream.transformToString();

// throws an error on 2nd call, stream cannot be rewound.
const __error__ = await bodyStream.transformToString();

sfwhite · 2022-10-21T17:58:31Z

So it looks like going by the latest PR: https://github.com/aws/aws-sdk-js-v3/pull/3977/files

The recommended way to do this is now:

import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
import { sdkStreamMixin } from '@aws-sdk/util-stream-node';

const s3Client = new S3Client({});
const { Body } = await s3Client.send(
  new GetObjectCommand({
    Bucket: 'your-bucket',
    Key: 'your-key',
  }),
);
const objectString = await sdkStreamMixin(Body).transformToString(); // this throws if Body is undefined

Took two solid years, but hey, we have an official solution..

zbagley · 2022-10-21T23:57:01Z

@sfwhite Thanks for the heads up on the throw. @kuhe Glad to see this in, and it probably would be useful in the docs to notate (in general) this should be a try { ... } catch { ... } for most use cases.

samchungy · 2022-10-22T00:07:31Z

This is now documented in the root readme with an example: https://github.com/kuhe/aws-sdk-js-v3/tree/main#streams

You do not need to import sdkStreamMixin explicitly. As of that version It is applied to stream objects in command outputs.
import { S3 } from "@aws-sdk/client-s3";

const client = new S3({});

const getObjectResult = await client.getObject({
  Bucket: "...",
  Key: "...",
});

// env-specific stream with added mixin methods.
const bodyStream = getObjectResult.Body; 

// one-time transform.
const bodyAsString = await bodyStream.transformToString();

// throws an error on 2nd call, stream cannot be rewound.
const __error__ = await bodyStream.transformToString();

Looks like we need to check for Body being undefined though or else we get Object is possibly 'undefined'.ts(2532) so

import { S3 } from "@aws-sdk/client-s3";

const client = new S3({});

const getObjectResult = await client.getObject({
  Bucket: "...",
  Key: "...",
});

if (!getObjectResult.Body) {
  // handle not found
  throw new Error("Object not found");
}

// env-specific stream with added mixin methods.
const bodyStream = getObjectResult.Body; 

// one-time transform.
const bodyAsString = await bodyStream.transformToString();

// throws an error on 2nd call, stream cannot be rewound.
const __error__ = await bodyStream.transformToString();

acommodari · 2022-11-21T19:12:06Z

With Node 18 introducing Web Streams API will this affect s3 download streams in any way?
To my knowledge if you were working in node you could assume the Body was always gonna be a Readable.
Will it now also support ReadableStream?

ryanblock · 2022-11-23T23:52:12Z

Hey @trivikr! Any updates or official word from your side on this? Haven't heard from you in this thread for over a year and a half, and it's especially relevant with Lambda nodejs18.x now out with SDK v3. Thanks! 💕

ShivamJoker · 2022-11-24T11:10:35Z

@kuhe any idea how do I get this working with sharp ? It's not taking the string or buffer or stream

misantronic · 2022-11-24T11:18:35Z

@kuhe any idea how do I get this working with sharp ? It's not taking the string or buffer or stream

this works for me with sharp:

async function streamToBuffer(stream: Readable): Promise<Buffer> {
    return await new Promise((resolve, reject) => {
        const chunks: Uint8Array[] = [];
        stream.on('data', (chunk) => chunks.push(chunk));
        stream.on('error', reject);
        stream.on('end', () => resolve(Buffer.concat(chunks)));
    });
}

const resp = await s3.send(new GetObjectCommand({ Bucket, Key }));

if (resp.Body) {
    resp.Body = (await streamToBuffer(resp.Body as Readable)) as any;
}

ShivamJoker · 2022-11-24T11:22:14Z

Can't we just use the stream instead of converting it?

misantronic · 2022-11-24T11:29:30Z

Can't we just use the stream instead of converting it?

I was trying to - no success. If you find a way, keep me posted.

ShivamJoker · 2022-11-24T11:55:53Z

Okay so after spending few hours I got it right. This way we can pipe our s3 response body into sharp and later use the .toBuffer() to push it to bucket.

  const getObj = new GetObjectCommand({
    Bucket,
    Key: objectKey,
  });

  const s3ImgRes = await s3Client.send(getObj);

  const sharpImg = sharp().resize({ width: 500 }).toFormat("webp");

  // pipe the body to sharp img
  s3ImgRes.Body.pipe(sharpImg);

  const putObj = new PutObjectCommand({
    Bucket,
    Key: `converted/${objectKey.replace(/[a-zA-Z]+$/, "webp")}`,
    Body: await sharpImg.toBuffer(),
  });

  await s3Client.send(putObj);

But AWS team please please you need update your docs, I know there is a lot to update but as developer its just so much struggle to use AWS services because of insufficient docs.

adcreare · 2022-12-02T05:42:12Z

Here is an example of how to download an object from S3 and write that as a file to disk, while keeping it as a stream. This example is typescript targeting node.

It seems silly to me if we're going to all this trouble of having a stream coming from AWS that we then convert that to a buffer or string to write to disk.

I also agree with the sentiments expressed by others in this thread. It is crazy that getObject has become such a complicated operation in the V3 SDK compared with the V2 SDK and is going to trip many people up for years to come.

import type { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import fs from 'node:fs'
import { GetObjectCommand, S3 } from '@aws-sdk/client-s3';

async function downloadFile() {
  const s3 = new S3({});
  const s3Result = await s3.send(new GetObjectCommand({ Bucket: sourceBucket, Key: sourceKey }));
  if (!s3Result.Body) {
    throw new Error('received empty body from S3');
  }
  await pipeline(s3Result.Body as Readable, fs.createWriteStream('/tmp/filedownload.zip'));
}

rdt712 · 2022-12-06T19:42:48Z

Found an easy solution using transformToString if wanting to parse a JSON file in S3.

import { S3, GetObjectCommand } from '@aws-sdk/client-s3'

const s3 = new S3({});

const getObjectParams = {
  Bucket: 'my-bucket',
  Key: 'my-object',
};
const getObjectCommand = new GetObjectCommand(getObjectParams);
const s3Object = await s3.send(getObjectCommand);

const dataStr = await s3Object.Body?.transformToString();

let data;
if (dataStr) {
  data = JSON.parse(dataStr);
}

kesavab · 2022-12-13T10:58:32Z

Found an easy solution using transformToString if wanting to parse a JSON file in S3.

import { S3, GetObjectCommand } from '@aws-sdk/client-s3'

const s3 = new S3({});

const getObjectParams = {
  Bucket: 'my-bucket',
  Key: 'my-object',
};
const getObjectCommand = new GetObjectCommand(getObjectParams);
const s3Object = await s3.send(getObjectCommand);

const dataStr = await s3Object.Body?.transformToString();

let data;
if (dataStr) {
  data = JSON.parse(dataStr);
}

When I use this, I get error during parsing. Error is
Uncaught SyntaxError SyntaxError: Unexpected token in JSON at position 0
at eval (repl:1:6)

Call to transformToString returns the json file contents

OlivierCuyp · 2023-01-11T17:59:58Z

@kesavab This means your dataStr is not a valid JSON string.
Did you try to log it with something like:

// ...
if (dataStr) {
 try {
   data = JSON.parse(dataStr);
 } catch (err) {
   console.log(err, dataStr);
 } 
}

ghost · 2023-02-15T20:37:48Z

What's the next step after getting the object string if I want to download the file? Should I convert it into a blob file and return it to the frontend?

kmordan24 · 2023-02-16T20:01:16Z

Typescript errors if you try to pipe Body even though it is a stream:
Property 'pipe' does not exist on type 'SdkStream<Readable | ReadableStream<any> | Blob | undefined>'. Property 'pipe' does not exist on type 'ReadableStream<any> & SdkStreamMixin'.

const { Body } = await s3Client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));

if (!Body) {
  throw new Error('....'');
}

Body.pipe(fs.createWriteStream(filePath))
    .on('error', (err: any) => reject(err))
    .on('close', () => resolve());

...

The only way around this is type casting - unless anyone has any other ideas.

Will there be a fix for this in a future release version?

RanVaknin · 2023-02-17T19:25:52Z

Hi all,

It is extremely hard for us to keep track of issues that lay at the end of the issue queue on Github.

Since the OP's concern was addressed , and additional concerns were also addressed I feel like we can close this.

If you still need help whether it be to report a bug, or to ask a question, please re-engage with us on a new thread / discussion.
This makes it so we have more visibility to your concerns and can answer you in a timely manner.

Sorry for the inconvenience,
Ran~

jsancho · 2023-02-28T12:39:31Z

Okay so after spending few hours I got it right. This way we can pipe our s3 response body into sharp and later use the .toBuffer() to push it to bucket.
  const getObj = new GetObjectCommand({
    Bucket,
    Key: objectKey,
  });

  const s3ImgRes = await s3Client.send(getObj);

  const sharpImg = sharp().resize({ width: 500 }).toFormat("webp");

  // pipe the body to sharp img
  s3ImgRes.Body.pipe(sharpImg);

  const putObj = new PutObjectCommand({
    Bucket,
    Key: `converted/${objectKey.replace(/[a-zA-Z]+$/, "webp")}`,
    Body: await sharpImg.toBuffer(),
  });

  await s3Client.send(putObj);
But AWS team please please you need update your docs, I know there is a lot to update but as developer its just so much struggle to use AWS services because of insufficient docs.

can't thank you enough for this workaround :)

j0k3r · 2023-03-10T14:56:48Z

I found an other solution depending on how you want to get your content from s3 when using Node.js >= v16.7.0 using stream/consumers:

import consumers from 'node:stream/consumers'
import { S3 } from '@aws-sdk/client-s3'

const s3 = new S3()
const { Body } = await s3.getObject({ Bucket: "your-bucket", Key: "your-object-key" })
// as a buffer
const buffer = await consumers.buffer(Body)
// as a text
const text = await consumers.text(Body)
// as a json
const json = await consumers.json(Body)

github-actions · 2023-03-25T00:02:54Z

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs and link to relevant comments in this thread.

yenfryherrerafeliz · 2023-06-26T16:52:26Z

Hi people, I just want to let you all know that we have introduced a new feature that allows us to convert the body of a bucket's object to a string by doing the following:

import {S3Client, GetObjectCommand} from "@aws-sdk/client-s3";

const client = new S3Client({
    region: 'us-east-2'
});
const response = await client.send(new GetObjectCommand({
    Bucket: process.env.TEST_BUCKET,
    Key: process.env.TEST_KEY
}));
console.log(await response.Body.transformToString('utf-8'));

This feature is available after version 3.357.0

Thanks!

igilham added bug This issue is a bug. needs-triage This issue or PR still needs to be triaged. labels Jan 6, 2021

trivikr mentioned this issue Jan 6, 2021

Show how to use S3 GetObjectCommand aws-samples/aws-sdk-js-v3-workshop#255

Closed

trivikr mentioned this issue Jan 6, 2021

Link to API Reference Client from README #1878

Closed

github-actions bot removed the response-requested Waiting on additional info and feedback. Will move to \"closing-soon\" in 7 days. label Jan 7, 2021

igilham closed this as completed Jan 7, 2021

trivikr mentioned this issue Jan 13, 2021

Add a summary of package usage in client README #1905

Closed

trivikr reopened this Feb 10, 2021

ajredniwja mentioned this issue Feb 25, 2021

S3 GetObjectCommand response does not return what the docs say it returns aws/aws-sdk-js#3649

Closed

2 tasks

wvkehoe mentioned this issue Mar 7, 2021

[BUG] v3 SDK GetObject example is insufficient awsdocs/aws-doc-sdk-examples#1677

Closed

kenoir mentioned this issue Oct 31, 2022

Simplify reading from S3 by using transformToString guardian/service-catalogue#34

Merged

kuhe mentioned this issue Dec 8, 2022

[@aws-sdk/client-lambda] - Payload data in uint8array format - how to resolve data to expected output? #2252

Closed

alucke mentioned this issue Jan 20, 2023

@aws-sdk/client-s3 Converting circular structure to JSON warning when using custom logger #4339

Closed

3 tasks

RanVaknin added the p2 This is a standard priority issue label Feb 17, 2023

RanVaknin closed this as completed Feb 17, 2023

RanVaknin assigned RanVaknin and unassigned AllanZhengYP Feb 17, 2023

github-actions bot locked as resolved and limited conversation to collaborators Mar 25, 2023

S3.GetObject no longer returns the result as a string #1877

S3.GetObject no longer returns the result as a string #1877

Comments

igilham commented Jan 6, 2021 • edited Loading

trivikr commented Jan 6, 2021

igilham commented Jan 6, 2021

trivikr commented Jan 6, 2021

trivikr commented Jan 6, 2021

igilham commented Jan 6, 2021

trivikr commented Jan 6, 2021

igilham commented Jan 7, 2021

leimd commented Jan 21, 2021 • edited by trivikr Loading

ffxsam commented Jan 28, 2021

lambrospetrou commented Feb 9, 2021 • edited by trivikr Loading

smiccoli commented Feb 10, 2021

ffxsam commented Feb 10, 2021 • edited Loading

trivikr commented Feb 10, 2021

moltar commented Mar 6, 2021 • edited Loading

kennu commented Mar 8, 2021 • edited Loading

m-radzikowski commented Mar 15, 2021

kuhe commented Oct 21, 2022

sfwhite commented Oct 21, 2022

zbagley commented Oct 21, 2022

samchungy commented Oct 22, 2022

acommodari commented Nov 21, 2022

ryanblock commented Nov 23, 2022

ShivamJoker commented Nov 24, 2022

misantronic commented Nov 24, 2022

ShivamJoker commented Nov 24, 2022

misantronic commented Nov 24, 2022

ShivamJoker commented Nov 24, 2022

adcreare commented Dec 2, 2022 • edited Loading

rdt712 commented Dec 6, 2022 • edited Loading

kesavab commented Dec 13, 2022

OlivierCuyp commented Jan 11, 2023

ghost commented Feb 15, 2023

kmordan24 commented Feb 16, 2023

RanVaknin commented Feb 17, 2023

jsancho commented Feb 28, 2023

j0k3r commented Mar 10, 2023

github-actions bot commented Mar 25, 2023

yenfryherrerafeliz commented Jun 26, 2023 • edited Loading

igilham commented Jan 6, 2021 •

edited

Loading

leimd commented Jan 21, 2021 •

edited by trivikr

Loading

lambrospetrou commented Feb 9, 2021 •

edited by trivikr

Loading

ffxsam commented Feb 10, 2021 •

edited

Loading

moltar commented Mar 6, 2021 •

edited

Loading

kennu commented Mar 8, 2021 •

edited

Loading

adcreare commented Dec 2, 2022 •

edited

Loading

rdt712 commented Dec 6, 2022 •

edited

Loading

yenfryherrerafeliz commented Jun 26, 2023 •

edited

Loading