semanticdb-core 1.0.2 → 1.0.3

package/README.md

@@ -18,7 +18,8 @@
 
 ### Logicform 相关
 
-- `isDimensionInQuery`: 判断维度是否在Query中使用
+- `isDimensionInQuery`: 判断维度是否在 Query 中使用
+- `getFlattenQuery`: 将嵌套的查询对象扁平化（如 `{ customer: { query: { name: '张三' } } }` 转换为 `{ 'customer_name': '张三' }`）
 
 ## 安装
 

package/dist/logicform/logicform.d.ts

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

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

@@ -1,2 +1,33 @@
-import { QueryType } from './logicform';
+import { QueryType } from './types/query';
+/**
+ * 判断一个维度是否在查询中被使用
+ * @param query - 查询对象
+ * @param dimension - 维度名称，支持链式结构（如：a_b_c）
+ * @returns 如果维度在查询中被使用则返回 true，否则返回 false
+ * @example
+ * ```typescript
+ * isDimensionInQuery({ customer: { name: "张三" } }, "customer_name") // true
+ * isDimensionInQuery({ "$or": [{ "a": "b" }] }, "$or") // false
+ * ```
+ */
 export declare const isDimensionInQuery: (query: QueryType, dimension: string) => boolean;
+/**
+ * 将嵌套的查询对象扁平化
+ * @param query - 查询对象
+ * @returns 扁平化后的查询对象
+ * @example
+ * ```typescript
+ * // Input
+ * {
+ *   customer: {
+ *     schema: 'customer',
+ *     query: { name: '张三' }
+ *   }
+ * }
+ * // Output
+ * {
+ *   'customer_name': '张三'
+ * }
+ * ```
+ */
+export declare const getFlattenQuery: (query: QueryType) => QueryType;

package/dist/logicform/logicform.utils.js

@@ -1,36 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDimensionInQuery = void 0;
+exports.getFlattenQuery = exports.isDimensionInQuery = void 0;
+/**
+ * 判断一个维度是否在查询中被使用
+ * @param query - 查询对象
+ * @param dimension - 维度名称，支持链式结构（如：a_b_c）
+ * @returns 如果维度在查询中被使用则返回 true，否则返回 false
+ * @example
+ * ```typescript
+ * isDimensionInQuery({ customer: { name: "张三" } }, "customer_name") // true
+ * isDimensionInQuery({ "$or": [{ "a": "b" }] }, "$or") // false
+ * ```
+ */
 const isDimensionInQuery = (query, dimension) => {
+    var _a, _b, _c, _d;
     const chain = dimension.split('_');
     let chainedQuery = query;
     for (let i = 0; i < chain.length; i++) {
         const item = chain[i];
-        if (!(chainedQuery && chainedQuery[item])) {
+        // TBD: 如果是$or, $and怎么办呢？
+        if (item === '$or' || item === '$and')
+            return false;
+        if (typeof chainedQuery !== 'object')
+            return false;
+        if (!(chainedQuery && 'item' in chainedQuery)) {
             return false;
         }
         // last one
         if (i === chain.length - 1) {
-            if (typeof chainedQuery[item] !== 'object' || !chainedQuery[item].query) {
+            if (typeof chainedQuery[item] !== 'object' || !('schema' in chainedQuery[item])) {
                 if (typeof chainedQuery[item] === 'object' && '$exists' in chainedQuery[item]) {
                     return false;
                 }
                 return true;
             }
+            // 接下去chainedQuery[item]都是LogicformType
             if (chainedQuery[item].entity_id) {
                 return true;
             }
+            // TBD: 如果是$or, $and怎么办呢？
+            if (((_b = (_a = chainedQuery[item]) === null || _a === void 0 ? void 0 : _a.query) === null || _b === void 0 ? void 0 : _b.$or) || ((_d = (_c = chainedQuery[item]) === null || _c === void 0 ? void 0 : _c.query) === null || _d === void 0 ? void 0 : _d.$and))
+                return false;
             // TODO: 如果是name property，也行的，现在先简单搞一个
-            if (chainedQuery[item].query && chainedQuery[item].query.别名) {
+            if (chainedQuery[item].query &&
+                !('$or' in chainedQuery[item].query) &&
+                !('$and' in chainedQuery[item].query) &&
+                '别名' in chainedQuery[item].query // TODO: 这里是一个临时的方案，后面需要改成动态获取property
+            ) {
                 return true;
             }
             return false;
         }
-        if (typeof chainedQuery[item] !== 'object' || !chainedQuery[item].query) {
+        if (typeof chainedQuery[item] !== 'object' || !('schema' in chainedQuery[item])) {
             return false;
         }
-        chainedQuery = chainedQuery[item].query;
+        if (chainedQuery[item].query) {
+            chainedQuery = chainedQuery[item].query;
+        }
     }
     return true;
 };
 exports.isDimensionInQuery = isDimensionInQuery;
+/**
+ * 将嵌套的查询对象扁平化
+ * @param query - 查询对象
+ * @returns 扁平化后的查询对象
+ * @example
+ * ```typescript
+ * // Input
+ * {
+ *   customer: {
+ *     schema: 'customer',
+ *     query: { name: '张三' }
+ *   }
+ * }
+ * // Output
+ * {
+ *   'customer_name': '张三'
+ * }
+ * ```
+ */
+const getFlattenQuery = (query) => {
+    const flattenQuery = {};
+    for (const [k, v] of Object.entries(query)) {
+        if (k === '$and' || k === '$or') {
+            // complex的暂时先不管
+            flattenQuery[k] = v;
+        }
+        else if (typeof v === 'object' &&
+            'schema' in v &&
+            'query' in v &&
+            !('groupby' in v) && // 不是复合的logicform
+            !('entity_id' in v) // entity_id的话，也没必要收起来
+        ) {
+            // 这里是一个logicform
+            const flattenSubQuery = (0, exports.getFlattenQuery)(v.query);
+            for (const [sk, sv] of Object.entries(flattenSubQuery)) {
+                flattenQuery[`${k}_${sk}`] = sv;
+            }
+        }
+        else {
+            flattenQuery[k] = v;
+        }
+    }
+    return flattenQuery;
+};
+exports.getFlattenQuery = getFlattenQuery;

package/dist/schema/schema.utils.js

@@ -12,6 +12,17 @@ const findPropertyByName = (schemaID, propertyName, schemasDict) => {
     const chain = propertyName.split('_');
     let currentSchemaID = schemaID;
     let property = undefined;
+    if (propertyName === '_id') {
+        return {
+            _sid: '_id',
+            _id: '_id',
+            name: '_id',
+            type: 'string',
+            primal_type: 'string',
+            constraints: {},
+            ui: {},
+        };
+    }
     for (let i = 0; i < chain.length; i++) {
         const schema = schemasDict[currentSchemaID];
         if (!schema) {

package/package.json

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