feat: polymorphic fields

Initial support for polymorphic field types. Polymorphic types are a single of or list of a specific type. For example, `Union[str, list[str]]`.

Polymorphics do not yet have support for direct input in the UI (will come in the future). They will be forcibly set as Connection-only fields, in which case users will not be able to provide direct input to the field.

If a polymorphic should present as a singleton type - which would allow direct input - the node must provide an explicit type hint.

For example, `DenoiseLatents`' `CFG Scale` is polymorphic, but in the node editor, we want to present this as a number input. In the node definition, the field is given `ui_type=UIType.Float`, which tells the UI to treat this as a `float` field.

The connection validation logic will prevent connecting a collection to `CFG Scale` in this situation, because it is typed as `float`. The workaround is to disable validation from the settings to make this specific connection. A future improvement will resolve this.

This also introduces better support for collection field types. Like polymorphics, collection types are parsed automatically by the client and do not need any specific type hints.

Also like polymorphics, there is no support yet for direct input of collection types in the UI.

- Disabling validation in workflow editor now displays the visual hints for valid connections, but lets you connect to anything.
- Added `ui_order: int` to `InputField` and `OutputField`. The UI will use this, if present, to order fields in a node UI. See usage in `DenoiseLatents` for an example.
- Updated the field colors - duplicate colors have just been lightened a bit. It's not perfect but it was a quick fix.
- Field handles for collections are the same color as their single counterparts, but have a dark dot in the center of them.
- Field handles for polymorphics are a rounded square with dot in the middle.
- Removed all fields that just render `null` from `InputFieldRenderer`, replaced with a single fallback
- Removed logic in `zValidatedWorkflow`, which checked for existence of node templates for each node in a workflow. This logic introduced a circular dependency, due to importing the global redux `store` in order to get the node templates within a zod schema. It's actually fine to just leave this out entirely; The case of a missing node template is handled by the UI. Fixing it otherwise would introduce a substantial headache.
- Fixed the `ControlNetInvocation.control_model` field default, which was a string when it shouldn't have one.

invokeai/frontend/web/src/features/nodes/hooks/useIsValidConnection.ts

@@ -3,9 +3,19 @@ import graphlib from '@dagrejs/graphlib';
 import { useAppSelector } from 'app/store/storeHooks';
 import { useCallback } from 'react';
 import { Connection, Edge, Node, useReactFlow } from 'reactflow';
-import { COLLECTION_TYPES } from '../types/constants';
+import {
+  COLLECTION_MAP,
+  COLLECTION_TYPES,
+  POLYMORPHIC_TO_SINGLE_MAP,
+  POLYMORPHIC_TYPES,
+} from '../types/constants';
 import { InvocationNodeData } from '../types/types';
 
+/**
+ * NOTE: The logic here must be duplicated in `invokeai/frontend/web/src/features/nodes/store/util/makeIsConnectionValidSelector.ts`
+ * TODO: Figure out how to do this without duplicating all the logic
+ */
+
 export const useIsValidConnection = () => {
   const flow = useReactFlow();
   const shouldValidateGraph = useAppSelector(
@@ -42,6 +52,19 @@ export const useIsValidConnection = () => {
         return false;
       }
 
+      if (
+        edges
+          .filter((edge) => {
+            return edge.target === target && edge.targetHandle === targetHandle;
+          })
+          .find((edge) => {
+            edge.source === source && edge.sourceHandle === sourceHandle;
+          })
+      ) {
+        // We already have a connection from this source to this target
+        return false;
+      }
+
       // Connection is invalid if target already has a connection
       if (
         edges.find((edge) => {
@@ -53,21 +76,59 @@ export const useIsValidConnection = () => {
         return false;
       }
 
-      // Connection types must be the same for a connection
-      if (
-        sourceType !== targetType &&
-        sourceType !== 'CollectionItem' &&
-        targetType !== 'CollectionItem'
-      ) {
-        if (
-          !(
-            COLLECTION_TYPES.includes(targetType) &&
-            COLLECTION_TYPES.includes(sourceType)
-          )
-        ) {
-          return false;
-        }
+      /**
+       * Connection types must be the same for a connection, with exceptions:
+       * - CollectionItem can connect to any non-Collection
+       * - Non-Collections can connect to CollectionItem
+       * - Anything (non-Collections, Collections, Polymorphics) can connect to Polymorphics of the same base type
+       * - Generic Collection can connect to any other Collection or Polymorphic
+       * - Any Collection can connect to a Generic Collection
+       */
+
+      if (sourceType !== targetType) {
+        const isCollectionItemToNonCollection =
+          sourceType === 'CollectionItem' &&
+          !COLLECTION_TYPES.includes(targetType);
+
+        const isNonCollectionToCollectionItem =
+          targetType === 'CollectionItem' &&
+          !COLLECTION_TYPES.includes(sourceType) &&
+          !POLYMORPHIC_TYPES.includes(sourceType);
+
+        const isAnythingToPolymorphicOfSameBaseType =
+          POLYMORPHIC_TYPES.includes(targetType) &&
+          (() => {
+            if (!POLYMORPHIC_TYPES.includes(targetType)) {
+              return false;
+            }
+            const baseType =
+              POLYMORPHIC_TO_SINGLE_MAP[
+                targetType as keyof typeof POLYMORPHIC_TO_SINGLE_MAP
+              ];
+
+            const collectionType =
+              COLLECTION_MAP[baseType as keyof typeof COLLECTION_MAP];
+
+            return sourceType === baseType || sourceType === collectionType;
+          })();
+
+        const isGenericCollectionToAnyCollectionOrPolymorphic =
+          sourceType === 'Collection' &&
+          (COLLECTION_TYPES.includes(targetType) ||
+            POLYMORPHIC_TYPES.includes(targetType));
+
+        const isCollectionToGenericCollection =
+          targetType === 'Collection' && COLLECTION_TYPES.includes(sourceType);
+
+        return (
+          isCollectionItemToNonCollection ||
+          isNonCollectionToCollectionItem ||
+          isAnythingToPolymorphicOfSameBaseType ||
+          isGenericCollectionToAnyCollectionOrPolymorphic ||
+          isCollectionToGenericCollection
+        );
       }
+
       // Graphs much be acyclic (no loops!)
       return getIsGraphAcyclic(source, target, nodes, edges);
     },