[feature] load schemas from file system

Author: marmoure

src/main/java/com/evolvedbinary/bblValidator/service/SchemaService.java

@@ -2,13 +2,13 @@
 
 import com.evolvedbinary.bblValidator.dto.SchemaInfo;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import io.micronaut.context.annotation.Value;
 import jakarta.annotation.PostConstruct;
 import jakarta.inject.Singleton;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
-import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -24,7 +24,9 @@
 public class SchemaService {
 
     private static final Logger LOG = LoggerFactory.getLogger(SchemaService.class);
-    private static final String SCHEMA_DIRECTORY = "schemas";
+
+    @Value("${schema.directory}")
+    private String schemaDirectory;
 
     private final List<SchemaInfo> schemas = new ArrayList<>();
     private final Map<String, String> schemaContents = new HashMap<>();
@@ -34,71 +36,75 @@ public class SchemaService {
     @PostConstruct
     public void loadSchemas() {
         try {
-            // Load schemas from classpath
-            ClassLoader classLoader = getClass().getClassLoader();
-
-            // Get all .json files from the schemas directory
-            try (InputStream is = classLoader.getResourceAsStream(SCHEMA_DIRECTORY)) {
-                if (is == null) {
-                    LOG.warn("Schemas directory not found in classpath");
-                    return;
-                }
+            // Resolve schema directory path
+            Path schemaPath = resolveSchemaPath();
+
+            if (!Files.exists(schemaPath)) {
+                LOG.warn("Schemas directory not found: {}", schemaPath);
+                return;
+            }
+
+            if (!Files.isDirectory(schemaPath)) {
+                LOG.warn("Schema path is not a directory: {}", schemaPath);
+                return;
             }
 
             // Scan for schema metadata files
-            loadSchemasFromClasspath();
+            loadSchemasFromFileSystem(schemaPath);
 
-            LOG.info("Loaded {} schemas from disk", schemas.size());
+            LOG.info("Loaded {} schemas from: {}", schemas.size(), schemaPath);
         } catch (Exception e) {
-            LOG.error("Error loading schemas from disk", e);
+            LOG.error("Error loading schemas from file system", e);
         }
     }
 
-    private void loadSchemasFromClasspath() {
-        // close the file input stream
-        // try with resoucres
-        // avoid class path
-        // in application yaml add a property for schema folder
-        // make it relative to the start up location
-        // if it starts with a slash then resolve it as absolut path
-        try {
-            // Get resource URL and list files
-            ClassLoader classLoader = getClass().getClassLoader();
-            var resource = classLoader.getResource(SCHEMA_DIRECTORY);
-
-            if (resource != null) {
-                Path schemaPath = Paths.get(resource.toURI());
-
-                try (Stream<Path> paths = Files.walk(schemaPath, 1)) {
-                    paths.filter(path -> path.toString().endsWith(".json"))
-                            .forEach(this::loadSchemaMetadata);
-                }
-            }
-        } catch (Exception e) {
-            LOG.error("Error scanning schema directory", e);
+    /**
+     * Resolves the schema directory path.
+     * If the path starts with a slash, it's treated as an absolute path.
+     * Otherwise, it's resolved relative to the current working directory (startup location).
+     */
+    private Path resolveSchemaPath() {
+        if (schemaDirectory.startsWith("/")) {
+            // Absolute path
+            return Paths.get(schemaDirectory);
+        } else {
+            // Relative to current working directory
+            return Paths.get(System.getProperty("user.dir"), schemaDirectory);
         }
     }
 
-    private void loadSchemaMetadata(Path metadataPath) {
-        try {
-            String content = Files.readString(metadataPath, StandardCharsets.UTF_8);
-            SchemaInfo schemaInfo = objectMapper.readValue(content, SchemaInfo.class);
-
-            // Load corresponding schema file
-            String schemaFileName = metadataPath.getFileName().toString().replace(".json", ".csvs");
-            Path schemaFilePath = metadataPath.getParent().resolve(schemaFileName);
-
-            if (Files.exists(schemaFilePath)) {
-                String schemaContent = Files.readString(schemaFilePath, StandardCharsets.UTF_8);
-                schemaContents.put(schemaInfo.getId(), schemaContent);
-                schemaFilePaths.put(schemaInfo.getId(), schemaFilePath);
-                schemas.add(schemaInfo);
-                LOG.debug("Loaded schema: {}", schemaInfo.getId());
-            } else {
-                LOG.warn("Schema file not found for metadata: {}", schemaFileName);
-            }
+    private void loadSchemasFromFileSystem(Path schemaPath) {
+        try (Stream<Path> paths = Files.walk(schemaPath, 1)) {
+            paths.filter(path -> path.toString().endsWith(".json"))
+                    .forEach(path -> {
+                        try {
+                            loadSchemaMetadata(path);
+                        } catch (Exception e) {
+                            LOG.error("Error loading schema metadata from: {}", path, e);
+                        }
+                    });
         } catch (IOException e) {
-            LOG.error("Error loading schema metadata from: {}", metadataPath, e);
+            LOG.error("Error scanning schema directory: {}", schemaPath, e);
+        }
+    }
+
+    private void loadSchemaMetadata(Path metadataPath) throws IOException {
+        String content = Files.readString(metadataPath, StandardCharsets.UTF_8);
+        SchemaInfo schemaInfo = objectMapper.readValue(content, SchemaInfo.class);
+
+        // Load corresponding schema file
+        String schemaFileName = metadataPath.getFileName().toString().replace(".json", ".csvs");
+        Path schemaFilePath = metadataPath.getParent().resolve(schemaFileName);
+
+        if (Files.exists(schemaFilePath)) {
+            String schemaContent = Files.readString(schemaFilePath, StandardCharsets.UTF_8);
+            // TODO: Only load the schema content when needed
+            schemaContents.put(schemaInfo.getId(), schemaContent);
+            schemaFilePaths.put(schemaInfo.getId(), schemaFilePath);
+            schemas.add(schemaInfo);
+            LOG.debug("Loaded schema: {}", schemaInfo.getId());
+        } else {
+            LOG.warn("Schema file not found for metadata: {}", schemaFileName);
         }
     }
 

src/main/resources/application.yml

@@ -4,4 +4,6 @@ micronaut:
   server:
     port: 8080
 api:
-  version: ${project.version}
+  version: ${project.version}
+schema:
+  directory: schemas