refactor(Schema): handle strange types

make adjustments to the way we handle unknown types and 'any'

app/components/Structure.tsx

@@ -80,14 +80,23 @@ const Structure: React.FunctionComponent<StructureProps> = ({ peername, name, st
 
   const handleWriteSchema = (row: number) => {
     return (field: string) => {
-      return (value: string) => {
+      return (value: DataTypes) => {
+        let val = value
+        if (Array.isArray(value) && value.length === 1) {
+          val = value[0]
+        }
+        // if the value is 'any', we don't want to make
+        // any type assertions, let's remove 'type' from this
+        // row and field
+        if (val === 'any') {
+          val = undefined
+        }
         const s = { ...structure.schema }
         try {
-          s.items.items[row][field] = value
+          s.items.items[row][field] = val
         } catch (e) {
           throw e
         }
-        console.log('writing')
         write(peername, name, {
           structure: {
             ...structure,

app/components/structure/Schema.tsx

@@ -1,6 +1,8 @@
 import * as React from 'react'
 import { Schema as ISchema } from '../../models/dataset'
 import SchemaItem from '../item/SchemaItem'
+import { typesAndDescriptions } from './TypePicker'
+import { DataTypes } from '../item/DataType'
 
 interface SchemaProps {
   schema: ISchema | undefined
@@ -23,6 +25,18 @@ const Schema: React.FunctionComponent<SchemaProps> = ({
 
   const items = schema.items.items
 
+  const typeList = typesAndDescriptions.map((el) => el.type)
+
+  const handleTypes = (types: DataTypes): DataTypes => {
+    // if there is an unknown type, return 'any'
+    if (!types ||
+        (typeof types === 'string' && !typeList.includes(types)) ||
+        (Array.isArray(types) && (types.length === 0 || types.some((el) => !typeList.includes(el))))) {
+      return 'any'
+    }
+    return types
+  }
+
   return (
     <div className='schema-wrap'>
       <div className='schema-header'>
@@ -38,7 +52,7 @@ const Schema: React.FunctionComponent<SchemaProps> = ({
               row={i}
               onAccept={onAccept ? onAccept(i) : undefined}
               title={item.title || ''}
-              type={item.type || 'any'}
+              type={handleTypes(item.type)}
               description={item.description || ''}
               validation={item.validation || ''}
               editable={editable}

app/components/structure/TypePicker.tsx

@@ -49,12 +49,17 @@ const TypePicker: React.FunctionComponent<TypePickerProps> = ({
     }
     if (activeTab === 'multi') {
       let pickedTypeList
-      if (pickedType.includes(picked)) {
+      // if they picked 'any', only 'any' should be picked
+      // since 'any' emcompasses all types
+      if (picked === 'any') {
+        pickedTypeList = ['any']
+      } else if (pickedType.includes(picked)) {
         pickedTypeList = pickedType.filter((type) => type !== picked)
       } else {
         pickedTypeList = typesAndDescriptions.map((el: any): DataTypes => {
           return el.type
         }).filter((type: DataTypes) => {
+          if (type === 'any') return false
           return type === picked || pickedType.includes(type)
         })
       }

stories/3-Structure.stories.tsx

@@ -33,7 +33,11 @@ const sampleSchema: ISchema = {
       {
         'title': 'Spanish',
         'description': 'The numerical value, in spanish',
-        'type': 'string'
+        'type': 'not a type'
+      },
+      {
+        'title': 'Misc',
+        'description': 'Can be anything'
       }
     ],
     type: 'array'
@@ -65,6 +69,11 @@ export const schema = () => {
   )
 }
 
+schema.story = {
+  name: 'Schema',
+  parameters: { note: 'The initial schema given has 1) multiple types, 2) a single type, 3) an unknown type, and 4) no type' }
+}
+
 export const nonEditableSchema = () => {
   return (
     <div style={{ display: 'flex', flexDirection: 'column', justifyContent: 'center', alignItems: 'center', margin: 20, width: 700 }}>