input.js

import { join } from 'path';
import fsp from 'fs-promise';
import { EventEmitter } from 'events';

/**
 * The minimum requirements for a standard file based operation
 */
type minimalFileDescriptorType = {
  name: string,
  path: Array<string>,
  encoding: ?string
};

/**
 * The minimum requirements for a path operation
 */
type pathFileDescriptorType = {
  name: ?string,
  path: Array<string>
};

/**
 * The minimum requirements for a write operation (data/buffer)
 */
type writeFileDescriptorType = {
  name: string,
  path: Array<string>,
  content: string | Buffer,
  encoding: ?string
};

module.exports = {
  /**
   * Service requires a configuration and must have dependencies pre-fulfilled
   */
  init: (config: Object, services: Object): Promise<Object> =>
    Promise.resolve().then(() => {
      const { root } = config;

      /**
     * Local storage operations (local could be NFS mapped of course...)
     * Every function has a Many alternative, e.g readMany
     */
      const fns = {
        /**
       * Read a file
       */
        read: (fD: minimalFileDescriptorType): Promise<Buffer | string> =>
          fsp.readFile(join(...root, ...fD.path, fD.name), fD.encoding),

        /**
       * Read file stream
       */
        readStream: (fD: minimalFileDescriptorType): EventEmitter =>
          fsp.createReadStream(join(...root, ...fD.path, fD.name), fD.encoding),

        /**
       * Write data to a file
       */
        write: (fD: writeFileDescriptorType): Promise =>
          fsp.writeFile(
            join(...root, ...fD.path, fD.name),
            fD.content,
            fD.encoding
          ),

        /**
       * Write file stream
       */
        writeStream: (fD: minimalFileDescriptorType): EventEmitter =>
          fsp.createWriteStream(
            join(...root, ...fD.path, fD.name),
            fD.encoding
          ),

        /**
       * Lists directory contents
       */
        ls: (path: Array<string>): Promise =>
          fsp.readdir(join(...root, ...path)),

        /**
       * Removes a file
       */
        rm: (fD: minimalFileDescriptor): Promise =>
          fsp.unlink(join(...root, ...fD.path, fD.name)),

        /**
       * Removes a directory. Think rf -rf
       */
        rmdir: (path: Array<string>): Promise =>
          fsp.remove(join(...root, ...path)),

        /**
       * Checks the existance of a dir or file
       */
        stat: (fD: pathFileDescriptorType): Promise =>
          fsp
            .stat(join(...root, ...fD.path, fD.name || ''))
            .then(() => true)
            .catch(() => false),

        /**
       * Creates a path if it doesn't exist. Think mkdir -p
       */
        mkdir: (path: Array<string>): Promise =>
          fsp.mkdirs(join(...root, ...path)),

        /**
       * Generates a path representation with which another application can upload to
       */
        getUploadUrl: (fD: minimalFileDescriptorType): Promise =>
          Promise.resolve().then(() => {
            return {
              url: 'file://' + join(...root, ...fD.path, fD.name)
            };
          }),

        /**
       * Generates a path representation with which another application can download from
       */
        getDownloadUrl: (fD: minimalFileDescriptorType): Promise =>
          fns.getUploadUrl(fD)
      };

      // create Many version of the above
      Object.keys(fns).forEach(key => {
        fns[`${key}Many`] = (paths: Array<mixed>, ...args) =>
          Promise.all(paths.map(path => fns[key](path, ...args)));
      });

      return fns;
    })
};

output.md

Table of Contents

• minimalFileDescriptorType
• pathFileDescriptorType
• writeFileDescriptorType
• init
• fns
  • read
  • readStream
  • write
  • writeStream
  • ls
  • rm
  • rmdir
  • stat
  • mkdir
  • getUploadUrl
  • getDownloadUrl

minimalFileDescriptorType

The minimum requirements for a standard file based operation

Type: {name: string, path: Array<string>, encoding: string?}

Properties

• name string
• path Array<string>
• encoding string?

pathFileDescriptorType

The minimum requirements for a path operation

Type: {name: string?, path: Array<string>}

Properties

• name string?
• path Array<string>

writeFileDescriptorType

The minimum requirements for a write operation (data/buffer)

Type: {name: string, path: Array<string>, content: (string | Buffer), encoding: string?}

Properties

• name string
• path Array<string>
• content (string | Buffer)
• encoding string?

init

Service requires a configuration and must have dependencies pre-fulfilled

Parameters

• config Object
• services Object

Returns Promise<Object>

fns

Local storage operations (local could be NFS mapped of course...) Every function has a Many alternative, e.g readMany

read

Read a file

Parameters

• fD minimalFileDescriptorType

Returns Promise<(Buffer | string)>

readStream

Read file stream

Parameters

• fD minimalFileDescriptorType

Returns EventEmitter

write

Write data to a file

Parameters

• fD writeFileDescriptorType

Returns Promise

writeStream

Write file stream

Parameters

• fD minimalFileDescriptorType

Returns EventEmitter

ls

Lists directory contents

Parameters

• path Array<string>

Returns Promise

rm

Removes a file

Parameters

• fD minimalFileDescriptor

Returns Promise

rmdir

Removes a directory. Think rf -rf

Parameters

• path Array<string>

Returns Promise

stat

Checks the existance of a dir or file

Parameters

• fD pathFileDescriptorType

Returns Promise

mkdir

Creates a path if it doesn't exist. Think mkdir -p

Parameters

• path Array<string>

Returns Promise

getUploadUrl

Generates a path representation with which another application can upload to

Parameters

• fD minimalFileDescriptorType

Returns Promise

getDownloadUrl

Generates a path representation with which another application can download from

Parameters

• fD minimalFileDescriptorType

Returns Promise