@nocobase/database 2.1.0-beta.9 → 2.2.0-beta.1

package/lib/interfaces/time-interface.js

@@ -44,8 +44,24 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_utc = __toESM(require("dayjs/plugin/utc"));
 var import_base_interface = require("./base-interface");
 import_dayjs.default.extend(import_utc.default);
+function isNumeric(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+__name(isNumeric, "isNumeric");
+function formatExcelTimeSerial(value) {
+  const normalized = (value % 1 + 1) % 1;
+  const totalSeconds = Math.round(normalized * 24 * 60 * 60) % (24 * 60 * 60);
+  const hours = Math.floor(totalSeconds / 3600).toString().padStart(2, "0");
+  const minutes = Math.floor(totalSeconds % 3600 / 60).toString().padStart(2, "0");
+  const seconds = (totalSeconds % 60).toString().padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+__name(formatExcelTimeSerial, "formatExcelTimeSerial");
 const _TimeInterface = class _TimeInterface extends import_base_interface.BaseInterface {
   toValue(value, ctx) {
+    if (isNumeric(value)) {
+      return formatExcelTimeSerial(value);
+    }
     if (this.validate(value)) {
       const result = (0, import_dayjs.default)(value).format("HH:mm:ss");
       return result;

package/lib/interfaces/to-one-interface.js

@@ -42,7 +42,7 @@ const _ToOneInterface = class _ToOneInterface extends import_base_interface.Base
     const { filterKey, associationField, targetCollection, transaction } = ctx;
     const targetInstance = await targetCollection.repository.findOne({
       filter: {
-        [filterKey]: str
+        [filterKey]: str.toString()
       },
       transaction
     });

package/lib/operators/date.js

@@ -47,6 +47,14 @@ function isDate(input) {
   return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
 }
 __name(isDate, "isDate");
+function isDatetimeNoTzField(field) {
+  return (field == null ? void 0 : field.type) === "datetimeNoTz" || (field == null ? void 0 : field.constructor.name) === "DatetimeNoTzField";
+}
+__name(isDatetimeNoTzField, "isDatetimeNoTzField");
+function isDateOnlyField(field) {
+  return (field == null ? void 0 : field.type) === "dateOnly" || (field == null ? void 0 : field.constructor.name) === "DateOnlyField";
+}
+__name(isDateOnlyField, "isDateOnlyField");
 const toDate = /* @__PURE__ */ __name((date, options = {}) => {
   const { ctx } = options;
   let val = isDate(date) ? date : new Date(date);
@@ -57,10 +65,10 @@ const toDate = /* @__PURE__ */ __name((date, options = {}) => {
   if (field.constructor.name === "UnixTimestampField") {
     val = field.dateToValue(val);
   }
-  if (field.constructor.name === "DatetimeNoTzField") {
+  if (isDatetimeNoTzField(field)) {
     val = (0, import_moment.default)(val).utcOffset("+00:00").format("YYYY-MM-DD HH:mm:ss");
   }
-  if (field.constructor.name === "DateOnlyField") {
+  if (isDateOnlyField(field)) {
     val = import_moment.default.utc(val).format("YYYY-MM-DD HH:mm:ss");
   }
   const eventObj = {
@@ -75,10 +83,10 @@ function parseDateTimezone(ctx) {
   if (!field) {
     return ctx.db.options.timezone;
   }
-  if (field.constructor.name === "DatetimeNoTzField") {
+  if (isDatetimeNoTzField(field)) {
     return "+00:00";
   }
-  if (field.constructor.name === "DateOnlyField") {
+  if (isDateOnlyField(field)) {
     return "+00:00";
   }
   return ctx.db.options.timezone;

package/lib/options-parser.d.ts

@@ -22,6 +22,7 @@ export declare class OptionsParser {
     model: ModelStatic<any>;
     filterParser: FilterParser;
     context: OptionsParserContext;
+    associationNotFoundWarnings: string[];
     constructor(options: FindOptions, context: OptionsParserContext);
     static appendInheritInspectAttribute(include: any, collection: any): any;
     isAssociation(key: string): boolean;

package/lib/options-parser.js

@@ -44,6 +44,7 @@ var import_lodash = __toESM(require("lodash"));
 var import_sequelize = require("sequelize");
 var import_filter_parser = __toESM(require("./filter-parser"));
 var import_qs = __toESM(require("qs"));
+var import_association_not_found_error = require("./errors/association-not-found-error");
 const debug = require("debug")("noco-database");
 const _OptionsParser = class _OptionsParser {
   options;
@@ -52,6 +53,7 @@ const _OptionsParser = class _OptionsParser {
   model;
   filterParser;
   context;
+  associationNotFoundWarnings = [];
   constructor(options, context) {
     const { collection } = context;
     this.collection = collection;
@@ -301,7 +303,7 @@ const _OptionsParser = class _OptionsParser {
     }
     const sortedAppends = import_lodash.default.sortBy(appendList, (append) => append.split(".").length);
     const setInclude = /* @__PURE__ */ __name((model, queryParams, append, parentAs) => {
-      var _a;
+      var _a, _b;
       const appendWithOptions = this.parseAppendWithOptions(append);
       append = appendWithOptions.name;
       const appendFields = append.split(".");
@@ -314,7 +316,7 @@ const _OptionsParser = class _OptionsParser {
       if (appendFields.length == 2) {
         const association = associations[appendFields[0]];
         if (!association) {
-          throw new Error(`association ${appendFields[0]} in ${model.name} not found`);
+          throw new import_association_not_found_error.AssociationNotFoundError(`association ${appendFields[0]} in ${model.name} not found`);
         }
         const associationModel = associations[appendFields[0]].target;
         if (associationModel.rawAttributes[appendFields[1]]) {
@@ -341,7 +343,13 @@ const _OptionsParser = class _OptionsParser {
       if (existIncludeIndex == -1) {
         const association = associations[appendAssociation];
         if (!association) {
-          throw new Error(`association ${appendAssociation} in ${model.name} not found`);
+          throw new import_association_not_found_error.AssociationNotFoundError(`association ${appendAssociation} in ${model.name} not found`);
+        }
+        const targetCollectionName = (_b = this.database.getCollectionByModelName(association.target.name)) == null ? void 0 : _b.name;
+        if (!targetCollectionName) {
+          throw new import_association_not_found_error.AssociationNotFoundError(
+            `target collection for association ${appendAssociation} in ${model.name} not found`
+          );
         }
         let includeOptions = {
           association: appendAssociation,
@@ -394,7 +402,15 @@ const _OptionsParser = class _OptionsParser {
       }
     }, "setInclude");
     for (const append of sortedAppends) {
-      setInclude(this.model, filterParams, append);
+      try {
+        setInclude(this.model, filterParams, append);
+      } catch (error) {
+        if (error instanceof import_association_not_found_error.AssociationNotFoundError) {
+          this.associationNotFoundWarnings.push(error.message);
+          continue;
+        }
+        throw error;
+      }
     }
     debug("filter params: %o", filterParams);
     return filterParams;

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,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;
+}