Drive

node ace add @adonisjs/drive

import env from '#start/env'
import app from '@adonisjs/core/services/app'
import { defineConfig, services } from '@adonisjs/drive'

const driveConfig = defineConfig({
  default: env.get('DRIVE_DISK'),

  services: {
    /**
     * Persist files on the local filesystem
     */
    fs: services.fs({
      location: app.makePath('storage'),
      serveFiles: true,
      routeBasePath: '/uploads',
      visibility: 'public',
    }),

    /**
     * Persist files on Digital Ocean spaces
     */
    spaces: services.s3({
      credentials: {
        accessKeyId: env.get('SPACES_KEY'),
        secretAccessKey: env.get('SPACES_SECRET'),
      },
      region: env.get('SPACES_REGION'),
      bucket: env.get('SPACES_BUCKET'),
      endpoint: env.get('SPACES_ENDPOINT'),
      visibility: 'public',
    }),
  },
})

export default driveConfig

import { cuid } from '@adonisjs/core/helpers'
import drive from '@adonisjs/drive/services/main'
import router from '@adonisjs/core/services/router'

router.put('/me', async ({ request, response }) => {
  /**
   * Step 1: Grab the image from the request and perform basic
   * validations
   */
  const image = request.file('avatar', {
    size: '2mb',
    extnames: ['jpeg', 'jpg', 'png'],
  })
  if (!image) {
    return response.badRequest({ error: 'Image missing' })
  }

  /**
   * Step 2: Move the image with a unique name using Drive
   */
  const key = `uploads/${cuid()}.${image.extname}`
  await image.moveToDisk(key)

  /**
   * Respond with the file's public URL
   */
  return {
    message: 'Image uploaded',
    url: image.meta.url,
  }
})

import drive from '@adonisjs/drive/services/main'

drive instanceof DriveManager // true

/**
 * Returns instance of the default disk
 */
const disk = drive.use()

/**
 * Returns instance of a disk named r2
 */
const disk = drive.use('r2')

/**
 * Returns instance of a disk named spaces
 */
const disk = drive.use('spaces')

await disk.put(key, value)
await disk.putStream(key, readableStream)

await disk.get(key)
await disk.getStream(key)
await disk.getArrayBuffer(key)

await disk.delete(key)
await disk.deleteAll(prefix)

await disk.copy(source, destination)
await disk.move(source, destination)

await disk.copyFromFs(source, destination)
await disk.moveFromFs(source, destination)

{
  services: {
    fs: services.fs({
      location: app.makePath('storage'),
      visibility: 'public',

      appUrl: env.get('APP_URL'),
      serveFiles: true,
      routeBasePath: '/uploads',
    }),
  }
}

<img src="{{ await driveUrl(user.avatar) }}" />

<!-- Generate URL for a named disk -->
<img src="{{ await driveUrl(user.avatar, 's3') }}" />
<img src="{{ await driveUrl(user.avatar, 'r2') }}" />

<a href="{{ await driveSignedUrl(invoice.key) }}">
  Download Invoice
</a>

<!-- Generate URL for a named disk -->
<a href="{{ await driveSignedUrl(invoice.key, 's3') }}">
  Download Invoice
</a>

<!-- Generate URL with signed options -->
<a href="{{ await driveSignedUrl(invoice.key, {
  expiresIn: '30 mins',
}) }}">
  Download Invoice
</a>

const image = request.file('image')!

const key = 'user-1-avatar.png'

/**
 * Move file to the default disk
 */
await image.moveToDisk(key)

/**
 * Move file to a named disk
 */
await image.moveToDisk(key, 's3')

/**
 * Define additional properties during the
 * move operation
 */
await image.moveToDisk(key, 's3', {
  contentType: 'image/png',
})

/**
 * Write file by first reading it as a buffer. You may use this
 * option when your cloud storage provider results in broken
 * files with the "stream" option
 */
await image.moveToDisk(key, 's3', {
  moveAs: 'buffer'
})

import { test } from '@japa/runner'
import drive from '@adonisjs/drive/services/main'
import fileGenerator from '@poppinss/file-generator'

test.group('Users | update', () => {
  test('should be able to update my avatar', async ({ client, cleanup }) => {
    /**
     * Fake the "spaces" disk and restore the fake
     * after the test finishes
     */
    const fakeDisk = drive.fake('spaces')
    cleanup(() => drive.restore('spaces'))

    /**
     * Create user to perform the login and update
     */
    const user = await UserFactory.create()

    /**
     * Generate a fake in-memory png file with size of
     * 1mb
     */
    const { contents, mime, name } = await fileGenerator.generatePng('1mb')

    /**
     * Make put request and send the file
     */
    await client
      .put('me')
      .file('avatar', contents, {
        filename: name,
        contentType: mime,
      })
      .loginAs(user)

    /**
     * Assert the file exists
     */
    fakeDisk.assertExists(user.avatar)
  })
})