@tachybase/database 0.23.8

package/lib/operators/empty.js

@@ -0,0 +1,89 @@
+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 empty_exports = {};
+__export(empty_exports, {
+  default: () => empty_default
+});
+module.exports = __toCommonJS(empty_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_fields = require("../fields");
+var import_array = __toESM(require("./array"));
+const findFilterFieldType = /* @__PURE__ */ __name((ctx) => {
+  const db = ctx.db;
+  const path = ctx.path.split(".");
+  path.pop();
+  const fieldName = path.pop();
+  let model = ctx.model;
+  const associationPath = path;
+  for (const association of associationPath) {
+    if (import_lodash.default.isNumber((0, import_lodash.parseInt)(association)) || association.startsWith("$")) {
+      continue;
+    }
+    model = model.associations[association].target;
+  }
+  const collection = db.modelCollection.get(model);
+  return collection.getField(fieldName);
+}, "findFilterFieldType");
+var empty_default = {
+  $empty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+    if (field instanceof import_fields.StringField) {
+      return {
+        [import_sequelize.Op.or]: {
+          [import_sequelize.Op.is]: null,
+          [import_sequelize.Op.eq]: ""
+        }
+      };
+    }
+    if (field instanceof import_fields.ArrayField) {
+      return import_array.default.$arrayEmpty(_, ctx);
+    }
+    return {
+      [import_sequelize.Op.is]: null
+    };
+  },
+  $notEmpty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+    if (field instanceof import_fields.StringField) {
+      return {
+        [import_sequelize.Op.and]: {
+          [import_sequelize.Op.not]: null,
+          [import_sequelize.Op.ne]: ""
+        }
+      };
+    }
+    if (field instanceof import_fields.ArrayField) {
+      return import_array.default.$arrayNotEmpty(_, ctx);
+    }
+    return {
+      [import_sequelize.Op.not]: null
+    };
+  }
+};

package/lib/operators/eq.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/eq.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 eq_exports = {};
+__export(eq_exports, {
+  default: () => eq_default
+});
+module.exports = __toCommonJS(eq_exports);
+var import_sequelize = require("sequelize");
+var eq_default = {
+  $eq(val) {
+    if (Array.isArray(val)) {
+      return {
+        [import_sequelize.Op.in]: val
+      };
+    }
+    return {
+      [import_sequelize.Op.eq]: val
+    };
+  }
+};

package/lib/operators/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    $empty(_: any, ctx: any): any;
+    $notEmpty(_: any, ctx: any): any;
+};
+export default _default;

package/lib/operators/index.js

@@ -0,0 +1,56 @@
+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 __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 operators_exports = {};
+__export(operators_exports, {
+  default: () => operators_default
+});
+module.exports = __toCommonJS(operators_exports);
+var import_array = __toESM(require("./array"));
+var import_association = __toESM(require("./association"));
+var import_boolean = __toESM(require("./boolean"));
+var import_child_collection = __toESM(require("./child-collection"));
+var import_date = __toESM(require("./date"));
+var import_empty = __toESM(require("./empty"));
+var import_eq = __toESM(require("./eq"));
+var import_jsonb = __toESM(require("./jsonb"));
+var import_ne = __toESM(require("./ne"));
+var import_notIn = __toESM(require("./notIn"));
+var import_string = __toESM(require("./string"));
+var operators_default = {
+  ...import_association.default,
+  ...import_date.default,
+  ...import_array.default,
+  ...import_empty.default,
+  ...import_string.default,
+  ...import_eq.default,
+  ...import_ne.default,
+  ...import_notIn.default,
+  ...import_boolean.default,
+  ...import_child_collection.default,
+  ...import_jsonb.default
+};

package/lib/operators/jsonb.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/jsonb.js

@@ -0,0 +1,50 @@
+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 jsonb_exports = {};
+__export(jsonb_exports, {
+  default: () => jsonb_default
+});
+module.exports = __toCommonJS(jsonb_exports);
+var import_sequelize = require("sequelize");
+var import_utils = require("./utils");
+function escapeLike(value) {
+  return value.replace(/[_%]/g, "\\$&");
+}
+__name(escapeLike, "escapeLike");
+var jsonb_default = {
+  $containsJsonbValue(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        ["::text"]: {
+          [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(item)}%`
+        }
+      }));
+      return {
+        [import_sequelize.Op.or]: conditions
+      };
+    }
+    return {
+      // 先将 jsonb 转换为字符串, 实际测试发现这种语法可行
+      ["::text"]: {
+        // 使用 Op.like 操作符来检查 JSONB 字段是否包含特定的字符串
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(value)}%`
+      }
+    };
+  }
+};

package/lib/operators/ne.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/ne.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 ne_exports = {};
+__export(ne_exports, {
+  default: () => ne_default
+});
+module.exports = __toCommonJS(ne_exports);
+var import_sequelize = require("sequelize");
+var ne_default = {
+  $ne(val, ctx) {
+    if (Array.isArray(val)) {
+      return {
+        [import_sequelize.Op.notIn]: val
+      };
+    }
+    return val === null ? {
+      [import_sequelize.Op.ne]: null
+    } : {
+      [import_sequelize.Op.or]: {
+        [import_sequelize.Op.ne]: val,
+        [import_sequelize.Op.is]: null
+      }
+    };
+  }
+};

package/lib/operators/notIn.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/notIn.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 notIn_exports = {};
+__export(notIn_exports, {
+  default: () => notIn_default
+});
+module.exports = __toCommonJS(notIn_exports);
+var import_sequelize = require("sequelize");
+var notIn_default = {
+  $notIn(val, ctx) {
+    return {
+      [import_sequelize.Op.or]: {
+        [import_sequelize.Op.notIn]: val,
+        [import_sequelize.Op.is]: null
+      }
+    };
+  }
+};

package/lib/operators/string.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;

package/lib/operators/string.js

@@ -0,0 +1,109 @@
+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 string_exports = {};
+__export(string_exports, {
+  default: () => string_default
+});
+module.exports = __toCommonJS(string_exports);
+var import_sequelize = require("sequelize");
+var import_utils = require("./utils");
+function escapeLike(value) {
+  return value.replace(/[_%]/g, "\\$&");
+}
+__name(escapeLike, "escapeLike");
+var string_default = {
+  $includes(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(item)}%`
+      }));
+      return {
+        [import_sequelize.Op.or]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(value)}%`
+    };
+  },
+  $notIncludes(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(item)}%`
+      }));
+      return {
+        [import_sequelize.Op.and]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(value)}%`
+    };
+  },
+  $startsWith(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `${escapeLike(item)}%`
+      }));
+      return {
+        [import_sequelize.Op.or]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `${escapeLike(value)}%`
+    };
+  },
+  $notStartsWith(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `${escapeLike(item)}%`
+      }));
+      return {
+        [import_sequelize.Op.and]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `${escapeLike(value)}%`
+    };
+  },
+  $endWith(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(item)}`
+      }));
+      return {
+        [import_sequelize.Op.or]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(value)}`
+    };
+  },
+  $notEndWith(value, ctx) {
+    if (Array.isArray(value)) {
+      const conditions = value.map((item) => ({
+        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(item)}`
+      }));
+      return {
+        [import_sequelize.Op.and]: conditions
+      };
+    }
+    return {
+      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(value)}`
+    };
+  }
+};

package/lib/operators/utils.d.ts

@@ -0,0 +1,4 @@
+declare const getDialect: (ctx: any) => any;
+declare const isPg: (ctx: any) => boolean;
+declare const isMySQL: (ctx: any) => boolean;
+export { getDialect, isPg, isMySQL };

package/lib/operators/utils.js

@@ -0,0 +1,40 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  getDialect: () => getDialect,
+  isMySQL: () => isMySQL,
+  isPg: () => isPg
+});
+module.exports = __toCommonJS(utils_exports);
+const getDialect = /* @__PURE__ */ __name((ctx) => {
+  return ctx.db.sequelize.getDialect();
+}, "getDialect");
+const isPg = /* @__PURE__ */ __name((ctx) => {
+  return getDialect(ctx) === "postgres";
+}, "isPg");
+const isMySQL = /* @__PURE__ */ __name((ctx) => {
+  return getDialect(ctx) === "mysql" || getDialect(ctx) === "mariadb";
+}, "isMySQL");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDialect,
+  isMySQL,
+  isPg
+});

package/lib/options-parser.d.ts

@@ -0,0 +1,37 @@
+import { ModelStatic } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import FilterParser from './filter-parser';
+import { Appends, Except, FindOptions } from './repository';
+interface OptionsParserContext {
+    collection: Collection;
+    targetKey?: string;
+}
+export declare class OptionsParser {
+    options: FindOptions;
+    database: Database;
+    collection: Collection;
+    model: ModelStatic<any>;
+    filterParser: FilterParser;
+    context: OptionsParserContext;
+    constructor(options: FindOptions, context: OptionsParserContext);
+    static appendInheritInspectAttribute(include: any, collection: any): any;
+    isAssociation(key: string): boolean;
+    isAssociationPath(path: string): boolean;
+    toSequelizeParams(): any;
+    /**
+     * parser sort options
+     * @param filterParams
+     * @protected
+     */
+    protected parseSort(filterParams: any): any;
+    protected parseFields(filterParams: any): any;
+    protected parseExcept(except: Except, filterParams: any): any;
+    protected parseAppendWithOptions(append: string): {
+        name: string;
+        options?: object;
+        raw?: string;
+    };
+    protected parseAppends(appends: Appends, filterParams: any): any;
+}
+export {};