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
+};