feat: enhance DFlow services to support dependencies for namespace, project, and runtime IDs

Author: nicosammito

src/components/d-flow-data-type/DFlowDataType.service.ts

@@ -1,22 +1,28 @@
 import {ReactiveArrayService} from "../../utils";
 import {DataTypeView} from "./DFlowDataType.view";
 import {resolveType} from "../../utils/generics";
-import type {
+import {
     DataTypeIdentifier,
     DataTypeRule,
     DataTypeRulesContainsKeyConfig,
     DataTypeRulesInputTypesConfig, Flow,
     GenericMapper,
     LiteralValue,
-    Maybe,
-    NodeParameterValue,
+    Maybe, Namespace, NamespaceProject,
+    NodeParameterValue, Runtime,
     Scalars
 } from "@code0-tech/sagittarius-graphql-types";
 import {useValueValidation} from "../d-flow-validation/DValueValidation.hook";
 
-export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<DataTypeView> {
+export type DFlowDataTypeDependencies = {
+    namespaceId: Namespace['id']
+    projectId: NamespaceProject['id']
+    runtimeId: Runtime['id']
+}
+
+export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<DataTypeView, DFlowDataTypeDependencies> {
 
-    getDataType (type: DataTypeIdentifier): DataTypeView | undefined {
+    getDataType (type: DataTypeIdentifier, dependencies?: DFlowDataTypeDependencies): DataTypeView | undefined {
         if (!type) return undefined
         if ((type as DataTypeIdentifier).genericKey) return undefined
         const identifier = (type as DataTypeIdentifier).dataType?.identifier ?? (type as DataTypeIdentifier).genericType?.dataType?.identifier
@@ -26,20 +32,20 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
         });
     }
 
-    getDataTypeFromValue (value: NodeParameterValue, flow?: Flow): DataTypeView | undefined {
+    getDataTypeFromValue (value: NodeParameterValue, flow?: Flow, dependencies?: DFlowDataTypeDependencies): DataTypeView | undefined {
 
         if (!value) return undefined
 
         if (value.__typename == "LiteralValue") {
             //hardcode primitive types (NUMBER, BOOLEAN, TEXT)
             if (Array.isArray(value.value) && Array.from(value.value).length > 0) return this.getDataType({dataType: {identifier: "ARRAY"}})
-            if (typeof value.value === "string") return this.getDataType({dataType: {identifier: "TEXT"}})
-            if (typeof value.value === "number") return this.getDataType({dataType: {identifier: "NUMBER"}})
-            if (typeof value.value === "boolean") return this.getDataType({dataType: {identifier: "BOOLEAN"}})
+            if (typeof value.value === "string") return this.getDataType({dataType: {identifier: "TEXT"}}, dependencies)
+            if (typeof value.value === "number") return this.getDataType({dataType: {identifier: "NUMBER"}}, dependencies)
+            if (typeof value.value === "boolean") return this.getDataType({dataType: {identifier: "BOOLEAN"}}, dependencies)
         }
 
         //TODO: performance here is bad
-        const matchingDataTypes = this.values().filter(type => {
+        const matchingDataTypes = this.values(dependencies).filter(type => {
             if (type.identifier === "OBJECT") return false
             if (value.__typename === "NodeFunctionIdWrapper" && (type.variant != "NODE" || !flow)) return false
             return useValueValidation(value, type, this, flow)
@@ -49,13 +55,13 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
 
     }
 
-    getTypeFromValue (value: NodeParameterValue, flow?: Flow): Maybe<DataTypeIdentifier> | undefined {
+    getTypeFromValue (value: NodeParameterValue, flow?: Flow, dependencies?: DFlowDataTypeDependencies): Maybe<DataTypeIdentifier> | undefined {
 
         if (!value) return undefined
 
         if (value.__typename === "ReferenceValue") return value.dataTypeIdentifier
 
-        const dataType = this.getDataTypeFromValue(value, flow)
+        const dataType = this.getDataTypeFromValue(value, flow, dependencies)
         if ((dataType?.genericKeys?.length ?? 0) <= 0 || !dataType?.genericKeys) return {dataType: {id: dataType?.id}}
 
         //TODO: missing generic combinations
@@ -75,7 +81,7 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
                     sourceDataTypeIdentifiers: [this.getTypeFromValue({
                         __typename: "LiteralValue",
                         value: ((value as LiteralValue).value as Array<any>)[0]
-                    }, flow)],
+                    }, flow, dependencies)],
                     target: genericKey
                 } as GenericMapper
             }
@@ -89,7 +95,7 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
                         __typename: "LiteralValue",
                         /* @ts-ignore */
                         value: (value.value as Object)[((ruleThatIncludesGenericKey.config as DataTypeRulesContainsKeyConfig)?.key ?? "")]
-                    }, flow)],
+                    }, flow, dependencies)],
                     target: genericKey
                 } as GenericMapper
             }
@@ -98,7 +104,7 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
                 && ruleThatIncludesGenericKey.variant == "RETURN_TYPE"
                 && dataType.variant === "NODE") {
                 return {
-                    sourceDataTypeIdentifiers: [this.getTypeFromValue(value, flow)],
+                    sourceDataTypeIdentifiers: [this.getTypeFromValue(value, flow, dependencies)],
                     target: genericKey
                 } as GenericMapper
             }
@@ -132,9 +138,9 @@ export abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<
 
     }
 
-    hasDataTypes(types: DataTypeIdentifier[]): boolean {
+    hasDataTypes(types: DataTypeIdentifier[], dependencies?: DFlowDataTypeDependencies): boolean {
         return types.every(type => {
-            return this.values().find(value => {
+            return this.values(dependencies).find(value => {
                 return value.id === (type.genericType?.dataType?.id ?? type.dataType?.id)
             })
         })

src/components/d-flow-function/DFlowFunction.service.ts

@@ -1,12 +1,17 @@
 import {ReactiveArrayService} from "../../utils";
 import {FunctionDefinitionView} from "./DFlowFunction.view";
-import type {FunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
+import {FunctionDefinition, Namespace, NamespaceProject, Runtime} from "@code0-tech/sagittarius-graphql-types";
 
+export type DFlowFunctionDependencies = {
+    namespaceId: Namespace['id']
+    projectId: NamespaceProject['id']
+    runtimeId: Runtime['id']
+}
 
-export abstract class DFlowFunctionReactiveService extends ReactiveArrayService<FunctionDefinitionView> {
+export abstract class DFlowFunctionReactiveService extends ReactiveArrayService<FunctionDefinitionView, DFlowFunctionDependencies> {
 
-    getById(id: FunctionDefinition['id']): FunctionDefinitionView | undefined {
-        return this.values().find(functionDefinition => functionDefinition.id === id)
+    getById(id: FunctionDefinition['id'], dependencies?: DFlowFunctionDependencies): FunctionDefinitionView | undefined {
+        return this.values(dependencies).find(functionDefinition => functionDefinition.id === id)
     }
 
 }

src/components/d-flow-type/DFlowType.service.ts

@@ -1,11 +1,17 @@
 import {ReactiveArrayService} from "../../utils";
 import {FlowTypeView} from "./DFlowType.view";
-import type {FlowType} from "@code0-tech/sagittarius-graphql-types";
+import {FlowType, Namespace, NamespaceProject, Runtime} from "@code0-tech/sagittarius-graphql-types";
 
-export abstract class DFlowTypeReactiveService extends ReactiveArrayService<FlowTypeView> {
+export type DFlowTypeDependencies = {
+    namespaceId: Namespace['id']
+    projectId: NamespaceProject['id']
+    runtimeId: Runtime['id']
+}
 
-    getById(id: FlowType['id']): FlowTypeView | undefined {
-        return this.values().find(value => value.id === id);
+export abstract class DFlowTypeReactiveService extends ReactiveArrayService<FlowTypeView, DFlowTypeDependencies> {
+
+    getById(id: FlowType['id'], dependencies?: DFlowTypeDependencies): FlowTypeView | undefined {
+        return this.values(dependencies).find(value => value.id === id);
     }
 
 }