Frontend fixes

frontend/src/metabase/lib/schema_metadata.js

@@ -61,36 +61,28 @@ const TYPES = {
 };
 
 export function isFieldType(type, field) {
-    if (!field) {
-        return false;
-    }
+    if (!field) return false;
 
-    let def = TYPES[type];
+    const typeDefinition = TYPES[type];
     // check to see if it belongs to any of the field types:
-    for (let prop of ["base", "special"]) {
-        const defTypes = def[prop];
-        if (defTypes) {
-            const fieldType = field[prop + "_type"];
-            for (const defType of defTypes) {
-                if (isa(fieldType, defType)) return true;
-            }
+    for (const prop of ["base", "special"]) {
+        const allowedTypes = typeDefinition[prop];
+        if (!allowedTypes) continue;
+
+        const fieldType = field[prop + "_type"];
+        for (const allowedType of allowedTypes) {
+            if (isa(fieldType, allowedType)) return true;
         }
     }
+
     // recursively check to see if it's NOT another field type:
-    if (def.exclude) {
-        for (let excludeType of def.exclude) {
-            if (isFieldType(excludeType, field)) {
-                return false;
-            }
-        }
+    for (const excludedType of (typeDefinition.exclude || [])) {
+        if (isFieldType(excludedType, field)) return false;
     }
+
     // recursively check to see if it's another field type:
-    if (def.include) {
-        for (let includeType of def.include) {
-            if (isFieldType(includeType, field)) {
-                return true;
-            }
-        }
+    for (const includedType of (typeDefinition.include || [])) {
+        if (isFieldType(includedType, field)) return true;
     }
     return false;
 }

frontend/src/metabase/visualizations/Scalar.jsx

@@ -7,6 +7,7 @@ import BarChart from "./BarChart.jsx";
 
 import Urls from "metabase/lib/urls";
 import { formatValue } from "metabase/lib/formatting";
+import { TYPE } from "metabase/lib/types";
 import { isSameSeries } from "metabase/visualizations/lib/utils";
 import { getSettings } from "metabase/lib/visualization_settings";
 
@@ -66,7 +67,7 @@ export default class Scalar extends Component {
                 card: { ...s.card, display: "bar" },
                 data: {
                     cols: [
-                        { base_type: "TextField", display_name: "Name", name: "dimension" },
+                        { base_type: TYPE.Text, display_name: "Name", name: "dimension" },
                         { ...s.data.cols[0], display_name: "Value", name: "metric" }],
                     rows: [
                         [s.card.name, s.data.rows[0][0]]

frontend/test/metabase-bootstrap.js

 import "metabase/vendor";
 
 window.MetabaseBootstrap = {
-  "timezones": [
-    "GMT",
-    "UTC",
-    "US\/Alaska",
-    "US\/Arizona",
-    "US\/Central",
-    "US\/Eastern",
-    "US\/Hawaii",
-    "US\/Mountain",
-    "US\/Pacific",
-    "America\/Costa_Rica"
-  ]
+    timezones: [
+        "GMT",
+        "UTC",
+        "US\/Alaska",
+        "US\/Arizona",
+        "US\/Central",
+        "US\/Eastern",
+        "US\/Hawaii",
+        "US\/Mountain",
+        "US\/Pacific",
+        "America\/Costa_Rica"
+    ],
+    types: {
+        "type/Address":                   ["type/*"],
+        "type/Array":                     ["type/Collection"],
+        "type/AvatarURL":                 ["type/URL"],
+        "type/BigInteger":                ["type/Integer"],
+        "type/Boolean":                   ["type/*"],
+        "type/Category":                  ["type/Special"],
+        "type/City":                      ["type/Category", "type/Address", "type/Text"],
+        "type/Collection":                ["type/*"],
+        "type/Coordinate":                ["type/Float"],
+        "type/Country":                   ["type/Category", "type/Address", "type/Text"],
+        "type/Date":                      ["type/DateTime"],
+        "type/DateTime":                  ["type/*"],
+        "type/Decimal":                   ["type/Float"],
+        "type/Description":               ["type/Text"],
+        "type/Dictionary":                ["type/Collection"],
+        "type/FK":                        ["type/Special"],
+        "type/Float":                     ["type/Number"],
+        "type/ImageURL":                  ["type/URL"],
+        "type/Integer":                   ["type/Number"],
+        "type/Latitude":                  ["type/Coordinate"],
+        "type/Longitude":                 ["type/Coordinate"],
+        "type/Name":                      ["type/Category", "type/Address", "type/Text"],
+        "type/Number":                    ["type/*"],
+        "type/PK":                        ["type/Special"],
+        "type/SerializedJSON":            ["type/Text", "type/Collection"],
+        "type/Special":                   ["type/*"],
+        "type/State":                     ["type/Category", "type/Address", "type/Text"],
+        "type/Text":                      ["type/*"],
+        "type/Time":                      ["type/DateTime"],
+        "type/UNIXTimestamp":             ["type/Integer", "type/DateTime"],
+        "type/UNIXTimestampMilliseconds": ["type/UNIXTimestamp"],
+        "type/UNIXTimestampSeconds":      ["type/UNIXTimestamp"],
+        "type/URL":                       ["type/Text"],
+        "type/UUID":                      ["type/Text"],
+        "type/Zip":                       ["type/Address"],
+        "type/ZipCode":                   ["type/Integer"]
+    }
 };

frontend/test/unit/lib/data_grid.spec.js

 import { pivot } from "metabase/lib/data_grid";
 
+import { TYPE } from "metabase/lib/types";
+
 function makeData(rows) {
     return {
         rows: rows,
         cols: [
-            { name: "D1", display_name: "Dimension 1", base_type: "TextField" },
-            { name: "D2", display_name: "Dimension 2", base_type: "TextField" },
-            { name: "M",  display_name: "Metric",      base_type: "IntegerField" }
+            { name: "D1", display_name: "Dimension 1", base_type: TYPE.Text },
+            { name: "D2", display_name: "Dimension 2", base_type: TYPE.Text },
+            { name: "M",  display_name: "Metric",      base_type: TYPE.Integer }
         ]
-    }
+    };
 }
 
 describe("data_grid", () => {

frontend/test/unit/lib/schema_metadata.spec.js

@@ -9,35 +9,36 @@ import {
     foreignKeyCountsByOriginTable
 } from 'metabase/lib/schema_metadata';
 
+import { TYPE } from "metabase/lib/types";
+
 describe('schema_metadata', () => {
     describe('getFieldType', () => {
         it('should know a date', () => {
-            expect(getFieldType({ base_type: 'DateField' })).toEqual(DATE_TIME)
-            expect(getFieldType({ base_type: 'DateTimeField' })).toEqual(DATE_TIME)
-            expect(getFieldType({ base_type: 'TimeField' })).toEqual(DATE_TIME)
-            expect(getFieldType({ special_type: 'timestamp_seconds' })).toEqual(DATE_TIME)
-            expect(getFieldType({ special_type: 'timestamp_milliseconds' })).toEqual(DATE_TIME)
+            expect(getFieldType({ base_type: TYPE.Date })).toEqual(DATE_TIME)
+            expect(getFieldType({ base_type: TYPE.DateTime })).toEqual(DATE_TIME)
+            expect(getFieldType({ base_type: TYPE.Time })).toEqual(DATE_TIME)
+            expect(getFieldType({ special_type: TYPE.UNIXTimestampSeconds })).toEqual(DATE_TIME)
+            expect(getFieldType({ special_type: TYPE.UNIXTimestampMilliseconds })).toEqual(DATE_TIME)
         });
         it('should know a number', () => {
-            expect(getFieldType({ base_type: 'BigIntegerField' })).toEqual(NUMBER)
-            expect(getFieldType({ base_type: 'IntegerField' })).toEqual(NUMBER)
-            expect(getFieldType({ base_type: 'FloatField' })).toEqual(NUMBER)
-            expect(getFieldType({ base_type: 'DecimalField' })).toEqual(NUMBER)
+            expect(getFieldType({ base_type: TYPE.BigInteger })).toEqual(NUMBER)
+            expect(getFieldType({ base_type: TYPE.Integer })).toEqual(NUMBER)
+            expect(getFieldType({ base_type: TYPE.Float })).toEqual(NUMBER)
+            expect(getFieldType({ base_type: TYPE.Decimal })).toEqual(NUMBER)
         });
         it('should know a string', () => {
-            expect(getFieldType({ base_type: 'CharField' })).toEqual(STRING)
-            expect(getFieldType({ base_type: 'TextField' })).toEqual(STRING)
+            expect(getFieldType({ base_type: TYPE.Text })).toEqual(STRING)
         });
         it('should know a bool', () => {
-            expect(getFieldType({ base_type: 'BooleanField' })).toEqual(BOOLEAN)
+            expect(getFieldType({ base_type: TYPE.Boolean })).toEqual(BOOLEAN)
         });
         it('should know a location', () => {
-            expect(getFieldType({ special_type: 'city' })).toEqual(LOCATION)
-            expect(getFieldType({ special_type: 'country' })).toEqual(LOCATION)
+            expect(getFieldType({ special_type: TYPE.City })).toEqual(LOCATION)
+            expect(getFieldType({ special_type: TYPE.Country })).toEqual(LOCATION)
         });
         it('should know a coordinate', () => {
-            expect(getFieldType({ special_type: 'latitude' })).toEqual(COORDINATE)
-            expect(getFieldType({ special_type: 'longitude' })).toEqual(COORDINATE)
+            expect(getFieldType({ special_type: TYPE.Latitude })).toEqual(COORDINATE)
+            expect(getFieldType({ special_type: TYPE.Longitude })).toEqual(COORDINATE)
         });
         it('should know what it doesn\'t know', () => {
             expect(getFieldType({ base_type: 'DERP DERP DERP' })).toEqual(undefined)

frontend/test/unit/visualizations/lib/timeseries.spec.js

@@ -3,6 +3,8 @@ import {
     computeTimeseriesDataInverval
 } from 'metabase/visualizations/lib/timeseries';
 
+import { TYPE } from "metabase/lib/types";
+
 describe('visualization.lib.timeseries', () => {
     describe('dimensionIsTimeseries', () => {
         // examples from https://en.wikipedia.org/wiki/ISO_8601
@@ -22,23 +24,23 @@ describe('visualization.lib.timeseries', () => {
             "scanner 005"
         ];
 
-        it("should detect DateField column as timeseries", () => {
-            expect(dimensionIsTimeseries({ cols: [{ base_type: "DateField" }]})).toBe(true);
+        it("should detect Date column as timeseries", () => {
+            expect(dimensionIsTimeseries({ cols: [{ base_type: TYPE.Date }]})).toBe(true);
         });
-        it("should detect TimeField column as timeseries", () => {
-            expect(dimensionIsTimeseries({ cols: [{ base_type: "TimeField" }]})).toBe(true);
+        it("should detect Time column as timeseries", () => {
+            expect(dimensionIsTimeseries({ cols: [{ base_type: TYPE.Time }]})).toBe(true);
         });
-        it("should detect DateTimeField column as timeseries", () => {
-            expect(dimensionIsTimeseries({ cols: [{ base_type: "DateTimeField" }]})).toBe(true);
+        it("should detect DateTime column as timeseries", () => {
+            expect(dimensionIsTimeseries({ cols: [{ base_type: TYPE.DateTime }]})).toBe(true);
         });
         ISO_8601_DATES.forEach(isoDate => {
             it("should detect values with ISO 8601 formatted string '" + isoDate + "' as timeseries", () => {
-                expect(dimensionIsTimeseries({ cols: [{ base_type: "TextField" }], rows: [[isoDate]]})).toBe(true);
+                expect(dimensionIsTimeseries({ cols: [{ base_type: TYPE.Text }], rows: [[isoDate]]})).toBe(true);
             })
         });
         NOT_DATES.forEach(notDate => {
             it("should not detect value '" + notDate + "' as timeseries", () => {
-                expect(dimensionIsTimeseries({ cols: [{ base_type: "TextField" }], rows: [[notDate]]})).toBe(false);
+                expect(dimensionIsTimeseries({ cols: [{ base_type: TYPE.Text }], rows: [[notDate]]})).toBe(false);
             });
         });
     });