@tachybase/module-instrumentation 1.0.22

package/dist/server/hooks/filterMatch.js

@@ -0,0 +1,81 @@
+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 filterMatch_exports = {};
+__export(filterMatch_exports, {
+  filterMatch: () => filterMatch
+});
+module.exports = __toCommonJS(filterMatch_exports);
+const operators = {
+  $eq: (a, b) => a === b,
+  $ne: (a, b) => a !== b,
+  $gt: (a, b) => a > b,
+  $gte: (a, b) => a >= b,
+  $lt: (a, b) => a < b,
+  $lte: (a, b) => a <= b,
+  $in: (a, b) => a.includes(b),
+  $exists: (a, b) => b ? a !== void 0 : a === void 0,
+  $null: (a, b) => b ? a === null : a !== null
+};
+function getValueByPath(obj, path) {
+  if (!obj || !path) return void 0;
+  return path.split(".").reduce((acc, key) => {
+    if (acc === void 0 || acc === null) return void 0;
+    return acc[key];
+  }, obj);
+}
+function matchCondition(value, condition) {
+  for (const op in condition) {
+    const operator = op;
+    if (operators[operator]) {
+      if (!operators[operator](value, condition[op])) return false;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function filterMatch(model, filter) {
+  if ("$and" in filter) {
+    return filter["$and"].every((subFilter) => filterMatch(model, subFilter));
+  }
+  if ("$or" in filter) {
+    return filter["$or"].some((subFilter) => filterMatch(model, subFilter));
+  }
+  for (const key in filter) {
+    const value = filter[key];
+    if (typeof value === "object" && !Array.isArray(value)) {
+      for (const subKey in value) {
+        const nested = value[subKey];
+        const fullPath = `${key}.${subKey}`;
+        const actualValue = getValueByPath(model, fullPath);
+        if (!matchCondition(actualValue, nested)) {
+          return false;
+        }
+      }
+    } else {
+      if (getValueByPath(model, key) !== value) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterMatch
+});

package/dist/server/hooks/getActiveUser.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '@tachybase/actions';
+export declare const getDailyActiveUser: (ctx: Context) => Promise<{
+    todayActiveUserCount: number;
+    average7: number;
+    average30: number;
+}>;

package/dist/server/hooks/getActiveUser.js

@@ -0,0 +1,84 @@
+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 getActiveUser_exports = {};
+__export(getActiveUser_exports, {
+  getDailyActiveUser: () => getDailyActiveUser
+});
+module.exports = __toCommonJS(getActiveUser_exports);
+var import_dayjs = __toESM(require("dayjs"));
+const getDailyActiveUser = async (ctx) => {
+  var _a, _b, _c, _d;
+  const repo = await ctx.db.getRepository("trackingEvents");
+  const todayStart = (0, import_dayjs.default)().startOf("day").toDate();
+  const todayEnd = (0, import_dayjs.default)().endOf("day").toDate();
+  const weekStart = (0, import_dayjs.default)().subtract(6, "day").startOf("day").toDate();
+  const monthStart = (0, import_dayjs.default)().subtract(29, "day").startOf("day").toDate();
+  try {
+    const last30DaysData = await repo.find({
+      filter: {
+        key: "sign-in",
+        createdAt: {
+          $gte: monthStart.toISOString(),
+          $lte: todayEnd.toISOString()
+        }
+      }
+    });
+    const dayUserMap = /* @__PURE__ */ new Map();
+    for (const item of last30DaysData) {
+      const createdAt = item.createdAt || ((_a = item.values) == null ? void 0 : _a.createdAt);
+      const account = (_c = (_b = item.values) == null ? void 0 : _b.payload) == null ? void 0 : _c.account;
+      if (!createdAt || !account) continue;
+      const dateStr = (0, import_dayjs.default)(createdAt).format("YYYY-MM-DD");
+      if (!dayUserMap.has(dateStr)) {
+        dayUserMap.set(dateStr, /* @__PURE__ */ new Set());
+      }
+      dayUserMap.get(dateStr).add(account);
+    }
+    const todayKey = (0, import_dayjs.default)().format("YYYY-MM-DD");
+    const todayActiveUserCount = ((_d = dayUserMap.get(todayKey)) == null ? void 0 : _d.size) || 0;
+    const past7Days = Array.from({ length: 7 }, (_, i) => (0, import_dayjs.default)().subtract(i, "day").format("YYYY-MM-DD"));
+    const past30Days = Array.from({ length: 30 }, (_, i) => (0, import_dayjs.default)().subtract(i, "day").format("YYYY-MM-DD"));
+    const average = (dates) => {
+      const total = dates.reduce((sum, dateStr) => {
+        var _a2;
+        return sum + (((_a2 = dayUserMap.get(dateStr)) == null ? void 0 : _a2.size) || 0);
+      }, 0);
+      return Math.round(total / dates.length);
+    };
+    const average7 = average(past7Days);
+    const average30 = average(past30Days);
+    return { todayActiveUserCount, average7, average30 };
+  } catch (error) {
+    console.error("Failed to fetch tracking events:", error);
+    return { todayActiveUserCount: 0, average7: 0, average30: 0 };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDailyActiveUser
+});

package/dist/server/hooks/getStatistics.d.ts

@@ -0,0 +1,17 @@
+type FilterConfig = {
+    filterKey: string | string[];
+    filterValues?: Record<string, any>;
+    dedupBy?: string;
+    minCount: number;
+    timeFilter?: {
+        after?: string;
+        before?: string;
+        on?: string;
+        today?: true;
+        rangeDays?: number;
+    };
+    timeGroup?: string;
+};
+export declare function countDataByEventFrequency(data: any[], config: FilterConfig): number;
+export declare function groupDataByTime(data: any[], config: FilterConfig): Record<string, number>;
+export {};

package/dist/server/hooks/getStatistics.js

@@ -0,0 +1,208 @@
+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 getStatistics_exports = {};
+__export(getStatistics_exports, {
+  countDataByEventFrequency: () => countDataByEventFrequency,
+  groupDataByTime: () => groupDataByTime
+});
+module.exports = __toCommonJS(getStatistics_exports);
+var import_dayjs = __toESM(require("dayjs"));
+function getValueByPath(obj, path) {
+  return path.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+}
+function isSameDay(date1, date2) {
+  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
+}
+function countDataByEventFrequency(data, config) {
+  var _a;
+  const { filterKey, filterValues = {}, dedupBy, minCount = 1, timeFilter } = config;
+  const matchKey = (itemKey) => {
+    if (Array.isArray(filterKey)) return filterKey.includes(itemKey);
+    return itemKey === filterKey;
+  };
+  const matchesValues = (values) => {
+    return Object.entries(filterValues).every(([k, v]) => values[k] === v);
+  };
+  const matchesTime = (item) => {
+    if (!timeFilter) return true;
+    const raw = item.createdAt;
+    if (!raw) return false;
+    const time = new Date(raw);
+    if (isNaN(time.getTime())) return false;
+    const now = /* @__PURE__ */ new Date();
+    if (timeFilter.rangeDays !== void 0) {
+      const start = (0, import_dayjs.default)().subtract(timeFilter.rangeDays - 1, "day").startOf("day").toDate();
+      const end = (0, import_dayjs.default)().endOf("day").toDate();
+      return time >= start && time <= end;
+    }
+    if (timeFilter.today) {
+      return isSameDay(time, /* @__PURE__ */ new Date());
+    }
+    if (timeFilter.on) {
+      const target = new Date(timeFilter.on);
+      if (isNaN(target.getTime())) return false;
+      return isSameDay(time, target);
+    }
+    if (timeFilter.after) {
+      const after = new Date(timeFilter.after);
+      if (isNaN(after.getTime())) return false;
+      if (time < after) return false;
+    }
+    if (timeFilter.before) {
+      const before = new Date(timeFilter.before);
+      if (isNaN(before.getTime())) return false;
+      if (time > before) return false;
+    }
+    return true;
+  };
+  const groupMap = {};
+  for (const item of data) {
+    if (!matchKey(item.key)) continue;
+    if (!matchesValues(item.values)) continue;
+    if (!matchesTime(item)) continue;
+    const key = dedupBy ? getValueByPath(item.values, dedupBy) : "__no_dedup__";
+    if (!key) continue;
+    if (!groupMap[key]) groupMap[key] = [];
+    groupMap[key].push(item);
+  }
+  let count = 0;
+  if (dedupBy) {
+    for (const key in groupMap) {
+      if (groupMap[key].length >= minCount) {
+        count++;
+      }
+    }
+  } else {
+    count = ((_a = groupMap["__no_dedup__"]) == null ? void 0 : _a.length) ?? 0;
+    if (count < minCount) {
+      count = 0;
+    }
+  }
+  return count;
+}
+function groupDataByTime(data, config) {
+  const { filterKey, filterValues = {}, dedupBy, minCount = 1, timeFilter, timeGroup = "day" } = config;
+  const matchKey = (itemKey) => {
+    if (Array.isArray(filterKey)) return filterKey.includes(itemKey);
+    return itemKey === filterKey;
+  };
+  const matchesValues = (values) => {
+    return Object.entries(filterValues).every(([k, v]) => values[k] === v);
+  };
+  const matchesTime = (item) => {
+    if (!timeFilter) return true;
+    const raw = item.createdAt;
+    if (!raw) return false;
+    const time = new Date(raw);
+    if (isNaN(time.getTime())) return false;
+    if (timeFilter.rangeDays !== void 0) {
+      const start2 = (0, import_dayjs.default)().subtract(timeFilter.rangeDays - 1, "day").startOf("day").toDate();
+      const end = (0, import_dayjs.default)().endOf("day").toDate();
+      return time >= start2 && time <= end;
+    }
+    if (timeFilter.today) {
+      return isSameDay(time, /* @__PURE__ */ new Date());
+    }
+    if (timeFilter.on) {
+      const target = new Date(timeFilter.on);
+      if (isNaN(target.getTime())) return false;
+      return isSameDay(time, target);
+    }
+    if (timeFilter.after) {
+      const after = new Date(timeFilter.after);
+      if (isNaN(after.getTime())) return false;
+      if (time < after) return false;
+    }
+    if (timeFilter.before) {
+      const before = new Date(timeFilter.before);
+      if (isNaN(before.getTime())) return false;
+      if (time > before) return false;
+    }
+    return true;
+  };
+  const range = (timeFilter == null ? void 0 : timeFilter.rangeDays) ?? 30;
+  const now = (0, import_dayjs.default)().endOf("day");
+  const start = (0, import_dayjs.default)().subtract(range - 1, "day").startOf("day");
+  const dateMap = {};
+  for (let i = 0; i < range; i++) {
+    const date = start.add(i, "day");
+    let key;
+    if (timeGroup === "week") {
+      const start2 = date.startOf("week");
+      const end = date.endOf("week");
+      key = `${start2.format("MM-DD")}~${end.format("MM-DD")}`;
+    } else if (timeGroup === "month") {
+      key = date.startOf("month").format("YYYY-MM");
+    } else {
+      key = date.format("MM-DD");
+    }
+    dateMap[key] = [];
+  }
+  for (const item of data) {
+    if (!matchKey(item.key)) continue;
+    if (!matchesValues(item.values)) continue;
+    if (!matchesTime(item)) continue;
+    const time = (0, import_dayjs.default)(item.createdAt);
+    let groupKey;
+    if (timeGroup === "week") {
+      const start2 = time.startOf("week");
+      const end = time.endOf("week");
+      groupKey = `${start2.format("MM-DD")}~${end.format("MM-DD")}`;
+    } else if (timeGroup === "month") {
+      groupKey = time.startOf("month").format("YYYY-MM");
+    } else {
+      groupKey = time.format("MM-DD");
+    }
+    if (!dateMap[groupKey]) {
+      dateMap[groupKey] = [];
+    }
+    dateMap[groupKey].push(item);
+  }
+  const result = {};
+  for (const key in dateMap) {
+    const group = dateMap[key];
+    if (dedupBy) {
+      const dedupSet = /* @__PURE__ */ new Map();
+      for (const item of group) {
+        const id = getValueByPath(item.values, dedupBy);
+        if (!id) continue;
+        dedupSet.set(id, (dedupSet.get(id) ?? 0) + 1);
+      }
+      result[key] = Array.from(dedupSet.values()).filter((v) => v >= minCount).length;
+    } else {
+      const count = group.length;
+      result[key] = count >= minCount ? count : 0;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countDataByEventFrequency,
+  groupDataByTime
+});

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/plugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '@tachybase/server';
+import { ServerTrackingFilter } from './ServerTrackingFilter';
+export declare class ModuleInstrumentationServer extends Plugin {
+    serverTrackingFilter: ServerTrackingFilter;
+    addServerTrackingListener(): Promise<void>;
+    load(): Promise<void>;
+}
+export default ModuleInstrumentationServer;

package/dist/server/plugin.js

@@ -0,0 +1,161 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var plugin_exports = {};
+__export(plugin_exports, {
+  ModuleInstrumentationServer: () => ModuleInstrumentationServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_node_worker_threads = require("node:worker_threads");
+var import_server = require("@tachybase/server");
+var import_tracking_controller = require("./actions/tracking-controller");
+var import_afterAction = require("./hooks/afterAction");
+var import_ServerTrackingFilter = require("./ServerTrackingFilter");
+var _ModuleInstrumentationServer_decorators, _init, _a;
+_ModuleInstrumentationServer_decorators = [(0, import_server.InjectedPlugin)({
+  Controllers: [import_tracking_controller.TrackingController]
+})];
+class ModuleInstrumentationServer extends (_a = import_server.Plugin) {
+  constructor() {
+    super(...arguments);
+    this.serverTrackingFilter = null;
+  }
+  async addServerTrackingListener() {
+    this.app.on("afterStart", async () => {
+      const SignInTracking = await this.app.db.getRepository("trackingConfig").findOne({
+        filter: {
+          title: "sign-in",
+          resourceName: "auth",
+          action: "signIn"
+        }
+      });
+      if (!SignInTracking) {
+        await this.app.db.getRepository("trackingConfig").create({
+          values: {
+            title: "sign-in",
+            resourceName: "auth",
+            action: "signIn",
+            trackingOptions: {
+              meta: ["userId", "recordId", "createdAt"],
+              filter: {
+                $and: [
+                  {
+                    payload: {
+                      errors: {
+                        $exists: false
+                      }
+                    }
+                  }
+                ]
+              },
+              payload: ["errors", "account"]
+            }
+          }
+        });
+      }
+      this.serverTrackingFilter = new import_ServerTrackingFilter.ServerTrackingFilter(this.db);
+      await this.serverTrackingFilter.load();
+    });
+    this.app.use(
+      async (ctx, next) => {
+        var _a2;
+        await next();
+        if (ctx.action) {
+          const { actionName, resourceName } = ctx.action;
+          if ((_a2 = this.serverTrackingFilter) == null ? void 0 : _a2.check(resourceName, actionName)) {
+            const whiteList = this.serverTrackingFilter.whiteList;
+            return await (0, import_afterAction.handleOtherAction)(ctx, next, whiteList);
+          }
+        }
+      },
+      { tag: "trackingConfig", before: "errorHandler" }
+    );
+  }
+  async load() {
+    if (import_node_worker_threads.isMainThread) {
+      this.addServerTrackingListener();
+    }
+    this.app.acl.allow("instrumentation", "create", "public");
+    this.app.acl.allow("instrumentation", "list", "loggedIn");
+    this.app.acl.registerSnippet({
+      name: `pm.system-services.custom-instrumentation.clientTracking`,
+      actions: ["trackingEvents:*"]
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.system-services.custom-instrumentation.trackingConfig`,
+      actions: ["trackingConfig:*"]
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.system-services.custom-instrumentation.trackingStatistics`,
+      actions: ["statisticsConfig:*"]
+    });
+  }
+}
+_init = __decoratorStart(_a);
+ModuleInstrumentationServer = __decorateElement(_init, 0, "ModuleInstrumentationServer", _ModuleInstrumentationServer_decorators, ModuleInstrumentationServer);
+__runInitializers(_init, 1, ModuleInstrumentationServer);
+var plugin_default = ModuleInstrumentationServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleInstrumentationServer
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@tachybase/module-instrumentation",
+  "displayName": "Custom instrumentation",
+  "version": "1.0.22",
+  "description": "A module for tracking and instrumentation in Tachybase.",
+  "keywords": [
+    "Logging and monitoring"
+  ],
+  "main": "dist/server/index.js",
+  "devDependencies": {
+    "@antv/g2": "^5.3.0",
+    "antd": "5.22.5",
+    "dayjs": "1.11.13",
+    "lodash": "^4.17.21"
+  },
+  "peerDependencies": {
+    "@tachybase/actions": "1.0.25",
+    "@tachybase/client": "1.0.25",
+    "@tachybase/database": "1.0.25",
+    "@tachybase/schema": "1.0.25",
+    "@tachybase/server": "1.0.25",
+    "@tachybase/test": "1.0.25",
+    "@tachybase/utils": "1.0.25"
+  },
+  "description.zh-CN": "Tachybase 应用的追踪和埋点模块",
+  "displayName.zh-CN": "埋点追踪"
+}

package/server.d.ts

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

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');