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

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

package/lib/query/formatters/sqlite.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 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, preserveLocalTime) {
+    const fmt = this.convertFormat(format);
+    if (timezone && /^[+-]\d{1,2}:\d{2}$/.test(timezone)) {
+      return this.sequelize.fn("strftime", fmt, field, this.getOffsetExpression(timezone));
+    }
+    if (preserveLocalTime && this.rawTimezone && /^[+-]\d{1,2}:\d{2}$/.test(this.rawTimezone)) {
+      return this.sequelize.fn("strftime", fmt, field, this.getOffsetExpression(this.rawTimezone));
+    }
+    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 && /^[+-]\d{1,2}:\d{2}$/.test(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");
@@ -151,12 +152,13 @@ const _Repository = class _Repository {
         [import_sequelize.Op.and]: [options["where"] || {}, optionParser.filterByTkToWhereOption()]
       };
     }
+    const hasInclude = Array.isArray(options["include"]) && options["include"].length > 0;
     const queryOptions = {
-      ...options,
-      distinct: Boolean(this.collection.model.primaryKeyAttribute) && !this.collection.isMultiFilterTargetKey()
+      ...options
     };
-    if (Array.isArray(queryOptions.include) && queryOptions.include.length > 0) {
+    if (hasInclude) {
       queryOptions.include = (0, import_utils2.processIncludes)(queryOptions.include, this.collection.model);
+      queryOptions.distinct = Boolean(this.collection.model.primaryKeyAttribute) && !this.collection.isMultiFilterTargetKey();
     } else {
       delete queryOptions.include;
     }
@@ -240,6 +242,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;
@@ -647,6 +664,9 @@ const _Repository = class _Repository {
       collection: this.collection
     });
     const params = parser.toSequelizeParams({ parseSort: import_lodash2.default.isBoolean(options == null ? void 0 : options.parseSort) ? options.parseSort : true });
+    if (parser.associationNotFoundWarnings.length > 0) {
+      this.database.logger.warn(parser.associationNotFoundWarnings.join("; "));
+    }
     debug("sequelize query params %o", params);
     if (options.where && params.where) {
       params.where = {

package/lib/utils/field-validation.js

@@ -42,6 +42,19 @@ __export(field_validation_exports, {
 module.exports = __toCommonJS(field_validation_exports);
 var import_joi = __toESM(require("joi"));
 var import_lodash = __toESM(require("lodash"));
+function getFractionLength(value) {
+  const normalized = value.trim().replace(/,/g, "");
+  if (!normalized || /e/i.test(normalized)) {
+    return 0;
+  }
+  const unsignedValue = normalized.startsWith("+") || normalized.startsWith("-") ? normalized.slice(1) : normalized;
+  const dotIndex = unsignedValue.indexOf(".");
+  if (dotIndex < 0) {
+    return 0;
+  }
+  return unsignedValue.slice(dotIndex + 1).length;
+}
+__name(getFractionLength, "getFractionLength");
 function buildJoiSchema(validation, options) {
   const { type, rules } = validation;
   const { label, value } = options;
@@ -59,6 +72,23 @@ function buildJoiSchema(validation, options) {
   if (rules) {
     rules.forEach((rule) => {
       const args = import_lodash.default.cloneDeep(rule.args);
+      if (rule.name === "precision") {
+        const limit = Number(args == null ? void 0 : args.limit);
+        schema = schema.custom((currentValue, helpers) => {
+          if (Number.isNaN(limit)) {
+            return currentValue;
+          }
+          const originalValue = helpers.original;
+          if (originalValue === null || originalValue === void 0 || originalValue === "") {
+            return currentValue;
+          }
+          if (getFractionLength(String(originalValue)) > limit) {
+            return helpers.error("number.precision", { limit });
+          }
+          return currentValue;
+        });
+        return;
+      }
       if (!import_lodash.default.isEmpty(args)) {
         if (rule.name === "pattern" && !import_lodash.default.isRegExp(args.regex)) {
           const lastSlash = args.regex.lastIndexOf("/");

package/lib/view/field-type-map.d.ts

@@ -23,7 +23,7 @@ declare const fieldTypeMap: {
         real: string;
         'double precision': string;
         'timestamp without time zone': string;
-        'timestamp with time zone': string;
+        'timestamp with time zone': string[];
         'time without time zone': string;
         date: string;
         boolean: string;
@@ -63,7 +63,7 @@ declare const fieldTypeMap: {
         decimal: string;
         year: string[];
         datetime: string[];
-        timestamp: string;
+        timestamp: string[];
         json: string[];
         enum: string;
     };
@@ -72,7 +72,7 @@ declare const fieldTypeMap: {
         varchar: string[];
         integer: string;
         real: string;
-        datetime: string;
+        datetime: string[];
         date: string;
         time: string;
         boolean: string;
@@ -105,7 +105,7 @@ declare const fieldTypeMap: {
         decimal: string;
         year: string[];
         datetime: string[];
-        timestamp: string;
+        timestamp: string[];
         json: string[];
         enum: string;
     };

package/lib/view/field-type-map.js

@@ -45,7 +45,7 @@ const postgres = {
   real: "float",
   "double precision": "float",
   "timestamp without time zone": "datetimeNoTz",
-  "timestamp with time zone": "datetimeTz",
+  "timestamp with time zone": ["datetimeTz", "date"],
   "time without time zone": "time",
   date: "dateOnly",
   boolean: "boolean",
@@ -84,8 +84,8 @@ const mysql = {
   boolean: "boolean",
   decimal: "decimal",
   year: ["string", "integer"],
-  datetime: ["datetimeNoTz", "datetimeTz"],
-  timestamp: "datetimeTz",
+  datetime: ["datetimeNoTz", "datetimeTz", "date"],
+  timestamp: ["datetimeTz", "date"],
   json: ["json", "array"],
   enum: "string"
 };
@@ -94,7 +94,7 @@ const sqlite = {
   varchar: ["string", "uuid", "nanoid", "encryption"],
   integer: "integer",
   real: "real",
-  datetime: "datetimeTz",
+  datetime: ["datetimeTz", "date"],
   date: "date",
   time: "time",
   boolean: "boolean",

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "2.1.0-beta.9",
+  "version": "2.2.0-beta.1",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "2.1.0-beta.9",
-    "@nocobase/utils": "2.1.0-beta.9",
+    "@nocobase/logger": "2.2.0-beta.1",
+    "@nocobase/utils": "2.2.0-beta.1",
     "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": "c3a2875e4cbbb43b1f2361e6f9f5f84a7d3f3c3c"
+  "gitHead": "f82fa9d0c3aa8e00e53dd94e404a312483b4866b"
 }