@nocobase/plugin-data-visualization 0.13.0-alpha.9 → 0.14.0-alpha.2

package/dist/externalVersion.js

@@ -0,0 +1,20 @@
+module.exports = {
+  "@ant-design/icons": "5.1.4",
+  "@formily/antd-v5": "1.1.0",
+  "@nocobase/client": "0.14.0-alpha.2",
+  "antd": "5.8.6",
+  "react": "18.2.0",
+  "@formily/react": "2.2.27",
+  "@formily/shared": "2.2.27",
+  "@nocobase/cache": "0.14.0-alpha.2",
+  "@nocobase/server": "0.14.0-alpha.2",
+  "dayjs": "1.11.9",
+  "@formily/core": "2.2.27",
+  "lodash": "4.17.21",
+  "react-i18next": "11.18.6",
+  "ahooks": "3.7.8",
+  "@emotion/css": "11.11.2",
+  "@nocobase/actions": "0.14.0-alpha.2",
+  "@nocobase/database": "0.14.0-alpha.2",
+  "@nocobase/utils": "0.14.0-alpha.2"
+};

package/dist/node_modules/koa-compose/index.js

@@ -0,0 +1 @@
+(function(){"use strict";var e={979:function(e){e.exports=compose;function compose(e){if(!Array.isArray(e))throw new TypeError("Middleware stack must be an array!");for(const r of e){if(typeof r!=="function")throw new TypeError("Middleware must be composed of functions!")}return function(r,t){let i=-1;return dispatch(0);function dispatch(n){if(n<=i)return Promise.reject(new Error("next() called multiple times"));i=n;let o=e[n];if(n===e.length)o=t;if(!o)return Promise.resolve();try{return Promise.resolve(o(r,dispatch.bind(null,n+1)))}catch(e){return Promise.reject(e)}}}}}};var r={};function __nccwpck_require__(t){var i=r[t];if(i!==undefined){return i.exports}var n=r[t]={exports:{}};var o=true;try{e[t](n,n.exports,__nccwpck_require__);o=false}finally{if(o)delete r[t]}return n.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var t=__nccwpck_require__(979);module.exports=t})();

package/dist/node_modules/koa-compose/package.json

@@ -0,0 +1 @@
+{"name":"koa-compose","description":"compose Koa middleware","repository":"koajs/compose","version":"4.1.0","keywords":["koa","middleware","compose"],"files":["index.js"],"dependencies":{},"devDependencies":{"codecov":"^3.0.0","jest":"^21.0.0","matcha":"^0.7.0","standard":"^10.0.3"},"scripts":{"bench":"matcha bench/bench.js","lint":"standard --fix .","test":"jest --forceExit --coverage"},"jest":{"testEnvironment":"node"},"license":"MIT","_lastModified":"2023-09-12T20:05:15.672Z"}

package/dist/server/actions/query.d.ts

@@ -1,86 +1,8 @@
 import { Context, Next } from '@nocobase/actions';
-import { Cache } from '@nocobase/cache';
-type MeasureProps = {
-    field: string | string[];
-    type?: string;
-    aggregation?: string;
-    alias?: string;
-};
-type DimensionProps = {
-    field: string | string[];
-    type?: string;
-    alias?: string;
-    format?: string;
-};
-type OrderProps = {
-    field: string | string[];
-    alias?: string;
-    order?: 'asc' | 'desc';
-};
-type QueryParams = Partial<{
-    uid: string;
-    collection: string;
-    measures: MeasureProps[];
-    dimensions: DimensionProps[];
-    orders: OrderProps[];
-    filter: any;
-    limit: number;
-    sql: {
-        fields?: string;
-        clauses?: string;
-    };
-    cache: {
-        enabled: boolean;
-        ttl: number;
-    };
-    refresh: boolean;
-}>;
-export declare const parseFieldAndAssociations: (ctx: Context, params: QueryParams) => {
-    where: any;
-    measures: {
-        field: any;
-        name: string;
-        type: any;
-        alias: string;
-    }[];
-    dimensions: {
-        field: any;
-        name: string;
-        type: any;
-        alias: string;
-    }[];
-    orders: {
-        field: any;
-        name: string;
-        type: any;
-        alias: string;
-    }[];
-    include: any[];
-};
-export declare const parseBuilder: (ctx: Context, builder: QueryParams) => {
-    queryParams: {
-        where: any;
-        attributes: any[];
-        include: any[];
-        group: any[];
-        order: any[];
-        limit: number;
-        raw: boolean;
-    };
-    fieldMap: {};
-};
-export declare const processData: (ctx: Context, data: any[], fieldMap: {
-    [source: string]: {
-        type?: string;
-    };
-}) => any[];
-export declare const queryData: (ctx: Context, builder: QueryParams) => Promise<any[]>;
-export declare const cacheWrap: (cache: Cache, options: {
-    func: () => Promise<any>;
-    key: string;
-    ttl?: number;
-    useCache?: boolean;
-    refresh?: boolean;
-}) => Promise<any>;
+export declare const postProcess: (ctx: Context, next: Next) => Promise<void>;
+export declare const queryData: (ctx: Context, next: Next) => Promise<void>;
+export declare const parseBuilder: (ctx: Context, next: Next) => Promise<void>;
+export declare const parseFieldAndAssociations: (ctx: Context, next: Next) => Promise<void>;
+export declare const parseVariables: (ctx: Context, next: Next) => Promise<any>;
+export declare const cacheMiddleware: (ctx: Context, next: Next) => Promise<void>;
 export declare const query: (ctx: Context, next: Next) => Promise<void>;
-export {};

package/dist/server/actions/query.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,21 +16,132 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var query_exports = {};
 __export(query_exports, {
-  cacheWrap: () => cacheWrap,
+  cacheMiddleware: () => cacheMiddleware,
   parseBuilder: () => parseBuilder,
   parseFieldAndAssociations: () => parseFieldAndAssociations,
-  processData: () => processData,
+  parseVariables: () => parseVariables,
+  postProcess: () => postProcess,
   query: () => query,
   queryData: () => queryData
 });
 module.exports = __toCommonJS(query_exports);
 var import_database = require("@nocobase/database");
 var import_formatter = require("./formatter");
-const parseFieldAndAssociations = (ctx, params) => {
-  const { collection: collectionName, measures, dimensions, orders, filter } = params;
+var import_koa_compose = __toESM(require("koa-compose"));
+var import_utils = require("@nocobase/utils");
+const postProcess = async (ctx, next) => {
+  const { sequelize } = ctx.db;
+  const dialect = sequelize.getDialect();
+  const { data, fieldMap } = ctx.action.params.values;
+  switch (dialect) {
+    case "postgres":
+      ctx.body = data.map((record) => {
+        const result = {};
+        Object.entries(record).forEach(([key, value]) => {
+          const { type } = fieldMap[key] || {};
+          switch (type) {
+            case "bigInt":
+            case "integer":
+            case "float":
+            case "double":
+              value = Number(value);
+              break;
+          }
+          result[key] = value;
+        });
+        return result;
+      });
+      break;
+    default:
+      ctx.body = data;
+  }
+  await next();
+};
+const queryData = async (ctx, next) => {
+  const { collection, queryParams, fieldMap } = ctx.action.params.values;
+  const model = ctx.db.getModel(collection);
+  const data = await model.findAll(queryParams);
+  ctx.action.params.values = {
+    data,
+    fieldMap
+  };
+  await next();
+};
+const parseBuilder = async (ctx, next) => {
+  const { sequelize } = ctx.db;
+  const { measures, dimensions, orders, include, where, limit } = ctx.action.params.values;
+  const attributes = [];
+  const group = [];
+  const order = [];
+  const fieldMap = {};
+  let hasAgg = false;
+  measures.forEach((measure) => {
+    const { field, aggregation, alias } = measure;
+    const attribute = [];
+    const col = sequelize.col(field);
+    if (aggregation) {
+      hasAgg = true;
+      attribute.push(sequelize.fn(aggregation, col));
+    } else {
+      attribute.push(col);
+    }
+    if (alias) {
+      attribute.push(alias);
+    }
+    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
+    fieldMap[alias || field] = measure;
+  });
+  dimensions.forEach((dimension) => {
+    const { field, format, alias, type } = dimension;
+    const attribute = [];
+    const col = sequelize.col(field);
+    if (format) {
+      attribute.push((0, import_formatter.formatter)(sequelize, type, field, format));
+    } else {
+      attribute.push(col);
+    }
+    if (alias) {
+      attribute.push(alias);
+    }
+    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
+    if (hasAgg) {
+      group.push(attribute[0]);
+    }
+    fieldMap[alias || field] = dimension;
+  });
+  orders.forEach((item) => {
+    const alias = sequelize.getQueryInterface().quoteIdentifier(item.alias);
+    const name = hasAgg ? sequelize.literal(alias) : sequelize.col(item.field);
+    order.push([name, item.order || "ASC"]);
+  });
+  ctx.action.params.values = {
+    ...ctx.action.params.values,
+    queryParams: {
+      where,
+      attributes,
+      include,
+      group,
+      order,
+      limit: limit > 2e3 ? 2e3 : limit,
+      raw: true
+    },
+    fieldMap
+  };
+  await next();
+};
+const parseFieldAndAssociations = async (ctx, next) => {
+  const { collection: collectionName, measures, dimensions, orders, filter } = ctx.action.params.values;
   const collection = ctx.db.getCollection(collectionName);
   const fields = collection.fields;
   const underscored = ctx.db.options.underscored;
@@ -87,149 +200,103 @@ const parseFieldAndAssociations = (ctx, params) => {
     }
     return item;
   });
-  return {
+  ctx.action.params.values = {
+    ...ctx.action.params.values,
     where,
     measures: parsedMeasures,
     dimensions: parsedDimensions,
     orders: parsedOrders,
     include: [...include, ...parsedFilterInclude || []]
   };
+  await next();
 };
-const parseBuilder = (ctx, builder) => {
-  const { sequelize } = ctx.db;
-  const { limit } = builder;
-  const { measures, dimensions, orders, include, where } = parseFieldAndAssociations(ctx, builder);
-  const attributes = [];
-  const group = [];
-  const order = [];
-  const fieldMap = {};
-  let hasAgg = false;
-  measures.forEach((measure) => {
-    const { field, aggregation, alias } = measure;
-    const attribute = [];
-    const col = sequelize.col(field);
-    if (aggregation) {
-      hasAgg = true;
-      attribute.push(sequelize.fn(aggregation, col));
-    } else {
-      attribute.push(col);
-    }
-    if (alias) {
-      attribute.push(alias);
-    }
-    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
-    fieldMap[alias || field] = measure;
-  });
-  dimensions.forEach((dimension) => {
-    const { field, format, alias, type } = dimension;
-    const attribute = [];
-    const col = sequelize.col(field);
-    if (format) {
-      attribute.push((0, import_formatter.formatter)(sequelize, type, field, format));
-    } else {
-      attribute.push(col);
-    }
-    if (alias) {
-      attribute.push(alias);
-    }
-    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
-    if (hasAgg) {
-      group.push(attribute[0]);
-    }
-    fieldMap[alias || field] = dimension;
-  });
-  orders.forEach((item) => {
-    const alias = sequelize.getQueryInterface().quoteIdentifier(item.alias);
-    const name = hasAgg ? sequelize.literal(alias) : sequelize.col(item.field);
-    order.push([name, item.order || "ASC"]);
-  });
-  return {
-    queryParams: {
-      where,
-      attributes,
-      include,
-      group,
-      order,
-      limit: limit > 2e3 ? 2e3 : limit,
-      raw: true
-    },
-    fieldMap
+const parseVariables = async (ctx, next) => {
+  const { filter } = ctx.action.params.values;
+  if (!filter) {
+    return next();
+  }
+  const isNumeric = (str) => {
+    if (typeof str === "number")
+      return true;
+    if (typeof str != "string")
+      return false;
+    return !isNaN(str) && !isNaN(parseFloat(str));
   };
-};
-const processData = (ctx, data, fieldMap) => {
-  const { sequelize } = ctx.db;
-  const dialect = sequelize.getDialect();
-  switch (dialect) {
-    case "postgres":
-      return data.map((record) => {
-        const result = {};
-        Object.entries(record).forEach(([key, value]) => {
-          const { type } = fieldMap[key] || {};
-          switch (type) {
-            case "bigInt":
-            case "integer":
-            case "float":
-            case "double":
-              value = Number(value);
-              break;
-          }
-          result[key] = value;
-        });
-        return result;
+  const getUser = () => {
+    return async ({ fields }) => {
+      var _a, _b;
+      const userFields = fields.filter((f) => f && ctx.db.getFieldByPath("users." + f));
+      (_a = ctx.logger) == null ? void 0 : _a.info("filter-parse: ", { userFields });
+      if (!ctx.state.currentUser) {
+        return;
+      }
+      if (!userFields.length) {
+        return;
+      }
+      const user = await ctx.db.getRepository("users").findOne({
+        filterByTk: ctx.state.currentUser.id,
+        fields: userFields
       });
-    default:
-      return data;
-  }
-};
-const queryData = async (ctx, builder) => {
-  const { collection, measures, dimensions, orders, filter, limit, sql } = builder;
-  const model = ctx.db.getModel(collection);
-  const { queryParams, fieldMap } = parseBuilder(ctx, { collection, measures, dimensions, orders, filter, limit });
-  const data = await model.findAll(queryParams);
-  return processData(ctx, data, fieldMap);
+      (_b = ctx.logger) == null ? void 0 : _b.info("filter-parse: ", {
+        $user: user == null ? void 0 : user.toJSON()
+      });
+      return user;
+    };
+  };
+  ctx.action.params.values.filter = await (0, import_utils.parseFilter)(filter, {
+    timezone: ctx.get("x-timezone"),
+    now: (/* @__PURE__ */ new Date()).toISOString(),
+    getField: (path) => {
+      const fieldPath = path.split(".").filter((p) => !p.startsWith("$") && !isNumeric(p)).join(".");
+      const { resourceName } = ctx.action;
+      return ctx.db.getFieldByPath(`${resourceName}.${fieldPath}`);
+    },
+    vars: {
+      $nDate: (0, import_utils.getDateVars)(),
+      $user: getUser()
+    }
+  });
+  await next();
 };
-const cacheWrap = async (cache, options) => {
-  const { func, key, ttl, useCache, refresh } = options;
+const cacheMiddleware = async (ctx, next) => {
+  const { uid, cache: cacheConfig, refresh } = ctx.action.params.values;
+  const plugin = ctx.app.getPlugin("data-visualization");
+  const cache = plugin.cache;
+  const useCache = (cacheConfig == null ? void 0 : cacheConfig.enabled) && uid;
   if (useCache && !refresh) {
-    const data2 = await cache.get(key);
-    if (data2) {
-      return data2;
+    const data = await cache.get(uid);
+    if (data) {
+      ctx.body = data;
+      return;
     }
   }
-  const data = await func();
+  await next();
   if (useCache) {
-    await cache.set(key, data, ttl);
+    console.log(uid, ctx.body);
+    await cache.set(uid, ctx.body, (cacheConfig == null ? void 0 : cacheConfig.ttl) || 30);
+    console.log(cache.get(uid));
   }
-  return data;
 };
-const query = async (ctx, next) => {
-  const {
-    uid,
-    collection,
-    measures,
-    dimensions,
-    orders,
-    filter,
-    limit,
-    sql,
-    cache: cacheConfig,
-    refresh
-  } = ctx.action.params.values;
+const checkPermission = (ctx, next) => {
+  const { collection } = ctx.action.params.values;
   const roleName = ctx.state.currentRole || "anonymous";
   const can = ctx.app.acl.can({ role: roleName, resource: collection, action: "list" });
   if (!can && roleName !== "root") {
     ctx.throw(403, "No permissions");
   }
-  const plugin = ctx.app.getPlugin("data-visualization");
-  const cache = plugin.cache;
-  const useCache = (cacheConfig == null ? void 0 : cacheConfig.enabled) && uid;
+  return next();
+};
+const query = async (ctx, next) => {
   try {
-    ctx.body = await cacheWrap(cache, {
-      func: async () => await queryData(ctx, { collection, measures, dimensions, orders, filter, limit, sql }),
-      key: uid,
-      ttl: (cacheConfig == null ? void 0 : cacheConfig.ttl) || 30,
-      useCache: useCache ? true : false,
-      refresh
+    await (0, import_koa_compose.default)([
+      checkPermission,
+      cacheMiddleware,
+      parseVariables,
+      parseFieldAndAssociations,
+      parseBuilder,
+      queryData,
+      postProcess
+    ])(ctx, async () => {
     });
   } catch (err) {
     ctx.app.logger.error("charts query: ", err);
@@ -239,10 +306,11 @@ const query = async (ctx, next) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  cacheWrap,
+  cacheMiddleware,
   parseBuilder,
   parseFieldAndAssociations,
-  processData,
+  parseVariables,
+  postProcess,
   query,
   queryData
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-data-visualization",
-  "version": "0.13.0-alpha.9",
+  "version": "0.14.0-alpha.2",
   "displayName": "Data Visualization",
   "displayName.zh-CN": "数据可视化",
   "description": "Provides business intelligence and data visualization features",
@@ -17,6 +17,7 @@
     "@testing-library/react": "^14.0.0",
     "antd": "5.x",
     "classnames": "^2.3.1",
+    "koa-compose": "^4.1.0",
     "lodash": "^4.17.21",
     "react": "^18.2.0",
     "react-error-boundary": "^4.0.10",
@@ -32,5 +33,5 @@
     "@nocobase/test": "0.x",
     "@nocobase/utils": "0.x"
   },
-  "gitHead": "ee5825377d8bec05f968a8365a0cdcd49878ada6"
+  "gitHead": "ea841d4a1e8c37aa77b4fbae6a6a4937e2aa3c0a"
 }