Merge pull request #58 from dont-code/prj-enh

Support for out of order types

Author: gcollin

libs/xt-components/projects/xt-components/src/lib/angular/xt-resolver.service.spec.ts

@@ -53,6 +53,56 @@ describe('XtResolverService', () => {
     expect(result).toEqual(['subType2', 'subType21']);
   });
 
+  it ('should support type registration', () => {
+    service.registerTypes({
+      "Author": {
+        firstName:"string",
+        lastName:"string"
+      },
+      "Book": {
+        children: {
+          "title": "string",
+          "publishedYear":"number",
+          "author": {
+            toType:"Author",
+            referenceType:"MANY-TO-ONE",
+            field:"lastName"
+          }
+        }
+      }
+    });
+    expect(service.typeResolver.findType("Author")).toBeTruthy();
+    expect(service.typeResolver.findType("Book")).toBeTruthy();
+  });
+
+  it ('should support out of order type registration', () => {
+    service.registerTypes({
+      "NewBook": {
+        children: {
+          "title": "string",
+          "publishedYear":"number",
+          "author": {
+            toType:"NewAuthor",
+            referenceType:"MANY-TO-ONE",
+            field:"lastName"
+          },
+          type: "NewBookType"
+        }
+      },
+      "NewAuthor": {
+        firstName:"string",
+        lastName:"string"
+      },
+      "NewBookType": {
+        typeName:"string"
+      }
+    });
+    service.resolvePendingReferences();
+    expect(service.typeResolver.findType("NewAuthor")).toBeTruthy();
+    expect(service.typeResolver.findType("NewBook")).toBeTruthy();
+    expect(service.typeResolver.findType("NewBookType")).toBeTruthy();
+  });
+
   it('should properly set typeHandlers', () => {
     service.registerPlugin({
       name: 'resolverTest',

libs/xt-type/src/resolver/xt-type-resolver.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { xtTypeManager } from '../globals';
+import { XtBaseTypeHierarchy } from './xt-type-resolver.ts';
 
 describe('Xt Type Resolver', () => {
   it ('should correctly calculates properties per types', () => {
@@ -34,7 +35,7 @@ describe('Xt Type Resolver', () => {
         name: 'string',
         author: {
           type: 'authorType',
-          referenceType:'ONE'
+          referenceType:'MANY-TO-ONE'
         }
       }
     });
@@ -43,5 +44,22 @@ describe('Xt Type Resolver', () => {
     expect(authorRef).toBeTruthy();
     expect(authorRef?.type).toEqual('authorType');
   });
+
+  it ('should correctly managed unordered types', () => {
+    const resolver = xtTypeManager();
+    resolver.addRootType('newBookType', {
+      name: 'string',
+      author:'newAuthorType'
+    });
+    resolver.addRootType('newAuthorType', {
+      firstName: 'string',
+      lastName: 'string'
+    });
+
+    resolver.resolveAllTypeReferences();
+    const newBookType=resolver.findType('newBookType') as XtBaseTypeHierarchy;
+    expect((newBookType.children!['author'] as XtBaseTypeHierarchy).children).toBeDefined();
+
+  });
 })
 

libs/xt-type/src/resolver/xt-type-resolver.ts

@@ -269,7 +269,10 @@ export class XtTypeHierarchyResolver implements XtUpdatableTypeResolver {
       if (!this.isPrimitiveType(typeHierarchy)) {
           // Find the reference to an non primitive type
         ret = this.types.get(typeHierarchy) as XtBaseTypeHierarchy??null;
-        if( ret==null) throw new Error('Type '+typeHierarchy+' not found in the type hierarchy.');
+        if( ret==null) {
+          // Either it's an unknown type, or the type is defined at a later stage. Let's keep a placeholder
+          ret = new UNRESOLVED_TYPE (typeHierarchy);
+        }
       } else {
           // Just create the hierarchy to the primitive type
         ret= new XtBaseTypeHierarchy(typeHierarchy, handler);
@@ -325,14 +328,25 @@ export class XtTypeHierarchyResolver implements XtUpdatableTypeResolver {
 
   resolveAllTypeReferences ():void {
     for (const type of this.types.values()) {
-      const refs = type.listReferences();
-      for (const ref of Object.keys(refs)) {
-        if( refs[ref].type==XtBaseTypeReference.UNRESOLVED_TYPE) {
-          const refType = this.findType(refs[ref].toType, refs[ref].field);
-          if( refType!=null) {
-            refs[ref].type=refType.type;
-          }else {
-            throw new Error('Unable to resolve reference '+ref+' of type '+type.type);
+      if (type.children!=null) {
+        for (const ref of Object.keys(type.children)) {
+          const subType=type.children[ref];
+          if (isTypeReference(subType)) {
+            if( subType.type==XtBaseTypeReference.UNRESOLVED_TYPE) {
+              const refType = this.findType(subType.toType, subType.field);
+              if( refType!=null) {
+                subType.type=refType.type;
+              }else {
+                throw new Error('Unable to resolve reference '+ref+' of type '+type.type);
+              }
+            }
+          } else if (isUnresolvedType(subType)) {
+            const realType=this.findType(subType.unknownType);
+            if( realType!=null) {
+              type.children[ref]=realType;
+            } else {
+              throw new Error('Unable to resolve type '+ref+' of type '+type.type+'. '+subType.unknownType+' is not defined.');
+            }
           }
         }
       }
@@ -367,6 +381,7 @@ export class XtBaseTypeHierarchy implements XtTypeHierarchy {
   displayTemplate?:string;
   numericField?:string;
 
+
   constructor (type:string, handler?:XtTypeHandler<any> ) {
       this.type=type;
       this.handler=handler;
@@ -412,6 +427,22 @@ export class XtBaseTypeHierarchy implements XtTypeHierarchy {
   }
 }
 
+export class UNRESOLVED_TYPE extends XtBaseTypeHierarchy {
+  unknownType:string|null=null;
+
+  constructor(unknownType:string) {
+    super(unknownType);
+    this.unknownType=unknownType;
+  }
+}
+
+export function isUnresolvedType (type: XtTypeHierarchy): type is UNRESOLVED_TYPE {
+  if ((type as any).unknownType!==undefined) return true;
+  else
+    return false;
+}
+
+
 /**
  * Internally manages a link between two types
  */