feat: Support Schema type in the Launch form (#110)

* feat: support schema as a launch input type

* test: add value test cases for schema

src/components/Launch/LaunchForm/LaunchFormInputs.tsx

@@ -23,7 +23,6 @@ function getComponentForInput(input: InputProps, showErrors: boolean) {
         case InputType.Collection:
             return <CollectionInput {...props} />;
         case InputType.Map:
-        case InputType.Schema:
         case InputType.Unknown:
         case InputType.None:
             return <UnsupportedInput {...props} />;

src/components/Launch/LaunchForm/SimpleInput.tsx

@@ -55,6 +55,7 @@ export const SimpleInput: React.FC<InputProps> = props => {
             );
         case InputType.Datetime:
             return <DatetimeInput {...props} />;
+        case InputType.Schema:
         case InputType.String:
         case InputType.Integer:
         case InputType.Float:

src/components/Launch/LaunchForm/__mocks__/utils.ts

@@ -1,5 +1,6 @@
 import { Core } from 'flyteidl';
 import { BlobDimensionality } from 'models';
+import { InputType, InputTypeDefinition } from '../types';
 
 export function primitiveLiteral(primitive: Core.IPrimitive): Core.ILiteral {
     return { scalar: { primitive } };
@@ -20,3 +21,33 @@ export function blobLiteral({
         }
     };
 }
+
+export function collectionInputTypeDefinition(
+    typeDefinition: InputTypeDefinition
+): InputTypeDefinition {
+    return {
+        literalType: {
+            collectionType: typeDefinition.literalType
+        },
+        type: InputType.Collection,
+        subtype: typeDefinition
+    };
+}
+
+export function nestedCollectionInputTypeDefinition(
+    typeDefinition: InputTypeDefinition
+): InputTypeDefinition {
+    return {
+        literalType: {
+            collectionType: {
+                collectionType: typeDefinition.literalType
+            }
+        },
+        type: InputType.Collection,
+        subtype: {
+            literalType: { collectionType: typeDefinition.literalType },
+            type: InputType.Collection,
+            subtype: typeDefinition
+        }
+    };
+}

src/components/Launch/LaunchForm/constants.ts

@@ -36,7 +36,7 @@ export const typeLabels: { [k in InputType]: string } = {
     [InputType.Integer]: 'integer',
     [InputType.Map]: '',
     [InputType.None]: 'none',
-    [InputType.Schema]: 'schema',
+    [InputType.Schema]: 'schema - uri',
     [InputType.String]: 'string',
     [InputType.Struct]: 'struct',
     [InputType.Unknown]: 'unknown'

src/components/Launch/LaunchForm/inputHelpers/constants.ts

@@ -8,6 +8,7 @@ export function literalNone(): Core.ILiteral {
 export const allowedDateFormats = [ISO_8601, RFC_2822];
 
 const primitivePath = 'scalar.primitive';
+export const schemaUriPath = 'scalar.schema.uri';
 
 /** Strings constants which can be used to perform a deep `get` on a scalar
  * literal type using a primitive value.

src/components/Launch/LaunchForm/inputHelpers/getHelperForInput.ts

@@ -7,6 +7,7 @@ import { durationHelper } from './duration';
 import { floatHelper } from './float';
 import { integerHelper } from './integer';
 import { noneHelper } from './none';
+import { schemaHelper } from './schema';
 import { stringHelper } from './string';
 import { InputHelper } from './types';
 
@@ -25,7 +26,7 @@ const inputHelpers: Record<InputType, InputHelper> = {
     [InputType.Integer]: integerHelper,
     [InputType.Map]: unsupportedHelper,
     [InputType.None]: noneHelper,
-    [InputType.Schema]: unsupportedHelper,
+    [InputType.Schema]: schemaHelper,
     [InputType.String]: stringHelper,
     [InputType.Struct]: unsupportedHelper,
     [InputType.Unknown]: unsupportedHelper

src/components/Launch/LaunchForm/inputHelpers/schema.ts

@@ -0,0 +1,30 @@
+import { Core } from 'flyteidl';
+import { InputValue } from '../types';
+import { schemaUriPath } from './constants';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
+import { extractLiteralWithCheck } from './utils';
+
+function fromLiteral(literal: Core.ILiteral): InputValue {
+    return extractLiteralWithCheck<string>(literal, schemaUriPath);
+}
+
+function toLiteral({ typeDefinition, value }: ConverterInput): Core.ILiteral {
+    const uri = typeof value === 'string' ? value : value.toString();
+    // Note: schema type may be undefined if user is working with a generic schema.
+    const {
+        literalType: { schema: type }
+    } = typeDefinition;
+    return { scalar: { schema: { type, uri } } };
+}
+
+function validate({ value }: InputValidatorParams) {
+    if (typeof value !== 'string') {
+        throw new Error('Value is not a string');
+    }
+}
+
+export const schemaHelper: InputHelper = {
+    fromLiteral,
+    toLiteral,
+    validate
+};