Newly Paranoid Maintainers
    Share your code. npm Orgs help your team discover, share, and reuse code. Create a free org »

    lactatepublic

    Lactate

    npm install -g lactate

    An exceedingly fast static file handler, with a few electives.

    Features

    • In-memory caching
    • Redis caching
    • Robust cache-control setting
    • Automatic gzipping
    • Automatic minification
    • Custom 404 pages
    • Custom response headers
    • Custom / automatic charset headers
    • Custom gzip patterns
    • Asset bundling and minification
    • Middleware export
    • Default error pages
    • on(status) listeners
    • Colored log output
    • Global executable
    • Directory indexing
    • Express.static API compatibility
    • node-static API compatibility

    Using Lactate

    Global executable

    If installed globally with npm install -g lactate, you will have the lactate command at your disposal. This will run lactate static file server in the current working directory, utilizing the cluster module for multiple CPU cores. All options are available.

    $ lactate --help
    Usage: lactate [options]
     
    Options:
    --root, -r          Local path                          [default: ""]
    --from, -f          Public path                         [default: ""]
    --subdirs, -s       Serve subdirectories                [default: true]
    --hidden, -h        Serve hidden files                  [default: false]
    --error-pages       Serve error pages                   [default: true]
    --autoindex, -a     Automatically index directories     [default: true]
    --cache, -c         Store assets in-memory              [default: true]
    --watch-files       Watch files for cache update        [default: true]
    --client-cache      Client-side caching max-age         [default: 172800]
    --gzip, -g          Gzip text assets                    [default: true]
    --minify, -m        Minify text assets                  [default: false]
    --bundle, -b        Bundle text assets                  [default: false]
    --rebundle, --rb    Rebundle assets if modified         [default: true]
    --headers, -H       Custom response headers             [default: ""]
    --debug, -d         Log HTTP info                       [default: true]
    --quiet, -q         Prevent all log output              [default: false]
     

    Programmatic lactating

    Lactate can be used with either plain node, or with Express. With Express, Lactate is a drop-in replacement for static middleware, but with far more ability. The examples below use Express 2.x API for simplicity. See the examples for various examples.

    var lactate = require('lactate');
    var express = require('express');
     
    var app = express();
    app.use(lactate.static(__dirname + '/files'));

    Testing Lactate

    If installed locally (without -g flag to npm install):

    1. cd into ~/node_modules/lactate
    2. npm install ./ to install devDependencies
    3. make test to run mocha test

    The varieties of Lactate experience

    Creating a Lactate server

    var lactate = require('lactate'); 
    var options = {root:'files'}; 
    var server = lactate.createServer(options); 
     
    server.listen(8080);

    Creating a directory handler

    var lactate = require('lactate');
    var options = {from:'public/path/to/files'};
    var files = lactate.dir('files', options);
     
    var http = require('http');
    var server = new http.Server;
     
    server.addListener('request', function(req, res) {
      files.serve(req, res);
    });
     
    server.listen(8080);

    Using directory middleware

    var lactate = require('lactate');
    var files = lactate.dir('files', options);
     
    var http = require('http');
    var server = new http.Server;
     
    server.addListener('request', files.toMiddleware());
    server.listen(8080);

    Integrating with Express

    var lactate = require('lactate');
    var files = lactate.dir('files', options);
     
    var express = require('express');
    var app = express();
     
    app.use(files.toMiddleware());
    app.listen(8080);

    Using Express.static API

    var lactate = require('lactate');
    var express = require('express');
    var app = express();
     
    app.use(lactate.static(__dirname + '/files'));
    app.listen(8000);

    Using node-static API

    var lactate = require('lactate');
    var files = new(lactate.Server)('./files');
     
    var http = require('http');
    var server = new http.Server;
     
    // You could also pass a .toMiddleware()'d function
     
    server.addListener('request', function(req, res) {
      files.serve(req, res);
    });
     
    server.listen(8000);

    Serving individual files

    var lactate = require('lactate');
     
    var fileOptions = {from:'public/directory'};
    var files = lactate.dir('files', fileOptions);
     
    var pageOptions = {};
    var pages = lactate.dir('pages');
     
    var http = require('http');
    var server = new http.Server;
     
    server.addListener('request', function(req, res) {
      if (req.url === '/') {
        pages.serve('index.html', req, res);
      } else {
        files.serve(req, res);
      };
    });
    server.listen(8000);

    Setting options

    var lactate = require('lactate');
     
    var fileOptions = {
      from:'public'
    };
     
    var files = lactate.dir('files', fileOptions);
     
    files.set('cache', false);
    files.disable('gzip');
    files.maxAge('ten days');
     
    var express = require('express');
    var app = express():
      
    app.get('/public/*', files.toMiddleware());
    app.listen(8080);

    Bundling assets

    var lactate = require('lactate');
    var options = {
      from:'files'
    };
     
    var files = lactate.dir('files', options);
     
    // Combine and minify all scripts to 'common.js'
    files.bundle('js', 'common.js', function(err, data) {
    // Handle errors
    });
     
    // Combine and minify all CSS to 'common.css'
    files.bundleCSS('common.css');
     
    var express = require('express');
    var app = express();
     
    app.use(files.toMiddleware());
    app.listen(8000);

    Using custom 404 pages

    var lactate = require('lactate');
    var files = lactate.dir('files');
     
    files.notFound('path/to/404/page.html');
     
    files.notFound(function(req, res) {
      res.writeHead(404);
      res.end('Woops, 404');
    });
     
    var express = require('express');
    var app = express();
     
    app.use(files.toMiddleware());
    app.listen(8000);

    Using custom response headers

    var lactate = require('lactate');
    var files = lactate.dir('files');
     
    files.setHeader('x-powered-by', 'Lactate');
    files.header('x-timestamp', function(req, res) {
      return new Date().toUTCString();
    });
     
    var headers = {};
    files.headers(headers);

    Status listeners

    Lactate extends EventEmitter for emitting status code events.

    var files = lactate.dir('files');
    files.on('404', function(req) {
      console.log('404', req.url);
    });

    Options

    Setting options

    Boolean options may be set using enable and disable methods. Other options may be set using set method with either key/value or an options object.

    Passing to initialization function

    var lactate = require('lactate').Lactate({
      max_age:'two days'
    })

    Using set method

    lactate.set('hidden', true)

    Using enable/disable:

    lactate.disable('gzip');
    lactate.enable('minify');

    Special options methods

    Lactate has some special methods to reduce visual clutter. For setting client-side expiration use maxAge

    lactate.maxAge('two days');

    is equivalent to:

    lactate.set('max age', 'two days');

    For setting custom headers you may use setHeader

    lactate.setHeader('x-powered-by', 'Rodent exercise');

    You can also use a function with setHeader for added variance:

    lactate.setHeader('x-id', function(req, res) {
      return Math.random().toString(36).substring(2);
    }):

    For defining charsets, you may use Lactate.define

    lactate.define('js', 'application/javascript');

    or with an object

    lactate.define({
      'html': 'text/html; charset=utf-8',
      'js': 'application/javascript'
    });

    Underscores or spaces

    Use spaces instead of underscores if you prefer:

    lactate.disable('max age');
    lactate.enable('watch files');

    Options available

    • root string

    Local directory from which to serve files. By default, the current working directory.

    • from string

    Public directory exposed to clients. If set, only requests from /directory will complete. Contrast this with the root option which is the location of files on the serving machine, not necessarily the requested path.

    • subdirs boolean

    By default subdirectories are served. To disable this, set subdirs to false.

    • hidden boolean

    Whether or not to serve hidden files. Default is false.

    • error pages boolean

    Enabled by default. When disabled, Lactate will not serve error pages for 404 resposes, etc..

    • autoindex boolean

    Automatically display directory indexes. Disabled by default.

    • cache boolean or object

    Keep files in-memory. Enabled by default. For caching options and more information about caching strategy, see Caching Options.

    • gzip boolean

    If false, disables automatic gzipping for text files (HTML, JS, CSS). Enabled by default.

    • minify boolean

    If true, will automatically minify JavaScript and CSS using Abridge. Disabled by default.

    • watch files boolean

    Determines whether Lactate will watch files to update its cache. If this is disabled, then your file cache will not update automatically as files are modified on the server.

    • headers object or function

    Sets custom response headers. If the option value is a function, it is a callback which is give (req, res) arguments. This function should return the header value; it is a mapping function.

    • max age number or string

    Pass this function a number (of seconds) or a string and appropriate headers will be set for client-side caching. Lactate comes with expiration defaults, such as 'two days' or '5 years and sixteen days' See Expire for details.

    lactate.set('max_age', 87500)
    //87500 seconds
    lactate.set('max_age', 'two days')
    //172800 seconds
    lactate.set'max_age', 'five weeks and one minute and ten seconds')
    //3024070 seconds
    lactate.set('max_age', 'one year and 2 months and seven weeks and 16 seconds')
    //41050028 seconds
    • not found string or function

    For custom 404 handling. Functions are supplied the response for 100% custom response handling. Otherwise, if set to a string, this option will be treated as an ordinary file path and abide rules for gzipping / in-memory cache.

    • gzip patterns array

    Set custom gzip RegExp patterns. The patterns are matched with mime types. E.g. /(\+|\/)xml$/ may be used for matching XML documents for gzipping. You may either use:

    lactate.set('gzip patterns', []);

    Or perhaps more conveniently:

    //Accepts RegExp or String
    lactate.gzip(/pattern/, ...);
    • charset boolean or string

    Set custom response charset, or automatically detect charset using node-mime.

    lactate.enable('charset');
    // Content-Type: text/html; charset=UTF-8
    lactate.set('charset', 'utf-8');
    // Content-Type: text/html; charset=UTF-8
    • debug boolean

    Colored status / msg / path logging, for debugging purposes.

    Caching options

    Pass an object to the cache option setting. The following fields are accepted and optional:

    • expire Seconds expiration for cache keys. Keys expire after they are untouched for x-seconds. Default is 15min.
    • max keys Maximum number of keys to keep in memory. Default is Infinity.
    • max size Maximum size in MB to keep in cache. Default is 100mb.
    • segment Determines the threshold after which to segment a file for streaming instead of traditional writing. Default is 200kb.
      var options = {};
      
      options.cache = {
        expire:5,
        max_keys:200,
        max_size:2,
        segment:100
      };
     
      var files = lactate.static('files', options);
     
      // Or use a string representation. Same as setting for max-age.
      options.cache.expire = 'fifteen minutes';
      files.set('cache', options.cache);

    License

    MIT

    Keywords

    none

    install

    npm i lactate

    Downloadsweekly downloads

    220

    version

    0.13.12

    license

    none

    repository

    githubgithub

    last publish

    collaborators

    • avatar