doc-detective-common 3.0.0-dev.0 → 3.0.0-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doc-detective-common",
-  "version": "3.0.0-dev.0",
+  "version": "3.0.0-dev.1",
   "description": "Shared components for Doc Detective projects.",
   "main": "src/index.js",
   "scripts": {
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/doc-detective/doc-detective-common.git"
   },
   "author": "Manny Silva",
-  "license": "MIT",
+  "license": "AGPL-3.0-only",
   "bugs": {
     "url": "https://github.com/doc-detective/doc-detective-common/issues"
   },
@@ -21,16 +21,16 @@
   "devDependencies": {
     "chai": "^5.2.0",
     "mocha": "^11.1.0",
-    "sinon": "^19.0.2"
+    "sinon": "^20.0.0"
   },
   "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "^11.9.3",
+    "@apidevtools/json-schema-ref-parser": "^12.0.1",
     "ajv": "^8.17.1",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^3.0.1",
     "ajv-keywords": "^5.1.0",
-    "axios": "^1.8.2",
+    "axios": "^1.8.4",
     "uuid": "^11.1.0",
-    "yaml": "^2.7.0"
+    "yaml": "^2.7.1"
   }
 }

package/src/files.js

@@ -7,42 +7,54 @@ const { URL } = require("url");
  * Reads a file from a given URL or local file path and returns its content.
  * Supports JSON and YAML file formats.
  *
- * @param {string} fileURL - The URL or local file path of the file to read.
- * @returns {Promise<Object|string|null>} - The parsed content of the file if it's JSON or YAML, 
- *                                          the raw content if it's another format, 
+ * @param {string} fileURLOrPath - The URL or local file path of the file to read.
+ * @returns {Promise<Object|string|null>} - The parsed content of the file if it's JSON or YAML,
+ *                                          the raw content if it's another format,
  *                                          or null if an error occurs.
  */
-async function readFile(fileURL) {
+async function readFile({ fileURLOrPath }) {
+  if (!fileURLOrPath) {
+    throw new Error("fileURLOrPath is required");
+  }
+  if (typeof fileURLOrPath !== "string") {
+    throw new Error("fileURLOrPath must be a string");
+  }
+  if (fileURLOrPath.trim() === "") {
+    throw new Error("fileURLOrPath cannot be an empty string");
+  }
 
   let content;
   let isRemote = false;
 
   try {
-    const parsedURL = new URL(fileURL);
-    isRemote = parsedURL.protocol === "http:" || parsedURL.protocol === "https:";
+    const parsedURL = new URL(fileURLOrPath);
+    isRemote =
+      parsedURL.protocol === "http:" || parsedURL.protocol === "https:";
   } catch (error) {
     // Not a valid URL, assume local file path
   }
 
   if (isRemote) {
     try {
-      const response = await axios.get(fileURL);
+      const response = await axios.get(fileURLOrPath);
       content = response.data;
     } catch (error) {
-      console.warn(`Error reading remote file from ${fileURL}: ${error.message}`);
+      console.warn(
+        `Error reading remote file from ${fileURLOrPath}: ${error.message}`
+      );
+      return null;
+    }
+  } else {
+    try {
+      content = await fs.promises.readFile(fileURLOrPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.warn(`File not found: ${fileURLOrPath}`);
+      } else {
+        console.warn(`Error reading file: ${error.message}`);
+      }
       return null;
     }
-  } else {  
-    try {  
-      content = await fs.promises.readFile(fileURL, "utf8");  
-    } catch (error) {  
-      if (error.code === 'ENOENT') {  
-        console.warn(`File not found: ${fileURL}`);  
-      } else {  
-        console.warn(`Error reading file: ${error.message}`);  
-      }  
-      return null;  
-    }  
   }
 
   // Parse based on file content, and return either object or string
@@ -58,7 +70,6 @@ async function readFile(fileURL) {
       return content;
     }
   }
-
 }
 
 module.exports = { readFile };

package/src/index.js

@@ -1,5 +1,5 @@
 const { schemas } = require("./schemas");
-const { validate } = require("./validate");
+const { validate, transformToSchemaKey } = require("./validate");
 const { resolvePaths } = require("./resolvePaths");
 const { readFile } = require("./files");
 
@@ -8,4 +8,5 @@ module.exports = {
   validate,
   resolvePaths,
   readFile,
+  transformToSchemaKey,
 };

package/src/resolvePaths.js

@@ -5,22 +5,29 @@ const { validate } = require("./validate");
 exports.resolvePaths = resolvePaths;
 
 /**
- * Resolves paths in config and spec objects based on the provided configuration, object type, object, and source file path.
+ * Resolves relative paths in configuration and specification objects to absolute paths.
  *
- * @param {object} config - The configuration object.
- * @param {object} object - The object containing the paths to resolve.
- * @param {string} filePath - The path of the file that contains the relative paths.
- * @param {boolean} [nested=false] - Whether the object is nested within another object.
- * @param {string} [objectType] - The type of object to resolve paths in ("config" or "spec"). Required if the object is nested.
- * @returns {object} - The object with resolved paths.
+ * This function traverses an object (either a config or spec) and converts all path properties
+ * to absolute paths based on the provided configuration and file path. It can handle nested objects
+ * and special path relationships like path/directory and savePath/saveDirectory.
+ *
+ * @async
+ * @param {Object} options - The options object.
+ * @param {Object} options.config - The configuration object containing settings like relativePathBase.
+ * @param {Object} options.object - The object whose paths need to be resolved.
+ * @param {string} options.filePath - The reference file path for resolving relative paths.
+ * @param {boolean} [options.nested=false] - Flag indicating if this is a recursive call for a nested object.
+ * @param {string} [options.objectType] - The type of object ('config' or 'spec'). Required for nested objects.
+ * @returns {Promise<Object>} The object with all paths resolved to absolute paths.
+ * @throws {Error} Throws an error if the object isn't a valid config or spec, or if objectType is missing for nested objects.
  */
-async function resolvePaths(
+async function resolvePaths({
   config,
   object,
   filePath,
   nested = false,
-  objectType
-) {
+  objectType,
+}) {
   // Config properties that contain paths
   const configPaths = [
     "input",
@@ -38,6 +45,9 @@ async function resolvePaths(
     "file",
     "path",
     "directory",
+    "before",
+    "after",
+    "loadVariables",
     "setup",
     "cleanup",
     "savePath",
@@ -68,13 +78,19 @@ async function resolvePaths(
     if (path.isAbsolute(relativePath)) {
       return relativePath;
     }
-    // If filePath is a file, use its directory as the base path
-    filePath = fs.lstatSync(filePath).isFile()
-      ? path.dirname(filePath)
-      : filePath;
+
+    // Check if filePath exists and is a file
+    const fileExists = fs.existsSync(filePath);
+    const isFile = fileExists
+      ? fs.lstatSync(filePath).isFile()
+      : path.parse(filePath).ext !== "";
+
+    // Use directory of filePath if it's a file (or looks like one)
+    const basePath = isFile ? path.dirname(filePath) : filePath;
+
     // Resolve the path based on the base type
     return baseType === "file"
-      ? path.resolve(filePath, relativePath)
+      ? path.resolve(basePath, relativePath)
       : path.resolve(relativePath);
   }
 
@@ -83,13 +99,19 @@ async function resolvePaths(
   let pathProperties;
   if (!nested && !objectType) {
     // Check if object matches the config schema
-    const validation = validate("config_v2", { ...object });
+    const validation = validate({
+      schemaKey: "config_v3",
+      object: { ...object },
+    });
     if (validation.valid) {
       pathProperties = configPaths;
       objectType = "config";
     } else {
       // Check if object matches the spec schema
-      const validation = validate("spec_v2", { ...object });
+      const validation = validate({
+        schemaKey: "spec_v3",
+        object: { ...object },
+      });
       if (validation.valid) {
         pathProperties = specPaths;
         objectType = "spec";
@@ -115,13 +137,13 @@ async function resolvePaths(
         objectType === "config")
     ) {
       // If the property is an object, recursively call resolvePaths to resolve paths within the object
-      object[property] = await resolvePaths(
-        config,
-        object[property],
-        filePath,
-        true,
-        objectType
-      );
+      object[property] = await resolvePaths({
+        config: config,
+        object: object[property],
+        filePath: filePath,
+        nested: true,
+        objectType: objectType,
+      });
     } else if (typeof object[property] === "string") {
       // If the property is a string, check if it matches any of the path properties and resolve it if it does
       pathProperties.forEach((pathProperty) => {
@@ -133,24 +155,6 @@ async function resolvePaths(
                 object[pathProperty],
                 object.directory
               );
-            } else {
-              object[pathProperty] = path.join(
-                object.directory,
-                object[pathProperty]
-              );
-            }
-          } else if (pathProperty === "savePath" && object.saveDirectory) {
-            if (path.isAbsolute(object.saveDirectory)) {
-              object[pathProperty] = resolve(
-                relativePathBase,
-                object[pathProperty],
-                object.saveDirectory
-              );
-            } else {
-              object[pathProperty] = path.join(
-                object.saveDirectory,
-                object[pathProperty]
-              );
             }
           } else {
             object[pathProperty] = resolve(