@nocobase/database 2.1.0-alpha.3 → 2.1.0-alpha.31

package/lib/query/builder.js

@@ -0,0 +1,268 @@
+/**
+ * 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"];
+const ALLOWED_ORDER_DIRECTIONS = ["ASC", "DESC"];
+function createQueryFormatter(database) {
+  switch (database.sequelize.getDialect()) {
+    case "sqlite":
+      return new import_sqlite.SQLiteQueryFormatter(database.sequelize, database.options.rawTimezone);
+    case "postgres":
+      return new import_postgres.PostgresQueryFormatter(database.sequelize, database.options.rawTimezone);
+    case "mysql":
+    case "mariadb":
+      return new import_mysql.MySQLQueryFormatter(database.sequelize, database.options.rawTimezone);
+    case "oracle":
+      return new import_oracle.OracleQueryFormatter(database.sequelize, database.options.rawTimezone);
+    default:
+      return new class extends import_formatter.QueryFormatter {
+        formatDate(field, _format, _timezone, _preserveLocalTime) {
+          return field;
+        }
+        formatUnixTimestamp(field, _format, _accuracy, _timezone) {
+          return this.sequelize.col(field);
+        }
+      }(database.sequelize, database.options.rawTimezone);
+  }
+}
+__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 = {};
+  const projectedFieldMap = {};
+  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;
+    projectedFieldMap[alias || field] = attribute[0];
+  });
+  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;
+    projectedFieldMap[alias || field] = attribute[0];
+  });
+  const order = orders.map((item) => {
+    var _a2;
+    const alias = sequelize.getQueryInterface().quoteIdentifier(item.alias);
+    const projectedField = projectedFieldMap[item.alias] || projectedFieldMap[item.name] || projectedFieldMap[item.field];
+    const name = hasAgg ? projectedField || sequelize.literal(alias) : sequelize.col(item.field);
+    let sort = ALLOWED_ORDER_DIRECTIONS.includes((_a2 = item.order) == null ? void 0 : _a2.toUpperCase()) ? item.order.toUpperCase() : "ASC";
+    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) {
+  const dateTimeTypes = ["date", "datetime", "datetimeTz", "datetimeNoTz"];
+  return data.map((record) => {
+    Object.entries(record).forEach(([key, value]) => {
+      if (value === null || value === void 0) {
+        return;
+      }
+      const field = fieldMap[key];
+      const type = field == null ? void 0 : field.type;
+      if (["bigInt", "integer", "float", "double", "decimal"].includes(type)) {
+        record[key] = Number(value);
+        return;
+      }
+      if (!(field == null ? void 0 : field.format) && dateTimeTypes.includes(type) && !(value instanceof Date)) {
+        const dateValue = new Date(value);
+        if (!Number.isNaN(dateValue.getTime())) {
+          record[key] = dateValue;
+        }
+      }
+    });
+    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,29 @@
+/**
+ * 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 { 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;
+    rawTimezone?: string;
+    constructor(sequelize: Sequelize, rawTimezone?: string);
+    abstract formatDate(field: Col, format: string, timezone?: string, preserveLocalTime?: boolean): 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,100 @@
+/**
+ * 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;
+  rawTimezone;
+  constructor(sequelize, rawTimezone) {
+    this.sequelize = sequelize;
+    this.rawTimezone = rawTimezone;
+  }
+  convertFormat(format) {
+    return format;
+  }
+  getTimezoneByOffset(offset) {
+    if (!offset) {
+      return;
+    }
+    if (import_moment_timezone.default.tz.zone(offset)) {
+      return offset;
+    }
+    if (/^[+-]\d{1,2}:\d{2}$/.test(offset)) {
+      return offset;
+    }
+    return;
+  }
+  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":
+        return this.formatDate(col, format, void 0, true);
+      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, _preserveLocalTime?: boolean): 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,70 @@
+/**
+ * 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, _preserveLocalTime) {
+    const fmt = this.convertFormat(format);
+    const resolvedTimezone = this.getTimezoneByOffset(timezone);
+    if (resolvedTimezone) {
+      return this.sequelize.fn(
+        "date_format",
+        this.sequelize.fn("convert_tz", field, process.env.TZ || "UTC", resolvedTimezone),
+        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 resolvedTimezone = this.getTimezoneByOffset(timezone);
+    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 (resolvedTimezone) {
+      return this.sequelize.fn(
+        "date_format",
+        this.sequelize.fn("convert_tz", timestamp, process.env.TZ || "UTC", resolvedTimezone),
+        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, _preserveLocalTime?: boolean): 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,64 @@
+/**
+ * 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, _preserveLocalTime) {
+    const fmt = this.convertFormat(format);
+    const resolvedTimezone = this.getTimezoneByOffset(timezone);
+    if (resolvedTimezone) {
+      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 resolvedTimezone = this.getTimezoneByOffset(timezone);
+    const literal = resolvedTimezone ? `${timestamp} AT TIME ZONE '${resolvedTimezone}'` : 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,15 @@
+/**
+ * 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;
+    private buildTimezoneLiteral;
+    formatDate(field: Col, format: string, timezone?: string, _preserveLocalTime?: boolean): 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,70 @@
+/**
+ * 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");
+  }
+  buildTimezoneLiteral(target) {
+    if (/^[+-]\d{1,2}:\d{2}$/.test(target)) {
+      return `INTERVAL '${target}'`;
+    }
+    return `'${target}'`;
+  }
+  formatDate(field, format, timezone, _preserveLocalTime) {
+    const fmt = this.convertFormat(format);
+    const resolvedTimezone = this.getTimezoneByOffset(timezone);
+    if (resolvedTimezone) {
+      const quoted = this.sequelize.getQueryInterface().quoteIdentifiers(field.col);
+      return this.sequelize.fn(
+        "to_char",
+        this.sequelize.literal(`timezone(${this.buildTimezoneLiteral(resolvedTimezone)}, ${quoted})`),
+        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 resolvedTimezone = this.getTimezoneByOffset(timezone);
+    const literal = resolvedTimezone ? `timezone(${this.buildTimezoneLiteral(resolvedTimezone)}, ${timestamp})` : 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, preserveLocalTime?: boolean): import("sequelize/types/utils").Fn;
+    formatUnixTimestamp(field: string, format: string, accuracy?: 'second' | 'millisecond', timezone?: string): import("sequelize/types/utils").Fn;
+}