semanticdb-core 1.1.20 → 1.1.22

package/dist/schema/property.d.ts

@@ -13,6 +13,8 @@ export declare type PropertyTypePrimalType = 'string' | 'number' | 'boolean' | '
 export interface PropertyTypeDraft {
     _sid?: string | number;
     _id?: string;
+    sid?: string;
+    id?: string;
     name: string;
     syno?: string[];
     description?: string;
@@ -20,6 +22,7 @@ export interface PropertyTypeDraft {
         required?: boolean;
         unique?: boolean;
         enum?: any[] | null;
+        enumMap?: any[];
     };
     type: PropertyTypeType;
     primal_type?: PropertyTypePrimalType;
@@ -29,8 +32,10 @@ export interface PropertyTypeDraft {
         dependencies: string[];
         function?: (self: any) => any;
     };
+    pattern?: RegExp | string;
     is_dynamic?: boolean;
     is_projection_for?: string;
+    is_version?: boolean;
     is_name?: boolean;
     is_categorical?: boolean;
     ref?: string;

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

@@ -14,7 +14,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDrilldownDimensions = void 0;
 const logicform_utils_1 = require("../../logicform/logicform.utils");
+const property_utils_1 = require("../property.utils");
 const moment_1 = __importDefault(require("moment"));
+// 日期粒度，从粗到细
+const DATE_GRANULARITIES = [
+    'year',
+    'quarter',
+    'month',
+    'week',
+    'day',
+    'hour',
+    'minute',
+    'second',
+];
 const getDrilldownDimensions = (schema_1, schemasDict_1, logicform_1, ...args_1) => __awaiter(void 0, [schema_1, schemasDict_1, logicform_1, ...args_1], void 0, function* (schema, schemasDict, logicform, usage = 'drilldown') {
     if (!schema)
         return []; // 如果没有schema，代表logicform result报错了
@@ -38,6 +50,7 @@ const getDrilldownDimensions = (schema_1, schemasDict_1, logicform_1, ...args_1)
     let drilldownProps = [];
     // 一个递归函数
     const addToArrayWithProperty = (property, prefix, schema) => {
+        var _a;
         if (usage === 'analyze' && property.is_analyzable === false)
             return;
         const pushToPropNames = (property, level, prefix, schema) => {
@@ -62,7 +75,26 @@ const getDrilldownDimensions = (schema_1, schemasDict_1, logicform_1, ...args_1)
             return;
         if (property.can_drilldown === false)
             return;
-        if (property.is_categorical) {
+        if (property.primal_type === 'date') {
+            // 日期维度的下钻：提供更细粒度的选项
+            const propertyId = prefix ? `${prefix}_${property.name}` : property.name;
+            // 找到当前 logicform 中该属性的粒度
+            const currentGroupBy = (_a = logicform === null || logicform === void 0 ? void 0 : logicform.groupby) === null || _a === void 0 ? void 0 : _a.find((g) => g._id === propertyId);
+            const currentGranularity = currentGroupBy === null || currentGroupBy === void 0 ? void 0 : currentGroupBy.level;
+            // 获取属性的默认粒度
+            const defaultGranularity = (0, property_utils_1.getGranularity)(property);
+            // 确定起始粒度索引
+            const startIndex = currentGranularity
+                ? DATE_GRANULARITIES.indexOf(currentGranularity)
+                : DATE_GRANULARITIES.indexOf(defaultGranularity);
+            if (startIndex >= 0 && startIndex < DATE_GRANULARITIES.length - 1) {
+                // 提供比当前粒度更细的所有选项
+                for (let i = startIndex + 1; i < DATE_GRANULARITIES.length; i++) {
+                    pushToPropNames(property, DATE_GRANULARITIES[i], prefix, schema);
+                }
+            }
+        }
+        else if (property.is_categorical) {
             pushToPropNames(property, undefined, prefix, schema);
         }
         else if (property.ref && schemasDict[property.ref]) {

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

@@ -8,9 +8,18 @@ export interface SchemaValidationResult {
 /**
  * 检查 schema 是否有效
  * @param schema - 要检查的 schema
+ * @param schemasDict - schema字典，用于验证ref引用
  * @returns 验证结果，包含 valid 和 message
  */
-export declare function isSchemaValid(schema: Partial<SchemaType>, schemasDict: Record<string, SchemaType>): SchemaValidationResult;
+export declare function isSchemaValid(schema: Partial<SchemaType>, schemasDict?: Record<string, SchemaType>): SchemaValidationResult;
+/**
+ * 验证一个property配置是否有效
+ * @param property - 属性配置
+ * @param schemaNames - schema名称列表（用于冲突检查）
+ * @param hierarchyNames - hierarchy名称列表（用于冲突检查）
+ * @returns 验证结果
+ */
+export declare function isPropertyValid(property: Partial<PropertyType>, schemaNames?: string[], hierarchyNames?: string[]): SchemaValidationResult;
 export declare const findPropertyByType: (type: string, schema: SchemaType) => PropertyType | undefined;
 /**
  * Find a property by name within a specific schema

package/dist/schema/schema.utils.js

@@ -2,46 +2,235 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRefChain = exports.getHierarchyCodeLength = exports.findPropertyForOtherSchema = exports.findTimestampLikeProperty = exports.findDisplayNameProperty = exports.findPropertyByName = exports.findPropertyByType = void 0;
 exports.isSchemaValid = isSchemaValid;
+exports.isPropertyValid = isPropertyValid;
 /**
  * 检查 schema 是否有效
  * @param schema - 要检查的 schema
+ * @param schemasDict - schema字典，用于验证ref引用
  * @returns 验证结果，包含 valid 和 message
  */
 function isSchemaValid(schema, schemasDict) {
-    if (!schema.name) {
+    var _a, _b;
+    // ==================== 基本字段检查 ====================
+    // 检查name - 兼容空字符串的情况
+    if (!schema.name || schema.name.trim() === '') {
         return { valid: false, message: '缺少名称' };
     }
+    // 检查type
     if (!schema.type) {
         return { valid: false, message: '缺少类型' };
     }
-    if (!schema.db) {
-        return { valid: false, message: '缺少数据库配置' };
+    if (['entity', 'event'].indexOf(schema.type) < 0) {
+        return { valid: false, message: 'type必须为entity或event之一' };
+    }
+    // 检查name是否包含非法字符
+    if ((_b = (_a = schema === null || schema === void 0 ? void 0 : schema.name) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, '/')) {
+        return { valid: false, message: `schema名字(${schema.name})不能包含 "/"。` };
     }
+    // 检查properties
     if (!schema.properties || schema.properties.length === 0) {
         return { valid: false, message: '缺少属性定义' };
     }
-    if (!schema.properties.every((property) => property.name && property.type)) {
+    // 检查每个属性是否有name和type
+    if (!schema.properties.every((property) => property.name && property.name.trim() !== '' && property.type)) {
         return { valid: false, message: '每一个属性都必须有名称和类型' };
     }
-    // entity和event各自必须的字段
+    // 检查db
+    if (!schema.db) {
+        return { valid: false, message: '缺少数据库配置' };
+    }
+    // ==================== tag字段验证 ====================
+    if (schema.tag && typeof schema.tag === 'object' && !Array.isArray(schema.tag)) {
+        return { valid: false, message: 'schema的标签不能是对象类型' };
+    }
+    // ==================== syno验证 ====================
+    if (schema.syno && !Array.isArray(schema.syno)) {
+        return { valid: false, message: 'schema的同义词必须为数组格式' };
+    }
+    // ==================== 构建名称列表（用于冲突检查） ====================
+    const schemaNames = [schema.name, ...(schema.syno || [])];
+    let hierarchyNames = [];
+    if (schema.hierarchy) {
+        for (const h of schema.hierarchy) {
+            hierarchyNames = [...hierarchyNames, h.name, ...(h.syno || [])];
+        }
+    }
+    // ==================== RULE: schema和hierarchy不能有名词重复 ====================
+    const conflicts = _intersection(schemaNames, hierarchyNames);
+    if (conflicts.length > 0) {
+        return {
+            valid: false,
+            message: `Schema: ${schema.name}和Hierarchy包含相同的关键词: ${conflicts.join(',')}`,
+        };
+    }
+    // ==================== 检查时间戳属性数量 ====================
+    const timestampProps = schema.properties.filter((p) => p.type === 'timestamp');
+    if (schema.type === 'event' && timestampProps.length > 1) {
+        return {
+            valid: false,
+            message: `事件表不能有两个或以上时间戳类型的属性：${timestampProps.map((p) => p.name).join('，')}`,
+        };
+    }
+    // ==================== 验证每个属性 ====================
+    for (const property of schema.properties) {
+        // 调用属性验证
+        const propertyValid = isPropertyValid(property, schemaNames, hierarchyNames);
+        if (!propertyValid.valid) {
+            return propertyValid;
+        }
+    }
+    // ==================== 事件表必须有timestamp ====================
+    if (schema.type === 'event') {
+        const timeProperty = schema.properties.find((p) => p.type === 'timestamp');
+        if (timeProperty === undefined) {
+            return { valid: false, message: '事件表必须要有一个时间戳类型的属性' };
+        }
+    }
+    // ==================== 检查属性name重复 ====================
+    const propertyNames = schema.properties.map((p) => p.name);
+    const seenNames = new Set();
+    for (const name of propertyNames) {
+        if (seenNames.has(name)) {
+            return { valid: false, message: `有两个相同名字的属性：${name}` };
+        }
+        seenNames.add(name);
+    }
+    // ==================== 检查属性_id重复 ====================
+    const propertyIds = schema.properties.map((p) => p.id).filter((id) => !!id);
+    const seenIds = new Set();
+    for (const id of propertyIds) {
+        if (seenIds.has(id)) {
+            return { valid: false, message: `${schema.name} 中有两个相同id的属性：${id}` };
+        }
+        seenIds.add(id);
+    }
+    // ==================== 生命周期日期检查 ====================
+    const birthdayProps = schema.properties.find((p) => p.type === 'start_date');
+    const endDateProps = schema.properties.find((p) => p.type === 'end_date');
+    if (birthdayProps && !endDateProps) {
+        return { valid: false, message: '有生命周期起始时间，则必须有生命周期结束时间' };
+    }
+    if (endDateProps && !birthdayProps) {
+        return { valid: false, message: '有生命周期结束时间，则必须有生命周期起始时间' };
+    }
+    if (schema.type !== 'entity' && birthdayProps) {
+        return { valid: false, message: '只有实体类有生命周期概念' };
+    }
+    // ==================== 实体表timestamp检查 ====================
+    const tmsProps = schema.properties.find((p) => p.type === 'timestamp');
+    if (schema.type === 'entity' && tmsProps && !tmsProps.i_am_an_expert) {
+        return {
+            valid: false,
+            message: `实体表 ${schema.name} 不允许使用时间戳类型字段: ${tmsProps.name}。不然会是一张快照表。如确实需要，请在专家模式中给该字段加入i_am_an_expert: true。`,
+        };
+    }
+    // ==================== entity必须有ID属性 ====================
     if (schema.type === 'entity') {
-        const IDProp = schema.properties.find((property) => property.type === 'ID');
-        if (!IDProp) {
-            return { valid: false, message: '实体必须有一个语义类型为 ID 的属性' };
+        const found = schema.properties.find((p) => p.type === 'ID');
+        if (!found) {
+            return { valid: false, message: 'entity schema必须要有一个ID型属性' };
         }
     }
-    else if (schema.type === 'event') {
-        const timestampProps = schema.properties.filter((property) => property.type === 'timestamp');
-        if (timestampProps.length === 0) {
-            return { valid: false, message: '事件必须有一个语义类型为 时间戳 的属性' };
+    // ==================== 有nameProp必须要有ID ====================
+    const nameProp = schema.properties.find((p) => p.is_name);
+    if (nameProp) {
+        if (!schema.properties.find((p) => p.type === 'ID')) {
+            let eventMsg = '';
+            if (schema.type === 'event') {
+                eventMsg = '事件表只有在非常特殊的情况下才会用到名称字段。请充分了解名称字段的含义后配置';
+            }
+            return { valid: false, message: '如果有名称类型，那么必须要有ID类型的字段。' + eventMsg };
         }
     }
-    const noRefProperty = schema.properties.find((property) => property.ref && !(property.ref in schemasDict));
-    if (noRefProperty) {
-        return { valid: false, message: `属性 ${noRefProperty.name} 引用的实体表 ${noRefProperty.ref} 不存在` };
+    // ==================== 只允许有一个ID类属性 ====================
+    const idProps = schema.properties.filter((item) => item.type === 'ID');
+    if (idProps.length > 1) {
+        return { valid: false, message: `只允许有一个ID类属性` };
+    }
+    // ==================== 检查ref引用是否有效 ====================
+    if (schemasDict) {
+        const noRefProperty = schema.properties.find((property) => property.ref && !(property.ref in schemasDict));
+        if (noRefProperty) {
+            return { valid: false, message: `属性 ${noRefProperty.name} 引用的实体表 ${noRefProperty.ref} 不存在` };
+        }
+    }
+    return { valid: true, message: '' };
+}
+/**
+ * 验证一个property配置是否有效
+ * @param property - 属性配置
+ * @param schemaNames - schema名称列表（用于冲突检查）
+ * @param hierarchyNames - hierarchy名称列表（用于冲突检查）
+ * @returns 验证结果
+ */
+function isPropertyValid(property, schemaNames = [], hierarchyNames = []) {
+    var _a, _b, _c, _d, _e, _f;
+    if (typeof property !== 'object') {
+        return { valid: false, message: '属性必须为Object类型' };
+    }
+    if (!('name' in property)) {
+        return { valid: false, message: '属性必须有name属性' };
+    }
+    if (!('type' in property)) {
+        return { valid: false, message: '属性必须有type属性' };
+    }
+    if ((_b = (_a = property === null || property === void 0 ? void 0 : property.name) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, '/')) {
+        return { valid: false, message: `property 属性名称(${property.name})不能有"/"。` };
+    }
+    if (property.name && property.name.indexOf('_') >= 0) {
+        return { valid: false, message: `属性${property.name}不得包含下划线` };
+    }
+    // 处理syno
+    const syno = property.syno;
+    let propertySyno = [];
+    if (Array.isArray(syno)) {
+        propertySyno = syno;
+    }
+    else if (typeof syno === 'string') {
+        propertySyno = syno.split(',');
+    }
+    // RULE: 属性名或者属性syno不能和schema名和schema syno一样
+    const propertyNames = [property.name || '', ...propertySyno];
+    const conflicts = _intersection(schemaNames, propertyNames);
+    if (conflicts.length > 0) {
+        return { valid: false, message: `属性${property.name}和Schema包含相同的关键词: ${conflicts.join(',')}` };
+    }
+    // RULE: 属性名或者属性syno不能和hierarchy名和hierarchy syno一样
+    const hierarchyConflicts = _intersection(hierarchyNames, propertyNames);
+    if (hierarchyConflicts.length > 0) {
+        return {
+            valid: false,
+            message: `属性${property.name}和Hierarchy包含相同的关键词: ${hierarchyConflicts.join(',')}`,
+        };
+    }
+    // enumMap和enum检查
+    if (((_c = property.constraints) === null || _c === void 0 ? void 0 : _c.enumMap) && !((_d = property.constraints) === null || _d === void 0 ? void 0 : _d.enum)) {
+        return { valid: false, message: `属性${property.name}设置了enumMap，但是没有设置enum。需要设置enum` };
+    }
+    if (((_e = property.constraints) === null || _e === void 0 ? void 0 : _e.enumMap) &&
+        ((_f = property.constraints) === null || _f === void 0 ? void 0 : _f.enum) &&
+        Array.isArray(property.constraints.enumMap) &&
+        Array.isArray(property.constraints.enum) &&
+        property.constraints.enumMap.length !== property.constraints.enum.length) {
+        return { valid: false, message: `属性${property.name}的enum和enumMap长度不相等` };
+    }
+    // 属性名字中的非法字符检查（除了下划线在前面已经检查过）
+    const invalidNameCharacters = ['(', ')', '!', ',', '，', '。', '.'];
+    if (property.name) {
+        for (const char of invalidNameCharacters) {
+            if (property.name.indexOf(char) > 0) {
+                return { valid: false, message: `${property.name}属性的名字中不得有${char}字符` };
+            }
+        }
     }
     return { valid: true, message: '' };
 }
+/**
+ * 计算两个数组的交集
+ */
+function _intersection(arr1, arr2) {
+    return arr1.filter((x) => arr2.includes(x));
+}
 const findPropertyByType = (type, schema) => {
     return schema.properties.find((property) => property.type === type);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semanticdb-core",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [