@nocobase/database 2.1.0-beta.2 → 2.1.0-beta.21

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;
@@ -58,16 +71,34 @@ function buildJoiSchema(validation, options) {
   }
   if (rules) {
     rules.forEach((rule) => {
-      if (!import_lodash.default.isEmpty(rule.args)) {
-        if (rule.name === "pattern" && !import_lodash.default.isRegExp(rule.args.regex)) {
-          const lastSlash = rule.args.regex.lastIndexOf("/");
-          const isRegExpStr = rule.args.regex.startsWith("/") && lastSlash > 0;
+      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("/");
+          const isRegExpStr = args.regex.startsWith("/") && lastSlash > 0;
           if (isRegExpStr) {
-            rule.args.regex = rule.args.regex.slice(1, lastSlash);
+            args.regex = args.regex.slice(1, lastSlash);
           }
-          rule.args.regex = new RegExp(rule.args.regex);
+          args.regex = new RegExp(args.regex);
         }
-        schema = rule.paramsType === "object" ? schema[rule.name](rule.args) : schema[rule.name](...Object.values(rule.args));
+        schema = rule.paramsType === "object" ? schema[rule.name](args) : schema[rule.name](...Object.values(args));
       } else {
         schema = schema[rule.name]();
       }

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.2",
+  "version": "2.1.0-beta.21",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
-  "license": "AGPL-3.0",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "2.1.0-beta.2",
-    "@nocobase/utils": "2.1.0-beta.2",
+    "@nocobase/logger": "2.1.0-beta.21",
+    "@nocobase/utils": "2.1.0-beta.21",
     "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": "d80433799fb4a8d59ded4d7eea114d585a137ea0"
+  "gitHead": "324bd82f33fca58e98711688a17ceb65c186b65e"
 }