semanticdb-core 1.0.53 → 1.1.0

package/dist/common/date.js

@@ -24,7 +24,7 @@ function getSupportedTimeWindows() {
     return ['second', 'minute', 'hour', 'weekday', 'day', 'week', 'month', 'quarter', 'year'];
 }
 function isStandardDateForm(dateValue) {
-    return typeof dateValue === 'object' && '$gte' in dateValue && '$lte' in dateValue;
+    return typeof dateValue === 'object' && dateValue !== null && '$gte' in dateValue && '$lte' in dateValue;
 }
 /**
  * year + offset形态
@@ -32,7 +32,7 @@ function isStandardDateForm(dateValue) {
  * @return {Boolean}
  */
 function isRelativeDateForm(dateValue) {
-    if (typeof dateValue !== 'object')
+    if (typeof dateValue !== 'object' || dateValue === null)
         return false;
     const complexOperators = ['$gte', '$gt', '$lte', '$lt', '$or', '$ne'];
     for (const complexOperator of complexOperators) {

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

@@ -1,5 +1,6 @@
 import { PropertyType } from './property';
 import { SchemaType } from './schema';
+import { LogicformType } from '../logicform/logicform';
 export declare const findPropertyByType: (type: string, schema: SchemaType) => PropertyType | undefined;
 /**
  * Find a property by name within a specific schema
@@ -15,6 +16,12 @@ export declare const findPropertyByName: (schemaID: string, propertyName: string
  * @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;
+/**
+ * 找到schema中的timestamp属性
+ * @param schema - The runtime schema to search in
+ * @returns The property with type 'timestamp' or undefined if not found
+ */
+export declare const findTimestampLikeProperty: (schema: SchemaType) => PropertyType | undefined;
 /**
  * 以fromSchema为基础，找到toSchema中对应的property
  * @param propertyName
@@ -22,3 +29,24 @@ export declare const findDisplayNameProperty: (schema: SchemaType) => PropertyTy
  * @param toSchema
  */
 export declare const findPropertyForOtherSchema: (propertyName: string, fromSchemaID: string, toSchemaID: string, schemasDict: Record<string, SchemaType>) => PropertyType | undefined;
+/**
+ * 获取hierarchy指定层级的累加代码长度
+ * @param schema - The schema with hierarchy
+ * @param name - The hierarchy level name to get accumulated code length for
+ * @returns The accumulated code length up to and including the specified level
+ * @throws Error if the level name is not found in the hierarchy
+ */
+export declare const getHierarchyCodeLength: (schema: SchemaType, name: string) => number;
+/**
+ * 获取从fromNode到toNode的引用链
+ * @param fromNode - 起始节点的logicform
+ * @param toNode - 目标节点的logicform
+ * @param schemas - Schema字典
+ * @returns 引用链数组或包含错误信息的对象
+ */
+export declare const getRefChain: (fromNode: LogicformType, toNode: LogicformType, schemas: Record<string, SchemaType>) => {
+    property: PropertyType;
+    schema?: SchemaType;
+}[] | {
+    error: string;
+} | null;

package/dist/schema/schema.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findPropertyForOtherSchema = exports.findDisplayNameProperty = exports.findPropertyByName = exports.findPropertyByType = void 0;
+exports.getRefChain = exports.getHierarchyCodeLength = exports.findPropertyForOtherSchema = exports.findTimestampLikeProperty = exports.findDisplayNameProperty = exports.findPropertyByName = exports.findPropertyByType = void 0;
 const findPropertyByType = (type, schema) => {
     return schema.properties.find((property) => property.type === type);
 };
@@ -65,6 +65,15 @@ const findDisplayNameProperty = (schema) => {
     return undefined;
 };
 exports.findDisplayNameProperty = findDisplayNameProperty;
+/**
+ * 找到schema中的timestamp属性
+ * @param schema - The runtime schema to search in
+ * @returns The property with type 'timestamp' or undefined if not found
+ */
+const findTimestampLikeProperty = (schema) => {
+    return schema.properties.find((property) => property.type === 'timestamp');
+};
+exports.findTimestampLikeProperty = findTimestampLikeProperty;
 /**
  * 以fromSchema为基础，找到toSchema中对应的property
  * @param propertyName
@@ -98,3 +107,123 @@ const findPropertyForOtherSchema = (propertyName, fromSchemaID, toSchemaID, sche
     return undefined;
 };
 exports.findPropertyForOtherSchema = findPropertyForOtherSchema;
+/**
+ * 获取hierarchy指定层级的累加代码长度
+ * @param schema - The schema with hierarchy
+ * @param name - The hierarchy level name to get accumulated code length for
+ * @returns The accumulated code length up to and including the specified level
+ * @throws Error if the level name is not found in the hierarchy
+ */
+const getHierarchyCodeLength = (schema, name) => {
+    if (!schema.hierarchy) {
+        throw new Error(`${schema.name}中没有hierarchy`);
+    }
+    let codeLength = 0;
+    let nameFound = false;
+    for (const hierarchyItem of schema.hierarchy) {
+        codeLength += hierarchyItem.code_length;
+        if (hierarchyItem.name === name) {
+            nameFound = true;
+            break;
+        }
+    }
+    if (!nameFound)
+        throw new Error(`${schema.name}中没有此level：${name}`);
+    return codeLength;
+};
+exports.getHierarchyCodeLength = getHierarchyCodeLength;
+/**
+ * 获取从fromNode到toNode的引用链
+ * @param fromNode - 起始节点的logicform
+ * @param toNode - 目标节点的logicform
+ * @param schemas - Schema字典
+ * @returns 引用链数组或包含错误信息的对象
+ */
+const getRefChain = (fromNode, toNode, schemas) => {
+    const getError = (p) => {
+        // granularity check
+        if (p.granularity && schemas[fromNode.schema].hierarchy) {
+            let levelLength;
+            if (fromNode.entity_id) {
+                levelLength = fromNode.entity_id.length;
+            }
+            else if (fromNode.groupby && fromNode.groupby.find((gi) => gi.level)) {
+                const levelGI = fromNode.groupby.find((gi) => gi.level);
+                if (levelGI === null || levelGI === void 0 ? void 0 : levelGI.level) {
+                    levelLength = (0, exports.getHierarchyCodeLength)(schemas[fromNode.schema], levelGI.level);
+                }
+            }
+            if (levelLength && p.granularity) {
+                // granularity check
+                const maxCodeLength = (0, exports.getHierarchyCodeLength)(schemas[fromNode.schema], p.granularity);
+                if (maxCodeLength && maxCodeLength < levelLength) {
+                    return `**${schemas[toNode.schema].name}**中，**${p.name}**要求为${p.granularity}以上。暂无法回答此问题。请联系技术支持。`;
+                }
+            }
+        }
+        return null;
+    };
+    let error = null;
+    // 优先拿直接能找到的，找不到再用一个dfs来找
+    const directFound = schemas[toNode.schema].properties.find((p) => {
+        if (!p.ref)
+            return false;
+        if (p.is_supplementary)
+            return false;
+        if (getError(p))
+            return false;
+        if (p.ref !== fromNode.schema)
+            return false;
+        const constraintsWithRole = p.constraints;
+        const fromNodeWithRole = fromNode;
+        if ((constraintsWithRole === null || constraintsWithRole === void 0 ? void 0 : constraintsWithRole.role) &&
+            (fromNodeWithRole === null || fromNodeWithRole === void 0 ? void 0 : fromNodeWithRole._role) &&
+            !Object.keys(constraintsWithRole.role).every((k) => constraintsWithRole.role[k] === fromNodeWithRole._role[k])) {
+            return false;
+        }
+        return true;
+    });
+    if (directFound) {
+        return [{ property: directFound }];
+    }
+    // 一个dfs
+    const fromTo = (from, to, chain = []) => {
+        // max depth
+        if (chain.length > 10)
+            return null;
+        const schema = schemas[from];
+        for (const property of schema.properties) {
+            if (property.type === 'object' && !property.is_supplementary && property.ref && schemas[property.ref]) {
+                if (chain.length > 0) {
+                    const lastItem = chain[chain.length - 1];
+                    if (lastItem.schema._id === schema._id && lastItem.property.name === property.name) {
+                        continue;
+                    }
+                }
+                const newChain = [...chain, { property, schema: schemas[property.ref] }];
+                if (property.ref === to) {
+                    // sanity check
+                    const errorMsg = getError(property);
+                    if (errorMsg) {
+                        error = errorMsg;
+                        continue;
+                    }
+                    return newChain;
+                }
+                else {
+                    const nestedChain = fromTo(property.ref, to, newChain);
+                    if (nestedChain) {
+                        return nestedChain;
+                    }
+                }
+            }
+        }
+        return null;
+    };
+    const chain = fromTo(toNode.schema, fromNode.schema);
+    if (!chain && error) {
+        return { error };
+    }
+    return chain;
+};
+exports.getRefChain = getRefChain;

package/package.json

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