@blamejs/blamejs-shop 0.3.56 → 0.3.58

package/lib/vendor/blamejs/test/layer-0-primitives/scim-server.test.js

@@ -22,8 +22,14 @@ function _mkRes() {
 async function _drive(mw, req) {
   var res = _mkRes();
   var nextCalled = false;
+  var ended = false;
+  var origEnd = res.end;
+  res.end = function (b) { ended = true; return origEnd.call(res, b); };
   mw(req, res, function () { nextCalled = true; });
-  await helpers.passiveObserve(50, "scim-server: middleware short-circuit window");
+  await helpers.waitUntil(function () { return ended || nextCalled; }, {
+    timeoutMs: 5000,
+    label:     "scim-server: middleware resolves (response written or next() called)",
+  });
   return { res: res, nextCalled: nextCalled };
 }
 
@@ -82,11 +88,168 @@ async function run() {
   var scimMod = require("../../lib/middleware/scim-server");
   check("ALLOWED_FILTER_OPS exported",    Array.isArray(scimMod.ALLOWED_FILTER_OPS));
   check("SCIM_CORE_SCHEMA_USER exported", scimMod.SCIM_CORE_SCHEMA_USER === "urn:ietf:params:scim:schemas:core:2.0:User");
+  check("BulkRequest URN exported",       scimMod.SCIM_MESSAGE_BULK_REQUEST === "urn:ietf:params:scim:api:messages:2.0:BulkRequest");
+  check("BulkResponse URN exported",      scimMod.SCIM_MESSAGE_BULK_RESPONSE === "urn:ietf:params:scim:api:messages:2.0:BulkResponse");
+
+  await _runBulkTests();
+}
+
+// RFC 7644 §3.7 — /Bulk operations.
+function _mkUsers() {
+  return {
+    _records: new Map(),
+    _seq:     0,
+    async create(rec) {
+      var id = "u-" + (++this._seq);
+      var out = Object.assign({ id: id, meta: { resourceType: "User" } }, rec);
+      this._records.set(id, out);
+      return out;
+    },
+    async read(id)        { return this._records.get(id) || null; },
+    async update(id, rec) { var r = Object.assign({}, rec, { id: id }); this._records.set(id, r); return r; },
+    async patch(id, ops)  { var r = this._records.get(id); ops.forEach(function (o) { if (o.op === "replace") r[o.path] = o.value; }); return r; },
+    async remove(id)      { this._records.delete(id); },
+    async list()          { return { totalResults: this._records.size, Resources: Array.from(this._records.values()) }; },
+  };
+}
+
+function _mkGroups() {
+  return {
+    _records:   new Map(),
+    _seq:       0,
+    _lastCreate: null,
+    async create(rec) {
+      var id = "g-" + (++this._seq);
+      var out = Object.assign({ id: id, meta: { resourceType: "Group" } }, rec);
+      this._records.set(id, out);
+      this._lastCreate = out;
+      return out;
+    },
+    async read(id)        { return this._records.get(id) || null; },
+    async update(id, rec) { var r = Object.assign({}, rec, { id: id }); this._records.set(id, r); return r; },
+    async patch(id, ops)  { var r = this._records.get(id); return r; },
+    async remove(id)      { this._records.delete(id); },
+    async list()          { return { totalResults: this._records.size, Resources: Array.from(this._records.values()) }; },
+  };
+}
+
+async function _bulkBody(mw, ops, extra) {
+  var body = Object.assign({
+    schemas:    ["urn:ietf:params:scim:api:messages:2.0:BulkRequest"],
+    Operations: ops,
+  }, extra || {});
+  return _drive(mw, { method: "POST", url: "/scim/v2/Bulk", headers: {}, body: body });
+}
+
+async function _runBulkTests() {
+  // Bulk disabled by default — SPC stays unsupported, /Bulk returns 501.
+  var off = b.middleware.scimServer({ basePath: "/scim/v2", users: _mkUsers() });
+  var offSpc = await _drive(off, { method: "GET", url: "/scim/v2/ServiceProviderConfig", headers: {} });
+  check("bulk default: SPC supported=false", JSON.parse(offSpc.res._body()).bulk.supported === false);
+  var offBulk = await _bulkBody(off, []);
+  check("bulk default: /Bulk → 501",         offBulk.res._sc() === 501);
+
+  // Enabled — SPC advertises supported=true + configured maxOperations.
+  var users  = _mkUsers();
+  var groups = _mkGroups();
+  var mw = b.middleware.scimServer({
+    basePath: "/scim/v2",
+    users:    users,
+    groups:   groups,
+    bulk:     { maxOperations: 3 },
+  });
+  var onSpc = JSON.parse((await _drive(mw, { method: "GET", url: "/scim/v2/ServiceProviderConfig", headers: {} })).res._body());
+  check("bulk enabled: SPC supported=true",  onSpc.bulk.supported === true);
+  check("bulk enabled: SPC maxOperations",   onSpc.bulk.maxOperations === 3);
+
+  // create + update + delete in one request → per-op statuses.
+  var seedUser = await users.create({ userName: "seed" });   // u-1
+  var batch = await _bulkBody(mw, [
+    { method: "POST",   path: "/Users", bulkId: "newuser",
+      data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "alice" } },
+    { method: "PUT",    path: "/Users/" + seedUser.id,
+      data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "seed-renamed" } },
+    { method: "DELETE", path: "/Users/" + seedUser.id },
+  ]);
+  var resp = JSON.parse(batch.res._body());
+  check("bulk: 200 envelope",                batch.res._sc() === 200);
+  check("bulk: BulkResponse schema",         resp.schemas.indexOf("urn:ietf:params:scim:api:messages:2.0:BulkResponse") !== -1);
+  check("bulk: 3 op results",                resp.Operations.length === 3);
+  check("bulk: POST → 201",                  resp.Operations[0].status === "201");
+  check("bulk: POST echoes bulkId",          resp.Operations[0].bulkId === "newuser");
+  check("bulk: POST location present",       typeof resp.Operations[0].location === "string");
+  check("bulk: PUT → 200",                   resp.Operations[1].status === "200");
+  check("bulk: DELETE → 204",                resp.Operations[2].status === "204");
+  check("bulk: DELETE has no response body", resp.Operations[2].response === undefined);
+
+  // A bulk POST whose resource body is missing its SCIM schema is rejected
+  // per-op (the same gate the singleton POST/PUT routes apply), not
+  // persisted through the adapter.
+  var badSchema = await _bulkBody(mw, [
+    { method: "POST", path: "/Users", data: { userName: "noschema" } },
+  ]);
+  var badSchemaResp = JSON.parse(badSchema.res._body());
+  check("bulk: POST with missing schema → per-op 400",
+        badSchemaResp.Operations.length === 1 && badSchemaResp.Operations[0].status === "400");
+
+  // bulkId cross-reference: create a user, then a group whose member
+  // references the just-created user by "bulkId:<id>" (RFC 7644 §3.7.2).
+  var users2  = _mkUsers();
+  var groups2 = _mkGroups();
+  var mw2 = b.middleware.scimServer({ basePath: "/scim/v2", users: users2, groups: groups2, bulk: { maxOperations: 10 } });
+  var ref = await _bulkBody(mw2, [
+    { method: "POST", path: "/Users", bulkId: "bob",
+      data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "bob" } },
+    { method: "POST", path: "/Groups", bulkId: "admins",
+      data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:Group"], displayName: "Admins",
+              members: [{ value: "bulkId:bob" }] } },
+  ]);
+  var refResp = JSON.parse(ref.res._body());
+  check("bulk ref: both succeed",            refResp.Operations[0].status === "201" && refResp.Operations[1].status === "201");
+  var createdUserId = users2._records.size === 1 ? Array.from(users2._records.keys())[0] : null;
+  var groupMembers  = groups2._lastCreate && groups2._lastCreate.members;
+  check("bulk ref: bulkId resolved to id",   Array.isArray(groupMembers) && groupMembers[0].value === createdUserId);
+  check("bulk ref: ref not left as token",   groupMembers[0].value.indexOf("bulkId:") === -1);
+
+  // over-maxOperations → 413, no operation dispatched.
+  var users3 = _mkUsers();
+  var mw3 = b.middleware.scimServer({ basePath: "/scim/v2", users: users3, bulk: { maxOperations: 1 } });
+  var tooMany = await _bulkBody(mw3, [
+    { method: "POST", path: "/Users", bulkId: "a", data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "a" } },
+    { method: "POST", path: "/Users", bulkId: "b", data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "b" } },
+  ]);
+  check("bulk: over-maxOperations → 413",    tooMany.res._sc() === 413);
+  check("bulk: over-max scimType=tooMany",   JSON.parse(tooMany.res._body()).scimType === "tooMany");
+  check("bulk: over-max dispatched nothing",  users3._records.size === 0);
+
+  // failOnErrors short-circuits at the first error.
+  var users4 = _mkUsers();
+  var failing = {
+    create: async function () { var e = new Error("upstream conflict"); e.statusCode = 409; e.scimType = "uniqueness"; throw e; },
+    read: users4.read.bind(users4), update: users4.update.bind(users4),
+    patch: users4.patch.bind(users4), remove: users4.remove.bind(users4), list: users4.list.bind(users4),
+  };
+  var mw4 = b.middleware.scimServer({ basePath: "/scim/v2", users: failing, bulk: { maxOperations: 10 } });
+  var short = await _bulkBody(mw4, [
+    { method: "POST", path: "/Users", bulkId: "x", data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "x" } },
+    { method: "POST", path: "/Users", bulkId: "y", data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "y" } },
+    { method: "POST", path: "/Users", bulkId: "z", data: { schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], userName: "z" } },
+  ], { failOnErrors: 1 });
+  var shortResp = JSON.parse(short.res._body());
+  check("bulk failOnErrors: stops after 1",  shortResp.Operations.length === 1);
+  check("bulk failOnErrors: error carries status", shortResp.Operations[0].status === "409");
+  check("bulk failOnErrors: error has body", shortResp.Operations[0].response.schemas.indexOf("urn:ietf:params:scim:api:messages:2.0:Error") !== -1);
+
+  // config-time refusal: non-integer cap throws at create time.
+  var threwCap = false;
+  try { b.middleware.scimServer({ basePath: "/scim/v2", users: _mkUsers(), bulk: { maxOperations: -5 } }); }
+  catch (e) { threwCap = /bad-bulk-max-operations/.test(e.code || ""); }
+  check("bulk: bad maxOperations refused",   threwCap);
 }
 
 module.exports = { run: run };
 
 if (require.main === module) {
   run().then(function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
-             function (e) { console.error("FAIL:", e.stack || e); process.exit(1); });
+             function (e) { process.exitCode = 1; throw e; });
 }

package/lib/vendor/blamejs/test/layer-0-primitives/sse.test.js

@@ -7,7 +7,9 @@ var helpers = require("../helpers");
 var b     = helpers.b;
 var check = helpers.check;
 
-var sseModule = require("../../lib/middleware/sse");
+var sseModule   = require("../../lib/middleware/sse");
+var EventEmitter = require("events");
+var auditModule = require("../../lib/audit");
 
 // Mock ServerResponse — captures writeHead + write + end.
 function _mockRes() {
@@ -148,6 +150,36 @@ async function run() {
     label: "sse: onAbort fires on res 'close'",
   });
   check("sse: onAbort fires on res close", aborted === true);
+
+  // ---- a transport-fault close audits as a failure, not a clean close ----
+  // A write-to-dead-pipe / stream error closes the channel like an operator
+  // close does, but it is NOT clean — the audit event must say so + carry the
+  // reason, so the evidence stream distinguishes the two.
+  var capturedAudit = [];
+  var origSafeEmit  = auditModule.safeEmit;
+  auditModule.safeEmit = function (e) { capturedAudit.push(e); };
+  try {
+    var faultRes = new EventEmitter();   // needs .on so sse attaches its fault handlers
+    faultRes.writeHead = function () {};
+    faultRes.setHeader = function () {};
+    faultRes.getHeader = function () { return undefined; };
+    faultRes.write     = function () { return true; };
+    faultRes.end       = function () {};
+    var faultReq = { method: "GET", url: "/events", headers: {}, on: function () {}, once: function () {} };
+    // b.sse.create(req, res, opts) is the low-level channel; audit defaults on.
+    b.sse.create(faultReq, faultRes, { heartbeatMs: 0 });
+    faultRes.emit("error", new Error("pipe broke"));
+    await helpers.waitUntil(function () {
+      return capturedAudit.some(function (e) { return e.action === "sse.channel_closed"; });
+    }, { label: "sse: fault-close audit emitted" });
+    var faultEv = capturedAudit.find(function (e) { return e.action === "sse.channel_closed"; });
+    check("sse fault-close: outcome is failure (not success)",
+          faultEv && faultEv.outcome === "failure");
+    check("sse fault-close: reason recorded in metadata",
+          faultEv && faultEv.metadata && faultEv.metadata.reason === "stream-error");
+  } finally {
+    auditModule.safeEmit = origSafeEmit;
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/static.test.js

@@ -243,6 +243,62 @@ function testRejectsUnknownOpts() {
   fs.rmSync(dir, { recursive: true, force: true });
 }
 
+// onError mirrors onServe on the refusal paths. A denying permissions
+// gate forces a 403, which previously fired no operator callback.
+async function testOnErrorFiresOnRefusal() {
+  var ctx = await _server();
+  _writeFile(ctx.dir, "secret.txt", "classified");
+  var seen = [];
+  var denyPerms = { check: async function () { return false; } };
+  var srv = await ctx.start({
+    contentSafety: null,
+    permissions:   denyPerms,
+    onError:       function (info) { seen.push(info); },
+  });
+  try {
+    var r = await _get(srv.port, "/secret.txt");
+    check("onError: refusal returns 403",            r.statusCode === 403);
+    check("onError: hook fired once on the refusal", seen.length === 1);
+    check("onError: hook carries status + code + urlPath",
+          seen[0].status === 403 && seen[0].code === "permission_denied" &&
+          seen[0].urlPath === "/secret.txt");
+  } finally {
+    srv.close();
+    ctx.cleanup();
+  }
+}
+
+// onError is observability-only: a throwing hook must not corrupt the
+// refusal response already on the wire.
+async function testOnErrorThrowDoesNotCorruptResponse() {
+  var ctx = await _server();
+  _writeFile(ctx.dir, "secret.txt", "classified");
+  var denyPerms = { check: async function () { return false; } };
+  var srv = await ctx.start({
+    contentSafety: null,
+    permissions:   denyPerms,
+    onError:       function () { throw new Error("sink broke"); },
+  });
+  try {
+    var r = await _get(srv.port, "/secret.txt");
+    check("onError: throwing hook still yields the 403",
+          r.statusCode === 403 && /Forbidden/.test(r.body.toString("utf8")));
+  } finally {
+    srv.close();
+    ctx.cleanup();
+  }
+}
+
+function testOnErrorRejectsNonFunction() {
+  var threw = null;
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-static-fa-"));
+  try {
+    b.staticServe.create({ root: dir, onError: "nope" });
+  } catch (e) { threw = e; }
+  check("onError non-function rejected at create()", threw !== null);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
 async function run() {
   await testForceAttachmentDefaultOff();
   await testForceAttachmentOnHtml();
@@ -254,6 +310,9 @@ async function run() {
   await testForceAttachmentPdfDefaultDownload();
   await testForceAttachmentPdfOptInInline();
   testRejectsUnknownOpts();
+  await testOnErrorFiresOnRefusal();
+  await testOnErrorThrowDoesNotCorruptResponse();
+  testOnErrorRejectsNonFunction();
 }
 
 module.exports = { run: run };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.3.56",
+  "version": "0.3.58",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {