semanticdb-core 1.0.0

package/dist/common/representation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 系统支持的图表类型
+ * - 基础图表：表格、饼图、柱状图（横向/纵向/堆积）、折线图、散点图、面积图
+ * - 高级图表：气泡图、漏斗图、仪表盘、热力图、直方图、帕累托图、雷达图、词云、地图
+ * - 其他可视化：KPI卡片、实体详情卡片、报告、文本、视频列表、图片列表、RAG
+ */
+export declare type RepresentationType = 'value' | 'table' | 'pie' | 'bar' | 'column' | 'stackedColumn' | 'line' | 'scatter' | 'area' | 'bubble' | 'funnel' | 'guage' | 'heatmap' | 'histogram' | 'pareto' | 'radar' | 'wordCloud' | 'map' | 'entity' | 'report' | 'text' | 'videos' | 'images' | 'rag';

package/dist/common/representation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schema/property';
+export * from './schema/schema';
+export * from './common/representation';
+export * from './schema/schema.utils';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema/property"), exports);
+__exportStar(require("./schema/schema"), exports);
+__exportStar(require("./common/representation"), exports);
+__exportStar(require("./schema/schema.utils"), exports);

package/dist/logicform/logicform.d.ts

@@ -0,0 +1,33 @@
+import { RepresentationType } from '../common/representation';
+import { SchemaType } from '../schema/schema';
+export declare type QueryType = {
+    [key: string]: any;
+};
+export interface PredItemType {
+    pred?: string | PredItemType;
+    operator?: string;
+    name?: string;
+    query?: QueryType;
+    type?: string;
+    schema?: string;
+    by?: string;
+    params?: any[];
+}
+export interface GroupbyItemType {
+    _id: string;
+    level?: string;
+    name?: string;
+    schema?: SchemaType;
+}
+export interface LogicformType {
+    schema: string;
+    query?: QueryType;
+    preds?: PredItemType[];
+    groupby?: GroupbyItemType[];
+    sort?: QueryType;
+    having?: QueryType;
+    limit?: number;
+    limitBy?: number;
+    skip?: number;
+    representation?: RepresentationType;
+}

package/dist/logicform/logicform.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logicform/logicform.utils.d.ts

@@ -0,0 +1,2 @@
+import { QueryType } from './logicform';
+export declare const isDimensionInQuery: (query: QueryType, dimension: string) => boolean;

package/dist/logicform/logicform.utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDimensionInQuery = void 0;
+const isDimensionInQuery = (query, dimension) => {
+    const chain = dimension.split('_');
+    let chainedQuery = query;
+    for (let i = 0; i < chain.length; i++) {
+        const item = chain[i];
+        if (!(chainedQuery && chainedQuery[item])) {
+            return false;
+        }
+        // last one
+        if (i === chain.length - 1) {
+            if (typeof chainedQuery[item] !== 'object' || !chainedQuery[item].query) {
+                if (typeof chainedQuery[item] === 'object' && '$exists' in chainedQuery[item]) {
+                    return false;
+                }
+                return true;
+            }
+            if (chainedQuery[item].entity_id) {
+                return true;
+            }
+            // TODO: 如果是name property，也行的，现在先简单搞一个
+            if (chainedQuery[item].query && chainedQuery[item].query.别名) {
+                return true;
+            }
+            return false;
+        }
+        if (typeof chainedQuery[item] !== 'object' || !chainedQuery[item].query) {
+            return false;
+        }
+        chainedQuery = chainedQuery[item].query;
+    }
+    return true;
+};
+exports.isDimensionInQuery = isDimensionInQuery;

package/dist/schema/property.d.ts

@@ -0,0 +1,69 @@
+import { RepresentationType } from '../common/representation';
+import { SchemaType } from './schema';
+export declare type PropertyTypeType = 'ID' | 'timestamp' | 'name' | 'humanName' | 'category' | 'string' | 'tag' | 'image' | 'file' | 'number' | 'int' | 'currency' | 'percentage' | 'duration' | 'order' | 'boolean' | 'date' | 'start_date' | 'end_date' | 'object';
+export declare type PropertyTypePrimalType = 'string' | 'number' | 'boolean' | 'date' | 'object';
+export interface PropertyTypeDraft {
+    _sid?: string;
+    _id?: string;
+    name: string;
+    syno?: string[];
+    description?: string;
+    constraints?: {
+        required?: boolean;
+        unique?: boolean;
+        enum?: string[];
+    };
+    type: PropertyTypeType;
+    primal_type?: PropertyTypePrimalType;
+    isArray?: boolean;
+    is_dynamic?: boolean;
+    is_name?: boolean;
+    is_categorical?: boolean;
+    ref?: string;
+    schema?: SchemaType;
+    granularity?: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'week' | 'year';
+    is_additive?: boolean;
+    use_minus_on_mom?: boolean;
+    is_supplementary?: boolean;
+    stats?: {
+        min?: number;
+        max?: number;
+        total?: number;
+        avg?: number;
+        distincts?: string[];
+    };
+    ui?: {
+        name?: boolean;
+        formatter?: string;
+        formatters?: {
+            min?: number;
+            max?: number;
+            formatter: string;
+            prefix?: string;
+            postfix?: string;
+            role?: string;
+        }[];
+        show_in_detail_only?: boolean;
+        hide?: boolean;
+        ellipsis?: boolean;
+        editable?: boolean;
+        type?: 'file';
+        startLevel?: string;
+        representation?: RepresentationType;
+        delimiter?: boolean;
+    };
+    unit?: string;
+    level?: string;
+    udf?: any;
+    versioned?: boolean;
+    can_drilldown?: boolean;
+    analyzer?: {
+        customSummary?: string;
+        drilldown?: any[];
+    };
+    recommend_kpis?: any[];
+    components?: any[];
+}
+export interface PropertyType extends Omit<PropertyTypeDraft, '_sid' | '_id' | 'constraints' | 'primal_type' | 'ui'>, Required<Pick<PropertyTypeDraft, '_sid' | '_id' | 'constraints' | 'primal_type' | 'ui'>> {
+    schemaID?: string;
+}

package/dist/schema/property.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/schema.d.ts

@@ -0,0 +1,25 @@
+import { GroupbyItemType } from '../logicform/logicform';
+import { PropertyTypeDraft, PropertyType } from './property';
+export interface HierarchyType {
+    name: string;
+    syno?: string[];
+    code_length: number;
+    use_full_length?: boolean;
+}
+export interface SchemaTypeDraft {
+    _id: string;
+    name: string;
+    type: 'entity' | 'event';
+    syno?: string[];
+    properties: PropertyTypeDraft[];
+    tag?: string[];
+    hierarchy?: [HierarchyType, ...HierarchyType[]];
+    analyzer?: {
+        drilldown?: string | GroupbyItemType[];
+        drilldown_blacklist?: string[];
+    };
+    drilldown?: GroupbyItemType[];
+}
+export interface SchemaType extends SchemaTypeDraft {
+    properties: PropertyType[];
+}

package/dist/schema/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/schema.utils/getDrilldownDimensions.d.ts

@@ -0,0 +1,3 @@
+import { GroupbyItemType, LogicformType } from '../../logicform/logicform';
+import { SchemaType } from '../schema';
+export declare const getDrilldownDimensions: (schema: SchemaType, schemas: Record<string, SchemaType>, logicform: LogicformType) => Promise<GroupbyItemType[]>;

package/dist/schema/schema.utils/getDrilldownDimensions.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDrilldownDimensions = void 0;
+const logicform_utils_1 = require("../../logicform/logicform.utils");
+const moment_1 = __importDefault(require("moment"));
+const getDrilldownDimensions = (schema, schemas, logicform) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!schema)
+        return []; // 如果没有schema，代表logicform result报错了
+    if (schema.analyzer && schema.analyzer.drilldown) {
+        if (typeof schema.analyzer.drilldown === 'string') {
+            try {
+                const func = new Function(`return ${schema.analyzer.drilldown}`)();
+                return func(logicform, { isDimensionInQuery: logicform_utils_1.isDimensionInQuery, moment: moment_1.default }) || [];
+            }
+            catch (error) {
+                console.error('error in gen schema.analyzer.drilldown function');
+                console.error('schema: ', schema._id);
+                console.error(error);
+                return [];
+            }
+        }
+        return schema.analyzer.drilldown; // 自定义的下钻维度
+    }
+    if (schema.drilldown)
+        return schema.drilldown; // 自定义的下钻维度
+    let drilldownProps = [];
+    // 一个递归函数
+    const addToArrayWithProperty = (property, prefix, schema) => {
+        const pushToPropNames = (propertyName, level, prefix, schema) => {
+            const groupbyItem = {
+                _id: prefix ? `${prefix}_${propertyName}` : propertyName,
+            };
+            if (level) {
+                groupbyItem.level = level;
+            }
+            if (schema) {
+                groupbyItem.schema = schema;
+            }
+            drilldownProps.push(groupbyItem);
+        };
+        if (property.isArray)
+            return; // array因为如果做分组的话，其中的一些统计值都会重复计算，所以默认不做drilldown了
+        if (property.is_supplementary)
+            return;
+        if (property.can_drilldown === false)
+            return;
+        if (property.is_categorical) {
+            pushToPropNames(property.name, undefined, prefix, schema);
+        }
+        else if (property.ref && schemas[property.ref]) {
+            if (schemas[property.ref].drilldown) {
+                schemas[property.ref].drilldown.forEach((h) => {
+                    if (!h._id.startsWith('_')) {
+                        property.name = h._id ? `${property.name}_${h._id}` : property.name;
+                    }
+                    pushToPropNames(property.name, h.level, prefix, schema);
+                });
+                return;
+            }
+            else if (schemas[property.ref].hierarchy) {
+                schemas[property.ref].hierarchy.forEach((h) => {
+                    pushToPropNames(property.name, h.name, prefix, schema);
+                });
+            }
+            else {
+                pushToPropNames(property.name, undefined, prefix, schema);
+            }
+            // 这里要获取其他schema的属性
+            if (!prefix || prefix.split('_').length < 3) {
+                // 最多三层
+                schemas[property.ref].properties.forEach((refProperty) => {
+                    if (prefix) {
+                        addToArrayWithProperty(refProperty, `${prefix}_${property.name}`, schema);
+                    }
+                    else {
+                        addToArrayWithProperty(refProperty, property.name, schema);
+                    }
+                });
+            }
+        }
+    };
+    schema.properties.forEach((property) => {
+        addToArrayWithProperty(property);
+    });
+    // console.log('drilldownProps', drilldownProps);
+    // blacklist
+    if (schema.analyzer && schema.analyzer.drilldown_blacklist) {
+        drilldownProps = drilldownProps.filter((prop) => schema.analyzer.drilldown_blacklist.indexOf(prop._id) < 0);
+    }
+    return drilldownProps;
+});
+exports.getDrilldownDimensions = getDrilldownDimensions;

package/dist/schema/schema.utils.d.ts

@@ -0,0 +1,16 @@
+import { PropertyType } from './property';
+import { SchemaType } from './schema';
+/**
+ * Find a property by name within a specific schema
+ * @param schemaID - The unique identifier of the schema to search in
+ * @param propertyName - The name of the property to find。支持chain式结构。chain式结构例如：a_b_c，a_b(level)_c
+ * @param schemas - Array of runtime schema types to search through
+ * @returns The found property or undefined if not found
+ */
+export declare const findPropertyByName: (schemaID: string, propertyName: string, schemas: Record<string, SchemaType>) => PropertyType | undefined;
+/**
+ * 找到用在UI上面显示的Name，找到第一个满足条件的property就返回
+ * @param schema - The runtime schema to search in
+ * @returns The property marked as display name (is_name=true or ui.name=true) or undefined if not found
+ */
+export declare const findDisplayNameProperty: (schema: SchemaType) => PropertyType | undefined;

package/dist/schema/schema.utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDisplayNameProperty = exports.findPropertyByName = void 0;
+/**
+ * Find a property by name within a specific schema
+ * @param schemaID - The unique identifier of the schema to search in
+ * @param propertyName - The name of the property to find。支持chain式结构。chain式结构例如：a_b_c，a_b(level)_c
+ * @param schemas - Array of runtime schema types to search through
+ * @returns The found property or undefined if not found
+ */
+const findPropertyByName = (schemaID, propertyName, schemas) => {
+    const chain = propertyName.split('_');
+    let currentSchemaID = schemaID;
+    let property = undefined;
+    for (let i = 0; i < chain.length; i++) {
+        const schema = schemas[currentSchemaID];
+        if (!schema) {
+            throw new Error(`[schema.utils.findPropertyByName]Schema with id ${currentSchemaID} not found`);
+        }
+        const chainItem = chain[i].split('(')[0]; // 去掉(level)
+        const p = schema.properties.find((property) => property.name === chainItem);
+        if (!p) {
+            throw new Error(`[schema.utils.findPropertyByName]Property with name ${chainItem} not found`);
+        }
+        if (i === chain.length - 1) {
+            property = p;
+            property.schemaID = currentSchemaID;
+            break;
+        }
+        if (!p.ref) {
+            throw new Error(`[schema.utils.findPropertyByName]Property with name ${chainItem} do not have ref field`);
+        }
+        currentSchemaID = p.ref;
+    }
+    return property;
+};
+exports.findPropertyByName = findPropertyByName;
+/**
+ * 找到用在UI上面显示的Name，找到第一个满足条件的property就返回
+ * @param schema - The runtime schema to search in
+ * @returns The property marked as display name (is_name=true or ui.name=true) or undefined if not found
+ */
+const findDisplayNameProperty = (schema) => {
+    let nameProp = schema.properties.find((p) => p.is_name || p.ui.name);
+    if (nameProp)
+        return nameProp;
+    nameProp = schema.properties.find((p) => p.type === 'ID');
+    if (nameProp)
+        return nameProp;
+    return undefined;
+};
+exports.findDisplayNameProperty = findDisplayNameProperty;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "semanticdb-core",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "prepare": "npm run build",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "repository": "https://github.com/YiwenData/semanticdb-core",
+  "keywords": [],
+  "author": "XiChi Zhu",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/lodash": "^4.17.16",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.2.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "moment": "^2.30.1"
+  }
+}