@nocobase/database 2.1.0-alpha.12 → 2.1.0-alpha.14

package/lib/fields/relation-field.js

@@ -43,7 +43,7 @@ const _RelationField = class _RelationField extends import_field.Field {
     return this.options.foreignKey;
   }
   get sourceKey() {
-    return this.options.sourceKey || this.collection.model.primaryKeyAttribute;
+    return this.options.sourceKey || this.collection.filterTargetKey;
   }
   get targetKey() {
     return this.options.targetKey || this.TargetModel.primaryKeyAttribute;

package/lib/index.d.ts

@@ -32,6 +32,9 @@ export * from './relation-repository/hasmany-repository';
 export * from './relation-repository/hasone-repository';
 export * from './relation-repository/multiple-relation-repository';
 export * from './relation-repository/single-relation-repository';
+export * from './query/builder';
+export * from './query/formatter';
+export * from './query/types';
 export * from './repository';
 export * from './relation-repository/relation-repository';
 export { default as sqlParser, SQLParserTypes } from './sql-parser';

package/lib/index.js

@@ -93,6 +93,9 @@ __reExport(src_exports, require("./relation-repository/hasmany-repository"), mod
 __reExport(src_exports, require("./relation-repository/hasone-repository"), module.exports);
 __reExport(src_exports, require("./relation-repository/multiple-relation-repository"), module.exports);
 __reExport(src_exports, require("./relation-repository/single-relation-repository"), module.exports);
+__reExport(src_exports, require("./query/builder"), module.exports);
+__reExport(src_exports, require("./query/formatter"), module.exports);
+__reExport(src_exports, require("./query/types"), module.exports);
 __reExport(src_exports, require("./repository"), module.exports);
 __reExport(src_exports, require("./relation-repository/relation-repository"), module.exports);
 var import_sql_parser = __toESM(require("./sql-parser"));
@@ -157,6 +160,9 @@ var import_filter_include = require("./utils/filter-include");
   ...require("./relation-repository/hasone-repository"),
   ...require("./relation-repository/multiple-relation-repository"),
   ...require("./relation-repository/single-relation-repository"),
+  ...require("./query/builder"),
+  ...require("./query/formatter"),
+  ...require("./query/types"),
   ...require("./repository"),
   ...require("./relation-repository/relation-repository"),
   ...require("./update-associations"),

package/lib/query/builder.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.
+ */
+import { FindOptions as SequelizeFindOptions } from 'sequelize';
+import { Collection } from '../collection';
+import { Database } from '../database';
+import { QueryOptions } from './types';
+export declare function buildQuery(database: Database, collection: Collection, options?: QueryOptions): {
+    queryOptions: SequelizeFindOptions<any>;
+    fieldMap: Record<string, any>;
+};
+export declare function normalizeQueryResult(data: any[], fieldMap: Record<string, any>): any[];

package/lib/query/builder.js

@@ -0,0 +1,254 @@
+/**
+ * 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 builder_exports = {};
+__export(builder_exports, {
+  buildQuery: () => buildQuery,
+  normalizeQueryResult: () => normalizeQueryResult
+});
+module.exports = __toCommonJS(builder_exports);
+var import_filter_parser = __toESM(require("../filter-parser"));
+var import_formatter = require("./formatter");
+var import_mysql = require("./formatters/mysql");
+var import_oracle = require("./formatters/oracle");
+var import_postgres = require("./formatters/postgres");
+var import_sqlite = require("./formatters/sqlite");
+var import_having = require("./having");
+const ALLOWED_AGG_FUNCS = ["sum", "count", "avg", "min", "max"];
+function createQueryFormatter(database) {
+  switch (database.sequelize.getDialect()) {
+    case "sqlite":
+      return new import_sqlite.SQLiteQueryFormatter(database.sequelize);
+    case "postgres":
+      return new import_postgres.PostgresQueryFormatter(database.sequelize);
+    case "mysql":
+    case "mariadb":
+      return new import_mysql.MySQLQueryFormatter(database.sequelize);
+    case "oracle":
+      return new import_oracle.OracleQueryFormatter(database.sequelize);
+    default:
+      return new class extends import_formatter.QueryFormatter {
+        formatDate(field, _format, _timezone) {
+          return field;
+        }
+        formatUnixTimestamp(field, _format, _accuracy, _timezone) {
+          return this.sequelize.col(field);
+        }
+      }(database.sequelize);
+  }
+}
+__name(createQueryFormatter, "createQueryFormatter");
+function parseSelectedField(database, collection, selected) {
+  var _a, _b, _c, _d, _e;
+  const collectionName = collection.name;
+  const fields = collection.fields;
+  let target;
+  let name;
+  const fieldPath = Array.isArray(selected.field) ? selected.field : selected.field.split(".").filter(Boolean);
+  if (fieldPath.length === 1) {
+    name = fieldPath[0];
+  } else {
+    [target, name] = fieldPath;
+  }
+  const rawAttributes = collection.model.getAttributes();
+  let field = ((_a = rawAttributes[name]) == null ? void 0 : _a.field) || name;
+  let fieldType = (_b = fields.get(name)) == null ? void 0 : _b.type;
+  let fieldOptions = (_c = fields.get(name)) == null ? void 0 : _c.options;
+  if (target) {
+    const targetField = fields.get(target);
+    const targetCollection = database.getCollection(targetField.target);
+    const targetFields = targetCollection.fields;
+    fieldType = (_d = targetFields.get(name)) == null ? void 0 : _d.type;
+    fieldOptions = (_e = targetFields.get(name)) == null ? void 0 : _e.options;
+    field = `${target}.${field}`;
+    name = `${target}.${name}`;
+  } else {
+    field = `${collectionName}.${field}`;
+  }
+  return {
+    ...selected,
+    field,
+    name,
+    type: fieldType,
+    options: fieldOptions,
+    alias: selected.alias || name,
+    target
+  };
+}
+__name(parseSelectedField, "parseSelectedField");
+function buildQuery(database, collection, options = {}) {
+  var _a;
+  const sequelize = database.sequelize;
+  const formatter = createQueryFormatter(database);
+  const measures = (options.measures || []).map((measure) => parseSelectedField(database, collection, measure));
+  const dimensions = (options.dimensions || []).map((dimension) => parseSelectedField(database, collection, dimension));
+  const orders = (options.orders || []).map((order2) => parseSelectedField(database, collection, order2));
+  const models = {};
+  [...measures, ...dimensions, ...orders].forEach((item) => {
+    var _a2;
+    if (item.target && !models[item.target]) {
+      models[item.target] = { type: (_a2 = collection.fields.get(item.target)) == null ? void 0 : _a2.type };
+    }
+  });
+  const include = Object.entries(models).map(([target, { type }]) => {
+    let includeOptions = {
+      association: target,
+      attributes: []
+    };
+    if (type === "belongsToMany") {
+      includeOptions.through = { attributes: [] };
+    }
+    if (type === "belongsToArray") {
+      const association = collection.model.associations[target];
+      if (association) {
+        includeOptions = {
+          ...includeOptions,
+          ...association.generateInclude()
+        };
+      }
+    }
+    return includeOptions;
+  });
+  const filterParser = new import_filter_parser.default(options.filter, { collection });
+  const { where, include: filterInclude } = filterParser.toSequelizeParams();
+  if (filterInclude) {
+    const stack = [...filterInclude];
+    while (stack.length) {
+      const item = stack.pop();
+      const parentCollection = database.getCollection(item.parentCollection || collection.name);
+      const field = parentCollection.fields.get(item.association);
+      if ((field == null ? void 0 : field.type) === "belongsToMany") {
+        item.through = { attributes: [] };
+      }
+      if ((field == null ? void 0 : field.target) && ((_a = item.include) == null ? void 0 : _a.length)) {
+        for (const child of item.include) {
+          child.parentCollection = field.target;
+          stack.push(child);
+        }
+      }
+    }
+  }
+  let hasAgg = false;
+  const attributes = [];
+  const fieldMap = {};
+  measures.forEach((measure) => {
+    const { field, aggregation, alias, distinct } = measure;
+    const col = sequelize.col(field);
+    const attribute = [];
+    if (aggregation) {
+      if (!ALLOWED_AGG_FUNCS.includes(aggregation)) {
+        throw new Error(`Invalid aggregation function: ${aggregation}`);
+      }
+      hasAgg = true;
+      attribute.push(sequelize.fn(aggregation, distinct ? sequelize.fn("DISTINCT", col) : col));
+    } else {
+      attribute.push(col);
+    }
+    if (alias) {
+      attribute.push(alias);
+    }
+    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
+    fieldMap[alias || field] = measure;
+  });
+  const group = [];
+  dimensions.forEach((dimension) => {
+    const { field, format, alias, type, options: fieldOptions } = dimension;
+    const attribute = [];
+    if (format) {
+      attribute.push(formatter.format({ type, field, format, timezone: options.timezone, fieldOptions }));
+    } else {
+      attribute.push(sequelize.col(field));
+    }
+    if (alias) {
+      attribute.push(alias);
+    }
+    attributes.push(attribute.length > 1 ? attribute : attribute[0]);
+    if (hasAgg) {
+      group.push(attribute[0]);
+    }
+    fieldMap[alias || field] = dimension;
+  });
+  const order = orders.map((item) => {
+    const alias = sequelize.getQueryInterface().quoteIdentifier(item.alias);
+    const name = hasAgg ? sequelize.literal(alias) : sequelize.col(item.field);
+    let sort = (item.order || "ASC").toUpperCase();
+    if (item.nulls === "first") {
+      sort += " NULLS FIRST";
+    }
+    if (item.nulls === "last") {
+      sort += " NULLS LAST";
+    }
+    return [name, sort];
+  });
+  const queryOptions = {
+    where,
+    having: (0, import_having.buildHaving)(database, formatter, fieldMap, options.having, options.timezone),
+    attributes,
+    include: [...include, ...filterInclude || []],
+    group,
+    order,
+    subQuery: false,
+    raw: true
+  };
+  if (!hasAgg || dimensions.length) {
+    queryOptions.limit = options.limit || 2e3;
+    queryOptions.offset = options.offset || 0;
+  }
+  return { queryOptions, fieldMap };
+}
+__name(buildQuery, "buildQuery");
+function normalizeQueryResult(data, fieldMap) {
+  return data.map((record) => {
+    Object.entries(record).forEach(([key, value]) => {
+      var _a;
+      if (value === null || value === void 0) {
+        return;
+      }
+      const type = (_a = fieldMap[key]) == null ? void 0 : _a.type;
+      if (["bigInt", "integer", "float", "double", "decimal"].includes(type)) {
+        record[key] = Number(value);
+      }
+    });
+    return record;
+  });
+}
+__name(normalizeQueryResult, "normalizeQueryResult");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildQuery,
+  normalizeQueryResult
+});

package/lib/query/formatter.d.ts

@@ -0,0 +1,20 @@
+import { Sequelize } from 'sequelize';
+export type Col = ReturnType<typeof Sequelize.col>;
+export type Literal = ReturnType<typeof Sequelize.literal>;
+export type Fn = ReturnType<typeof Sequelize.fn>;
+export declare abstract class QueryFormatter {
+    sequelize: Sequelize;
+    constructor(sequelize: Sequelize);
+    abstract formatDate(field: Col, format: string, timezone?: string): Fn | Col;
+    abstract formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): Fn | Literal | Col;
+    convertFormat(format: string): string;
+    protected getTimezoneByOffset(offset: string): string;
+    protected getOffsetExpression(timezone: string): string;
+    format(options: {
+        type: string;
+        field: string;
+        format: string;
+        timezone?: string;
+        fieldOptions?: any;
+    }): import("sequelize/types/utils").Fn | import("sequelize/types/utils").Col | import("sequelize/types/utils").Literal;
+}

package/lib/query/formatter.js

@@ -0,0 +1,94 @@
+/**
+ * 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 formatter_exports = {};
+__export(formatter_exports, {
+  QueryFormatter: () => QueryFormatter
+});
+module.exports = __toCommonJS(formatter_exports);
+var import_moment_timezone = __toESM(require("moment-timezone"));
+const _QueryFormatter = class _QueryFormatter {
+  sequelize;
+  constructor(sequelize) {
+    this.sequelize = sequelize;
+  }
+  convertFormat(format) {
+    return format;
+  }
+  getTimezoneByOffset(offset) {
+    if (!/^[+-]\d{1,2}:\d{2}$/.test(offset)) {
+      return offset;
+    }
+    const offsetMinutes = import_moment_timezone.default.duration(offset).asMinutes();
+    return import_moment_timezone.default.tz.names().find((timezone) => {
+      return import_moment_timezone.default.tz(timezone).utcOffset() === offsetMinutes;
+    });
+  }
+  getOffsetExpression(timezone) {
+    const sign = timezone.charAt(0);
+    const value = timezone.slice(1);
+    const [hours, minutes] = value.split(":").map(Number);
+    return `${sign}${hours * 60 + minutes} minutes`;
+  }
+  format(options) {
+    var _a, _b;
+    const { type, field, format, timezone, fieldOptions } = options;
+    const col = this.sequelize.col(field);
+    switch (type) {
+      case "date":
+      case "datetime":
+      case "datetimeTz":
+        return this.formatDate(col, format, timezone);
+      case "datetimeNoTz":
+      case "dateOnly":
+      case "time":
+        return this.formatDate(col, format);
+      case "unixTimestamp": {
+        const accuracy = ((_b = (_a = fieldOptions == null ? void 0 : fieldOptions.uiSchema) == null ? void 0 : _a["x-component-props"]) == null ? void 0 : _b.accuracy) || (fieldOptions == null ? void 0 : fieldOptions.accuracy) || "second";
+        return this.formatUnixTimestamp(field, format, accuracy, timezone);
+      }
+      default:
+        return col;
+    }
+  }
+};
+__name(_QueryFormatter, "QueryFormatter");
+let QueryFormatter = _QueryFormatter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryFormatter
+});

package/lib/query/formatters/mysql.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { QueryFormatter, Col } from '../formatter';
+export declare class MySQLQueryFormatter extends QueryFormatter {
+    convertFormat(format: string): string;
+    formatDate(field: Col, format: string, timezone?: string): import("sequelize/types/utils").Fn;
+    formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): import("sequelize/types/utils").Fn;
+}

package/lib/query/formatters/mysql.js

@@ -0,0 +1,68 @@
+/**
+ * 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 mysql_exports = {};
+__export(mysql_exports, {
+  MySQLQueryFormatter: () => MySQLQueryFormatter
+});
+module.exports = __toCommonJS(mysql_exports);
+var import_formatter = require("../formatter");
+const _MySQLQueryFormatter = class _MySQLQueryFormatter extends import_formatter.QueryFormatter {
+  convertFormat(format) {
+    return format.replace(/YYYY/g, "%Y").replace(/MM/g, "%m").replace(/DD/g, "%d").replace(/hh/g, "%H").replace(/mm/g, "%i").replace(/ss/g, "%S");
+  }
+  formatDate(field, format, timezone) {
+    const fmt = this.convertFormat(format);
+    if (timezone) {
+      return this.sequelize.fn(
+        "date_format",
+        this.sequelize.fn("convert_tz", field, process.env.TZ || "UTC", timezone),
+        fmt
+      );
+    }
+    return this.sequelize.fn("date_format", field, fmt);
+  }
+  formatUnixTimestamp(field, format, accuracy = "second", timezone) {
+    const fmt = this.convertFormat(format);
+    const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field);
+    const timestamp = accuracy === "millisecond" ? this.sequelize.fn("from_unixtime", this.sequelize.literal(`ROUND(${quoted} / 1000)`)) : this.sequelize.fn("from_unixtime", this.sequelize.col(field));
+    if (timezone) {
+      return this.sequelize.fn(
+        "date_format",
+        this.sequelize.fn("convert_tz", timestamp, process.env.TZ || "UTC", timezone),
+        fmt
+      );
+    }
+    return accuracy === "millisecond" ? this.sequelize.fn("from_unixtime", this.sequelize.literal(`ROUND(${quoted} / 1000)`), fmt) : this.sequelize.fn("from_unixtime", this.sequelize.col(field), fmt);
+  }
+};
+__name(_MySQLQueryFormatter, "MySQLQueryFormatter");
+let MySQLQueryFormatter = _MySQLQueryFormatter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MySQLQueryFormatter
+});

package/lib/query/formatters/oracle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { QueryFormatter, Col } from '../formatter';
+export declare class OracleQueryFormatter extends QueryFormatter {
+    convertFormat(format: string): string;
+    formatDate(field: Col, format: string, timezone?: string): import("sequelize/types/utils").Fn;
+    formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): import("sequelize/types/utils").Fn;
+}

package/lib/query/formatters/oracle.js

@@ -0,0 +1,63 @@
+/**
+ * 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 oracle_exports = {};
+__export(oracle_exports, {
+  OracleQueryFormatter: () => OracleQueryFormatter
+});
+module.exports = __toCommonJS(oracle_exports);
+var import_formatter = require("../formatter");
+const _OracleQueryFormatter = class _OracleQueryFormatter extends import_formatter.QueryFormatter {
+  convertFormat(format) {
+    return format.replace(/hh/g, "HH24").replace(/mm/g, "MI").replace(/ss/g, "SS");
+  }
+  formatDate(field, format, timezone) {
+    const fmt = this.convertFormat(format);
+    if (timezone) {
+      const resolvedTimezone = this.getTimezoneByOffset(timezone);
+      const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field.col);
+      return this.sequelize.fn(
+        "to_char",
+        this.sequelize.literal(`(${quoted} AT TIME ZONE '${resolvedTimezone}')`),
+        fmt
+      );
+    }
+    return this.sequelize.fn("to_char", field, fmt);
+  }
+  formatUnixTimestamp(field, format, accuracy = "second", timezone) {
+    const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field);
+    const timestamp = accuracy === "millisecond" ? `to_timestamp(ROUND(${quoted} / 1000))` : `to_timestamp(${quoted})`;
+    const literal = timezone ? `${timestamp} AT TIME ZONE '${this.getTimezoneByOffset(timezone)}'` : timestamp;
+    return this.sequelize.fn("to_char", this.sequelize.literal(literal), this.convertFormat(format));
+  }
+};
+__name(_OracleQueryFormatter, "OracleQueryFormatter");
+let OracleQueryFormatter = _OracleQueryFormatter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OracleQueryFormatter
+});

package/lib/query/formatters/postgres.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { QueryFormatter, Col } from '../formatter';
+export declare class PostgresQueryFormatter extends QueryFormatter {
+    convertFormat(format: string): string;
+    formatDate(field: Col, format: string, timezone?: string): import("sequelize/types/utils").Fn;
+    formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): import("sequelize/types/utils").Fn;
+}

package/lib/query/formatters/postgres.js

@@ -0,0 +1,63 @@
+/**
+ * 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 postgres_exports = {};
+__export(postgres_exports, {
+  PostgresQueryFormatter: () => PostgresQueryFormatter
+});
+module.exports = __toCommonJS(postgres_exports);
+var import_formatter = require("../formatter");
+const _PostgresQueryFormatter = class _PostgresQueryFormatter extends import_formatter.QueryFormatter {
+  convertFormat(format) {
+    return format.replace(/hh/g, "HH24").replace(/mm/g, "MI").replace(/ss/g, "SS");
+  }
+  formatDate(field, format, timezone) {
+    const fmt = this.convertFormat(format);
+    if (timezone) {
+      const resolvedTimezone = this.getTimezoneByOffset(timezone);
+      const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field.col);
+      return this.sequelize.fn(
+        "to_char",
+        this.sequelize.literal(`(${quoted} AT TIME ZONE '${resolvedTimezone}')`),
+        fmt
+      );
+    }
+    return this.sequelize.fn("to_char", field, fmt);
+  }
+  formatUnixTimestamp(field, format, accuracy = "second", timezone) {
+    const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field);
+    const timestamp = accuracy === "millisecond" ? `to_timestamp(ROUND(${quoted} / 1000))` : `to_timestamp(${quoted})`;
+    const literal = timezone ? `${timestamp} AT TIME ZONE '${this.getTimezoneByOffset(timezone)}'` : timestamp;
+    return this.sequelize.fn("to_char", this.sequelize.literal(literal), this.convertFormat(format));
+  }
+};
+__name(_PostgresQueryFormatter, "PostgresQueryFormatter");
+let PostgresQueryFormatter = _PostgresQueryFormatter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresQueryFormatter
+});

package/lib/query/formatters/sqlite.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { QueryFormatter, Col } from '../formatter';
+export declare class SQLiteQueryFormatter extends QueryFormatter {
+    convertFormat(format: string): string;
+    formatDate(field: Col, format: string, timezone?: string): import("sequelize/types/utils").Fn;
+    formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): import("sequelize/types/utils").Fn;
+}

package/lib/query/formatters/sqlite.js

@@ -0,0 +1,60 @@
+/**
+ * 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 sqlite_exports = {};
+__export(sqlite_exports, {
+  SQLiteQueryFormatter: () => SQLiteQueryFormatter
+});
+module.exports = __toCommonJS(sqlite_exports);
+var import_formatter = require("../formatter");
+const _SQLiteQueryFormatter = class _SQLiteQueryFormatter extends import_formatter.QueryFormatter {
+  convertFormat(format) {
+    return format.replace(/YYYY/g, "%Y").replace(/MM/g, "%m").replace(/DD/g, "%d").replace(/hh/g, "%H").replace(/mm/g, "%M").replace(/ss/g, "%S");
+  }
+  formatDate(field, format, timezone) {
+    const fmt = this.convertFormat(format);
+    if (timezone) {
+      return this.sequelize.fn("strftime", fmt, field, this.getOffsetExpression(timezone));
+    }
+    return this.sequelize.fn("strftime", fmt, field);
+  }
+  formatUnixTimestamp(field, format, accuracy = "second", timezone) {
+    const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field);
+    const base = accuracy === "millisecond" ? this.sequelize.literal(`ROUND(${quoted} / 1000)`) : this.sequelize.col(field);
+    const args = [base, "unixepoch"];
+    if (timezone) {
+      args.push(this.getOffsetExpression(timezone));
+    }
+    return this.sequelize.fn("strftime", this.convertFormat(format), this.sequelize.fn("DATETIME", ...args));
+  }
+};
+__name(_SQLiteQueryFormatter, "SQLiteQueryFormatter");
+let SQLiteQueryFormatter = _SQLiteQueryFormatter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SQLiteQueryFormatter
+});

package/lib/query/having.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { WhereOptions } from 'sequelize';
+import { Database } from '../database';
+import { QueryFormatter } from './formatter';
+type QueryFieldMeta = {
+    field: string;
+    alias?: string;
+    aggregation?: string;
+    distinct?: boolean;
+    format?: string;
+    type?: string;
+    options?: any;
+};
+export declare function buildHaving(database: Database, formatter: QueryFormatter, fieldMap: Record<string, QueryFieldMeta>, having?: any, timezone?: string): WhereOptions;
+export {};

package/lib/query/having.js

@@ -0,0 +1,112 @@
+/**
+ * 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 having_exports = {};
+__export(having_exports, {
+  buildHaving: () => buildHaving
+});
+module.exports = __toCommonJS(having_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+function buildFieldExpression(database, formatter, fieldMap, key, timezone) {
+  const meta = fieldMap[key];
+  if (!meta) {
+    throw new Error(`Invalid having field: ${key}`);
+  }
+  const col = database.sequelize.col(meta.field);
+  if (meta.aggregation) {
+    return database.sequelize.fn(meta.aggregation, meta.distinct ? database.sequelize.fn("DISTINCT", col) : col);
+  }
+  if (meta.format) {
+    return formatter.format({
+      type: meta.type,
+      field: meta.field,
+      format: meta.format,
+      timezone,
+      fieldOptions: meta.options
+    });
+  }
+  return col;
+}
+__name(buildFieldExpression, "buildFieldExpression");
+function isOperatorCondition(database, value) {
+  return (0, import_lodash.isPlainObject)(value) && Object.keys(value).some((key) => database.operators.has(key));
+}
+__name(isOperatorCondition, "isOperatorCondition");
+function buildFieldCondition(database, formatter, fieldMap, key, value, timezone) {
+  const field = buildFieldExpression(database, formatter, fieldMap, key, timezone);
+  if (!isOperatorCondition(database, value)) {
+    return database.sequelize.where(field, { [import_sequelize.Op.eq]: value });
+  }
+  const condition = {};
+  for (const [operatorKey, operatorValue] of Object.entries(value)) {
+    const operator = database.operators.get(operatorKey);
+    if (typeof operator !== "symbol") {
+      throw new Error(`Unsupported having operator: ${operatorKey}`);
+    }
+    condition[operator] = operatorValue;
+  }
+  return database.sequelize.where(field, condition);
+}
+__name(buildFieldCondition, "buildFieldCondition");
+function buildHavingNode(database, formatter, fieldMap, node, timezone) {
+  if (!(0, import_lodash.isPlainObject)(node)) {
+    throw new Error("Having must be an object");
+  }
+  const conditions = [];
+  for (const [key, value] of Object.entries(node)) {
+    if ((key === "$and" || key === "$or") && Array.isArray(value)) {
+      const operator = database.operators.get(key);
+      if (typeof operator !== "symbol") {
+        throw new Error(`Unsupported having operator: ${key}`);
+      }
+      conditions.push({
+        [operator]: value.map((item) => buildHavingNode(database, formatter, fieldMap, item, timezone))
+      });
+      continue;
+    }
+    conditions.push(buildFieldCondition(database, formatter, fieldMap, key, value, timezone));
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return {
+    [import_sequelize.Op.and]: conditions
+  };
+}
+__name(buildHavingNode, "buildHavingNode");
+function buildHaving(database, formatter, fieldMap, having, timezone) {
+  if (!having) {
+    return void 0;
+  }
+  return buildHavingNode(database, formatter, fieldMap, having, timezone);
+}
+__name(buildHaving, "buildHaving");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildHaving
+});

package/lib/query/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 type QueryField = string | string[];
+export interface QueryMeasure {
+    field: QueryField;
+    type?: string;
+    aggregation?: string;
+    alias?: string;
+    distinct?: boolean;
+}
+export interface QueryDimension {
+    field: QueryField;
+    type?: string;
+    alias?: string;
+    format?: string;
+    options?: any;
+}
+export interface QueryOrder {
+    field: QueryField;
+    alias?: string;
+    order?: 'asc' | 'desc';
+    nulls?: 'default' | 'first' | 'last';
+}
+export interface QueryOptions {
+    measures?: QueryMeasure[];
+    dimensions?: QueryDimension[];
+    orders?: QueryOrder[];
+    filter?: any;
+    having?: any;
+    limit?: number;
+    offset?: number;
+    timezone?: string;
+    context?: any;
+}

package/lib/query/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/repository.d.ts

@@ -15,6 +15,7 @@ import { Database } from './database';
 import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import { Model } from './model';
 import operators from './operators';
+import type { QueryOptions } from './query/types';
 import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
 import { BelongsToRepository } from './relation-repository/belongs-to-repository';
 import { HasManyRepository } from './relation-repository/hasmany-repository';
@@ -136,6 +137,8 @@ export interface AggregateOptions {
     filter?: Filter;
     distinct?: boolean;
 }
+export interface QueryOptionsWithTransaction extends QueryOptions, Transactionable {
+}
 export interface FirstOrCreateOptions extends Transactionable {
     filterKeys: string[];
     values?: Values;
@@ -156,6 +159,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
     count(countOptions?: CountOptions): Promise<number>;
     getEstimatedRowCount(): Promise<number>;
     private getOracleSchema;
+    query(options?: QueryOptionsWithTransaction): Promise<any[]>;
     aggregate(options: AggregateOptions & {
         optionsTransformer?: (options: any) => any;
     }): Promise<any>;

package/lib/repository.js

@@ -65,6 +65,7 @@ var import_array_field_repository = require("./field-repository/array-field-repo
 var import_fields = require("./fields");
 var import_filter_parser = __toESM(require("./filter-parser"));
 var import_options_parser = require("./options-parser");
+var import_builder = require("./query/builder");
 var import_belongs_to_many_repository = require("./relation-repository/belongs-to-many-repository");
 var import_belongs_to_repository = require("./relation-repository/belongs-to-repository");
 var import_hasmany_repository = require("./relation-repository/hasmany-repository");
@@ -240,6 +241,21 @@ const _Repository = class _Repository {
     });
     return (result == null ? void 0 : result["USER"]) ?? "";
   }
+  async query(options = {}) {
+    const transaction2 = await this.getTransaction(options);
+    const { queryOptions, fieldMap } = (0, import_builder.buildQuery)(this.database, this.collection, options);
+    const finalQueryOptions = {
+      ...queryOptions,
+      transaction: transaction2
+    };
+    if (Array.isArray(finalQueryOptions.include) && finalQueryOptions.include.length > 0) {
+      finalQueryOptions.include = (0, import_utils2.processIncludes)(finalQueryOptions.include, this.collection.model);
+    } else {
+      delete finalQueryOptions.include;
+    }
+    const data = await this.model.findAll(finalQueryOptions);
+    return (0, import_builder.normalizeQueryResult)(data, fieldMap);
+  }
   async aggregate(options) {
     var _a;
     const { method, field } = options;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "2.1.0-alpha.12",
+  "version": "2.1.0-alpha.14",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "2.1.0-alpha.12",
-    "@nocobase/utils": "2.1.0-alpha.12",
+    "@nocobase/logger": "2.1.0-alpha.14",
+    "@nocobase/utils": "2.1.0-alpha.14",
     "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": "f12c4a75470590b1670ce54510b96ef94c2cd7a2"
+  "gitHead": "d8735b541de0ff9557bba704de49c799b4962672"
 }