@nocobase/plugin-data-visualization 0.10.1-alpha.1

package/lib/client/renderer/library/G2PlotLibrary.js

@@ -0,0 +1,288 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.G2PlotLibrary = void 0;
+function _plots() {
+  const data = require("@ant-design/plots");
+  _plots = function _plots() {
+    return data;
+  };
+  return data;
+}
+var _locale = require("../../locale");
+var _ChartLibrary = require("../ChartLibrary");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const init = _ChartLibrary.commonInit;
+const basicSchema = {
+  type: 'object',
+  properties: {
+    xField: {
+      title: (0, _locale.lang)('xField'),
+      type: 'string',
+      'x-decorator': 'FormItem',
+      'x-component': 'Select',
+      'x-reactions': '{{ useChartFields }}',
+      required: true
+    },
+    yField: {
+      title: (0, _locale.lang)('yField'),
+      type: 'string',
+      'x-decorator': 'FormItem',
+      'x-component': 'Select',
+      'x-reactions': '{{ useChartFields }}',
+      required: true
+    },
+    seriesField: {
+      title: (0, _locale.lang)('seriesField'),
+      type: 'string',
+      'x-decorator': 'FormItem',
+      'x-component': 'Select',
+      'x-reactions': '{{ useChartFields }}'
+    }
+  }
+};
+const _useProps = ({
+  data,
+  fieldProps,
+  general,
+  advanced
+}) => {
+  const meta = {};
+  Object.entries(fieldProps).forEach(([key, props]) => {
+    meta[key] = {
+      formatter: props.transformer,
+      alias: props.label
+    };
+  });
+  return _objectSpread(_objectSpread({
+    data,
+    meta
+  }, general), advanced);
+};
+const G2PlotLibrary = {
+  line: {
+    name: (0, _locale.lang)('Line Chart'),
+    component: _plots().Line,
+    schema: basicSchema,
+    init,
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Line Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/bar'
+    }
+  },
+  area: {
+    name: (0, _locale.lang)('Area Chart'),
+    component: _plots().Area,
+    schema: basicSchema,
+    init,
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Area Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/area'
+    }
+  },
+  column: {
+    name: (0, _locale.lang)('Column Chart'),
+    component: _plots().Column,
+    schema: basicSchema,
+    init,
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Column Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/column'
+    }
+  },
+  bar: {
+    name: (0, _locale.lang)('Bar Chart'),
+    component: _plots().Bar,
+    schema: basicSchema,
+    init: (fields, {
+      measures,
+      dimensions
+    }) => {
+      const _infer = (0, _ChartLibrary.infer)(fields, {
+          measures,
+          dimensions
+        }),
+        xField = _infer.xField,
+        yField = _infer.yField,
+        seriesField = _infer.seriesField;
+      return {
+        general: {
+          xField: yField === null || yField === void 0 ? void 0 : yField.value,
+          yField: xField === null || xField === void 0 ? void 0 : xField.value,
+          seriesField: seriesField === null || seriesField === void 0 ? void 0 : seriesField.value
+        }
+      };
+    },
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Bar Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/bar'
+    }
+  },
+  pie: {
+    name: (0, _locale.lang)('Pie Chart'),
+    component: _plots().Pie,
+    schema: {
+      type: 'object',
+      properties: {
+        angleField: {
+          title: (0, _locale.lang)('angleField'),
+          type: 'string',
+          'x-decorator': 'FormItem',
+          'x-component': 'Select',
+          'x-reactions': '{{ useChartFields }}',
+          required: true
+        },
+        colorField: {
+          title: (0, _locale.lang)('colorField'),
+          type: 'string',
+          'x-decorator': 'FormItem',
+          'x-component': 'Select',
+          'x-reactions': '{{ useChartFields }}',
+          required: true
+        }
+      }
+    },
+    init: (fields, {
+      measures,
+      dimensions
+    }) => {
+      const _infer2 = (0, _ChartLibrary.infer)(fields, {
+          measures,
+          dimensions
+        }),
+        xField = _infer2.xField,
+        yField = _infer2.yField;
+      return {
+        general: {
+          colorField: xField === null || xField === void 0 ? void 0 : xField.value,
+          angleField: yField === null || yField === void 0 ? void 0 : yField.value
+        }
+      };
+    },
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Pie Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/pie'
+    }
+  },
+  dualAxes: {
+    name: (0, _locale.lang)('Dual Axes Chart'),
+    component: _plots().DualAxes,
+    useProps: ({
+      data,
+      fieldProps,
+      general,
+      advanced
+    }) => {
+      return _objectSpread(_objectSpread({}, _useProps({
+        data,
+        fieldProps,
+        general,
+        advanced
+      })), {}, {
+        data: [data, data]
+      });
+    },
+    schema: {
+      type: 'object',
+      properties: {
+        xField: {
+          title: (0, _locale.lang)('xField'),
+          type: 'string',
+          'x-decorator': 'FormItem',
+          'x-component': 'Select',
+          'x-reactions': '{{ useChartFields }}',
+          required: true
+        },
+        yField: {
+          title: (0, _locale.lang)('yField'),
+          type: 'array',
+          'x-decorator': 'FormItem',
+          'x-component': 'ArrayItems',
+          items: {
+            type: 'void',
+            'x-component': 'Space',
+            properties: {
+              sort: {
+                type: 'void',
+                'x-decorator': 'FormItem',
+                'x-component': 'ArrayItems.SortHandle'
+              },
+              input: {
+                type: 'string',
+                'x-decorator': 'FormItem',
+                'x-component': 'Select',
+                'x-reactions': '{{ useChartFields }}',
+                'x-component-props': {
+                  style: {
+                    'min-width': '200px'
+                  }
+                },
+                required: true
+              },
+              remove: {
+                type: 'void',
+                'x-decorator': 'FormItem',
+                'x-component': 'ArrayItems.Remove'
+              }
+            }
+          },
+          properties: {
+            add: {
+              type: 'void',
+              title: (0, _locale.lang)('Add'),
+              'x-component': 'ArrayItems.Addition'
+            }
+          }
+        }
+      }
+    },
+    init: (fields, {
+      measures,
+      dimensions
+    }) => {
+      const _infer3 = (0, _ChartLibrary.infer)(fields, {
+          measures,
+          dimensions
+        }),
+        xField = _infer3.xField,
+        yFields = _infer3.yFields;
+      return {
+        general: {
+          xField: xField === null || xField === void 0 ? void 0 : xField.value,
+          yField: (yFields === null || yFields === void 0 ? void 0 : yFields.map(f => f.value).slice(0, 2)) || []
+        }
+      };
+    },
+    reference: {
+      title: (0, _locale.lang)('Dual Axes Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/dual-axes'
+    }
+  },
+  // gauge: {
+  //   name: lang('Gauge Chart'),
+  //   component: Gauge,
+  // },
+  scatter: {
+    name: (0, _locale.lang)('Scatter Chart'),
+    component: _plots().Scatter,
+    schema: basicSchema,
+    init,
+    useProps: _useProps,
+    reference: {
+      title: (0, _locale.lang)('Scatter Chart'),
+      link: 'https://g2plot.antv.antgroup.com/api/plots/scatter'
+    }
+  }
+};
+exports.G2PlotLibrary = G2PlotLibrary;

package/lib/client/renderer/library/index.d.ts

@@ -0,0 +1,3 @@
+export declare const InternalLibrary: {
+    [x: string]: import("..").ChartProps;
+};

package/lib/client/renderer/library/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InternalLibrary = void 0;
+var _AntdLibrary = require("./AntdLibrary");
+var _G2PlotLibrary = require("./G2PlotLibrary");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const InternalLibrary = _objectSpread(_objectSpread({}, _G2PlotLibrary.G2PlotLibrary), _AntdLibrary.AntdLibrary);
+exports.InternalLibrary = InternalLibrary;

package/lib/client/utils.d.ts

@@ -0,0 +1,96 @@
+import { FieldOption } from './hooks';
+import { QueryProps } from './renderer';
+export declare const createRendererSchema: (decoratorProps: any, componentProps?: {}) => {
+    type: string;
+    'x-decorator': string;
+    'x-decorator-props': any;
+    'x-acl-action': string;
+    'x-designer': string;
+    'x-component': string;
+    'x-component-props': {
+        size: string;
+    };
+    'x-initializer': string;
+    properties: {
+        [x: string]: {
+            type: string;
+            'x-component': string;
+            'x-component-props': {};
+        };
+    };
+};
+export declare const parseField: (field: string | string[]) => {
+    target: string;
+    name: string;
+    alias: string;
+};
+export declare const getField: (fields: FieldOption[], field: string | string[]) => FieldOption;
+export declare const getSelectedFields: (fields: FieldOption[], query: QueryProps) => {
+    key: string;
+    label: string;
+    value: string;
+    alias?: string;
+    name?: string;
+    type?: string;
+    interface?: string;
+    uiSchema?: import("@formily/react").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/react").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/react").SchemaTypes;
+        enum?: import("@formily/react").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/react").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/react").Stringify<any>;
+        patternProperties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/react").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/react").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>;
+    target?: string;
+    targetFields?: FieldOption[];
+}[];
+export declare const processData: (fields: FieldOption[], data: any[], scope: any) => {}[];

package/lib/client/utils.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processData = exports.parseField = exports.getSelectedFields = exports.getField = exports.createRendererSchema = void 0;
+function _react() {
+  const data = require("@formily/react");
+  _react = function _react() {
+    return data;
+  };
+  return data;
+}
+function _shared() {
+  const data = require("@formily/shared");
+  _shared = function _shared() {
+    return data;
+  };
+  return data;
+}
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+const createRendererSchema = (decoratorProps, componentProps = {}) => {
+  const collection = decoratorProps.collection;
+  return {
+    type: 'void',
+    'x-decorator': 'ChartRendererProvider',
+    'x-decorator-props': decoratorProps,
+    'x-acl-action': `${collection}:list`,
+    'x-designer': 'ChartRenderer.Designer',
+    'x-component': 'CardItem',
+    'x-component-props': {
+      size: 'small'
+    },
+    'x-initializer': 'ChartInitializers',
+    properties: {
+      [(0, _shared().uid)()]: {
+        type: 'void',
+        'x-component': 'ChartRenderer',
+        'x-component-props': componentProps
+      }
+    }
+  };
+};
+// For AssociationField, the format of field is [targetField, field]
+exports.createRendererSchema = createRendererSchema;
+const parseField = field => {
+  let target;
+  let name;
+  if (!Array.isArray(field)) {
+    name = field;
+  } else if (field.length === 1) {
+    name = field[0];
+  } else if (field.length > 1) {
+    var _field = _slicedToArray(field, 2);
+    target = _field[0];
+    name = _field[1];
+  }
+  return {
+    target,
+    name,
+    alias: target ? `${target}.${name}` : name
+  };
+};
+exports.parseField = parseField;
+const getField = (fields, field) => {
+  var _fields$find, _fields$find$targetFi;
+  const _parseField = parseField(field),
+    target = _parseField.target,
+    name = _parseField.name;
+  if (!target) {
+    return fields.find(f => f.name === name);
+  }
+  const targetField = (_fields$find = fields.find(f => f.name === target)) === null || _fields$find === void 0 ? void 0 : (_fields$find$targetFi = _fields$find.targetFields) === null || _fields$find$targetFi === void 0 ? void 0 : _fields$find$targetFi.find(f => f.name === name);
+  return targetField;
+};
+exports.getField = getField;
+const getSelectedFields = (fields, query) => {
+  // When field alias is set, appends it to the field list
+  const process = selectedFields => {
+    return selectedFields.map(selectedField => {
+      const fieldProps = getField(fields, selectedField.field);
+      return _objectSpread(_objectSpread({}, fieldProps), {}, {
+        key: selectedField.alias || (fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.key),
+        label: selectedField.alias || (fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.label),
+        value: selectedField.alias || (fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.value)
+      });
+    });
+  };
+  const measures = query.measures || [];
+  const dimensions = query.dimensions || [];
+  // unique
+  const map = new Map([...process(measures), ...process(dimensions)].map(item => [item.value, item]));
+  const selectedFields = [...map.values()];
+  return selectedFields;
+};
+exports.getSelectedFields = getSelectedFields;
+const processData = (fields, data, scope) => {
+  const parseEnum = (field, value) => {
+    var _field$uiSchema;
+    const options = (_field$uiSchema = field.uiSchema) === null || _field$uiSchema === void 0 ? void 0 : _field$uiSchema.enum;
+    if (!options || !Array.isArray(options)) {
+      return value;
+    }
+    const option = options.find(option => option.value === value);
+    return _react().Schema.compile((option === null || option === void 0 ? void 0 : option.label) || value, scope);
+  };
+  return data.map(record => {
+    const processed = {};
+    Object.entries(record).forEach(([key, value]) => {
+      const field = getField(fields, key.split('.'));
+      if (!field) {
+        processed[key] = value;
+        return;
+      }
+      switch (field.interface) {
+        case 'select':
+        case 'radioGroup':
+          processed[key] = parseEnum(field, value);
+          break;
+        default:
+          processed[key] = value;
+      }
+    });
+    return processed;
+  });
+};
+exports.processData = processData;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { default } from './server';

package/lib/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _server.default;
+  }
+});
+var _server = _interopRequireDefault(require("./server"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/server/actions/formatter.d.ts

@@ -0,0 +1,3 @@
+export declare const dateFormatFn: (sequelize: any, dialect: string, field: string, format: string) => any;
+export declare const formatFn: (sequelize: any, dialect: string, field: string, format: string) => any;
+export declare const formatter: (sequelize: any, type: string, field: string, format: string) => any;

package/lib/server/actions/formatter.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatter = exports.formatFn = exports.dateFormatFn = void 0;
+const dateFormatFn = (sequelize, dialect, field, format) => {
+  switch (dialect) {
+    case 'sqlite':
+      format = format.replace(/YYYY/g, '%Y').replace(/MM/g, '%m').replace(/DD/g, '%d').replace(/hh/g, '%H').replace(/mm/g, '%M').replace(/ss/g, '%S');
+      return sequelize.fn('strftime', format, sequelize.col(field));
+    case 'mysql':
+      format = format.replace(/YYYY/g, '%Y').replace(/MM/g, '%m').replace(/DD/g, '%d').replace(/hh/g, '%H').replace(/mm/g, '%i').replace(/ss/g, '%S');
+      return sequelize.fn('date_format', sequelize.col(field), format);
+    case 'postgres':
+      format = format.replace(/hh/g, 'HH24').replace(/mm/g, 'MI').replace(/ss/g, 'SS');
+      return sequelize.fn('to_char', sequelize.col(field), format);
+    default:
+      return field;
+  }
+};
+exports.dateFormatFn = dateFormatFn;
+const formatFn = (sequelize, dialect, field, format) => {
+  switch (dialect) {
+    case 'sqlite':
+    case 'postgres':
+      return sequelize.fn('format', format, sequelize.col(field));
+    default:
+      return field;
+  }
+};
+exports.formatFn = formatFn;
+const formatter = (sequelize, type, field, format) => {
+  const dialect = sequelize.getDialect();
+  switch (type) {
+    case 'date':
+    case 'datetime':
+    case 'time':
+      return dateFormatFn(sequelize, dialect, field, format);
+    default:
+      return formatFn(sequelize, dialect, field, format);
+  }
+};
+exports.formatter = formatter;