Create collections specific for ddo versions

schemas/op_ddo_v1.json

@@ -0,0 +1,5 @@
+{
+  "name": "op_ddo_v4.1.0",
+  "enable_nested_fields": true,
+  "fields": [{ "name": ".*", "type": "auto", "optional": true }]
+}

schemas/op_ddo_v3.json

@@ -0,0 +1,5 @@
+{
+  "name": "op_ddo_v4.3.0",
+  "enable_nested_fields": true,
+  "fields": [{ "name": ".*", "type": "auto", "optional": true }]
+}

schemas/op_ddo_v5.json

@@ -0,0 +1,5 @@
+{
+  "name": "op_ddo_v4.5.0",
+  "enable_nested_fields": true,
+  "fields": [{ "name": ".*", "type": "auto", "optional": true }]
+}

src/components/core/utils/validateDdoHandler.ts

@@ -19,7 +19,7 @@
     CORE_LOGGER.logMessage(`Can't find schema ${version}`, true)
     return
   }
-  const path = `../../../../schemas/v4/${version}.ttl`
+  const path = `../../../../schemas/${version}.ttl`
   // Use fileURLToPath to convert the URL to a file path
   const currentModulePath = fileURLToPath(import.meta.url)
 
@@ -58,7 +58,7 @@
 }
 
 function isIsoFormat(dateString: string): boolean {
   const isoDateRegex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z)?$/
   return isoDateRegex.test(dateString)
 }
 
@@ -117,7 +117,7 @@
   const filename = new URL(schemaFilePath, import.meta.url)
   const dataset = rdfDataset.dataset()
   try {
     const contents = await readFile(filename, { encoding: 'utf8' })
     const parser = new Parser()
     const quads = parser.parse(contents)
     quads.forEach((quad: Quad) => {

src/components/database/index.ts

@@ -614,11 +614,11 @@ export class Database {
         configureCustomDBTransport(this, DATABASE_LOGGER)
       }
 
-      this.ddo = await new DdoDatabase(config, schemas.ddoSchemas)
-      this.nonce = await new NonceDatabase(config, schemas.nonceSchemas)
-      this.indexer = await new IndexerDatabase(config, schemas.indexerSchemas)
-      this.logs = await new LogDatabase(config, schemas.logSchemas)
-      this.order = await new OrderDatabase(config, schemas.orderSchema)
+      this.ddo = await new DdoDatabase(this.config, schemas.ddoSchemas)
+      this.nonce = await new NonceDatabase(this.config, schemas.nonceSchemas)
+      this.indexer = await new IndexerDatabase(this.config, schemas.indexerSchemas)
+      this.logs = await new LogDatabase(this.config, schemas.logSchemas)
+      this.order = await new OrderDatabase(this.config, schemas.orderSchema)
       return this
     })() as unknown as Database
   }

src/components/database/schemas.ts

@@ -1,4 +1,46 @@
 import { TypesenseCollectionCreateSchema } from '../../@types/index.js'
+import fs from 'fs'
+import path, { dirname, resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { DATABASE_LOGGER } from '../../utils/logging/common.js'
+import { LOG_LEVELS_STR } from '../../utils/logging/Logger.js'
+
+export function readJsonSchemas(): any[] {
+  const jsonDocuments: any[] = []
+  const pathToSchemaDir: string = '../../../schemas'
+  const currentModulePath = fileURLToPath(import.meta.url)
+
+  // Use dirname to get the directory name
+  const currentDirectory = dirname(currentModulePath)
+  const schemaFilePath = resolve(currentDirectory, pathToSchemaDir)
+  const jsonFiles = fs
+    .readdirSync(schemaFilePath)
+    .filter((file) => path.extname(file) === '.json')
+
+  if (!jsonFiles || jsonFiles === undefined) {
+    DATABASE_LOGGER.log(
+      LOG_LEVELS_STR.LEVEL_ERROR,
+      `JSON mappings could not be read. Possibly the JSON format mappings for Typesense DB are missing or invalid.`,
+      true
+    )
+    return []
+  }
+  jsonFiles.forEach((file) => {
+    try {
+      // eslint-disable-next-line security/detect-non-literal-fs-filename
+      const fileData = fs.readFileSync(path.join(schemaFilePath, file), 'utf-8')
+      const jsonFile = JSON.parse(fileData.toString())
+      jsonDocuments.push(jsonFile)
+    } catch (err) {
+      DATABASE_LOGGER.log(
+        LOG_LEVELS_STR.LEVEL_ERROR,
+        `Error loading DDO schema from ${path.join(pathToSchemaDir, file)}: ${err}`,
+        true
+      )
+    }
+  })
+  return jsonDocuments
+}
 
 export type Schema = TypesenseCollectionCreateSchema
 export type Schemas = {
@@ -8,14 +50,9 @@ export type Schemas = {
   logSchemas: Schema
   orderSchema: Schema
 }
+const ddoSchemas = readJsonSchemas()
 export const schemas: Schemas = {
-  ddoSchemas: [
-    {
-      name: 'ddo_v0.1',
-      enable_nested_fields: true,
-      fields: [{ name: '.*', type: 'auto', optional: true }] // optional: true for turning the full version DDO into short one for states DEPRECATED and REVOKED
-    }
-  ],
+  ddoSchemas,
   nonceSchemas: {
     name: 'nonce',
     enable_nested_fields: true,

src/index.ts

@@ -70,6 +70,7 @@ let dbconn = null
 if (config.dbConfig?.url) {
   // once we create a database instance, we check the environment and possibly add the DB transport
   // after that, all loggers will eventually have it too (if in production/staging environments)
+  // it creates dinamically DDO schemas
   dbconn = await new Database(config.dbConfig)
 } else {
   config.hasIndexer = false