Support for type references

Support for type references

Author: gcollin

.gitignore

@@ -121,3 +121,7 @@ out-tsc/
 # Heft temporary files
 .cache/
 .heft/
+/libs/xt-type/vitest.config.d.ts
+/libs/xt-type/vitest.config.d.ts.map
+/libs/xt-type/vitest.config.js
+/libs/xt-type/vitest.config.js.map

apps/xt-host/projects/host/src/app/shared/app-config/app-config.service.ts

@@ -133,6 +133,8 @@ export class AppConfigService {
       if (errors.length > 0) {
         return Promise.reject(errors);
       }
+      // Once all plugins are loaded, we resolve all type references
+      this.resolverService.resolvePendingReferences();
     }
     return Promise.resolve(true);
   }

apps/xt-host/projects/host/src/app/shared/models/dc-application-model.ts

@@ -1,3 +1,5 @@
+import { XtTypeReference } from 'xt-type';
+
 export type DcApplicationModel = {
   name:string,
   description?: string,
@@ -18,10 +20,12 @@ export type DcEntityModel = {
   name: string,
   fields?: {
     [key:string]:DcFieldModel
-  }
+  },
+  compatibleWith?: string[]
 }
 
 export type DcFieldModel = {
   name: string,
-  type: string
+  type: string,
+  reference?: XtTypeReference
 }

apps/xt-plugin-tester/projects/plugin-tester/src/app/hierarchy-test/hierarchy-test.component.ts

@@ -27,6 +27,10 @@ export class HierarchyTestComponent {
     // Register the edited type
     this.xtResolver.registerTypes (
       {
+        'money': {
+          amount: 'number',
+          currency: 'string'
+        },
         'TestPayment': {
           toWho: 'string',
           payment: 'money'

apps/xt-plugin-tester/projects/plugin-tester/src/app/plugin-manager/plugin-manager.component.spec.ts

@@ -76,13 +76,13 @@ describe('PluginManagerComponent', () => {
         }
       ],
       types: {
-        'TestType21': {
-          'subProp':'TestType211'
-        },
         'TestType211': {
           'TestProperty2111':'date',
           'TestProperty2112':'boolean'
         },
+        'TestType21': {
+          'subProp':'TestType211'
+        },
         'TestType22': 'string',
         'TestType23': {
           'TestProperty231':'string',

apps/xt-plugin-tester/projects/plugin-tester/src/app/plugin-manager/plugin-manager.component.ts

@@ -11,7 +11,7 @@ import {
 import { XtComponentInfo, XtPluginInfo, XtResolverService } from 'xt-components';
 import { Button } from 'primeng/button';
 import { PrimeIcons } from 'primeng/api';
-import { XtTypeInfo } from 'xt-type';
+import { XtTypeDetail, XtTypeInfo, isTypeDetail } from 'xt-type';
 import { Card } from 'primeng/card';
 import { JsonPipe } from '@angular/common';
 import { Panel } from 'primeng/panel';
@@ -130,6 +130,12 @@ export class PluginManagerComponent implements OnDestroy, OnInit {
       this.resolverService.loadPlugin(url).catch((error) => {
         this.errorHandler.errorOccurred(error, "Error while loading plugin.");
       });
+
+      try {
+        this.resolverService.resolvePendingReferences();
+      } catch (error) {
+        this.errorHandler.errorOccurred(error, "Error while resolving pending references.");
+      }
     }
   }
 
@@ -188,7 +194,7 @@ class TypeDisplayInfo {
   name:string;
   typeName?: string;
 
-  constructor(name:string, type:XtTypeInfo|string) {
+  constructor(name:string, type:XtTypeInfo|XtTypeDetail|string) {
     this.name=name;
     if (typeof type == 'string') {
       this.typeName = type;

common/config/rush/pnpm-lock.yaml

@@ -10,6 +10,7 @@ Must enable:
 - Workflow View One per category => Edit
 - Workflow New Element
 - Workflow Select from SubList => New Element
+- Workflow list + report: Display a report in realtime (total expense, monthly expense) while displaying and editing elements of the list
 
 Configuration:
 - Menu to Workflow

docs/workflow-requirements.txt

@@ -57,6 +57,8 @@ describe('XtResolverService', () => {
     service.registerPlugin({
       name: 'resolverTest',
       types: {
+        testString: 'string',
+        testType2:'number',
         type1: {
           subType1: 'testString'
         },

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

@@ -1,17 +1,26 @@
-import { computed, inject, Injectable, Injector, runInInjectionContext, Type } from '@angular/core';
+import { computed, inject, Injectable, Type } from '@angular/core';
 import { XtContext } from '../xt-context';
 import { XtRegistryResolver } from '../resolver/xt-registry-resolver';
 import { XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN } from './xt-tokens';
 import { XtResolvedComponent } from '../xt-resolved-component';
-import { ManagedDataHandler,
-  MappingHelper, XtTypeHandler, XtTypeInfo, xtTypeManager, XtTypeResolver, XtUpdatableTypeResolver } from 'xt-type';
+import {
+  ManagedDataHandler,
+  MappingHelper,
+  XtSpecialFieldsHelper,
+  XtTypeHandler,
+  XtTypeInfo,
+  xtTypeManager,
+  XtTypeResolver,
+  XtUpdatableTypeResolver
+} from 'xt-type';
 import { XtComponentInfo, XtPluginInfo, XtTypeHandlerInfo } from '../plugin/xt-plugin-info';
 import { XtResolver } from '../resolver/xt-resolver';
 import { XtComponent } from '../xt-component';
 import { loadRemoteModule } from '@angular-architects/native-federation';
 import { XtAction } from '../action/xt-action';
-import { IStoreProvider } from '../store/store-support';
 import { XtActionHandler, XtActionResult } from '../action/xt-action-handler';
+import { IStoreManager, StoreSupport } from '../store/store-support';
+import { firstValueFrom, Observable } from 'rxjs';
 
 /**
  * An all in one helper class, enabling manipulation of the context, with data and type associated with it.
@@ -52,7 +61,12 @@ export class XtResolverService {
   }
 
   findTypeHandlerOf<T> (baseContext:XtContext<T>, subName?:string, value?:T): {typeName?:string | null, handler?:XtTypeHandler<any>} {
-    const ret = this.typeResolver.findTypeHandler(baseContext.valueType, false, subName, value);
+    let ret:{typeName?:string | null, handler?:XtTypeHandler<any>} = {typeName:undefined, handler:undefined};
+    if (baseContext.isReference()){
+      ret = this.typeResolver.findTypeHandler(baseContext.reference!.toType, false, undefined, value);
+    }else {
+      ret = this.typeResolver.findTypeHandler(baseContext.valueType, false, subName, value);
+    }
     return ret;
   }
 
@@ -71,6 +85,7 @@ export class XtResolverService {
 
   registerTypes (types:XtTypeInfo|undefined, handlers?:XtTypeHandlerInfo<any>[]): void {
     if ((types !=null) && (this.typeResolver.canUpdate())) {
+
       for (const newType in types) {
         let handler=this.handlerDefinedFor (newType, handlers);
         if (handler==null) {
@@ -232,4 +247,62 @@ export class XtResolverService {
     return undefined;
   }
 
+  async resolveReferencedValue<T,U> (context: XtContext<T>, storeMgr: IStoreManager): Promise<U | U[] | null | undefined> {
+    if (!context.isReference()) return undefined;
+    const ref= context.reference!;
+    const storeProvider = storeMgr.getProvider<U> (ref.type);
+    if (storeProvider == null) {
+      throw new Error ('No Store provider found for type '+ref.type);
+    }
+
+    const ret= await firstValueFrom(storeProvider.searchEntities(ref.toType, storeMgr.newStoreCriteria(ref.field, context.value(),'=')));
+    if (ret.length == 0) return null;
+      if (ref.referenceType=='MANY-TO-ONE') {
+        if (ret.length > 1) throw new Error('Multiple values for many to one relation between ' + context.valueType + ' and ' + ref.type + ' with value ' + context.value());
+        return ret[0];
+      } else if (ref.referenceType=='ONE-TO-MANY') {
+        return ret;
+      }
+    return undefined;
+  }
+
+  resolvePendingReferences () {
+    (this.typeResolver as XtUpdatableTypeResolver).resolveAllTypeReferences();
+  }
+
+  /**
+   * Calculates the values that can be referenced by the reference & value of this context
+   * @param context
+   */
+  findPossibleReferences<T, U> (context:XtContext<T>): Observable<U[]> {
+    if (!context.isReference()) throw new Error('Cannot find possible references of this non reference context'+context.toString());
+    const reference = context.reference!;
+    const store =StoreSupport.getStoreManager().getProviderSafe<U>(reference.toType);
+    return store.searchEntities(reference.toType );
+  }
+
+/*  async loadAllReferencesForContext<T> (context:XtContext<T>, storeMgr: IStoreManager): Promise<void> {
+    const refs  =this.typeResolver.listReferences(context.valueType);
+    const promises:Promise<void>[]=[];
+    for (const ref of Object.keys(refs)) {
+      const subContext= context.subContext(ref, undefined, this.typeResolver);
+      promises.push(this.resolveReferencedValue(subContext, storeMgr).then ((value) => {
+        subContext.updateReferencedContext(value);
+      }));
+    }
+
+    if( promises.length>0) {
+      return Promise.all(promises).then((values) => {
+        context.subReferencesResolved.set(true);
+        return;
+      });
+    } else {
+      return Promise.resolve().then (() => {
+        context.subReferencesResolved.set(true);
+      });
+    }
+
+  }
+*/
+
 }