@blamejs/blamejs-shop 0.3.56 → 0.3.58

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

@@ -693,6 +693,44 @@ function run() {
           function () {});
   check("openapiServe: same-origin omits CORS",  sentSO.headers["Access-Control-Allow-Origin"] == null);
 
+  // accessControl={ allowOrigin } echoes one validated origin + Vary: Origin
+  var serveAO = b.middleware.openapiServe({
+    document: serveDoc,
+    accessControl: { allowOrigin: "https://docs.example.com" },
+    audit: false,
+  });
+  var sentAO = { headers: null };
+  serveAO({ method: "GET", url: "/openapi.json", pathname: "/openapi.json", headers: {} },
+          { writeHead: function (s, h) { sentAO.headers = h; },
+            end:       function () {} },
+          function () {});
+  check("openapiServe: allowOrigin echoed",      sentAO.headers["Access-Control-Allow-Origin"] === "https://docs.example.com");
+  check("openapiServe: allowOrigin sets Vary",   sentAO.headers["Vary"] === "Origin");
+
+  // allowOrigin with a default port is canonicalized (443 dropped)
+  var serveAOPort = b.middleware.openapiServe({
+    document: serveDoc,
+    accessControl: { allowOrigin: "https://Docs.Example.com:443" },
+    audit: false,
+  });
+  var sentAOPort = { headers: null };
+  serveAOPort({ method: "GET", url: "/openapi.json", pathname: "/openapi.json", headers: {} },
+          { writeHead: function (s, h) { sentAOPort.headers = h; },
+            end:       function () {} },
+          function () {});
+  check("openapiServe: allowOrigin canonicalized", sentAOPort.headers["Access-Control-Allow-Origin"] === "https://docs.example.com");
+
+  // A bad allowOrigin throws at config time (header-injection / pathful / junk)
+  rejects("openapiServe: allowOrigin with path rejected",
+    function () { b.middleware.openapiServe({ document: serveDoc, accessControl: { allowOrigin: "https://x.example.com/docs" } }); },
+    /bare origin/);
+  rejects("openapiServe: allowOrigin CRLF rejected",
+    function () { b.middleware.openapiServe({ document: serveDoc, accessControl: { allowOrigin: "https://x.example.com\r\nX-Evil: 1" } }); },
+    /valid|bare origin/);
+  rejects("openapiServe: allowOrigin non-http rejected",
+    function () { b.middleware.openapiServe({ document: serveDoc, accessControl: { allowOrigin: "ftp://x.example.com" } }); },
+    /valid|origin/);
+
   check("openapiServe.forceRebuild is fn",       typeof serve.forceRebuild === "function");
 
   // ---- bigger schema-walk coverage ----
@@ -862,12 +900,151 @@ function run() {
   });
   check("openapi.parse: dangling security",      dangling.valid === false &&
                                                   dangling.errors.join(",").indexOf("undefined scheme") !== -1);
+  var danglingWebhook = b.openapi.parse({
+    openapi: "3.2.0", info: { title: "T", version: "1.0" },
+    webhooks: { e: { post: { responses: { "200": { description: "ok" } }, security: [{ missing: [] }] } } },
+    components: { securitySchemes: {} },
+  });
+  check("openapi.parse: dangling webhook-operation security",
+        danglingWebhook.valid === false &&
+        danglingWebhook.errors.join(",").indexOf("undefined scheme") !== -1);
 
   rejects("openapi.parse: bad JSON",
     function () { b.openapi.parse("{not valid json"); }, /invalid JSON/);
   rejects("openapi.parse: bad input",
     function () { b.openapi.parse(42); }, /must be a JSON string/);
 
+  // ---- OpenAPI 3.2: opt-in version + webhooks + jsonSchemaDialect ----
+
+  // 3.1 stays the default emitted version unless opted in.
+  var apiDefault = b.openapi.create({ info: { title: "Def", version: "1.0.0" } });
+  check("3.2: default version still 3.1.0",      apiDefault.toJson().openapi === "3.1.0");
+  check("3.2: no webhooks key by default",       apiDefault.toJson().webhooks === undefined);
+  check("3.2: no jsonSchemaDialect by default",  apiDefault.toJson().jsonSchemaDialect === undefined);
+
+  // Opt into 3.2 with webhooks + jsonSchemaDialect.
+  var api32 = b.openapi.create({
+    openapi:           "3.2.0",
+    jsonSchemaDialect: "https://spec.openapis.org/oas/3.1/dialect/base",
+    info:              { title: "Webhook API", version: "1.0.0" },
+  });
+  api32.path("get", "/health", { responses: { "200": { description: "ok" } } });
+  api32.webhook("newPet", "post", {
+    summary:     "A new pet has been created",
+    requestBody: { content: { "application/json": { schema: { type: "object" } } } },
+    responses:   { "200": { description: "ack" }, "410": { description: "stop" } },
+  });
+  var doc32 = api32.toJson();
+  check("3.2: opted-in version emitted",         doc32.openapi === "3.2.0");
+  check("3.2: jsonSchemaDialect emitted",        doc32.jsonSchemaDialect === "https://spec.openapis.org/oas/3.1/dialect/base");
+  check("3.2: webhooks map present",             doc32.webhooks != null && doc32.webhooks.newPet != null);
+  check("3.2: webhook operation method",         doc32.webhooks.newPet.post.summary === "A new pet has been created");
+  check("3.2: webhook responses retained",       doc32.webhooks.newPet.post.responses["200"].description === "ack");
+  check("3.2: paths still emitted alongside",    doc32.paths["/health"].get != null);
+
+  // YAML emits the new top-level keys.
+  var yaml32 = api32.toYaml();
+  check("3.2: YAML has webhooks",                yaml32.indexOf("webhooks:") !== -1);
+  check("3.2: YAML has jsonSchemaDialect",       yaml32.indexOf("jsonSchemaDialect:") !== -1);
+
+  // Unsupported version refused at config time.
+  rejects("3.2: unknown version 4.0 refused",
+    function () { b.openapi.create({ openapi: "4.0.0", info: { title: "x", version: "1.0.0" } }); },
+    /version must be one of/);
+
+  // Non-string jsonSchemaDialect refused at config time.
+  rejects("3.2: non-string dialect refused",
+    function () { b.openapi.create({ jsonSchemaDialect: 123, info: { title: "x", version: "1.0.0" } }); },
+    /jsonSchemaDialect/);
+
+  // Webhook duplicate operation rejected.
+  rejects("3.2: duplicate webhook operation",
+    function () {
+      api32.webhook("newPet", "post", { responses: { "200": { description: "ok" } } });
+    },
+    /duplicate operation/);
+
+  // Webhook bad method rejected.
+  rejects("3.2: webhook bad method",
+    function () { api32.webhook("e", "nope", { responses: { "200": { description: "ok" } } }); },
+    /method must be/);
+
+  // Webhook missing name rejected.
+  rejects("3.2: webhook missing name",
+    function () { api32.webhook("", "post", { responses: { "200": { description: "ok" } } }); },
+    /name/);
+
+  // Webhook responses still required (operation rules apply).
+  rejects("3.2: webhook missing responses",
+    function () { api32.webhook("noResp", "post", {}); },
+    /responses object is required/);
+
+  // Per-webhook-operation dangling security is caught.
+  var apiWhSec = b.openapi.create({ openapi: "3.2.0", info: { title: "WS", version: "1.0.0" } });
+  apiWhSec.webhook("evt", "post", {
+    security:  [{ ghost: [] }],
+    responses: { "200": { description: "ok" } },
+  });
+  rejects("3.2: dangling webhook security",
+    function () { apiWhSec.toJson(); },
+    /webhook POST evt references undefined security scheme/);
+
+  // Webhook with a registered scheme passes.
+  var apiWhOk = b.openapi.create({ openapi: "3.2.0", info: { title: "WO", version: "1.0.0" } });
+  apiWhOk.security.add("bearerAuth", b.openapi.security.bearer());
+  apiWhOk.webhook("evt", "post", {
+    security:  [{ bearerAuth: [] }],
+    responses: { "200": { description: "ok" } },
+  });
+  check("3.2: webhook with registered scheme ok", apiWhOk.toJson().webhooks.evt.post.security[0].bearerAuth.length === 0);
+
+  // ---- parse() accepts 3.2 + validates webhooks / jsonSchemaDialect ----
+  var p32 = b.openapi.parse({
+    openapi:           "3.2.0",
+    jsonSchemaDialect: "https://spec.openapis.org/oas/3.1/dialect/base",
+    info:              { title: "T", version: "1.0.0" },
+    paths:             { "/x": { get: { responses: { "200": { description: "ok" } } } } },
+    webhooks:          { newPet: { post: { responses: { "200": { description: "ack" } } } } },
+  });
+  check("parse: 3.2 webhook doc valid",          p32.valid === true && p32.errors.length === 0);
+
+  // 3.1 doc still parses unchanged.
+  var p31 = b.openapi.parse({ openapi: "3.1.0", info: { title: "T", version: "1.0.0" } });
+  check("parse: 3.1 still valid",                p31.valid === true);
+
+  // Unknown version 4.0 still refused.
+  var p40 = b.openapi.parse({ openapi: "4.0.0", info: { title: "T", version: "1.0.0" } });
+  check("parse: 4.0 invalid",                    p40.valid === false &&
+                                                  p40.errors.join(",").indexOf("3.2.x") !== -1);
+
+  // Webhook operation missing description is invalid.
+  var pWhBad = b.openapi.parse({
+    openapi: "3.2.0", info: { title: "T", version: "1.0.0" },
+    webhooks: { e: { post: { responses: { "200": {} } } } },
+  });
+  check("parse: webhook missing description",    pWhBad.valid === false &&
+                                                  pWhBad.errors.join(",").indexOf("webhook e") !== -1);
+
+  // Webhooks not an object is invalid.
+  var pWhType = b.openapi.parse({
+    openapi: "3.2.0", info: { title: "T", version: "1.0.0" }, webhooks: "nope",
+  });
+  check("parse: webhooks non-object invalid",    pWhType.valid === false &&
+                                                  pWhType.errors.join(",").indexOf("webhooks") !== -1);
+
+  // Non-string jsonSchemaDialect is invalid.
+  var pDialect = b.openapi.parse({
+    openapi: "3.2.0", info: { title: "T", version: "1.0.0" }, jsonSchemaDialect: 5,
+  });
+  check("parse: bad jsonSchemaDialect invalid",  pDialect.valid === false &&
+                                                  pDialect.errors.join(",").indexOf("jsonSchemaDialect") !== -1);
+
+  // Round-trip a built 3.2 doc through parse.
+  var built32 = b.openapi.create({ openapi: "3.2.0", info: { title: "T", version: "1.0.0" } });
+  built32.webhook("evt", "post", { responses: { "200": { description: "ok" } } });
+  var roundTrip32 = b.openapi.parse(built32.toJsonString());
+  check("parse: 3.2 round-trip valid",           roundTrip32.valid === true);
+
   console.log("OK — openapi tests");
 }
 

package/lib/vendor/blamejs/test/layer-0-primitives/queue-byo-db.test.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * queue — bring-your-own database for the local backend.
+ *
+ * The local protocol defaults to the framework DB + "_blamejs_jobs"
+ * table, but accepts { db, table, schema } so an operator can point the
+ * queue rows at their own store / table / schema. Identifiers are
+ * validated + quoted through b.safeSql (SQL identifier injection, CWE-89)
+ * and refused at config time when unsafe; sealed columns (payload,
+ * lastError) stay sealed regardless of which physical table the rows
+ * land in.
+ *
+ * Run standalone: `node test/layer-0-primitives/queue-byo-db.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b              = helpers.b;
+var fs             = helpers.fs;
+var os             = helpers.os;
+var path           = helpers.path;
+var check          = helpers.check;
+var setupTestDb    = helpers.setupTestDb;
+var teardownTestDb = helpers.teardownTestDb;
+
+function _tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-q-byo-")); }
+
+// A jobs-shaped table with the same columns as _blamejs_jobs so the
+// local backend can write to it when pointed there via { table }.
+// payload + lastError are TEXT to hold the vault-sealed blobs.
+function _createCustomJobsTable(name) {
+  b.db.exec(
+    "CREATE TABLE IF NOT EXISTS " + name + " (" +
+    "  _id              TEXT PRIMARY KEY," +
+    "  queueName        TEXT NOT NULL," +
+    "  payload          TEXT," +
+    "  status           TEXT NOT NULL," +
+    "  enqueuedAt       INTEGER NOT NULL," +
+    "  availableAt      INTEGER NOT NULL," +
+    "  leasedAt         INTEGER," +
+    "  leaseExpiresAt   INTEGER," +
+    "  attempts         INTEGER NOT NULL DEFAULT 0," +
+    "  maxAttempts      INTEGER NOT NULL DEFAULT 5," +
+    "  lastError        TEXT," +
+    "  finishedAt       INTEGER," +
+    "  traceId          TEXT," +
+    "  classification   TEXT," +
+    "  priority         INTEGER NOT NULL DEFAULT 0," +
+    "  repeatCron       TEXT," +
+    "  repeatTimezone   TEXT," +
+    "  flowId           TEXT," +
+    "  flowChildName    TEXT," +
+    "  dependsOn        TEXT" +
+    ")"
+  );
+}
+
+// ---- Default config unchanged ----
+
+async function testDefaultConfigUsesFrameworkJobsTable() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    b.queue.init({ backends: { primary: { protocol: "local" } } });
+    await b.queue.enqueue("default-q", { tag: "default" });
+
+    var rows = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "default-q", status: "pending" }).all();
+    check("default: row lands in _blamejs_jobs", rows.length === 1);
+    check("default: size reads the default table",
+          (await b.queue.size("default-q")) === 1);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Custom table ----
+
+async function testCustomTableRoutesRowsThere() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    _createCustomJobsTable("app_jobs");
+    b.queue.init({ backends: { byo: { protocol: "local", table: "app_jobs" } } });
+
+    await b.queue.enqueue("byo-q", { tag: "custom" }, { traceId: "t-1" });
+
+    var inCustom = await b.db.from("app_jobs")
+      .where({ queueName: "byo-q" }).all();
+    check("custom table: enqueued row lands in app_jobs", inCustom.length === 1);
+
+    var inDefault = await b.db.from("_blamejs_jobs")
+      .where({ queueName: "byo-q" }).all();
+    check("custom table: nothing written to _blamejs_jobs", inDefault.length === 0);
+
+    check("custom table: size reads from the custom table",
+          (await b.queue.size("byo-q")) === 1);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testCustomTableFullLifecycleAndSealing() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    _createCustomJobsTable("app_jobs");
+    b.queue.init({ backends: { byo: { protocol: "local", table: "app_jobs" } } });
+
+    var seen = null;
+    var consumer = b.queue.consume("byo-life", async function (job) {
+      seen = job.payload;
+    }, { backend: "byo", concurrency: 1, pollIntervalMs: 25, fastPollMs: 5 });
+
+    await b.queue.enqueue("byo-life", { secret: "social-9999" }, { backend: "byo" });
+    await helpers.waitUntil(function () { return seen !== null; }, {
+      timeoutMs: 4000, label: "queue byo-db: consumer leased + ran the job from the custom table",
+    });
+    check("custom table: payload round-trips through lease/unseal",
+          seen && seen.secret === "social-9999");
+
+    // The stored payload column is sealed — raw bytes must NOT contain the
+    // plaintext. Sealing keys off the _blamejs_jobs column map even though
+    // the physical row lives in app_jobs.
+    var raw = await b.db.from("app_jobs").where({ queueName: "byo-life" }).all();
+    check("custom table: a row exists in app_jobs", raw.length === 1);
+    var storedPayload = String(raw[0].payload || "");
+    check("custom table: stored payload is sealed (no plaintext)",
+          storedPayload.indexOf("social-9999") === -1 && storedPayload.length > 0);
+
+    consumer.cancel();
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Bring-your-own store handle ----
+
+async function testCustomDbHandleReceivesCalls() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    _createCustomJobsTable("handle_jobs");
+    // A spy handle that delegates to the framework store but records the
+    // SQL it was handed, so we can confirm the backend dispatches through
+    // the operator-supplied handle (not cluster-storage directly) and
+    // targets the configured table.
+    var sqls = [];
+    var spy = {
+      execute: function (sql, params) {
+        sqls.push(sql);
+        return b.clusterStorage.execute(sql, params);
+      },
+      executeOne: function (sql, params) {
+        sqls.push(sql);
+        return b.clusterStorage.executeOne(sql, params);
+      },
+      executeAll: function (sql, params) {
+        sqls.push(sql);
+        return b.clusterStorage.executeAll(sql, params);
+      },
+    };
+    b.queue.init({ backends: { byo: { protocol: "local", db: spy, table: "handle_jobs" } } });
+
+    await b.queue.enqueue("handle-q", { tag: "via-handle" }, { backend: "byo" });
+    await b.queue.size("handle-q", { backend: "byo" });
+
+    check("byo handle: enqueue dispatched through the supplied handle",
+          sqls.some(function (s) { return /INSERT INTO "handle_jobs"/.test(s); }));
+    check("byo handle: size dispatched through the supplied handle",
+          sqls.some(function (s) { return /FROM "handle_jobs"/.test(s); }));
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Schema qualifier ----
+
+async function testSchemaQualifierIsQuoted() {
+  // Verifies the schema.table qualifier is composed via safeSql quoting.
+  // No physical schema needed — we capture the SQL through a spy handle
+  // and assert the quoted dotted form, which is the injection-safe shape.
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    var sqls = [];
+    var spy = {
+      execute:    function (sql) { sqls.push(sql); return Promise.resolve({ rows: [], rowCount: 0 }); },
+      executeOne: function (sql) { sqls.push(sql); return Promise.resolve(null); },
+      executeAll: function (sql) { sqls.push(sql); return Promise.resolve([]); },
+    };
+    b.queue.init({ backends: { byo: { protocol: "local", db: spy, schema: "work", table: "jobs_t" } } });
+    await b.queue.enqueue("sch-q", { tag: "x" }, { backend: "byo" });
+    check("schema qualifier: composed as quoted \"work\".\"jobs_t\"",
+          sqls.some(function (s) { return s.indexOf('"work"."jobs_t"') !== -1; }));
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Config-time validation (the security boundary) ----
+
+async function testRejectsUnsafeTableAndSchemaAndHandle() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    function initThrew(cfg) {
+      var threw = false;
+      try {
+        b.queue.init({ backends: { byo: Object.assign({ protocol: "local" }, cfg) } });
+      } catch (_e) { threw = true; }
+      try { b.queue._resetForTest(); } catch (_e2) {}
+      return threw;
+    }
+
+    check("rejects an injection-shaped table name",
+          initThrew({ table: "jobs; DROP TABLE users" }));
+    check("rejects a quote-bearing table name",
+          initThrew({ table: 'jobs" --' }));
+    check("rejects a SQL reserved word as table",
+          initThrew({ table: "select" }));
+    check("rejects a non-string table",
+          initThrew({ table: 123 }));
+    check("rejects an injection-shaped schema name",
+          initThrew({ table: "jobs_t", schema: "public; DROP" }));
+    check("rejects a non-string schema",
+          initThrew({ table: "jobs_t", schema: {} }));
+    check("rejects a db handle that is not an object",
+          initThrew({ db: "not-a-handle" }));
+    check("rejects a db handle missing required methods",
+          initThrew({ db: { execute: function () {} } }));
+
+    // The default (no custom table/schema/db) must still init cleanly.
+    var ok = true;
+    try {
+      b.queue.init({ backends: { plain: { protocol: "local" } } });
+    } catch (_e) { ok = false; }
+    check("default config still inits cleanly", ok);
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+// ---- Flow routing under a custom table ----
+
+async function testFlowSecondPassTargetsCustomTable() {
+  var tmpDir = _tmp();
+  await setupTestDb(tmpDir);
+  try {
+    _createCustomJobsTable("flow_jobs");
+    b.queue.init({
+      backends: { byo: { protocol: "local", table: "flow_jobs" } },
+      defaultBackend: "byo",
+    });
+
+    var ord = [];
+    var consumer = b.queue.consume("byo-flow", async function (job) {
+      ord.push(job.payload.tag);
+    }, { backend: "byo", concurrency: 4, pollIntervalMs: 25, fastPollMs: 5 });
+
+    await b.queue.enqueueFlow({
+      queueName: "byo-flow",
+      children: [
+        { name: "fetch",     payload: { tag: "fetch" } },
+        { name: "transform", payload: { tag: "transform" }, dependsOn: ["fetch"] },
+      ],
+    });
+
+    // The flow children — including the dependsOn second pass — must all
+    // land in flow_jobs, not _blamejs_jobs.
+    var inCustom = await b.db.from("flow_jobs").where({ queueName: "byo-flow" }).all();
+    check("flow byo: both children written to the custom table", inCustom.length === 2);
+    var inDefault = await b.db.from("_blamejs_jobs").where({ queueName: "byo-flow" }).all();
+    check("flow byo: nothing leaked to _blamejs_jobs", inDefault.length === 0);
+
+    await helpers.waitUntil(function () { return ord.length === 2; }, {
+      timeoutMs: 5000, label: "queue byo-flow: both flow jobs processed in order",
+    });
+    check("flow byo: dependency order preserved through the custom table",
+          ord[0] === "fetch" && ord[1] === "transform");
+
+    consumer.cancel();
+  } finally {
+    try { await b.queue.shutdown({ timeoutMs: 500 }); } catch (_e) {}
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function run() {
+  await testDefaultConfigUsesFrameworkJobsTable();
+  await testCustomTableRoutesRowsThere();
+  await testCustomTableFullLifecycleAndSealing();
+  await testCustomDbHandleReceivesCalls();
+  await testSchemaQualifierIsQuoted();
+  await testRejectsUnsafeTableAndSchemaAndHandle();
+  await testFlowSecondPassTargetsCustomTable();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { process.exitCode = 1; throw e; }
+  );
+}