uppy-s3_multipart 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e12372444e16d107d5c90ec8af0a414ce4be9cb80789104d876ccbcb659f2e47
-  data.tar.gz: 72b57faaed4df24f0e5614f7b9fe2a9129773bd3dfeba2e34c13929f930df196
+  metadata.gz: 127c554611e36c8802a60174dfbd624bab6de29aaa5f1ccdd04b71c2224f108e
+  data.tar.gz: 6950b75f85c04b03e973ae9581f59ec8defc4d1be7c5c50080fcd638c71adf97
 SHA512:
-  metadata.gz: cc918fcce0cba1544acf9fe92996d81a3afc165c248cafe9ce6c615e1cd6c9d0feef8ec787b4269c0583f2478c7a94467b47964e41fb31aade21e11e569a5a03
-  data.tar.gz: cf5352bb5dbe444dc748eaa593b311a2545f0d1fdb4a0c2f0f3f364290e3a82acdbd7912536851a951aecc3ff872acb0580fd73cb60daf4af85757c2a32fc89e
+  metadata.gz: 292d94dbb74c0efe2108f041207e86a5d46b99d63fb85f4cf2ccc5c252d47c00507b6118bdfd995ee762049fc389705982cfc566ddc1f906b7956185179db1fd
+  data.tar.gz: 305fb7fea58a49a3768ebda006c5827b9b3911006087bb61f623a2519b10f5c680a39ab0578db085823963d2046753f3f4b294a4716c3e6e836b3c18173c1999

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,37 +10,49 @@ uploads.
 Add the gem to your Gemfile:
 
 ```rb
-gem "uppy-s3_multipart", "~> 0.2"
+gem "uppy-s3_multipart", "~> 1.0"
 ```
 
 ## 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:
 
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<CORSConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
-  <CORSRule>
-    <AllowedOrigin>https://my-app.com</AllowedOrigin>
-    <AllowedMethod>GET</AllowedMethod>
-    <AllowedMethod>POST</AllowedMethod>
-    <AllowedMethod>PUT</AllowedMethod>
-    <MaxAgeSeconds>3000</MaxAgeSeconds>
-    <AllowedHeader>Authorization</AllowedHeader>
-    <AllowedHeader>x-amz-date</AllowedHeader>
-    <AllowedHeader>x-amz-content-sha256</AllowedHeader>
-    <AllowedHeader>content-type</AllowedHeader>
-    <ExposeHeader>ETag</ExposeHeader>
-  </CORSRule>
-  <CORSRule>
-    <AllowedOrigin>*</AllowedOrigin>
-    <AllowedMethod>GET</AllowedMethod>
-    <MaxAgeSeconds>3000</MaxAgeSeconds>
-  </CORSRule>
-</CORSConfiguration>
+```json
+[
+    {
+        "AllowedHeaders": [
+            "content-type",
+            "x-amz-content-sha256",
+            "x-amz-date"
+        ],
+        "AllowedMethods": [
+            "GET",
+            "POST",
+            "PUT"
+        ],
+        "AllowedOrigins": [
+            "https://my-app.com"
+        ],
+        "ExposeHeaders": [
+            "ETag"
+        ],
+        "MaxAgeSeconds": 3000
+    },
+    {
+        "AllowedHeaders": [],
+        "AllowedMethods": [
+            "GET"
+        ],
+        "AllowedOrigins": [
+            "*"
+        ],
+        "ExposeHeaders": [],
+        "MaxAgeSeconds": 3000
+    }
+]
 ```
 
 Replace `https://my-app.com` with the URL to your app (in development you can
@@ -51,11 +63,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,39 +135,34 @@ 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, data, uploadURL) {
+uppy.on('upload-success', function (file, response) {
   var uploadedFileData = JSON.stringify({
-    id: uploadURL.match(/\/cache\/([^\?]+)/)[1], // extract key without prefix
+    id: response.uploadURL.match(/\/cache\/([^\?]+)/)[1], // extract key without prefix
     storage: 'cache',
     metadata: {
       size:      file.size,
@@ -115,108 +174,57 @@ uppy.on('upload-success', function (file, data, uploadURL) {
 })
 ```
 
-**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 +235,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 +327,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 +476,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

@@ -20,6 +20,11 @@ module Uppy
         @router.call(env)
       end
 
+      def inspect
+        "#<Uppy::S3Multipart::App>"
+      end
+      alias to_s inspect
+
       class Router < Roda
         plugin :all_verbs
         plugin :json
@@ -33,23 +38,27 @@ module Uppy
         route do |r|
           # POST /s3/multipart
           r.post ["", true] do
-            content_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]
+            type     = r.params["type"]
+            filename = r.params["filename"]
 
-            content_disposition = ContentDisposition.inline(filename) if filename
+            key = SecureRandom.hex + File.extname(filename.to_s)
+            key = [*opts[:prefix], key].join("/")
 
-            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)
 
             { uploadId: result.fetch(:upload_id), key: result.fetch(:key) }
           end
 
+          # OPTIONS /s3/multipart
+          r.options ["", true] do
+            r.halt 204
+          end
+
           # GET /s3/multipart/:uploadId
           r.get String do |upload_id|
             key = param!("key")

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.1"
+  gem.version      = "1.0.0"
 
   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.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Janko Marohnić
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-19 00:00:00.000000000 Z
+date: 2021-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roda
@@ -142,7 +142,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.23'
-description: 
+description:
 email:
 - janko.marohnic@gmail.com
 executables: []
@@ -161,7 +161,7 @@ homepage: https://github.com/janko/uppy-s3_multipart
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -176,8 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Provides a Rack application that implements endpoints for the AwsS3Multipart
   Uppy plugin.