uppy-s3_multipart 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 701a2e46d55f76fb336473db225e298fad66daa9bd45fcef78aae4aedb928d3d
-  data.tar.gz: c157522695c642ba85aa702ffc68d24a5ae8df88eebf6a45033adfc704ddbc71
+  metadata.gz: dc97a26ba80d456081aa3972306acf87ab3b16a2689da06abf0351ea328c4ca6
+  data.tar.gz: 20f0a190ff1a875858cd69dd06d3505292c918b3af2056838d28cad554828c72
 SHA512:
-  metadata.gz: bf9903c90a654d59c1bc0f442a4e4510cf4fe309d6775a12870b93253742dfa84e3f8c5854f5c60cab87048324c959abfd11679d010899554ca0ed61f8f0ab0f
-  data.tar.gz: 4ffa1e3fdf4173754424e83d3e035b1cf6b71363198c6bfb29cf3507bd8599f16a724c6e9cee44f0942308cd345ca4973ff61eba9047e71516a7d849dc00c5b5
+  metadata.gz: eed1595f31dc9ac39e9ecf4f52f38608c3c1c9ed04902618d05782d63092f1af6933a700ecf24b1fca8217af327367ff93b4510ef16167684662f354d0ab3821
+  data.tar.gz: dbfe414174143758540e1077b65d611e5bd846132c0d4b609959d93d3d7fe73693bd2e5dfa995ddc0f3c84170018b8fb44ed1b4594c26696ae6438aa77b4c7e3

data/README.md

@@ -1,6 +1,6 @@
 # Uppy::S3Multipart
 
-Provides a Rack application that implements endpoints for the [AwsS3Multipart]
+Provides a Rack application that implements endpoints for the [aws-s3-multipart]
 Uppy plugin. This enables multipart uploads directly to S3, which is
 recommended when dealing with large files, as it allows resuming interrupted
 uploads.
@@ -10,12 +10,12 @@ uploads.
 Add the gem to your Gemfile:
 
 ```rb
-gem "uppy-s3_multipart", "~> 0.2"
+gem "uppy-s3_multipart", "~> 0.3"
 ```
 
 ## Setup
 
-In order to allow direct multipart uploads to your S3 bucket, we need to update
+In order to allow direct multipart uploads to your S3 bucket, you need to update
 the bucket's CORS configuration. In the AWS S3 Console go to your bucket, click
 on "Permissions" tab and then on "CORS configuration". There paste in the
 following:
@@ -51,11 +51,63 @@ CORS settings to be applied.
 
 This gem provides a Rack application that you can mount inside your main
 application. If you're using [Shrine], you can initialize the Rack application
-via the `uppy_s3_multipart` Shrine plugin, otherwise you can initialize it
-directly.
+via the [Shrine plugin](#shrine).
+
+### App
+
+At its core, you initialize an `Uppy::S3Multipart::App` with an
+`Aws::S3::Bucket` object:
+
+```rb
+require "uppy/s3_multipart"
+
+bucket = Aws::S3::Bucket.new(
+  name:              "my-bucket",
+  access_key_id:     "...",
+  secret_access_key: "...",
+  region:            "...",
+)
+
+UPPY_S3_MULTIPART_APP = Uppy::S3Multipart::App.new(bucket: bucket)
+```
+
+The instance of `Uppy::S3Multipart::App` is a Rack application that can be
+mounted in your router (`config/routes.rb` in Rails). It should be
+mounted at `/s3/multipart`:
+
+```rb
+# config/routes.rb (Rails)
+Rails.application.routes.draw do
+  # ...
+  mount UPPY_S3_MULTIPART_APP => "/s3/multipart"
+end
+```
+
+This will add the routes that the `aws-s3-multipart` Uppy plugin expects:
+
+```
+POST   /s3/multipart
+GET    /s3/multipart/:uploadId
+GET    /s3/multipart/:uploadId/:partNumber
+POST   /s3/multipart/:uploadId/complete
+DELETE /s3/multipart/:uploadId
+```
+
+Since your app will now play the role of Uppy Companion, in your Uppy
+configuration you can point `companionUrl` to your app's URL:
+
+```js
+// ...
+uppy.use(Uppy.AwsS3Multipart, {
+  companionUrl: '/',
+})
+```
 
 ### Shrine
 
+If you're using Shrine, you can use the `uppy_s3_multipart` Shrine plugin that
+ships with this gem to simplify the setup.
+
 In your Shrine initializer load the `uppy_s3_multipart` plugin:
 
 ```rb
@@ -71,34 +123,29 @@ Shrine.storages = {
 Shrine.plugin :uppy_s3_multipart # load the plugin
 ```
 
-The plugin will provide a `Shrine.uppy_s3_multipart` method that creates a new
-`Uppy::S3Multipart::App` instance, which is a Rack app that you can mount
-inside your main application:
+The plugin will provide a `Shrine.uppy_s3_multipart` method that creates the
+`Uppy::S3Multipart::App` instance, which you can then mount inside your router:
 
 ```rb
-# Rails (config/routes.rb)
+# config/routes.rb (Rails)
 Rails.application.routes.draw do
+  # ...
   mount Shrine.uppy_s3_multipart(:cache) => "/s3/multipart"
 end
-
-# Rack (config.ru)
-map "/s3/multipart" do
-  run Shrine.uppy_s3_multipart(:cache)
-end
 ```
 
-Now in your Uppy configuration point `serverUrl` to your app's URL:
+Now in your Uppy configuration point `companionUrl` to your app's URL:
 
 ```js
 // ...
 uppy.use(Uppy.AwsS3Multipart, {
-  serverUrl: '/',
+  companionUrl: '/',
 })
 ```
 
-In the `upload-success` Uppy callback you can then construct the Shrine
-uploaded file data (this example assumes your temporary Shrine S3 storage has
-`prefix: "cache"` set):
+In the `upload-success` Uppy callback, you can construct the Shrine uploaded
+file data (this example assumes your temporary Shrine S3 storage has `prefix:
+"cache"` set):
 
 ```js
 uppy.on('upload-success', function (file, response) {
@@ -115,108 +162,57 @@ uppy.on('upload-success', function (file, response) {
 })
 ```
 
-**See [Adding Direct S3 Uploads] for an example of a complete Uppy setup with
-Shrine. From there you can swap the `presign_endpoint` + `AwsS3` code with the
-`uppy_s3_multipart` + `AwsS3Multipart` setup.**
+See [Adding Direct S3 Uploads] for an example of a complete Uppy setup with
+Shrine. From there you can swap the `presign_endpoint` + `aws-s3` code with the
+`uppy_s3_multipart` + `aws-s3-multipart` setup.
 
 Note that **Shrine won't extract metadata from directly upload files on
 assignment** by default. Instead, it will just copy metadata that was extracted
 on the client side. See [this section][metadata direct uploads] for the
 rationale and instructions on how to opt in.
 
-### App
-
-You can also use `uppy-s3_multipart` without Shrine, by initializing the
-`Uppy::S3Multipart::App` directly:
-
-```rb
-require "uppy/s3_multipart"
-
-resource = Aws::S3::Resource.new(
-  access_key_id:     "...",
-  secret_access_key: "...",
-  region:            "...",
-)
-
-bucket = resource.bucket("my-bucket")
-
-UPPY_S3_MULTIPART_APP = Uppy::S3Multipart::App.new(bucket: bucket)
-```
-
-You can mount it inside your main app in the same way:
-
-```rb
-# Rails (config/routes.rb)
-Rails.application.routes.draw do
-  mount UPPY_S3_MULTIPART_APP => "/s3/multipart"
-end
-
-# Rack (config.ru)
-map "/s3/multipart" do
-  run UPPY_S3_MULTIPART_APP
-end
-```
-
-This will add the routes that the `AwsS3Multipart` Uppy plugin expects:
-
-```
-POST   /s3/multipart
-GET    /s3/multipart/:uploadId
-GET    /s3/multipart/:uploadId/:partNumber
-POST   /s3/multipart/:uploadId/complete
-DELETE /s3/multipart/:uploadId
-```
-
-Now in your Uppy configuration point `serverUrl` to your app's URL:
-
-```js
-// ...
-uppy.use(Uppy.AwsS3Multipart, {
-  serverUrl: '/',
-})
-```
-
-### Configuration
+## Configuration
 
 This section describe various configuration options that you can pass to
 `Uppy::S3Multipart::App`.
 
 #### `:bucket`
 
-The `:bucket` option is mandatory and accepts an instance of `Aws::S3::Bucket`.
-It's easiest to create an `Aws::S3::Resource`, and call `#bucket` on it.
+The `:bucket` option is mandatory and accepts an instance of `Aws::S3::Bucket`:
 
 ```rb
 require "uppy/s3_multipart"
 
-resource = Aws::S3::Resource.new(
+bucket = Aws::S3::Bucket.new(
+  name:              "<BUCKET>",
   access_key_id:     "<ACCESS_KEY_ID>",
   secret_access_key: "<SECRET_ACCESS_KEY>",
   region:            "<REGION>",
 )
 
-bucket = resource.bucket("<BUCKET>")
-
-Uppy::S3MUltipart::App.new(bucket: bucket)
+Uppy::S3Multipart::App.new(bucket: bucket)
 ```
 
-If you want to use [Minio], you can easily configure your `Aws::S3::Bucket` to
-point to your Minio server:
+If you want to use [Minio], you can easily configure the `Aws::S3::Bucket` to
+use your Minio server:
 
 ```rb
-resource = Aws::S3::Resource.new(
+bucket = Aws::S3::Bucket.new(
+  name:              "<MINIO_BUCKET>",
   access_key_id:     "<MINIO_ACCESS_KEY>", # "AccessKey" value
   secret_access_key: "<MINIO_SECRET_KEY>", # "SecretKey" value
   endpoint:          "<MINIO_ENDPOINT>",   # "Endpoint"  value
   region:            "us-east-1",
-  force_path_style:  true,
 )
 
-bucket = resource.bucket("<MINIO_BUCKET>") # name of the bucket you created
+Uppy::S3Multipart::App.new(bucket: bucket)
 ```
 
-See the [`Aws::S3::Client#initialize`] docs for all supported configuration
-options. In the Shrine plugin this option is inferred from the S3 storage.
+Except for `:name`, all options passed to [`Aws::S3::Bucket#initialize`] are
+forwarded to [`Aws::S3::Client#initialize`], see its documentation for
+additional options.
+
+In the Shrine plugin this configuration is inferred from the S3 storage.
 
 #### `:prefix`
 
@@ -227,14 +223,7 @@ to be uploaded to.
 Uppy::S3Multipart::App.new(bucket: bucket, prefix: "cache")
 ```
 
-In the Shrine plugin this option is inferred from the S3 storage:
-
-```rb
-Shrine.storages = {
-  cache: Shrine::Storage::S3.new(prefix: "cache", **options),
-  store: Shrine::Storage::S3.new(**options),
-}
-```
+In the Shrine plugin this option is inferred from the S3 storage.
 
 #### `:options`
 
@@ -326,7 +315,7 @@ Shrine.storages = {
 }
 ```
 
-### Client
+## Client
 
 If you would rather implement the endpoints yourself, you can utilize the
 `Uppy::S3Multipart::Client` to make S3 requests.
@@ -475,13 +464,14 @@ Covenant](http://contributor-covenant.org) code of conduct.
 The gem is available as open source under the terms of the [MIT
 License](https://opensource.org/licenses/MIT).
 
-[AwsS3Multipart]: https://uppy.io/docs/aws-s3-multipart/
+[aws-s3-multipart]: https://uppy.io/docs/aws-s3-multipart/
 [Shrine]: https://shrinerb.com
 [Adding Direct S3 Uploads]: https://github.com/shrinerb/shrine/wiki/Adding-Direct-S3-Uploads
 [Minio]: https://minio.io/
 [Client]: #client
 [content_disposition]: https://github.com/shrinerb/content_disposition
 [`Rack::Request`]: https://www.rubydoc.info/github/rack/rack/master/Rack/Request
+[`Aws::S3::Bucket#initialize`]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Bucket.html#initialize-instance_method
 [`Aws::S3::Client#initialize`]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#initialize-instance_method
 [`Aws::S3::Client#create_multipart_upload`]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#create_multipart_upload-instance_method
 [`Aws::S3::Client#list_parts`]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#list_parts-instance_method

data/lib/uppy/s3_multipart/app.rb

@@ -38,17 +38,16 @@ module Uppy
         route do |r|
           # POST /s3/multipart
           r.post ["", true] do
-            content_type = r.params["type"]
-            filename     = r.params["filename"]
+            type     = r.params["type"]
+            filename = r.params["filename"]
 
-            extension = File.extname(filename.to_s)
-            key       = SecureRandom.hex + extension
-            key       = "#{opts[:prefix]}/#{key}" if opts[:prefix]
+            key = SecureRandom.hex + File.extname(filename.to_s)
+            key = [*opts[:prefix], key].join("/")
 
-            content_disposition = ContentDisposition.inline(filename) if filename
-
-            options = { content_type: content_type, content_disposition: content_disposition }
-            options[:acl] = "public-read" if opts[:public]
+            options = {}
+            options[:content_type]        = type if type
+            options[:content_disposition] = ContentDisposition.inline(filename) if filename
+            options[:acl]                 = "public-read" if opts[:public]
 
             result = client_call(:create_multipart_upload, key: key, **options)
 

data/lib/uppy/s3_multipart/client.rb

@@ -56,13 +56,7 @@ module Uppy
 
       def abort_multipart_upload(upload_id:, key:, **options)
         multipart_upload = multipart_upload(upload_id, key)
-
-        # aws-sdk-s3 docs recommend retrying the abort in case the multipart
-        # upload still has parts
-        loop do
-          multipart_upload.abort(**options)
-          break unless multipart_upload.parts.any?
-        end
+        multipart_upload.abort(**options)
 
         {}
       end

data/uppy-s3_multipart.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name         = "uppy-s3_multipart"
-  gem.version      = "0.3.2"
+  gem.version      = "0.3.3"
 
   gem.required_ruby_version = ">= 2.2"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uppy-s3_multipart
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-04 00:00:00.000000000 Z
+date: 2020-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -176,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.1
 signing_key: 
 specification_version: 4
 summary: Provides a Rack application that implements endpoints for the AwsS3Multipart