@nocobase/database 1.9.0-beta.1 → 1.9.0-beta.11

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

@@ -110,8 +110,15 @@ const _PostgresQueryInterface = class _PostgresQueryInterface extends import_que
     const results = await this.db.sequelize.query(sql, { type: "SELECT", transaction });
     return results[0]["exists"];
   }
-  async listViews() {
-    const sql = `
+  async listViews(options) {
+    var _a;
+    const targetSchema = (options == null ? void 0 : options.schema) || ((_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/query-interface/query-interface.d.ts

@@ -18,7 +18,9 @@ export default abstract class QueryInterface {
     sequelizeQueryInterface: SequelizeQueryInterface;
     protected constructor(db: Database);
     abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
-    abstract listViews(): any;
+    abstract listViews(options?: {
+        schema?: string;
+    }): any;
     abstract viewDef(viewName: string): Promise<string>;
     abstract viewColumnUsage(options: {
         viewName: string;

package/lib/relation-repository/belongs-to-many-repository.js

@@ -86,6 +86,11 @@ const _BelongsToManyRepository = class _BelongsToManyRepository extends import_m
       through: values[this.throughName()],
       transaction: transaction2
     };
+    this.collection.validate({
+      values,
+      operation: "create",
+      context: options.context
+    });
     const instance = await sourceModel[createAccessor](values, createOptions);
     await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });
     return instance;

package/lib/relation-repository/relation-repository.js

@@ -178,6 +178,7 @@ const _RelationRepository = class _RelationRepository {
     const values = options.values;
     const transaction2 = await this.getTransaction(options);
     const sourceModel = await this.getSourceModel(transaction2);
+    this.collection.validate({ values, context: options.context, operation: "create" });
     const instance = await sourceModel[createAccessor](guard.sanitize(options.values), { ...options, transaction: transaction2 });
     await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });
     if (options.hooks !== false) {

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>;
@@ -207,6 +209,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      */
     firstOrCreate(options: FirstOrCreateOptions): Promise<any>;
     updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    private validate;
     /**
      * Save instance to database
      *

package/lib/repository.js

@@ -72,6 +72,7 @@ var import_hasone_repository = require("./relation-repository/hasone-repository"
 var import_update_associations = require("./update-associations");
 var import_update_guard = require("./update-guard");
 var import_filter_utils = require("./utils/filter-utils");
+var import_utils2 = require("./utils");
 var import_sequelize2 = require("sequelize");
 const debug = require("debug")("noco-database");
 const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
@@ -134,7 +135,6 @@ const _Repository = class _Repository {
    * return count by filter
    */
   async count(countOptions) {
-    var _a;
     let options = countOptions ? import_lodash.default.clone(countOptions) : {};
     const transaction2 = await this.getTransaction(options);
     if (countOptions == null ? void 0 : countOptions.filter) {
@@ -155,7 +155,9 @@ const _Repository = class _Repository {
       ...options,
       distinct: Boolean(this.collection.model.primaryKeyAttribute) && !this.collection.isMultiFilterTargetKey()
     };
-    if (((_a = queryOptions.include) == null ? void 0 : _a.length) === 0) {
+    if (Array.isArray(queryOptions.include) && queryOptions.include.length > 0) {
+      queryOptions.include = (0, import_utils2.processIncludes)(queryOptions.include, this.collection.model);
+    } else {
       delete queryOptions.include;
     }
     return await this.collection.model.count({
@@ -163,6 +165,81 @@ 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()) {
+        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[this.database.inDialect("mysql") ? "TABLE_ROWS" : "table_rows"]) ?? 0);
+      }
+      if (this.database.isPostgresCompatibleDialect()) {
+        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 = ?;
+      `,
+          { replacements: [tableName, this.collection.collectionSchema()], type: import_sequelize.QueryTypes.SELECT, logging: true }
+        );
+        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;
@@ -268,6 +345,9 @@ const _Repository = class _Repository {
       subQuery: false,
       ...this.buildQueryOptions(options)
     };
+    if (!import_lodash2.default.isUndefined(opts.limit)) {
+      opts.limit = Number(opts.limit);
+    }
     let rows;
     if (opts.include && opts.include.length > 0) {
       const eagerLoadingTree = import_eager_loading_tree.EagerLoadingTree.buildFromSequelizeOptions({
@@ -356,6 +436,9 @@ const _Repository = class _Repository {
     }
     return this.create({ values, transaction: transaction2, context, ...rest });
   }
+  validate(options) {
+    this.collection.validate(options);
+  }
   async create(options) {
     if (Array.isArray(options.values)) {
       return this.createMany({
@@ -370,6 +453,7 @@ const _Repository = class _Repository {
       underscored: this.collection.options.underscored
     });
     const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
+    this.validate({ values, context: options.context, operation: "create" });
     const instance = await this.model.create(values, {
       ...options,
       transaction: transaction2
@@ -414,6 +498,7 @@ const _Repository = class _Repository {
     const transaction2 = await this.getTransaction(options);
     const guard = import_update_guard.UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
     const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
+    this.validate({ values, context: options.context, operation: "update" });
     if (options.individualHooks === false) {
       const { model: Model2 } = this.collection;
       const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;

package/lib/update-associations.js

@@ -79,6 +79,11 @@ async function updateModelByValues(instance, values, options) {
     guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
     values = guard.sanitize(values);
   }
+  instance.constructor.collection.validate({
+    values,
+    operation: "update",
+    context: options == null ? void 0 : options.context
+  });
   await instance.update(values, options);
   await updateAssociations(instance, values, options);
 }
@@ -266,6 +271,11 @@ async function updateSingleAssociation(model, key, value, options = {}) {
       return true;
     }
   }
+  association.target.collection.validate({
+    values: value,
+    context: options.context,
+    operation: "create"
+  });
   const instance = await model[createAccessor](value, { context, transaction });
   await updateAssociations(instance, value, {
     ...options,
@@ -356,6 +366,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
       throw new Error(`${targetKey} field value is empty`);
     }
     if ((0, import_utils.isUndefinedOrNull)(item[targetKey])) {
+      association.target.collection.validate({
+        values: item,
+        context: options.context,
+        operation: "create"
+      });
       const instance = await model[createAccessor](item, accessorOptions);
       await updateAssociations(instance, item, {
         ...options,
@@ -373,6 +388,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
         transaction
       });
       if (!instance) {
+        association.target.collection.validate({
+          values: item,
+          context: options.context,
+          operation: "create"
+        });
         instance = await model[createAccessor](item, accessorOptions);
         await updateAssociations(instance, item, {
           ...options,
@@ -392,6 +412,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
         if (association.associationType === "HasMany") {
           delete item[association.foreignKey];
         }
+        association.target.collection.validate({
+          values: item,
+          context: options.context,
+          operation: "update"
+        });
         await instance.update(item, { ...options, transaction });
       }
       await updateAssociations(instance, item, {

package/lib/utils/field-validation.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { AnySchema } from 'joi';
+import { ValidationOptions } from '../fields';
+export declare function buildJoiSchema(validation: ValidationOptions, options: {
+    label?: string;
+    value: string;
+}): AnySchema;
+export declare function getJoiErrorMessage(t: Function): {
+    'string.base': any;
+    'string.empty': any;
+    'string.min': any;
+    'string.max': any;
+    'string.length': any;
+    'string.alphanum': any;
+    'string.token': any;
+    'string.regex': any;
+    'string.email': any;
+    'string.uri': any;
+    'string.uriCustomScheme': any;
+    'string.isoDate': any;
+    'string.guid': any;
+    'string.hex': any;
+    'string.hostname': any;
+    'string.lowercase': any;
+    'string.uppercase': any;
+    'string.trim': any;
+    'string.creditCard': any;
+    'string.pattern.base': any;
+    'string.pattern.name': any;
+    'string.pattern.invert.base': any;
+    'string.pattern.invert.name': any;
+    'any.required': any;
+    'number.base': any;
+    'number.min': any;
+    'number.max': any;
+    'number.less': any;
+    'number.greater': any;
+    'number.float': any;
+    'number.integer': any;
+    'number.negative': any;
+    'number.positive': any;
+    'number.precision': any;
+    'number.multiple': any;
+    'number.port': any;
+    'number.unsafe': any;
+    'date.base': any;
+    'date.format': any;
+    'date.greater': any;
+    'date.less': any;
+    'date.max': any;
+    'date.min': any;
+};

package/lib/utils/field-validation.js

@@ -0,0 +1,143 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_validation_exports = {};
+__export(field_validation_exports, {
+  buildJoiSchema: () => buildJoiSchema,
+  getJoiErrorMessage: () => getJoiErrorMessage
+});
+module.exports = __toCommonJS(field_validation_exports);
+var import_joi = __toESM(require("joi"));
+var import_lodash = __toESM(require("lodash"));
+function buildJoiSchema(validation, options) {
+  const { type, rules } = validation;
+  const { label, value } = options;
+  if (!type || typeof type !== "string" || !(type in import_joi.default)) {
+    throw new Error(`Invalid validation type: "${type}". Type must be a valid Joi schema type.`);
+  }
+  let schema = import_joi.default[type]();
+  const isRequired = rules.some((rule) => rule.name === "required");
+  if (isRequired) {
+    schema = schema.empty(null);
+  } else {
+    schema = schema.allow(null, "");
+    if ([null, ""].includes(value)) return schema;
+  }
+  if (rules) {
+    rules.forEach((rule) => {
+      if (!import_lodash.default.isEmpty(rule.args)) {
+        if (rule.name === "pattern" && !import_lodash.default.isRegExp(rule.args.regex)) {
+          const lastSlash = rule.args.regex.lastIndexOf("/");
+          const isRegExpStr = rule.args.regex.startsWith("/") && lastSlash > 0;
+          if (isRegExpStr) {
+            rule.args.regex = rule.args.regex.slice(1, lastSlash);
+          }
+          rule.args.regex = new RegExp(rule.args.regex);
+        }
+        schema = rule.paramsType === "object" ? schema[rule.name](rule.args) : schema[rule.name](...Object.values(rule.args));
+      } else {
+        schema = schema[rule.name]();
+      }
+    });
+  }
+  if (label) {
+    schema = schema.label(label);
+  }
+  return schema;
+}
+__name(buildJoiSchema, "buildJoiSchema");
+function getJoiErrorMessage(t) {
+  const tOptions = { ns: "client" };
+  const JoiErrorMessages = {
+    "string.base": t("{{#label}} must be a string", tOptions),
+    "string.empty": t("{{#label}} is not allowed to be empty", tOptions),
+    "string.min": t("{{#label}} length must be at least {{#limit}} characters long", tOptions),
+    "string.max": t("{{#label}} length must be less than or equal to {{#limit}} characters long", tOptions),
+    "string.length": t("{{#label}} length must be {{#limit}} characters long", tOptions),
+    "string.alphanum": t("{{#label}} must only contain alpha-numeric characters", tOptions),
+    "string.token": t("{{#label}} must only contain alpha-numeric and underscore characters", tOptions),
+    "string.regex": t("{{#label}} with value {{#value}} fails to match the required pattern", tOptions),
+    "string.email": t("{{#label}} email address doesn\u2019t meet the required format", tOptions),
+    "string.uri": t("{{#label}} must be a valid uri", tOptions),
+    "string.uriCustomScheme": t(
+      "{{#label}} must be a valid uri with a scheme matching the {{#scheme}} pattern",
+      tOptions
+    ),
+    "string.isoDate": t("{{#label}} must be a valid ISO 8601 date", tOptions),
+    "string.guid": t("{{#label}} must be a valid UUID", tOptions),
+    "string.hex": t("{{#label}} must only contain hexadecimal characters", tOptions),
+    "string.hostname": t("{{#label}} must be a valid hostname", tOptions),
+    "string.lowercase": t("{{#label}} must only contain lowercase characters", tOptions),
+    "string.uppercase": t("{{#label}} must only contain uppercase characters", tOptions),
+    "string.trim": t("{{#label}} must not have leading or trailing whitespace", tOptions),
+    "string.creditCard": t("{{#label}} must be a credit card", tOptions),
+    "string.pattern.base": t('{{#label}} with value "{{#value}}" fails to match the required pattern', tOptions),
+    "string.pattern.name": t('{{#label}} with value "{{#value}}" fails to match the {{#name}} pattern', tOptions),
+    "string.pattern.invert.base": t('{{#label}} with value "{{#value}}" matches the inverted pattern', tOptions),
+    "string.pattern.invert.name": t(
+      '{{#label}} with value "{{#value}}" matches the inverted {{#name}} pattern',
+      tOptions
+    ),
+    "any.required": t("{{#label}} is required", tOptions),
+    "number.base": t("{{#label}} must be a number", tOptions),
+    "number.min": t("{{#label}} must be greater than or equal to {{#limit}}", tOptions),
+    "number.max": t("{{#label}} must be less than or equal to {{#limit}}", tOptions),
+    "number.less": t("{{#label}} must be less than {{#limit}}", tOptions),
+    "number.greater": t("{{#label}} must be greater than {{#limit}}", tOptions),
+    "number.float": t("{{#label}} must be a float or double", tOptions),
+    "number.integer": t("{{#label}} must be an integer", tOptions),
+    "number.negative": t("{{#label}} must be a negative number", tOptions),
+    "number.positive": t("{{#label}} must be a positive number", tOptions),
+    "number.precision": t("{{#label}} must not have more than {{#limit}} decimal places", tOptions),
+    "number.multiple": t("{{#label}} must be a multiple of {{#multiple}}", tOptions),
+    "number.port": t("{{#label}} must be a valid port", tOptions),
+    "number.unsafe": t("{{#label}} must be a safe number", tOptions),
+    "date.base": t("{{#label}} must be a valid date", tOptions),
+    "date.format": t("{{#label}} must be in {{#format}} format", tOptions),
+    "date.greater": t("{{#label}} must be greater than {{#limit}}", tOptions),
+    "date.less": t("{{#label}} must be less than {{#limit}}", tOptions),
+    "date.max": t("{{#label}} must be less than or equal to {{#limit}}", tOptions),
+    "date.min": t("{{#label}} must be greater than or equal to {{#limit}}", tOptions)
+  };
+  return JoiErrorMessages;
+}
+__name(getJoiErrorMessage, "getJoiErrorMessage");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildJoiSchema,
+  getJoiErrorMessage
+});

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/lib/utils.d.ts

@@ -16,3 +16,4 @@ export declare function percent2float(value: string): number;
 export declare function isUndefinedOrNull(value: any): boolean;
 export declare function isStringOrNumber(value: any): boolean;
 export declare function getKeysByPrefix(keys: string[], prefix: string): string[];
+export declare function processIncludes(includes: any[], model: any, parentAs?: string): any[];