@nocobase/database 1.9.0-beta.4 → 1.9.0-beta.6

package/lib/cursor-builder.js

@@ -87,7 +87,7 @@ const _SmartCursorBuilder = class _SmartCursorBuilder {
         AND a.attnum = ANY(ix.indkey)
         AND t.relkind = 'r'
         AND n.nspname = current_schema()
-        AND t.relname = $1
+        AND t.relname = ?
       ORDER BY 
         i.relname, 
         array_position(ix.indkey, a.attnum)
@@ -145,8 +145,9 @@ const _SmartCursorBuilder = class _SmartCursorBuilder {
           isUnique: indexType < 3
         });
       }
-      const index = indexes.get(row.INDEX_NAME);
-      index.columns[row.SEQ_IN_INDEX - 1] = row.COLUMN_NAME;
+      const seqInIndex = dialect === "postgres" ? row.seq_in_index : row.SEQ_IN_INDEX;
+      const index = indexes.get(indexName);
+      index.columns[seqInIndex - 1] = columnName;
     }
     for (const index of indexes.values()) {
       if (index.isPrimary) {

package/lib/index.d.ts

@@ -41,3 +41,5 @@ export * from './view-collection';
 export { default as fieldTypeMap } from './view/field-type-map';
 export * from './view/view-inference';
 export * from './update-guard';
+export { default as operators } from './operators';
+export { filterIncludes, mergeIncludes } from './utils/filter-include';

package/lib/index.js

@@ -54,8 +54,11 @@ __export(src_exports, {
   ValidationErrorItem: () => import_sequelize.ValidationErrorItem,
   default: () => import_database.Database,
   fieldTypeMap: () => import_field_type_map.default,
+  filterIncludes: () => import_filter_include.filterIncludes,
   fn: () => import_sequelize.fn,
   literal: () => import_sequelize.literal,
+  mergeIncludes: () => import_filter_include.mergeIncludes,
+  operators: () => import_operators.default,
   snakeCase: () => import_utils.snakeCase,
   sqlParser: () => import_sql_parser.default,
   where: () => import_sequelize.where
@@ -96,6 +99,8 @@ __reExport(src_exports, require("./view-collection"), module.exports);
 var import_field_type_map = __toESM(require("./view/field-type-map"));
 __reExport(src_exports, require("./view/view-inference"), module.exports);
 __reExport(src_exports, require("./update-guard"), module.exports);
+var import_operators = __toESM(require("./operators"));
+var import_filter_include = require("./utils/filter-include");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseError,
@@ -114,8 +119,11 @@ __reExport(src_exports, require("./update-guard"), module.exports);
   ValidationError,
   ValidationErrorItem,
   fieldTypeMap,
+  filterIncludes,
   fn,
   literal,
+  mergeIncludes,
+  operators,
   snakeCase,
   sqlParser,
   where,

package/lib/magic-attribute-model.js

@@ -126,6 +126,9 @@ const _MagicAttributeModel = class _MagicAttributeModel extends import_model.Mod
       return this;
     }
     if (!options) options = {};
+    if (this.dataValues[this.magicAttribute] === null) {
+      this.dataValues[this.magicAttribute] = {};
+    }
     if (!options.raw) {
       originalValue = this.dataValues[key];
     }

package/lib/operators/empty.d.ts

@@ -6,8 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-declare const _default: {
-    $empty(_: any, ctx: any): any;
-    $notEmpty(_: any, ctx: any): any;
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/operators/index.d.ts

@@ -7,7 +7,6 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 declare const _default: {
-    $empty(_: any, ctx: any): any;
-    $notEmpty(_: any, ctx: any): any;
+    [x: string]: any;
 };
 export default _default;

package/lib/options-parser.js

@@ -150,7 +150,7 @@ const _OptionsParser = class _OptionsParser {
     if (defaultSortField && !((_b = this.options) == null ? void 0 : _b.group)) {
       defaultSortField = import_lodash.default.castArray(defaultSortField);
       for (const key of defaultSortField) {
-        if (!sort.includes(key)) {
+        if (!sort.includes(key) && !sort.includes(`-${key}`)) {
           sort.push(key);
         }
       }

package/lib/query-interface/postgres-query-interface.js

@@ -111,7 +111,14 @@ const _PostgresQueryInterface = class _PostgresQueryInterface extends import_que
     return results[0]["exists"];
   }
   async listViews() {
-    const sql = `
+    var _a;
+    const targetSchema = ((_a = this.db.options) == null ? void 0 : _a.schema) || "public";
+    const sql = targetSchema ? `
+      SELECT viewname as name, definition, schemaname as schema
+      FROM pg_views
+      WHERE schemaname = '${targetSchema}'
+      ORDER BY viewname;
+    ` : `
       SELECT viewname as name, definition, schemaname as schema
       FROM pg_views
       WHERE schemaname NOT IN ('pg_catalog', 'information_schema')

package/lib/repository.d.ts

@@ -154,6 +154,8 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      * return count by filter
      */
     count(countOptions?: CountOptions): Promise<number>;
+    getEstimatedRowCount(): Promise<number>;
+    private getOracleSchema;
     aggregate(options: AggregateOptions & {
         optionsTransformer?: (options: any) => any;
     }): Promise<any>;

package/lib/repository.js

@@ -163,6 +163,83 @@ const _Repository = class _Repository {
       transaction: transaction2
     });
   }
+  async getEstimatedRowCount() {
+    var _a, _b, _c, _d;
+    if (import_lodash2.default.isFunction(this.collection["isSql"]) && this.collection["isSql"]()) {
+      return 0;
+    }
+    if (import_lodash2.default.isFunction(this.collection["isView"]) && this.collection["isView"]()) {
+      return 0;
+    }
+    const tableName = this.collection.tableName();
+    try {
+      if (this.database.isMySQLCompatibleDialect()) {
+        await this.database.sequelize.query(`ANALYZE TABLE ${this.collection.getTableNameWithSchema()}`);
+        const results = await this.database.sequelize.query(
+          `
+        SELECT table_rows FROM information_schema.tables
+        WHERE table_schema = DATABASE()
+          AND table_name = ?
+      `,
+          { replacements: [tableName], type: import_sequelize.QueryTypes.SELECT }
+        );
+        return Number(((_a = results == null ? void 0 : results[0]) == null ? void 0 : _a.table_rows) ?? 0);
+      }
+      if (this.database.isPostgresCompatibleDialect()) {
+        await this.database.sequelize.query(`ANALYZE ${this.collection.getTableNameWithSchema()}`);
+        const results = await this.database.sequelize.query(
+          `
+        SELECT reltuples::BIGINT AS estimate
+        FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE c.relname = ? AND n.nspname = current_schema();
+      `,
+          { replacements: [tableName], type: import_sequelize.QueryTypes.SELECT }
+        );
+        return Number(((_b = results == null ? void 0 : results[0]) == null ? void 0 : _b.estimate) ?? 0);
+      }
+      if (this.database.sequelize.getDialect() === "mssql") {
+        const results = await this.database.sequelize.query(
+          `
+        SELECT SUM(row_count) AS estimate
+        FROM sys.dm_db_partition_stats
+        WHERE object_id = OBJECT_ID(?) AND (index_id = 0 OR index_id = 1)
+      `,
+          { replacements: [tableName], type: import_sequelize.QueryTypes.SELECT }
+        );
+        return Number(((_c = results == null ? void 0 : results[0]) == null ? void 0 : _c.estimate) ?? 0);
+      }
+      if (this.database.sequelize.getDialect() === "oracle") {
+        const tableName2 = this.collection.name.toUpperCase();
+        const schemaName = (await this.getOracleSchema()).toUpperCase();
+        await this.database.sequelize.query(`BEGIN DBMS_STATS.GATHER_TABLE_STATS(:schema, :table); END;`, {
+          replacements: { schema: schemaName, table: tableName2 },
+          type: import_sequelize.QueryTypes.RAW
+        });
+        const results = await this.database.sequelize.query(
+          `
+      SELECT NUM_ROWS AS "estimate"
+      FROM ALL_TABLES
+      WHERE TABLE_NAME = :table AND OWNER = :schema
+      `,
+          {
+            replacements: { table: tableName2, schema: schemaName },
+            type: import_sequelize.QueryTypes.SELECT
+          }
+        );
+        return Number(((_d = results == null ? void 0 : results[0]) == null ? void 0 : _d.estimate) ?? 0);
+      }
+    } catch (error) {
+      this.database.logger.error(`Failed to get estimated row count for ${this.collection.name}:`, error);
+      return 0;
+    }
+    return 0;
+  }
+  async getOracleSchema() {
+    const [result] = await this.database.sequelize.query(`SELECT USER FROM DUAL`, {
+      type: import_sequelize.QueryTypes.SELECT
+    });
+    return (result == null ? void 0 : result["USER"]) ?? "";
+  }
   async aggregate(options) {
     var _a;
     const { method, field } = options;

package/lib/utils/filter-include.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+/**
+ * Merge a flat list of include descriptors by association (alias) key.
+ * - Nodes with the same association are merged into one.
+ * - `required` is OR-ed (true if any source is true).
+ * - Child includes are recursively merged with the same rules.
+ * - Empty `include` arrays are removed to keep the payload minimal.
+ *
+ * Notes:
+ * - Association keys are normalized via snake_case to ensure consistent merging.
+ * - This function is idempotent and order-insensitive for equivalent input sets.
+ *
+ * Usage example (input and output):
+ *
+ *   const includesA = [
+ *     { association: 'posts', required: true, include: [{ association: 'comments' }] },
+ *     { association: 'profile' },
+ *   ];
+ *
+ *   const includesB = [
+ *     { association: 'posts', include: [
+ *         { association: 'comments', required: true },
+ *         { association: 'tags' },
+ *       ]
+ *     },
+ *     { association: 'roles', required: true },
+ *   ];
+ *
+ *   const merged = mergeIncludes([...includesA, ...includesB]);
+ *
+ *   Result:
+ *   [
+ *     {
+ *       association: 'posts',
+ *       required: true,
+ *       include: [
+ *         { association: 'comments', required: true },
+ *         { association: 'tags' },
+ *       ],
+ *     },
+ *     { association: 'profile' },
+ *     { association: 'roles', required: true },
+ *   ]
+ */
+export declare const mergeIncludes: (includes?: any[]) => any[];
+export declare const filterIncludes: (where: any, includes: any, options: {
+    underscored: boolean;
+}) => any[];

package/lib/utils/filter-include.js

@@ -0,0 +1,118 @@
+/**
+ * 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 filter_include_exports = {};
+__export(filter_include_exports, {
+  filterIncludes: () => filterIncludes,
+  mergeIncludes: () => mergeIncludes
+});
+module.exports = __toCommonJS(filter_include_exports);
+var import_utils = require("../utils");
+const collectAssociationPathsFromWhere = /* @__PURE__ */ __name((where) => {
+  const aliasPaths = /* @__PURE__ */ new Set();
+  const traverse = /* @__PURE__ */ __name((value) => {
+    if (value == null) return;
+    if (Array.isArray(value)) {
+      for (const item of value) traverse(item);
+      return;
+    }
+    if (typeof value === "object") {
+      for (const [rawKey, child] of Object.entries(value)) {
+        if (typeof rawKey === "string" && rawKey.startsWith("$") && rawKey.endsWith("$")) {
+          const inner = rawKey.slice(1, -1);
+          const segments = inner.split(".");
+          if (segments.length > 1) {
+            aliasPaths.add(segments.slice(0, -1).join("."));
+          }
+        }
+        traverse(child);
+      }
+      for (const sym of Object.getOwnPropertySymbols(value)) {
+        traverse(value[sym]);
+      }
+    }
+  }, "traverse");
+  traverse(where);
+  return Array.from(aliasPaths);
+}, "collectAssociationPathsFromWhere");
+const pruneIncludeTreeByPaths = /* @__PURE__ */ __name((includes = [], requiredPathsRaw, options) => {
+  const normalizedPaths = options.underscored ? requiredPathsRaw.map(
+    (p) => p.split(".").map((s) => (0, import_utils.snakeCase)(s)).join(".")
+  ) : requiredPathsRaw;
+  if (!(includes == null ? void 0 : includes.length) || !(normalizedPaths == null ? void 0 : normalizedPaths.length)) return [];
+  const pruned = [];
+  for (const inc of includes) {
+    const association = inc == null ? void 0 : inc.association;
+    if (!association) continue;
+    const assocKey = options.underscored ? (0, import_utils.snakeCase)(String(association)) : String(association);
+    const matched = normalizedPaths.filter((p) => p === assocKey || p.startsWith(assocKey + "."));
+    if (!matched.length) continue;
+    const childRemainders = matched.map((p) => p === assocKey ? null : p.slice(assocKey.length + 1)).filter(Boolean);
+    const children = pruneIncludeTreeByPaths(inc.include ?? [], childRemainders, options);
+    const copy = { ...inc };
+    if (children.length) {
+      copy.include = children;
+    } else if ("include" in copy) {
+      delete copy.include;
+    }
+    pruned.push(copy);
+  }
+  return pruned;
+}, "pruneIncludeTreeByPaths");
+const mergeIncludes = /* @__PURE__ */ __name((includes = []) => {
+  const byAssociation = /* @__PURE__ */ new Map();
+  const mergeAll = /* @__PURE__ */ __name((list = []) => {
+    for (const inc of list) {
+      const association = inc == null ? void 0 : inc.association;
+      if (!association) continue;
+      const key = (0, import_utils.snakeCase)(String(association));
+      if (!byAssociation.has(key)) {
+        byAssociation.set(key, { ...inc, include: void 0 });
+      }
+      const target = byAssociation.get(key);
+      if (inc.required) target.required = true;
+      const mergedChildren = mergeIncludes([...target.include ?? [], ...inc.include ?? []]);
+      if (mergedChildren.length) {
+        target.include = mergedChildren;
+      } else if ("include" in target) {
+        delete target.include;
+      }
+    }
+  }, "mergeAll");
+  mergeAll(includes);
+  return Array.from(byAssociation.values());
+}, "mergeIncludes");
+const filterIncludes = /* @__PURE__ */ __name((where, includes, options) => {
+  const path = collectAssociationPathsFromWhere(where);
+  const result = pruneIncludeTreeByPaths(includes, path, options);
+  return result;
+}, "filterIncludes");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterIncludes,
+  mergeIncludes
+});

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "1.9.0-beta.4",
+  "version": "1.9.0-beta.6",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "1.9.0-beta.4",
-    "@nocobase/utils": "1.9.0-beta.4",
+    "@nocobase/logger": "1.9.0-beta.6",
+    "@nocobase/utils": "1.9.0-beta.6",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -38,5 +38,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "0276aa12d87f82c73d62a9712134fe363e2c772a"
+  "gitHead": "ada5e359a91135cb9baf605c04c5c380f067a046"
 }