@nocobase/utils 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/assign.js

@@ -45,7 +45,10 @@ var import_deepmerge = __toESM(require("deepmerge"));
 var import_lodash = __toESM(require("lodash"));
 var import_common = require("./common");
 function getEnumerableOwnPropertySymbols(target) {
-  return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter((symbol) => target.propertyIsEnumerable(symbol)) : [];
+  return Object.getOwnPropertySymbols ? (
+    // eslint-disable-next-line no-prototype-builtins
+    Object.getOwnPropertySymbols(target).filter((symbol) => target.propertyIsEnumerable(symbol))
+  ) : [];
 }
 __name(getEnumerableOwnPropertySymbols, "getEnumerableOwnPropertySymbols");
 function getKeys(target) {
@@ -119,6 +122,15 @@ mergeStrategies.set(
     if (typeof y === "string") {
       y = y.split(",");
     }
+    if (typeof x === "object" && !Array.isArray(x)) {
+      x = Object.values(x || {});
+    }
+    if (typeof y === "object" && !Array.isArray(y)) {
+      y = Object.values(y || {});
+    }
+    if (!Array.isArray(x) || x.length === 0) {
+      return y || [];
+    }
     if (!Array.isArray(x) || x.length === 0) {
       return y || [];
     }

package/lib/client.d.ts

@@ -31,4 +31,6 @@ export * from './url';
 export * from './transformMultiColumnToSingleColumn';
 export * from './transformFilter';
 export * from './variable-usage';
+export * from './run-sql';
+export * from './liquidjs';
 export { dayjs, lodash, getDayRangeByParams, getOffsetRangeByParams };

package/lib/client.js

@@ -68,6 +68,8 @@ __reExport(client_exports, require("./url"), module.exports);
 __reExport(client_exports, require("./transformMultiColumnToSingleColumn"), module.exports);
 __reExport(client_exports, require("./transformFilter"), module.exports);
 __reExport(client_exports, require("./variable-usage"), module.exports);
+__reExport(client_exports, require("./run-sql"), module.exports);
+__reExport(client_exports, require("./liquidjs"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   dayjs,
@@ -95,5 +97,7 @@ __reExport(client_exports, require("./variable-usage"), module.exports);
   ...require("./url"),
   ...require("./transformMultiColumnToSingleColumn"),
   ...require("./transformFilter"),
-  ...require("./variable-usage")
+  ...require("./variable-usage"),
+  ...require("./run-sql"),
+  ...require("./liquidjs")
 });

package/lib/common.js

@@ -67,7 +67,7 @@ const isEmpty = /* @__PURE__ */ __name((value) => {
   if (Array.isArray(value)) {
     return value.length === 0;
   }
-  return !value;
+  return false;
 }, "isEmpty");
 const isPlainObject = /* @__PURE__ */ __name((value) => {
   if (Object.prototype.toString.call(value) !== "[object Object]") {
@@ -154,6 +154,11 @@ const removeNullCondition = /* @__PURE__ */ __name((filter, customFlat = import_
     }
   }
   const result = customFlat.unflatten(values);
+  for (const key in result) {
+    if (Array.isArray(result[key])) {
+      result[key] = result[key].filter((item) => item != null);
+    }
+  }
   return import_lodash.default.isEmpty(result) ? void 0 : result;
 }, "removeNullCondition");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/i18n.d.ts

@@ -7,4 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { TFuncKey, TOptions } from 'i18next';
+/**
+ * @deprecated use tExpr from @nocobase/flow-engine instead
+ */
 export declare function tval(text: TFuncKey | TFuncKey[], options?: TOptions): string;

package/lib/index.d.ts

@@ -41,4 +41,6 @@ export * from './uid';
 export * from './url';
 export * from './variable-usage';
 export * from './wrap-middleware';
+export * from './run-sql';
+export * from './liquidjs';
 export { lodash };

package/lib/index.js

@@ -77,6 +77,8 @@ __reExport(src_exports, require("./uid"), module.exports);
 __reExport(src_exports, require("./url"), module.exports);
 __reExport(src_exports, require("./variable-usage"), module.exports);
 __reExport(src_exports, require("./wrap-middleware"), module.exports);
+__reExport(src_exports, require("./run-sql"), module.exports);
+__reExport(src_exports, require("./liquidjs"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Schema,
@@ -113,5 +115,7 @@ __reExport(src_exports, require("./wrap-middleware"), module.exports);
   ...require("./uid"),
   ...require("./url"),
   ...require("./variable-usage"),
-  ...require("./wrap-middleware")
+  ...require("./wrap-middleware"),
+  ...require("./run-sql"),
+  ...require("./liquidjs")
 });

package/lib/liquidjs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare function transformLiquidContext(paths?: any[]): {};
+export declare function getLiquidContext(template: string): Promise<{}>;
+export declare function parseLiquidContext(template: string, liquidContext: any): Promise<any>;

package/lib/liquidjs.js

@@ -0,0 +1,71 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 liquidjs_exports = {};
+__export(liquidjs_exports, {
+  getLiquidContext: () => getLiquidContext,
+  parseLiquidContext: () => parseLiquidContext,
+  transformLiquidContext: () => transformLiquidContext
+});
+module.exports = __toCommonJS(liquidjs_exports);
+var import_liquidjs = require("liquidjs");
+const liquid = new import_liquidjs.Liquid();
+function transformLiquidContext(paths = []) {
+  const result = {};
+  for (const fullPath of paths) {
+    const path = fullPath.replace(/^ctx\./, "");
+    const keys = path.split(".");
+    let current = result;
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const isLast = i === keys.length - 1;
+      if (isLast) {
+        current[key] = `{{${fullPath}}}`;
+      } else {
+        current[key] = current[key] || {};
+        current = current[key];
+      }
+    }
+  }
+  return result;
+}
+__name(transformLiquidContext, "transformLiquidContext");
+async function getLiquidContext(template) {
+  const vars = await liquid.fullVariables(template);
+  return transformLiquidContext(vars);
+}
+__name(getLiquidContext, "getLiquidContext");
+async function parseLiquidContext(template, liquidContext) {
+  return await liquid.parseAndRender(template, { ctx: liquidContext });
+}
+__name(parseLiquidContext, "parseLiquidContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLiquidContext,
+  parseLiquidContext,
+  transformLiquidContext
+});

package/lib/run-sql.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare function parseSQLBindParams(template: string): {
+    sql: string;
+    bind: {};
+};
+export declare function transformSQL(template: string): Promise<{
+    sql: string;
+    bind: {};
+    liquidContext: {};
+}>;

package/lib/run-sql.js

@@ -0,0 +1,57 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 run_sql_exports = {};
+__export(run_sql_exports, {
+  parseSQLBindParams: () => parseSQLBindParams,
+  transformSQL: () => transformSQL
+});
+module.exports = __toCommonJS(run_sql_exports);
+var import_liquidjs = require("./liquidjs");
+function parseSQLBindParams(template) {
+  let index = 1;
+  const bind = {};
+  const sql = template.replace(/{{\s*([^}]+)\s*}}/g, (_, expr) => {
+    const key = `__var${index}`;
+    bind[key] = `{{${expr.trim()}}}`;
+    index++;
+    return `$${key}`;
+  });
+  return { sql, bind };
+}
+__name(parseSQLBindParams, "parseSQLBindParams");
+async function transformSQL(template) {
+  const { sql, bind } = parseSQLBindParams(template);
+  const liquidContext = await (0, import_liquidjs.getLiquidContext)(sql);
+  return { sql, bind, liquidContext };
+}
+__name(transformSQL, "transformSQL");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSQLBindParams,
+  transformSQL
+});

package/lib/transformFilter.d.ts

@@ -99,6 +99,7 @@ export type QueryObject = {
  * ```
  */
 export declare function transformFilter(filter: FilterGroupType): QueryObject;
+export declare function removeInvalidFilterItems(filter: FilterGroupType): FilterGroupType;
 /**
  * 条件评估器函数类型
  *

package/lib/transformFilter.js

@@ -28,11 +28,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var transformFilter_exports = {};
 __export(transformFilter_exports, {
   evaluateConditions: () => evaluateConditions,
+  removeInvalidFilterItems: () => removeInvalidFilterItems,
   transformFilter: () => transformFilter
 });
 module.exports = __toCommonJS(transformFilter_exports);
+var import_common = require("./common");
 function isFilterCondition(item) {
-  return "path" in item && "operator" in item && "value" in item;
+  return "path" in item && "operator" in item;
 }
 __name(isFilterCondition, "isFilterCondition");
 function isFilterGroup(item) {
@@ -74,9 +76,30 @@ function transformFilter(filter) {
   if (!Array.isArray(filter.items)) {
     throw new Error("Invalid filter: items must be an array");
   }
-  return transformGroup(filter);
+  return (0, import_common.removeNullCondition)(transformGroup(filter));
 }
 __name(transformFilter, "transformFilter");
+function removeInvalidFilterItems(filter) {
+  if (!filter || typeof filter !== "object") {
+    throw new Error("Invalid filter: filter must be an object");
+  }
+  if (!isFilterGroup(filter)) {
+    throw new Error("Invalid filter: filter must have logic and items properties");
+  }
+  if (!Array.isArray(filter.items)) {
+    throw new Error("Invalid filter: items must be an array");
+  }
+  filter.items = filter.items.filter((item) => {
+    if (isFilterCondition(item)) {
+      return !!item.operator;
+    } else if (isFilterGroup(item)) {
+      return removeInvalidFilterItems(item);
+    }
+    return false;
+  });
+  return { ...filter };
+}
+__name(removeInvalidFilterItems, "removeInvalidFilterItems");
 function evaluateCondition(condition, evaluator) {
   const { path, operator, value } = condition;
   return evaluator(path, operator, value);
@@ -124,5 +147,6 @@ __name(evaluateConditions, "evaluateConditions");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   evaluateConditions,
+  removeInvalidFilterItems,
   transformFilter
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/utils",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.71",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
@@ -11,10 +11,12 @@
     "dayjs": "^1.11.9",
     "deepmerge": "^4.2.2",
     "flat-to-nested": "^1.1.1",
+    "fs-extra": "^11.1.1",
     "graphlib": "^2.1.8",
     "handlebars": "^4.7.8",
+    "liquidjs": "^10.23.0",
     "multer": "^1.4.5-lts.2",
     "object-path": "^0.11.8"
   },
-  "gitHead": "cb012f93256f534472d3ae56e075839ca1675779"
+  "gitHead": "b6fc484eb698fa12fba02dd468a04e39079b1e79"
 }

package/plugin-symlink.js

@@ -1,107 +1,184 @@
-const { dirname, resolve } = require('path');
-const { realpath, readFile, writeFile, readdir, symlink, unlink, mkdir, stat } = require('fs').promises;
+const { resolve } = require('path');
+const fs = require('fs-extra');
 
+/**
+ * Recursively get plugin names from a directory
+ * @param {string} target - Target directory to scan
+ * @returns {Promise<string[]>} Array of plugin names
+ */
 async function getStoragePluginNames(target) {
   const plugins = [];
-  const items = await readdir(target);
+  const items = await fs.readdir(target);
+
   for (const item of items) {
+    const itemPath = resolve(target, item);
+
     if (item.startsWith('@')) {
-      const dirPath = resolve(target, item);
-      const s = await stat(dirPath);
-      if (!s.isDirectory()) {
+      const statResult = await fs.stat(itemPath);
+      if (!statResult.isDirectory()) {
         continue;
       }
-      const children = await getStoragePluginNames(dirPath);
-      plugins.push(
-        ...children.map((child) => {
-          return `${item}/${child}`;
-        }),
-      );
-    } else if (await fsExists(resolve(target, item, 'package.json'))) {
+      const children = await getStoragePluginNames(itemPath);
+      plugins.push(...children.map((child) => `${item}/${child}`));
+    } else if (await fs.pathExists(resolve(itemPath, 'package.json'))) {
       plugins.push(item);
     }
   }
+
   return plugins;
 }
 
-async function fsExists(path) {
+/**
+ * Ensure the organization directory exists for scoped packages
+ * @param {string} nodeModulesPath - Path to node_modules
+ * @param {string} pluginName - Plugin name (may be scoped)
+ * @returns {Promise<void>}
+ */
+async function ensureOrgDirectory(nodeModulesPath, pluginName) {
+  if (pluginName.startsWith('@')) {
+    const [orgName] = pluginName.split('/');
+    const orgPath = resolve(nodeModulesPath, orgName);
+    await fs.ensureDir(orgPath);
+  }
+}
+
+/**
+ * Check if a symlink already points to the correct target
+ * @param {string} linkPath - Path to the symlink
+ * @param {string} targetPath - Expected target path
+ * @returns {Promise<boolean>} True if symlink exists and points to target
+ */
+async function isSymlinkValid(linkPath, targetPath) {
   try {
-    await stat(path);
-    return true;
+    if (await fs.pathExists(linkPath)) {
+      const realPath = await fs.realpath(linkPath);
+      return realPath === targetPath;
+    }
   } catch (error) {
+    // If realpath fails, the symlink is invalid
     return false;
   }
+  return false;
+}
+
+/**
+ * Remove an existing symlink or file at the given path
+ * @param {string} linkPath - Path to remove
+ * @param {string} pluginName - Plugin name for error messages
+ * @param {string} pluginType - Type of plugin ('storage' or 'dev') for error messages
+ * @returns {Promise<void>}
+ */
+async function removeExistingLink(linkPath, pluginName, pluginType) {
+  try {
+    await fs.remove(linkPath);
+  } catch (error) {
+    // Ignore ENOENT errors (file doesn't exist)
+    if (error.code !== 'ENOENT') {
+      console.error(`Failed to remove existing symlink for ${pluginType} plugin: ${pluginName}`, error.message);
+    }
+  }
 }
 
-exports.fsExists = fsExists;
+/**
+ * Create a symlink for a plugin
+ * @param {string} pluginName - Name of the plugin
+ * @param {string} sourcePath - Source directory path
+ * @param {string} nodeModulesPath - Target node_modules path
+ * @param {string} pluginType - Type of plugin ('storage' or 'dev')
+ * @returns {Promise<void>}
+ */
+async function createPluginSymLink(pluginName, sourcePath, nodeModulesPath, pluginType) {
+  if (!nodeModulesPath) {
+    console.error(`NODE_MODULES_PATH is not set, cannot create symlink for ${pluginType} plugin: ${pluginName}`);
+    return;
+  }
+
+  const distClientIndexPath = resolve(sourcePath, pluginName, 'dist', 'client', 'index.js');
+
+  if (await fs.pathExists(distClientIndexPath)) {
+    // Update the mtime of distClientIndexPath
+    const now = new Date();
+    await fs.utimes(distClientIndexPath, now, now);
+  }
 
-async function createStoragePluginSymLink(pluginName) {
-  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
-  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
-  // const nodeModulesPath = resolve(process.cwd(), 'node_modules');
   try {
-    if (pluginName.startsWith('@')) {
-      const [orgName] = pluginName.split('/');
-      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
-        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
-      }
+    const targetPath = resolve(sourcePath, pluginName);
+
+    // Check if source exists
+    if (!(await fs.pathExists(targetPath))) {
+      console.warn(`Source path does not exist for ${pluginType} plugin: ${pluginName} at ${targetPath}`);
+      return;
     }
-    const link = resolve(nodeModulesPath, pluginName);
-    if (await fsExists(link)) {
-      await unlink(link);
+
+    // Ensure organization directory exists for scoped packages
+    await ensureOrgDirectory(nodeModulesPath, pluginName);
+
+    const linkPath = resolve(nodeModulesPath, pluginName);
+
+    // Check if symlink already points to the correct target
+    if (await isSymlinkValid(linkPath, targetPath)) {
+      return; // Symlink is already correct, no need to recreate
     }
-    await symlink(resolve(storagePluginsPath, pluginName), link, 'dir');
+
+    // Remove existing link if it exists
+    await removeExistingLink(linkPath, pluginName, pluginType);
+
+    // Create new symlink
+    await fs.symlink(targetPath, linkPath, 'dir');
   } catch (error) {
-    console.error(error);
+    console.error(`Failed to create symlink for ${pluginType} plugin: ${pluginName}`, error.message);
   }
 }
 
-exports.createStoragePluginSymLink = createStoragePluginSymLink;
+/**
+ * Create a symlink for a storage plugin
+ * @param {string} pluginName - Name of the plugin
+ * @returns {Promise<void>}
+ */
+async function createStoragePluginSymLink(pluginName) {
+  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
+  const nodeModulesPath = process.env.NODE_MODULES_PATH;
+  await createPluginSymLink(pluginName, storagePluginsPath, nodeModulesPath, 'storage');
+}
 
+/**
+ * Create symlinks for all storage plugins
+ * @returns {Promise<void>}
+ */
 async function createStoragePluginsSymlink() {
   const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
-  if (!(await fsExists(storagePluginsPath))) {
+  if (!(await fs.pathExists(storagePluginsPath))) {
     return;
   }
   const pluginNames = await getStoragePluginNames(storagePluginsPath);
   await Promise.all(pluginNames.map((pluginName) => createStoragePluginSymLink(pluginName)));
 }
 
-exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
-
+/**
+ * Create a symlink for a dev plugin
+ * @param {string} pluginName - Name of the plugin
+ * @returns {Promise<void>}
+ */
 async function createDevPluginSymLink(pluginName) {
   const packagePluginsPath = resolve(process.cwd(), 'packages/plugins');
-  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
-  try {
-    if (pluginName.startsWith('@')) {
-      const [orgName] = pluginName.split('/');
-      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
-        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
-      }
-    }
-    const link = resolve(nodeModulesPath, pluginName);
-    if (await fsExists(link)) {
-      const real = await realpath(link);
-      if (real === resolve(packagePluginsPath, pluginName)) {
-        return;
-      }
-      await unlink(link);
-    }
-    await symlink(resolve(packagePluginsPath, pluginName), link, 'dir');
-  } catch (error) {
-    console.error(error);
-  }
+  const nodeModulesPath = process.env.NODE_MODULES_PATH;
+  await createPluginSymLink(pluginName, packagePluginsPath, nodeModulesPath, 'dev');
 }
 
-exports.createDevPluginSymLink = createDevPluginSymLink;
-
+/**
+ * Create symlinks for all dev plugins
+ * @returns {Promise<void>}
+ */
 async function createDevPluginsSymlink() {
-  const storagePluginsPath = resolve(process.cwd(), 'packages/plugins');
-  if (!(await fsExists(storagePluginsPath))) {
+  const packagePluginsPath = resolve(process.cwd(), 'packages/plugins');
+  if (!(await fs.pathExists(packagePluginsPath))) {
     return;
   }
-  const pluginNames = await getStoragePluginNames(storagePluginsPath);
+  const pluginNames = await getStoragePluginNames(packagePluginsPath);
   await Promise.all(pluginNames.map((pluginName) => createDevPluginSymLink(pluginName)));
 }
 
+exports.createStoragePluginSymLink = createStoragePluginSymLink;
+exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
+exports.createDevPluginSymLink = createDevPluginSymLink;
 exports.createDevPluginsSymlink = createDevPluginsSymlink;