fix: Put schema files into a Map to allow direct access with a schema…

.gitignore

@@ -134,6 +134,8 @@ dist
 **/cypress/videos/*
 
 .vscode/*
+.idea/*
+**/*.iml
 
 # storybook
 storybook-static

packages/camel-catalog/assembly/src/test/java/io/kaoto/camelcatalog/CamelCatalogTestSupport.java

@@ -24,16 +24,8 @@ protected ObjectNode getIndex() throws Exception {
     }
 
     protected ObjectNode getSchema(String name) throws Exception {
-        var index = getIndex();
-        for (JsonNode schema : index.withArray("schemas")) {
-            var fileName = schema.get("file").asText();
-            var tokens = fileName.split("-");
-            if ("camelYamlDsl".equals(tokens[0]) && name.isEmpty() && tokens[1].matches("\\d+.*")) {
-                return (ObjectNode) jsonMapper.readTree(Paths.get("..").resolve("dist").resolve(fileName).toFile());
-            } else if ("camelYamlDsl".equals(tokens[0]) && tokens[1].equals(name)) {
-                return (ObjectNode) jsonMapper.readTree(Paths.get("..").resolve("dist").resolve(fileName).toFile());
-            }
-        }
-        return null;
+        var schema = getIndex().withObject("/schemas").withObject("/" + name);
+        return (ObjectNode) jsonMapper.readTree(
+                Paths.get("..").resolve("dist").resolve(schema.get("file").asText()).toFile());
     }
 }

packages/camel-catalog/assembly/src/test/java/io/kaoto/camelcatalog/CamelYamlDslSchemaTest.java

@@ -9,7 +9,7 @@ public class CamelYamlDslSchemaTest extends CamelCatalogTestSupport {
 
     @Test
     public void testRootSchema() throws Exception {
-        var rootSchema = getSchema("");
+        var rootSchema = getSchema("camelYamlDsl");
         assertEquals(rootSchema.get("type").asText(), "array");
         var definitions = rootSchema.withObject("/items").withObject("/definitions");
         assertTrue(definitions.has("org.apache.camel.model.ProcessorDefinition"));

packages/camel-catalog/assembly/src/test/java/io/kaoto/camelcatalog/IndexTest.java

@@ -20,27 +20,25 @@ public void test() throws Exception {
         assertTrue(catalogs.has("kamelets"));
         assertTrue(catalogs.has("dataformats"));
         assertTrue(index.has("schemas"));
-        var schemas = index.withArray("/schemas");
-        List<String> names = new ArrayList<>();
-        schemas.forEach(schema -> names.add(schema.get("name").asText()));
-        assertTrue(names.contains("camelYamlDsl"));
-        assertTrue(names.contains("beans"));
-        assertTrue(names.contains("errorHandler"));
-        assertTrue(names.contains("from"));
-        assertTrue(names.contains("intercept"));
-        assertTrue(names.contains("interceptFrom"));
-        assertTrue(names.contains("interceptSendToEndpoint"));
-        assertTrue(names.contains("onCompletion"));
-        assertTrue(names.contains("onException"));
-        assertTrue(names.contains("rest"));
-        assertTrue(names.contains("restConfiguration"));
-        assertTrue(names.contains("route"));
-        assertTrue(names.contains("routeConfiguration"));
-        assertTrue(names.contains("routeTemplate"));
-        assertTrue(names.contains("templatedRoute"));
-        assertTrue(names.contains("Integration"));
-        assertTrue(names.contains("Kamelet"));
-        assertTrue(names.contains("KameletBinding"));
-        assertTrue(names.contains("Pipe"));
+        var schemas = index.withObject("/schemas");
+        assertTrue(schemas.has("camelYamlDsl"));
+        assertTrue(schemas.has("beans"));
+        assertTrue(schemas.has("errorHandler"));
+        assertTrue(schemas.has("from"));
+        assertTrue(schemas.has("intercept"));
+        assertTrue(schemas.has("interceptFrom"));
+        assertTrue(schemas.has("interceptSendToEndpoint"));
+        assertTrue(schemas.has("onCompletion"));
+        assertTrue(schemas.has("onException"));
+        assertTrue(schemas.has("rest"));
+        assertTrue(schemas.has("restConfiguration"));
+        assertTrue(schemas.has("route"));
+        assertTrue(schemas.has("routeConfiguration"));
+        assertTrue(schemas.has("routeTemplate"));
+        assertTrue(schemas.has("templatedRoute"));
+        assertTrue(schemas.has("Integration"));
+        assertTrue(schemas.has("Kamelet"));
+        assertTrue(schemas.has("KameletBinding"));
+        assertTrue(schemas.has("Pipe"));
     }
 }

packages/camel-catalog/kaoto-camel-catalog-maven-plugin/src/main/java/io/kaoto/camelcatalog/Index.java

@@ -30,12 +30,12 @@ public class Index {
 
     private Map<String, Entry> catalogs = new HashMap<>();
 
-    private List<Entry> schemas = new ArrayList<>();
+    private Map<String, Entry> schemas = new HashMap<>();
 
     public Map<String, Entry> getCatalogs() {
         return catalogs;
     }
-    public List<Entry> getSchemas() {
+    public Map<String, Entry> getSchemas() {
         return schemas;
     }
 }

packages/camel-catalog/kaoto-camel-catalog-maven-plugin/src/main/java/io/kaoto/camelcatalog/KaotoCamelCatalogMojo.java

@@ -134,7 +134,7 @@ private void processSchema(Path inputDir, Index index) {
                 "Camel YAML DSL JSON schema",
                 camelVersion,
                 outputFileName);
-        index.getSchemas().add(indexEntry);
+        index.getSchemas().put("camelYamlDsl", indexEntry);
 
         try {
             var rootSchema = (ObjectNode) jsonMapper.readTree(schema.toFile());
@@ -186,7 +186,7 @@ private void processSubSchema(
                     "Camel YAML DSL JSON schema: " + propName,
                     camelVersion,
                     outputFileName);
-            index.getSchemas().add(indexEntry);
+            index.getSchemas().put(propName, indexEntry);
         } catch (Exception e) {
             getLog().error(e);
         }
@@ -326,7 +326,7 @@ private void processCRDFile(Path file, Index index) {
                     description,
                     camelKCRDVersion,
                     outputFileName);
-            index.getSchemas().add(indexEntry);
+            index.getSchemas().put(name, indexEntry);
         } catch (Exception e) {
             getLog().error(e);
         }

packages/camel-catalog/src/json-schema-to-typescript.mts

@@ -53,7 +53,12 @@ async function main() {
   const exportedFiles: string[] = [];
 
   console.log('---');
-  const schemaPromises = index.schemas.map(async (schema) => {
+  const targetSchemaNames = ['camelYamlDsl', 'Integration', 'Kamelet', 'KameletBinding', 'Pipe'];
+  const schemaPromises = Object.entries(index.schemas).map(async ([name, schema]) => {
+    if (!targetSchemaNames.includes(name)) {
+      return;
+    }
+
     const schemaFile = resolve(`./dist/${schema.file}`);
 
     /**
@@ -64,33 +69,23 @@ async function main() {
      */
     const schemaFileUri = pathToFileURL(`./dist/${schema.file}`).toString();
 
-    const schemaContent = (await import(schemaFileUri, { assert: { type: 'json' } })).default;
+    const schemaContent = (await import(schemaFileUri, {assert: {type: 'json'}})).default;
 
-    let filename = schema.name;
-
-    if (schema.file.includes('camelYamlDsl')) {
-      if (schema.file.match(/camelYamlDsl-\d+.*\.json/)) {
-        addTitleToDefinitions(schemaContent);
-        filename = 'camelYamlDsl';
-      } else {
-        return;
-      }
-    }
+    addTitleToDefinitions(schemaContent);
 
     /** Remove the -4.0.0.json section of the filename */
-    const outputFile = resolve(`./dist/types/${filename}.d.ts`);
+    const outputFile = resolve(`./dist/types/${name}.d.ts`);
 
     /** Add the file to the exported files */
-    exportedFiles.push(filename);
+    exportedFiles.push(name);
 
     console.log(`Input: '${schemaFile}'`);
     console.log(`Output: ${outputFile}`);
     console.log('---');
 
-    return compileSchema(schemaContent, filename, outputFile);
+    return compileSchema(schemaContent, name, outputFile);
   });
-
-  await Promise.all(schemaPromises);
+  await Promise.all(schemaPromises)
 
   /** Generate the index file */
   const indexFile = resolve(`./dist/types/index.ts`);

packages/ui/src/camel-utils/camel-schemas-processor.test.ts

@@ -22,31 +22,41 @@ describe('camel-schemas-processor', () => {
     },
   };
 
-  const schemas = [
-    {
-      name: 'user-schema',
-      version: '3.2.0',
-      uri: 'https://camel.apache.org/schema/user-schema.json',
-      tags: [],
-      schema: userSchemaJson,
-    },
-  ];
+  const schemas = {
+    'userSchema':
+        {
+          name: 'userSchema',
+          version: '3.2.0',
+          uri: 'https://camel.apache.org/schema/user-schema.json',
+          tags: [],
+          schema: userSchemaJson,
+        }
+  };
 
-  it('should return a list of schemas', () => {
+  it('should return a map of schemas', () => {
     const result = CamelSchemasProcessor.getSchemas(schemas);
 
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toEqual('user-schema');
-    expect(result[0].version).toEqual('3.2.0');
-    expect(result[0].tags).toEqual([]);
-    expect(result[0].uri).toEqual('https://camel.apache.org/schema/user-schema.json');
-    expect(result[0].schema).toEqual(userSchemaJson);
+    expect(Object.keys(result)).toHaveLength(1);
+    expect(result.userSchema.name).toEqual('userSchema');
+    expect(result.userSchema.version).toEqual('3.2.0');
+    expect(result.userSchema.tags).toEqual([]);
+    expect(result.userSchema.uri).toEqual('https://camel.apache.org/schema/user-schema.json');
+    expect(result.userSchema.schema).toEqual(userSchemaJson);
   });
 
   it('should return a list of schemas for camel schemas', () => {
-    const result = CamelSchemasProcessor.getSchemas([{ ...schemas[0], name: "Camel YAML DSL JSON schema", schema: camelSchema }]);
-    const expected = [
+    const result = CamelSchemasProcessor.getSchemas(
       {
+        'userSchema' :
+          {
+            ...schemas.userSchema,
+            name: "Camel YAML DSL JSON schema",
+            schema: camelSchema
+          }
+      }
+    );
+    const expected = {
+      'userSchema': {
         name: 'Camel YAML DSL JSON schema',
         schema: {
           $schema: 'http://json-schema.org/draft-07/schema#',
@@ -73,26 +83,26 @@ describe('camel-schemas-processor', () => {
         uri: 'https://camel.apache.org/schema/user-schema.json',
         version: '3.2.0',
       },
-    ];
+    };
 
     expect(result).toEqual(expected);
   });
 
   it.each([
     [
       'Beans',
-      { ...schemas[0], schema: { ...camelSchema, items: { ...camelSchema.items, properties: { beans: {} } } } },
+      { ...schemas.userSchema, schema: { ...camelSchema, items: { ...camelSchema.items, properties: { beans: {} } } } },
       [],
     ],
-    ['userSchema', { ...schemas[0], schema: userSchemaJson }, []],
-    ['Route', { ...schemas[0], name: 'route', schema: camelSchema }, ['visualization']],
-    ['Integration', { ...schemas[0], name: 'Integration' }, ['visualization']],
-    ['Kamelet', { ...schemas[0], name: 'Kamelet' }, ['visualization']],
-    ['KameletBinding', { ...schemas[0], name: 'KameletBinding' }, ['visualization']],
-    ['Pipe', { ...schemas[0], name: 'Pipe' }, ['visualization']],
+    ['userSchema', { ...schemas.userSchema, schema: userSchemaJson }, []],
+    ['Route', { ...schemas.userSchema, name: 'route', schema: camelSchema }, ['visualization']],
+    ['Integration', { ...schemas.userSchema, name: 'Integration' }, ['visualization']],
+    ['Kamelet', { ...schemas.userSchema, name: 'Kamelet' }, ['visualization']],
+    ['KameletBinding', { ...schemas.userSchema, name: 'KameletBinding' }, ['visualization']],
+    ['Pipe', { ...schemas.userSchema, name: 'Pipe' }, ['visualization']],
   ])('should return a list of schemas with a tag property for: %s', (_name, schema, tags) => {
-    const result = CamelSchemasProcessor.getSchemas([schema]);
+    const result = CamelSchemasProcessor.getSchemas({name: schema});
 
-    expect(result[0].tags).toEqual(tags);
+    expect(result.name.tags).toEqual(tags);
   });
 });

packages/ui/src/camel-utils/camel-schemas-processor.ts

@@ -5,22 +5,22 @@ export const DEFAULT_CATALOG_PATH = '/camel-catalog';
 export class CamelSchemasProcessor {
   static readonly VISUAL_FLOWS = ['route', 'Integration', 'Kamelet', 'KameletBinding', 'Pipe'];
 
-  static getSchemas(schemas: Schema[]): Schema[] {
-    return schemas.reduce((acc, schema) => {
+  static getSchemas(schemaMap: {[key: string]: Schema}): {[key: string]: Schema} {
+    return Object.entries(schemaMap).reduce((acc, [key, schema]) => {
       /** Standard JSON Schemas (Kamelets, KameletBindings & Pipes) */
       const tags = [];
       if (this.VISUAL_FLOWS.includes(schema.name)) {
         tags.push('visualization');
       }
 
-      acc.push({
+      acc[key] = {
         ...schema,
         name: schema.name,
         tags,
-      });
+      };
 
       return acc;
-    }, [] as Schema[]);
+    }, {} as {[key: string]: Schema});
   }
 
 }

packages/ui/src/components/SourceCode/SourceCode.tsx

@@ -14,8 +14,7 @@ interface SourceCodeProps {
 
 export const SourceCode: FunctionComponent<SourceCodeProps> = (props) => {
   const editorRef = useRef<Parameters<EditorDidMount>[0] | null>(null);
-  const schemas = useSchemasStore((state) => state.schemas);
-  const camelYamlDslSchema = schemas.find(s => s.name === 'camelYamlDsl');
+  const camelYamlDslSchema = useSchemasStore((state) => state.schemas.camelYamlDsl);
 
   useEffect(() => {
     setDiagnosticsOptions({

packages/ui/src/providers/catalog-schema-loader.provider.tsx

@@ -24,13 +24,14 @@ export const CatalogSchemaLoaderProvider: FunctionComponent<PropsWithChildren> =
 
         const schemaFiles = getSchemasFiles(catalogIndex.schemas);
 
-        Promise.all([camelComponentsFiles, camelProcessorsFiles, kameletsFiles, Promise.all(schemaFiles)]).then(
+        Promise.all([camelComponentsFiles, camelProcessorsFiles, kameletsFiles, schemaFiles]).then(
           ([camelComponents, camelProcessors, kamelets, schemas]) => {
             setCatalog(CatalogKind.Component, camelComponents.body);
             setCatalog(CatalogKind.Processor, camelProcessors.body);
             setCatalog(CatalogKind.Kamelet, kamelets.body);
 
-            CamelSchemasProcessor.getSchemas(schemas).forEach(setSchema);
+            Object.entries(CamelSchemasProcessor.getSchemas(schemas))
+              .forEach(([key, schema]) => setSchema(key, schema));
 
             setIsLoading(false);
           },
@@ -53,16 +54,18 @@ async function fetchFile(file: string) {
   return { body, uri: response.url };
 }
 
-function getSchemasFiles(schemaFiles: CatalogEntry[]): Promise<Schema>[] {
-  return schemaFiles.map(async (schemaDef) => {
+function getSchemasFiles(schemaFiles: CatalogEntry[]): Promise<{[key: string]: Schema}> {
+  const answer: any = {};
+  Object.entries(schemaFiles).forEach(async ([schemaName, schemaDef]) => {
     const fetchedSchema = await fetchFile(schemaDef.file);
-
-    return {
-      name: schemaDef.name,
-      tags: [],
-      version: schemaDef.version,
-      uri: fetchedSchema.uri,
-      schema: fetchedSchema.body,
-    };
+    answer[schemaName] =
+      {
+        name: schemaDef.name,
+        tags: [],
+        version: schemaDef.version,
+        uri: fetchedSchema.uri,
+        schema: fetchedSchema.body,
+      };
   });
+  return Promise.resolve(answer);
 }

packages/ui/src/store/schemas.store.ts

@@ -3,16 +3,19 @@ import { createWithEqualityFn } from 'zustand/traditional';
 import { Schema } from '../models';
 
 interface SchemasState {
-  schemas: Schema[];
-  setSchema: (schema: Schema) => void;
+  schemas: {[key: string]: Schema};
+  setSchema: (schemaKey: string, schema: Schema) => void;
 }
 
 export const useSchemasStore = createWithEqualityFn<SchemasState>(
   (set) => ({
-    schemas: [],
-    setSchema: (schema: Schema) => {
+    schemas: {},
+    setSchema: (schemaKey: string, schema: Schema) => {
       set((state) => ({
-        schemas: [...state.schemas, schema],
+        schemas: {
+          ...state.schemas,
+          [schemaKey]: schema
+        },
       }));
     },
   }),