@blamejs/core 0.7.0 → 0.7.4

package/lib/object-store/azure-blob.js

@@ -36,6 +36,7 @@ var { Readable } = require("stream");
 var safeXml = require("../parsers/safe-xml");
 var sharedRequest = require("./http-request");
 var C = require("../constants");
+var requestHelpers = require("../request-helpers");
 var { ObjectStoreError } = require("../framework-error");
 var time = require("../time");
 var safeUrl = require("../safe-url");
@@ -248,16 +249,51 @@ function create(config) {
     });
   }
 
-  function get(key) {
+  // get(key, opts?) — opts forwarded to Azure as conditional / range
+  // headers (Range / x-ms-range, If-None-Match, If-Match,
+  // If-Modified-Since, If-Unmodified-Since). Returns the body buffer;
+  // operators wanting status + response headers call getResponse().
+  function get(key, opts) {
+    return getResponse(key, opts).then(function (r) { return r.body; });
+  }
+
+  function getStream(key, opts) { return Readable.from(get(key, opts)); }
+
+  function getResponse(key, opts) {
+    opts = opts || {};
     var url = _blobUrl(key);
-    var headers = _signed("GET", url, {});
+    var extraHeaders = {};
+    if (opts.range) {
+      extraHeaders["x-ms-range"] = "bytes=" + opts.range.start + "-" + opts.range.end;
+    }
+    if (opts.ifNoneMatch)       extraHeaders["If-None-Match"]       = opts.ifNoneMatch;
+    if (opts.ifMatch)           extraHeaders["If-Match"]            = opts.ifMatch;
+    if (opts.ifModifiedSince)   extraHeaders["If-Modified-Since"]   = opts.ifModifiedSince;
+    if (opts.ifUnmodifiedSince) extraHeaders["If-Unmodified-Since"] = opts.ifUnmodifiedSince;
+    var headers = _signed("GET", url, extraHeaders);
     return _httpRequest("GET", url, headers, null, reqOpts).then(function (res) {
-      return res.body;
+      return {
+        statusCode:   res.statusCode,
+        body:         res.body,
+        etag:         res.headers && res.headers.etag,
+        lastModified: res.headers && res.headers["last-modified"]
+                      ? Date.parse(res.headers["last-modified"]) : null,
+        contentRange: res.headers && res.headers["content-range"] || null,
+        size:         res.headers && res.headers["content-length"]
+                      ? parseInt(res.headers["content-length"], 10) : null,
+        contentType:  res.headers && res.headers["content-type"] || null,
+      };
+    }, function (err) {
+      if (err && err.statusCode === requestHelpers.HTTP_STATUS.NOT_MODIFIED) {
+        return {
+          statusCode: requestHelpers.HTTP_STATUS.NOT_MODIFIED,
+          body: null, etag: null, lastModified: null,
+        };
+      }
+      throw err;
     });
   }
 
-  function getStream(key) { return Readable.from(get(key)); }
-
   function head(key) {
     var url = _blobUrl(key);
     var headers = _signed("HEAD", url, {});
@@ -434,6 +470,7 @@ function create(config) {
     put:         put,
     get:         get,
     getStream:   getStream,
+    getResponse: getResponse,
     head:        head,
     delete:      deleteKey,
     list:        list,

package/lib/object-store/gcs.js

@@ -28,6 +28,7 @@ var { Readable } = require("stream");
 var safeJson = require("../safe-json");
 var C = require("../constants");
 var nb = require("../numeric-bounds");
+var requestHelpers = require("../request-helpers");
 var { ObjectStoreError } = require("../framework-error");
 var safeUrl = require("../safe-url");
 var sharedRequest = require("./http-request");
@@ -223,15 +224,53 @@ function create(config) {
     return { size: parseInt(meta.size || buf.length, 10), etag: meta.etag };
   }
 
-  async function get(key) {
-    var token = await _ensureToken();
-    var url = _objectUrl(key, { alt: "media" });
-    var res = await _httpRequest("GET", url, authHeader.bearer(token), null, reqOpts);
-    return res.body;
+  // get(key, opts?) — opts forwarded to GCS as conditional / range
+  // headers (Range, If-None-Match, If-Match, If-Modified-Since,
+  // If-Unmodified-Since). Returns the body buffer for backwards compat;
+  // operators wanting full status + response headers call getResponse().
+  async function get(key, opts) {
+    var r = await getResponse(key, opts);
+    return r.body;
   }
 
-  function getStream(key) {
-    return Readable.from(get(key));
+  function getStream(key, opts) {
+    return Readable.from(get(key, opts));
+  }
+
+  async function getResponse(key, opts) {
+    opts = opts || {};
+    var token = await _ensureToken();
+    var url = _objectUrl(key, { alt: "media" });
+    var headers = authHeader.bearer(token);
+    if (opts.range) {
+      headers["Range"] = "bytes=" + opts.range.start + "-" + opts.range.end;
+    }
+    if (opts.ifNoneMatch)       headers["If-None-Match"]       = opts.ifNoneMatch;
+    if (opts.ifMatch)           headers["If-Match"]            = opts.ifMatch;
+    if (opts.ifModifiedSince)   headers["If-Modified-Since"]   = opts.ifModifiedSince;
+    if (opts.ifUnmodifiedSince) headers["If-Unmodified-Since"] = opts.ifUnmodifiedSince;
+    try {
+      var res = await _httpRequest("GET", url, headers, null, reqOpts);
+      return {
+        statusCode:   res.statusCode,
+        body:         res.body,
+        etag:         res.headers && res.headers.etag,
+        lastModified: res.headers && res.headers["last-modified"]
+                      ? Date.parse(res.headers["last-modified"]) : null,
+        contentRange: res.headers && res.headers["content-range"] || null,
+        size:         res.headers && res.headers["content-length"]
+                      ? parseInt(res.headers["content-length"], 10) : null,
+        contentType:  res.headers && res.headers["content-type"] || null,
+      };
+    } catch (err) {
+      if (err && err.statusCode === requestHelpers.HTTP_STATUS.NOT_MODIFIED) {
+        return {
+          statusCode: requestHelpers.HTTP_STATUS.NOT_MODIFIED,
+          body: null, etag: null, lastModified: null,
+        };
+      }
+      throw err;
+    }
   }
 
   async function head(key) {
@@ -457,6 +496,7 @@ function create(config) {
     put:       put,
     get:       get,
     getStream: getStream,
+    getResponse: getResponse,
     head:      head,
     delete:    deleteKey,
     list:      list,

package/lib/object-store/sigv4.js

@@ -30,6 +30,7 @@ var safeXml = require("../parsers/safe-xml");
 var sharedRequest = require("./http-request");
 var C = require("../constants");
 var nb = require("../numeric-bounds");
+var requestHelpers = require("../request-helpers");
 var { ObjectStoreError } = require("../framework-error");
 var safeUrl = require("../safe-url");
 
@@ -593,18 +594,64 @@ function create(config) {
     }
   }
 
-  function get(key) {
+  // get(key, opts?) — opts forwarded to the request as conditional /
+  // range headers so operator HTTP routes can pass If-None-Match,
+  // If-Match, If-Modified-Since, If-Unmodified-Since, and Range from the
+  // client request straight through to S3. Returns just the body buffer
+  // for backwards compatibility; operators wanting status + response
+  // headers (304 vs 206 vs 200) call getResponse() instead.
+  function get(key, opts) {
+    return getResponse(key, opts).then(function (r) { return r.body; });
+  }
+
+  function getStream(key, opts) {
+    return Readable.from(get(key, opts));
+  }
+
+  // getResponse(key, opts?) — full-fidelity GET. Returns
+  // { body, statusCode, etag, lastModified, contentRange, size,
+  //   contentType }. Throws on non-2xx EXCEPT 304 (returned as
+  // { statusCode: 304, etag, lastModified, body: null }) so operator
+  // routes can short-circuit conditional GETs without losing the
+  // response headers.
+  function getResponse(key, opts) {
+    opts = opts || {};
     var url = _keyToUrl(key);
     var headers = _makeSigned("GET", url, sha256Hex(Buffer.alloc(0)));
-    return _request("GET", url, headers, null, reqOpts).then(function (res) {
-      return res.body;
+    if (opts.range) {
+      headers["Range"] = "bytes=" + opts.range.start + "-" + opts.range.end;
+    }
+    if (opts.ifNoneMatch)      headers["If-None-Match"]      = opts.ifNoneMatch;
+    if (opts.ifMatch)          headers["If-Match"]           = opts.ifMatch;
+    if (opts.ifModifiedSince)  headers["If-Modified-Since"]  = opts.ifModifiedSince;
+    if (opts.ifUnmodifiedSince) headers["If-Unmodified-Since"] = opts.ifUnmodifiedSince;
+    var localReqOpts = Object.assign({}, reqOpts, { _resolveOnRedirect: false });
+    return _request("GET", url, headers, null, localReqOpts).then(function (res) {
+      return {
+        statusCode:   res.statusCode,
+        body:         res.body,
+        etag:         res.headers && res.headers.etag,
+        lastModified: res.headers && res.headers["last-modified"]
+                      ? Date.parse(res.headers["last-modified"]) : null,
+        contentRange: res.headers && res.headers["content-range"] || null,
+        size:         res.headers && res.headers["content-length"]
+                      ? parseInt(res.headers["content-length"], 10) : null,
+        contentType:  res.headers && res.headers["content-type"] || null,
+      };
+    }, function (err) {
+      // 304 surfaces as a "non-2xx error" via httpClient; propagate it
+      // as a structured 304 result instead so operator routes get
+      // the conditional-GET short-circuit they expect.
+      if (err && err.statusCode === requestHelpers.HTTP_STATUS.NOT_MODIFIED) {
+        return {
+          statusCode: requestHelpers.HTTP_STATUS.NOT_MODIFIED,
+          body: null, etag: null, lastModified: null,
+        };
+      }
+      throw err;
     });
   }
 
-  function getStream(key) {
-    return Readable.from(get(key));
-  }
-
   function head(key) {
     var url = _keyToUrl(key);
     var headers = _makeSigned("HEAD", url, sha256Hex(Buffer.alloc(0)));
@@ -829,6 +876,7 @@ function create(config) {
     put:       put,
     get:       get,
     getStream: getStream,
+    getResponse: getResponse,
     head:      head,
     delete:    deleteKey,
     list:      list,

package/lib/pubsub-redis.js

@@ -41,17 +41,7 @@ function create(opts) {
   // double-fire local handlers).
   var instanceNonce = fwCrypto.generateToken(C.BYTES.bytes(8));
 
-  var clientOpts = {
-    url:                  opts.redisUrl,
-    password:             opts.redisPassword,
-    username:             opts.redisUsername,
-    tls:                  opts.redisTls,
-    ca:                   opts.redisCa,
-    servername:           opts.redisServername,
-    connectTimeoutMs:     opts.redisConnectTimeoutMs,
-    commandTimeoutMs:     opts.redisCommandTimeoutMs,
-    maxReconnectAttempts: opts.redisMaxReconnectAttempts,
-  };
+  var clientOpts = redisClient.pickClientOpts(opts, "redis");
 
   var subscriberConn = null;
   var publisherConn  = null;

package/lib/queue-redis.js

@@ -254,14 +254,7 @@ function create(opts) {
   var prefix = typeof opts.keyPrefix === "string" && opts.keyPrefix.length > 0
                     ? opts.keyPrefix : DEFAULT_PREFIX;
 
-  var client = redisClient.create({
-    url:       opts.url,
-    password:  opts.password,
-    username:  opts.username,
-    tls:       opts.tls,
-    connectTimeoutMs: opts.connectTimeoutMs,
-    commandTimeoutMs: opts.commandTimeoutMs,
-  });
+  var client = redisClient.create(redisClient.pickClientOpts(opts));
 
   // Lazy connect — defer first connect until the first operation so
   // queue.init({ backends }) doesn't have to be async.

package/lib/redis-client.js

@@ -479,8 +479,38 @@ function _parseRedisUrl(s) {
   };
 }
 
+// pickClientOpts(cfg, prefix?) — extract the standard redis-client opts
+// from a larger config bag. Lets cache-redis / pubsub-redis / queue-redis
+// / etc. forward to redisClient.create without each repeating the 9-key
+// list. The optional `prefix` lets callers whose operator-facing opts
+// are namespaced (`redisUrl`, `redisPassword`, ...) reuse the same
+// helper by passing prefix="redis" — the helper camel-cases the prefix
+// onto each key.
+//
+//   var opts = redisClient.pickClientOpts(cfg);                // unprefixed
+//   var opts = redisClient.pickClientOpts(operatorOpts, "redis"); // redisUrl etc.
+function pickClientOpts(cfg, prefix) {
+  if (!cfg || typeof cfg !== "object") return {};
+  function pick(name) {
+    if (!prefix) return cfg[name];
+    return cfg[prefix + name.charAt(0).toUpperCase() + name.slice(1)];
+  }
+  return {
+    url:                  pick("url"),
+    password:             pick("password"),
+    username:             pick("username"),
+    tls:                  pick("tls"),
+    ca:                   pick("ca"),
+    servername:           pick("servername"),
+    connectTimeoutMs:     pick("connectTimeoutMs"),
+    commandTimeoutMs:     pick("commandTimeoutMs"),
+    maxReconnectAttempts: pick("maxReconnectAttempts"),
+  };
+}
+
 module.exports = {
   create:           create,
+  pickClientOpts:   pickClientOpts,
   // Exposed for tests / direct callers that already manage their own socket.
   _encodeCommand:   _encodeCommand,
   _parseFrame:      _parseFrame,

package/lib/request-helpers.js

@@ -41,23 +41,27 @@
 // every consumer reads HTTP_STATUS.<NAME> rather than the underlying
 // integer, so the hex form is purely an internal storage detail.
 var HTTP_STATUS = Object.freeze({
-  OK:                       0xC8,
-  NO_CONTENT:               0xCC,
-  NOT_MODIFIED:             0x130,
-  BAD_REQUEST:              0x190,
-  UNAUTHORIZED:             0x191,
-  FORBIDDEN:                0x193,
-  NOT_FOUND:                0x194,
-  METHOD_NOT_ALLOWED:       0x195,
-  CONFLICT:                 0x199,
-  PAYLOAD_TOO_LARGE:        0x19D,
-  UNSUPPORTED_MEDIA_TYPE:   0x19F,
-  UNPROCESSABLE_CONTENT:    0x1A6,
-  TOO_MANY_REQUESTS:        0x1AD,
-  INTERNAL_SERVER_ERROR:    0x1F4,
-  BAD_GATEWAY:              0x1F6,
-  SERVICE_UNAVAILABLE:      0x1F7,
-  GATEWAY_TIMEOUT:          0x1F8,
+  OK:                            0xC8,
+  PARTIAL_CONTENT:               0xCE,
+  NO_CONTENT:                    0xCC,
+  NOT_MODIFIED:                  0x130,
+  BAD_REQUEST:                   0x190,
+  UNAUTHORIZED:                  0x191,
+  FORBIDDEN:                     0x193,
+  NOT_FOUND:                     0x194,
+  METHOD_NOT_ALLOWED:            0x195,
+  CONFLICT:                      0x199,
+  PAYLOAD_TOO_LARGE:             0x19D,
+  UNSUPPORTED_MEDIA_TYPE:        0x19F,
+  RANGE_NOT_SATISFIABLE:         0x1A0,
+  UNPROCESSABLE_CONTENT:         0x1A6,
+  PRECONDITION_FAILED:           0x19C,
+  TOO_MANY_REQUESTS:             0x1AD,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 0x1C3,
+  INTERNAL_SERVER_ERROR:         0x1F4,
+  BAD_GATEWAY:                   0x1F6,
+  SERVICE_UNAVAILABLE:           0x1F7,
+  GATEWAY_TIMEOUT:               0x1F8,
 });
 
 // extractActorContext(req) — pull the 5 W's from a request for audit

package/lib/seeders.js

@@ -137,11 +137,9 @@ function _validateEnv(name, value) {
 function _validateCreateOpts(opts) {
   validateOpts.requireObject(opts, "seeders.create", SeederError);
   validateOpts.requireNonEmptyString(opts.dir, "seeders.create: dir", SeederError, "BAD_OPT");
-  if (opts.db !== undefined && opts.db !== null) {
-    if (typeof opts.db !== "object" || typeof opts.db.prepare !== "function") {
-      throw _err("BAD_OPT", "seeders.create: db must be a SQLite-shaped handle (prepare fn)");
-    }
-  }
+  validateOpts.optionalObjectWithMethod(opts.db, "prepare",
+    "seeders.create: db", SeederError, "BAD_OPT",
+    "must be a SQLite-shaped handle (prepare fn)");
   validateOpts.auditShape(opts.audit, "seeders.create", SeederError);
   validateOpts.optionalBoolean(opts.auditApplied, "seeders.create: auditApplied", SeederError);
   validateOpts.optionalBoolean(opts.auditFailures, "seeders.create: auditFailures", SeederError);
@@ -205,18 +203,8 @@ function _loadSeed(rootDir, env, file) {
     throw _err("BAD_SEED",
       "seed '" + env + "/" + file + "': rerunnable must be a boolean");
   }
-  if (mod.dependsOn !== undefined) {
-    if (!Array.isArray(mod.dependsOn)) {
-      throw _err("BAD_SEED",
-        "seed '" + env + "/" + file + "': dependsOn must be an array of seed filenames");
-    }
-    for (var j = 0; j < mod.dependsOn.length; j++) {
-      if (typeof mod.dependsOn[j] !== "string" || mod.dependsOn[j].length === 0) {
-        throw _err("BAD_SEED",
-          "seed '" + env + "/" + file + "': dependsOn[" + j + "] must be a non-empty string");
-      }
-    }
-  }
+  validateOpts.optionalNonEmptyStringArray(mod.dependsOn,
+    "seed '" + env + "/" + file + "': dependsOn", SeederError, "BAD_SEED");
   if (mod.description !== undefined && typeof mod.description !== "string") {
     throw _err("BAD_SEED",
       "seed '" + env + "/" + file + "': description must be a string");