@tachybase/plugin-block-charts 0.23.8

package/dist/node_modules/fs-extra/lib/util/stat.js

@@ -0,0 +1,158 @@
+'use strict'
+
+const fs = require('../fs')
+const path = require('path')
+const u = require('universalify').fromPromise
+
+function getStats (src, dest, opts) {
+  const statFunc = opts.dereference
+    ? (file) => fs.stat(file, { bigint: true })
+    : (file) => fs.lstat(file, { bigint: true })
+  return Promise.all([
+    statFunc(src),
+    statFunc(dest).catch(err => {
+      if (err.code === 'ENOENT') return null
+      throw err
+    })
+  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
+}
+
+function getStatsSync (src, dest, opts) {
+  let destStat
+  const statFunc = opts.dereference
+    ? (file) => fs.statSync(file, { bigint: true })
+    : (file) => fs.lstatSync(file, { bigint: true })
+  const srcStat = statFunc(src)
+  try {
+    destStat = statFunc(dest)
+  } catch (err) {
+    if (err.code === 'ENOENT') return { srcStat, destStat: null }
+    throw err
+  }
+  return { srcStat, destStat }
+}
+
+async function checkPaths (src, dest, funcName, opts) {
+  const { srcStat, destStat } = await getStats(src, dest, opts)
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      const srcBaseName = path.basename(src)
+      const destBaseName = path.basename(dest)
+      if (funcName === 'move' &&
+        srcBaseName !== destBaseName &&
+        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true }
+      }
+      throw new Error('Source and destination must not be the same.')
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
+    }
+  }
+
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+
+  return { srcStat, destStat }
+}
+
+function checkPathsSync (src, dest, funcName, opts) {
+  const { srcStat, destStat } = getStatsSync(src, dest, opts)
+
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      const srcBaseName = path.basename(src)
+      const destBaseName = path.basename(dest)
+      if (funcName === 'move' &&
+        srcBaseName !== destBaseName &&
+        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true }
+      }
+      throw new Error('Source and destination must not be the same.')
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
+    }
+  }
+
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+  return { srcStat, destStat }
+}
+
+// recursively check if dest parent is a subdirectory of src.
+// It works for all file types including symlinks since it
+// checks the src and dest inodes. It starts from the deepest
+// parent and stops once it reaches the src parent or the root path.
+async function checkParentPaths (src, srcStat, dest, funcName) {
+  const srcParent = path.resolve(path.dirname(src))
+  const destParent = path.resolve(path.dirname(dest))
+  if (destParent === srcParent || destParent === path.parse(destParent).root) return
+
+  let destStat
+  try {
+    destStat = await fs.stat(destParent, { bigint: true })
+  } catch (err) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+
+  if (areIdentical(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+
+  return checkParentPaths(src, srcStat, destParent, funcName)
+}
+
+function checkParentPathsSync (src, srcStat, dest, funcName) {
+  const srcParent = path.resolve(path.dirname(src))
+  const destParent = path.resolve(path.dirname(dest))
+  if (destParent === srcParent || destParent === path.parse(destParent).root) return
+  let destStat
+  try {
+    destStat = fs.statSync(destParent, { bigint: true })
+  } catch (err) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+  return checkParentPathsSync(src, srcStat, destParent, funcName)
+}
+
+function areIdentical (srcStat, destStat) {
+  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
+}
+
+// return true if dest is a subdir of src, otherwise false.
+// It only checks the path strings.
+function isSrcSubdir (src, dest) {
+  const srcArr = path.resolve(src).split(path.sep).filter(i => i)
+  const destArr = path.resolve(dest).split(path.sep).filter(i => i)
+  return srcArr.every((cur, i) => destArr[i] === cur)
+}
+
+function errMsg (src, dest, funcName) {
+  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
+}
+
+module.exports = {
+  // checkPaths
+  checkPaths: u(checkPaths),
+  checkPathsSync,
+  // checkParent
+  checkParentPaths: u(checkParentPaths),
+  checkParentPathsSync,
+  // Misc
+  isSrcSubdir,
+  areIdentical
+}

package/dist/node_modules/fs-extra/lib/util/utimes.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const fs = require('../fs')
+const u = require('universalify').fromPromise
+
+async function utimesMillis (path, atime, mtime) {
+  // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
+  const fd = await fs.open(path, 'r+')
+
+  let closeErr = null
+
+  try {
+    await fs.futimes(fd, atime, mtime)
+  } finally {
+    try {
+      await fs.close(fd)
+    } catch (e) {
+      closeErr = e
+    }
+  }
+
+  if (closeErr) {
+    throw closeErr
+  }
+}
+
+function utimesMillisSync (path, atime, mtime) {
+  const fd = fs.openSync(path, 'r+')
+  fs.futimesSync(fd, atime, mtime)
+  return fs.closeSync(fd)
+}
+
+module.exports = {
+  utimesMillis: u(utimesMillis),
+  utimesMillisSync
+}

package/dist/node_modules/fs-extra/package.json

@@ -0,0 +1 @@
+{"name":"fs-extra","version":"11.2.0","description":"fs-extra contains methods that aren't included in the vanilla Node.js fs package. Such as recursive mkdir, copy, and remove.","engines":{"node":">=14.14"},"homepage":"https://github.com/jprichardson/node-fs-extra","repository":{"type":"git","url":"https://github.com/jprichardson/node-fs-extra"},"keywords":["fs","file","file system","copy","directory","extra","mkdirp","mkdir","mkdirs","recursive","json","read","write","extra","delete","remove","touch","create","text","output","move","promise"],"author":"JP Richardson <jprichardson@gmail.com>","license":"MIT","dependencies":{"graceful-fs":"^4.2.0","jsonfile":"^6.0.1","universalify":"^2.0.0"},"devDependencies":{"klaw":"^2.1.1","klaw-sync":"^3.0.2","minimist":"^1.1.1","mocha":"^10.1.0","nyc":"^15.0.0","proxyquire":"^2.0.1","read-dir-files":"^0.1.1","standard":"^17.0.0"},"main":"./lib/index.js","exports":{".":"./lib/index.js","./esm":"./lib/esm.mjs"},"files":["lib/","!lib/**/__tests__/"],"scripts":{"lint":"standard","test-find":"find ./lib/**/__tests__ -name *.test.js | xargs mocha","test":"npm run lint && npm run unit && npm run unit-esm","unit":"nyc node test.js","unit-esm":"node test.mjs"},"sideEffects":false,"_lastModified":"2024-12-22T16:06:01.213Z"}

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

@@ -0,0 +1 @@
+(function(){"use strict";var e={943: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__(943);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":"2024-12-22T16:06:01.005Z"}

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

@@ -0,0 +1,4 @@
+import { Sequelize } from 'sequelize';
+export declare const dateFormatFn: (sequelize: Sequelize, dialect: string, field: string, format: string, timezone: string) => import("sequelize/lib/utils").Col | import("sequelize/lib/utils").Fn;
+export declare const formatFn: (sequelize: Sequelize, dialect: string, field: string, format: string) => string | import("sequelize/lib/utils").Fn;
+export declare const formatter: (sequelize: Sequelize, type: string, field: string, format: string, timezone: string) => string | import("sequelize/lib/utils").Col | import("sequelize/lib/utils").Fn;

package/dist/server/actions/formatter.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var formatter_exports = {};
+__export(formatter_exports, {
+  dateFormatFn: () => dateFormatFn,
+  formatFn: () => formatFn,
+  formatter: () => formatter
+});
+module.exports = __toCommonJS(formatter_exports);
+const dateFormatFn = (sequelize, dialect, field, format, timezone) => {
+  const reversedTimezone = timezone[0] === "+" ? "-" + timezone.slice(1) : "+" + timezone.slice(1);
+  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":
+    case "mariadb":
+      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("format_timestamp_with_timezone", sequelize.col(field), reversedTimezone, format);
+    default:
+      return sequelize.col(field);
+  }
+};
+const formatFn = (sequelize, dialect, field, format) => {
+  switch (dialect) {
+    case "sqlite":
+    case "postgres":
+      return sequelize.fn("format", format, sequelize.col(field));
+    default:
+      return field;
+  }
+};
+const formatter = (sequelize, type, field, format, timezone) => {
+  const dialect = sequelize.getDialect();
+  switch (type) {
+    case "date":
+    case "datetime":
+    case "time":
+      return dateFormatFn(sequelize, dialect, field, format, timezone);
+    default:
+      return formatFn(sequelize, dialect, field, format);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dateFormatFn,
+  formatFn,
+  formatter
+});

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

@@ -0,0 +1,8 @@
+import { Context, Next } from '@tachybase/actions';
+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>;

package/dist/server/actions/query.js

@@ -0,0 +1,320 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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, {
+  cacheMiddleware: () => cacheMiddleware,
+  parseBuilder: () => parseBuilder,
+  parseFieldAndAssociations: () => parseFieldAndAssociations,
+  parseVariables: () => parseVariables,
+  postProcess: () => postProcess,
+  query: () => query,
+  queryData: () => queryData
+});
+module.exports = __toCommonJS(query_exports);
+var import_database = require("@tachybase/database");
+var import_utils = require("@tachybase/utils");
+var import_koa_compose = __toESM(require("koa-compose"));
+var import_formatter = require("./formatter");
+const getDB = (ctx, dataSource) => {
+  const ds = ctx.app.dataSourceManager.dataSources.get(dataSource);
+  return ds == null ? void 0 : ds.collectionManager.db;
+};
+const postProcess = async (ctx, next) => {
+  const { data, fieldMap } = ctx.action.params.values;
+  ctx.body = data.map((record) => {
+    Object.entries(record).forEach(([key, value]) => {
+      if (!value) {
+        return;
+      }
+      const { type } = fieldMap[key] || {};
+      switch (type) {
+        case "bigInt":
+        case "integer":
+        case "float":
+        case "double":
+          record[key] = Number(value);
+          break;
+      }
+    });
+    return record;
+  });
+  await next();
+};
+const queryData = async (ctx, next) => {
+  const { dataSource, collection, queryParams, fieldMap } = ctx.action.params.values;
+  const db = getDB(ctx, dataSource) || ctx.db;
+  const model = db.getModel(collection);
+  const data = await model.findAll(queryParams);
+  ctx.action.params.values = {
+    data,
+    fieldMap
+  };
+  await next();
+};
+const parseBuilder = async (ctx, next) => {
+  const { dataSource, measures, dimensions, orders, include, where, limit } = ctx.action.params.values;
+  const db = getDB(ctx, dataSource) || ctx.db;
+  const { sequelize } = db;
+  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, ctx.get("x-timezone")));
+    } 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,
+      subQuery: false,
+      raw: true
+    },
+    fieldMap
+  };
+  await next();
+};
+const parseFieldAndAssociations = async (ctx, next) => {
+  const {
+    dataSource,
+    collection: collectionName,
+    measures,
+    dimensions,
+    orders,
+    filter
+  } = ctx.action.params.values;
+  const db = getDB(ctx, dataSource) || ctx.db;
+  const collection = db.getCollection(collectionName);
+  const fields = collection.fields;
+  const models = {};
+  const parseField = (selected) => {
+    var _a, _b, _c, _d;
+    let target;
+    let name;
+    if (!Array.isArray(selected.field)) {
+      name = selected.field;
+    } else if (selected.field.length === 1) {
+      name = selected.field[0];
+    } else if (selected.field.length > 1) {
+      [target, name] = selected.field;
+    }
+    const rawAttributes = collection.model.getAttributes();
+    let field = ((_a = rawAttributes[name]) == null ? void 0 : _a.field) || name;
+    let fieldType = (_b = fields.get(name)) == null ? void 0 : _b.type;
+    if (target) {
+      const targetField = fields.get(target);
+      const targetCollection = db.getCollection(targetField.target);
+      const targetFields = targetCollection.fields;
+      fieldType = (_c = targetFields.get(name)) == null ? void 0 : _c.type;
+      field = `${target}.${field}`;
+      name = `${target}.${name}`;
+      const targetType = (_d = fields.get(target)) == null ? void 0 : _d.type;
+      if (!models[target]) {
+        models[target] = { type: targetType };
+      }
+    } else {
+      field = `${collectionName}.${field}`;
+    }
+    return {
+      ...selected,
+      field,
+      name,
+      type: fieldType,
+      alias: selected.alias || name
+    };
+  };
+  const parsedMeasures = (measures == null ? void 0 : measures.map(parseField)) || [];
+  const parsedDimensions = (dimensions == null ? void 0 : dimensions.map(parseField)) || [];
+  const parsedOrders = (orders == null ? void 0 : orders.map(parseField)) || [];
+  const include = Object.entries(models).map(([target, { type }]) => ({
+    association: target,
+    attributes: [],
+    ...type === "belongsToMany" ? { through: { attributes: [] } } : {}
+  }));
+  const filterParser = new import_database.FilterParser(filter, {
+    collection
+  });
+  const { where, include: filterInclude } = filterParser.toSequelizeParams();
+  const parsedFilterInclude = filterInclude == null ? void 0 : filterInclude.map((item) => {
+    var _a;
+    if (((_a = fields.get(item.association)) == null ? void 0 : _a.type) === "belongsToMany") {
+      item.through = { attributes: [] };
+    }
+    return item;
+  });
+  ctx.action.params.values = {
+    ...ctx.action.params.values,
+    where,
+    measures: parsedMeasures,
+    dimensions: parsedDimensions,
+    orders: parsedOrders,
+    include: [...include, ...parsedFilterInclude || []]
+  };
+  await next();
+};
+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 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("parse filter variables", { userFields, method: "parseVariables" });
+      if (!ctx.state.currentUser) {
+        return;
+      }
+      if (!userFields.length) {
+        return;
+      }
+      const user = await ctx.db.getRepository("users").findOne({
+        filterByTk: ctx.state.currentUser.id,
+        fields: userFields
+      });
+      (_b = ctx.logger) == null ? void 0 : _b.info("parse filter variables", {
+        $user: user == null ? void 0 : user.toJSON(),
+        method: "parseVariables"
+      });
+      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 cacheMiddleware = async (ctx, next) => {
+  const { uid, cache: cacheConfig, refresh } = ctx.action.params.values;
+  const cache = ctx.app.cacheManager.getCache("data-visualization");
+  const useCache = (cacheConfig == null ? void 0 : cacheConfig.enabled) && uid;
+  if (useCache && !refresh) {
+    const data = await cache.get(uid);
+    if (data) {
+      ctx.body = data;
+      return;
+    }
+  }
+  await next();
+  if (useCache) {
+    await cache.set(uid, ctx.body, (cacheConfig == null ? void 0 : cacheConfig.ttl) * 1e3);
+  }
+};
+const checkPermission = (ctx, next) => {
+  if (ctx.action.params.values === void 0) {
+    ctx.action.params.values = ctx.action.params;
+  }
+  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");
+  }
+  return next();
+};
+const query = async (ctx, next) => {
+  try {
+    await (0, import_koa_compose.default)([
+      checkPermission,
+      cacheMiddleware,
+      parseVariables,
+      parseFieldAndAssociations,
+      parseBuilder,
+      queryData,
+      postProcess
+    ])(ctx, next);
+  } catch (err) {
+    ctx.throw(500, err);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheMiddleware,
+  parseBuilder,
+  parseFieldAndAssociations,
+  parseVariables,
+  postProcess,
+  query,
+  queryData
+});

package/dist/server/index.d.ts

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

package/dist/server/index.js

@@ -0,0 +1,33 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/migrations/20230926211750-rename-charttype.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@tachybase/server';
+export default class RenameChartTypeMigration extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}