@cyclonedx/cdxgen 12.1.5 → 12.2.1

package/lib/cli/index.poku.js

@@ -120,5 +120,122 @@ describe("CLI tests", () => {
       assert.match(options.headers["user-agent"], /@CycloneDX\/cdxgen/);
       assert.deepEqual(options.json, expectedRequestPayload);
     });
+
+    it("should include parentName and parentVersion when parent project name and version are passed", async () => {
+      const fakeGotResponse = {
+        json: sinon.stub().resolves({ success: true }),
+      };
+
+      const gotStub = sinon.stub().returns(fakeGotResponse);
+      gotStub.extend = sinon.stub().returns(gotStub);
+
+      const { submitBom } = await esmock("./index.js", {
+        got: { default: gotStub },
+      });
+
+      const serverUrl = "https://dtrack.example.com";
+      const projectName = "cdxgen-test-project";
+      const projectVersion = "2.0.0";
+      const parentProjectName = "parent-project";
+      const parentProjectVersion = "1.0.0";
+      const bomContent = {
+        bom: "test3",
+      };
+      const apiKey = "TEST_API_KEY";
+      const skipDtTlsCheck = false;
+
+      const expectedRequestPayload = {
+        autoCreate: "true",
+        bom: "eyJib20iOiJ0ZXN0MyJ9", // stringified and base64 encoded bomContent
+        parentName: parentProjectName,
+        parentVersion: parentProjectVersion,
+        projectName,
+        projectVersion,
+      };
+
+      await submitBom(
+        {
+          serverUrl,
+          projectName,
+          projectVersion,
+          parentProjectName,
+          parentProjectVersion,
+          apiKey,
+          skipDtTlsCheck,
+        },
+        bomContent,
+      );
+
+      sinon.assert.calledOnce(gotStub);
+      const [calledUrl, options] = gotStub.firstCall.args;
+
+      assert.equal(calledUrl, `${serverUrl}/api/v1/bom`);
+      assert.equal(options.method, "PUT");
+      assert.equal(options.https.rejectUnauthorized, !skipDtTlsCheck);
+      assert.equal(options.headers["X-Api-Key"], apiKey);
+      assert.match(options.headers["user-agent"], /@CycloneDX\/cdxgen/);
+      assert.deepEqual(options.json, expectedRequestPayload);
+    });
+
+    it("should include configurable autoCreate and isLatest values in payload", async () => {
+      const fakeGotResponse = {
+        json: sinon.stub().resolves({ success: true }),
+      };
+
+      const gotStub = sinon.stub().returns(fakeGotResponse);
+      gotStub.extend = sinon.stub().returns(gotStub);
+
+      const { submitBom } = await esmock("./index.js", {
+        got: { default: gotStub },
+      });
+
+      const serverUrl = "https://dtrack.example.com";
+      const projectName = "cdxgen-test-project";
+      const apiKey = "TEST_API_KEY";
+
+      await submitBom(
+        {
+          serverUrl,
+          projectName,
+          apiKey,
+          autoCreate: false,
+          isLatest: true,
+        },
+        { bom: "test4" },
+      );
+
+      sinon.assert.calledOnce(gotStub);
+      const [_calledUrl, options] = gotStub.firstCall.args;
+      assert.equal(options.json.autoCreate, "false");
+      assert.equal(options.json.isLatest, true);
+      assert.equal(options.json.projectVersion, "main");
+    });
+
+    it("should reject invalid mixed parent modes before making network request", async () => {
+      const fakeGotResponse = {
+        json: sinon.stub().resolves({ success: true }),
+      };
+
+      const gotStub = sinon.stub().returns(fakeGotResponse);
+      gotStub.extend = sinon.stub().returns(gotStub);
+
+      const { submitBom } = await esmock("./index.js", {
+        got: { default: gotStub },
+      });
+
+      const response = await submitBom(
+        {
+          serverUrl: "https://dtrack.example.com",
+          projectName: "cdxgen-test-project",
+          parentProjectId: "5103b8b4-4ca3-46ea-8051-036a3b2ab17e",
+          parentProjectName: "parent",
+          parentProjectVersion: "1.0.0",
+        },
+        { bom: "test5" },
+      );
+
+      assert.equal(response, undefined);
+      sinon.assert.notCalled(gotStub);
+    });
   });
 });

package/lib/evinser/db.js

@@ -0,0 +1,137 @@
+class Model {
+  constructor(tableName) {
+    this.tableName = tableName;
+    this.store = new Map();
+  }
+
+  async init() {
+    this.store.clear();
+  }
+
+  async findByPk(purl) {
+    if (this.store.has(purl)) {
+      const record = this.store.get(purl);
+      let parsedData;
+
+      try {
+        parsedData = JSON.parse(record.dataStr);
+      } catch (_e) {
+        parsedData = record.dataStr;
+      }
+
+      return {
+        purl: record.purl,
+        data: parsedData,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+      };
+    }
+
+    return null;
+  }
+
+  async findOrCreate(options) {
+    const { where, defaults } = options;
+    const existing = await this.findByPk(where.purl);
+
+    if (existing) {
+      return [existing, false];
+    }
+
+    let dataStr;
+    if (typeof defaults.data === "string") {
+      dataStr = defaults.data;
+    } else {
+      dataStr = JSON.stringify(defaults.data);
+    }
+
+    const now = new Date().toISOString();
+    const searchStr = dataStr.toLowerCase();
+
+    const record = {
+      purl: defaults.purl,
+      dataStr: dataStr,
+      searchStr: searchStr,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.store.set(defaults.purl, record);
+
+    let parsedData;
+    try {
+      parsedData = JSON.parse(record.dataStr);
+    } catch (_e) {
+      parsedData = record.dataStr;
+    }
+
+    const instance = {
+      purl: record.purl,
+      data: parsedData,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+    };
+
+    return [instance, true];
+  }
+
+  async findAll(options) {
+    const results = [];
+    let searchTerm = null;
+
+    if (options?.where?.data?.like) {
+      searchTerm = options.where.data.like.replace(/%/g, "").toLowerCase();
+    }
+
+    for (const record of this.store.values()) {
+      let matches = true;
+
+      if (searchTerm) {
+        if (!record.searchStr.includes(searchTerm)) {
+          matches = false;
+        }
+      }
+
+      if (matches) {
+        let parsedData;
+        try {
+          parsedData = JSON.parse(record.dataStr);
+        } catch (_e) {
+          parsedData = record.dataStr;
+        }
+
+        results.push({
+          purl: record.purl,
+          data: parsedData,
+          createdAt: record.createdAt,
+          updatedAt: record.updatedAt,
+        });
+      }
+    }
+
+    return results;
+  }
+}
+
+export const createOrLoad = async () => {
+  const Namespaces = new Model("Namespaces");
+  const Usages = new Model("Usages");
+  const DataFlows = new Model("DataFlows");
+
+  await Namespaces.init();
+  await Usages.init();
+  await DataFlows.init();
+
+  const sequelize = {
+    close: () => {
+      return true;
+    },
+  };
+
+  return {
+    sequelize,
+    Namespaces,
+    Usages,
+    DataFlows,
+  };
+};

package/lib/{helpers → evinser}/db.poku.js

@@ -2,12 +2,8 @@ import { assert, describe, test } from "poku";
 
 import { createOrLoad } from "./db.js";
 
-describe("SQLite3 Helper Tests", async () => {
-  const { sequelize, Namespaces } = await createOrLoad(
-    "test.db",
-    ":memory:",
-    false,
-  );
+describe("In-Memory DB Helper Tests", async () => {
+  const { sequelize, Namespaces } = await createOrLoad();
 
   await test("Model Initialization", () => {
     assert.ok(sequelize, "Database instance should exist");

package/lib/evinser/evinser.js

@@ -5,7 +5,6 @@ import process from "node:process";
 import { PackageURL } from "packageurl-js";
 
 import { findCryptoAlgos } from "../helpers/cbomutils.js";
-import * as db from "../helpers/db.js";
 import {
   collectGradleDependencies,
   collectMvnDependencies,
@@ -18,13 +17,12 @@ import {
   getTmpDir,
   PROJECT_TYPE_ALIASES,
   safeExistsSync,
-  safeMkdirSync,
 } from "../helpers/utils.js";
 import { postProcess } from "../stages/postgen/postgen.js";
+import { createOrLoad } from "./db.js";
 import { findPurlLocations } from "./scalasem.js";
 import { createSemanticsSlices } from "./swiftsem.js";
 
-const DB_NAME = "evinser.db";
 const typePurlsCache = {};
 
 /**
@@ -33,13 +31,6 @@ const typePurlsCache = {};
  * @param {Object} options Command line options
  */
 export async function prepareDB(options) {
-  if (!options.dbPath.includes("memory") && !safeExistsSync(options.dbPath)) {
-    try {
-      safeMkdirSync(options.dbPath, { recursive: true });
-    } catch (_e) {
-      // ignore
-    }
-  }
   const dirPath = options._[0] || ".";
   const bomJsonFile = options.input;
   if (!safeExistsSync(bomJsonFile)) {
@@ -61,10 +52,7 @@ export async function prepareDB(options) {
     process.exit(0);
   }
   const components = bomJson.components || [];
-  const { sequelize, Namespaces, Usages, DataFlows } = await db.createOrLoad(
-    DB_NAME,
-    options.dbPath,
-  );
+  const { sequelize, Namespaces, Usages, DataFlows } = await createOrLoad();
   let hasMavenPkgs = false;
   // We need to slice only non-maven packages
   const purlsToSlice = {};