@tachybase/database 0.23.8

package/lib/fields/set-field.js

@@ -0,0 +1,46 @@
+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 set_field_exports = {};
+__export(set_field_exports, {
+  SetField: () => SetField
+});
+module.exports = __toCommonJS(set_field_exports);
+var import_array_field = require("./array-field");
+const _SetField = class _SetField extends import_array_field.ArrayField {
+  beforeSave = /* @__PURE__ */ __name((model) => {
+    const oldValue = model.get(this.options.name);
+    if (oldValue) {
+      model.set(this.options.name, [...new Set(oldValue)]);
+    }
+  }, "beforeSave");
+  bind() {
+    super.bind();
+    this.on("beforeSave", this.beforeSave);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeSave", this.beforeSave);
+  }
+};
+__name(_SetField, "SetField");
+let SetField = _SetField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SetField
+});

package/lib/fields/sort-field.d.ts

@@ -0,0 +1,16 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class SortField extends Field {
+    get dataType(): DataTypes.BigIntDataTypeConstructor;
+    setSortValue: (instance: any, options: any) => Promise<void>;
+    onScopeChange: (instance: any, options: any) => Promise<void>;
+    initRecordsSortValue: ({ transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    bind(): void;
+    unbind(): void;
+}
+export interface SortFieldOptions extends BaseColumnFieldOptions {
+    type: 'sort';
+    scopeKey?: string;
+}

package/lib/fields/sort-field.js

@@ -0,0 +1,187 @@
+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 sort_field_exports = {};
+__export(sort_field_exports, {
+  SortField: () => SortField
+});
+module.exports = __toCommonJS(sort_field_exports);
+var import_async_mutex = require("async-mutex");
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const sortFieldMutex = new import_async_mutex.Mutex();
+const _SortField = class _SortField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.BIGINT;
+  }
+  setSortValue = /* @__PURE__ */ __name(async (instance, options) => {
+    const { name, scopeKey } = this.options;
+    const { model } = this.context.collection;
+    if ((0, import_lodash.isNumber)(instance.get(name)) && instance._previousDataValues[scopeKey] == instance[scopeKey]) {
+      return;
+    }
+    const where = {};
+    if (scopeKey) {
+      const value = instance.get(scopeKey);
+      if (value !== void 0 && value !== null) {
+        where[scopeKey] = value;
+      }
+    }
+    await sortFieldMutex.runExclusive(async () => {
+      const max = await model.max(name, { ...options, where });
+      const newValue = (max || 0) + 1;
+      instance.set(name, newValue);
+    });
+  }, "setSortValue");
+  onScopeChange = /* @__PURE__ */ __name(async (instance, options) => {
+    const { scopeKey } = this.options;
+    if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
+      await this.setSortValue(instance, options);
+    }
+  }, "onScopeChange");
+  initRecordsSortValue = /* @__PURE__ */ __name(async ({ transaction }) => {
+    const orderField = (() => {
+      const model = this.collection.model;
+      if (model.primaryKeyAttribute) {
+        return model.primaryKeyAttribute;
+      }
+      if (model.rawAttributes["createdAt"]) {
+        return model.rawAttributes["createdAt"].field;
+      }
+      throw new Error(`can not find order key for collection ${this.collection.name}`);
+    })();
+    const needInit = /* @__PURE__ */ __name(async (scopeKey2 = null, scopeValue = null) => {
+      const filter = {};
+      if (scopeKey2 && scopeValue) {
+        filter[scopeKey2] = scopeValue;
+      }
+      const totalCount = await this.collection.repository.count({
+        filter,
+        transaction
+      });
+      const emptyCount = await this.collection.repository.count({
+        filter: {
+          [this.name]: null,
+          ...filter
+        },
+        transaction
+      });
+      return emptyCount === totalCount && emptyCount > 0;
+    }, "needInit");
+    const doInit = /* @__PURE__ */ __name(async (scopeKey2 = null, scopeValue = null) => {
+      const queryInterface = this.collection.db.sequelize.getQueryInterface();
+      if (scopeKey2) {
+        const scopeAttribute = this.collection.model.rawAttributes[scopeKey2];
+        if (!scopeAttribute) {
+          throw new Error(`can not find scope field ${scopeKey2} for collection ${this.collection.name}`);
+        }
+        scopeKey2 = scopeAttribute.field;
+      }
+      const quotedOrderField = queryInterface.quoteIdentifier(orderField);
+      const sortColumnName = queryInterface.quoteIdentifier(this.collection.model.rawAttributes[this.name].field);
+      let sql;
+      const whereClause = scopeKey2 && scopeValue ? (() => {
+        const filteredScopeValue = scopeValue.filter((v) => v !== null);
+        if (filteredScopeValue.length === 0) {
+          return "";
+        }
+        const initialClause = `
+  WHERE ${queryInterface.quoteIdentifier(scopeKey2)} IN (${filteredScopeValue.map((v) => `'${v}'`).join(", ")})`;
+        const nullCheck = scopeValue.includes(null) ? ` OR ${queryInterface.quoteIdentifier(scopeKey2)} IS NULL` : "";
+        return initialClause + nullCheck;
+      })() : "";
+      if (this.collection.db.inDialect("postgres")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    SET ${sortColumnName} = ordered_table.new_sequence_number
+    FROM (
+      SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+      FROM ${this.collection.quotedTableName()}
+      ${whereClause}
+    ) AS ordered_table
+    WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField};
+  `;
+      } else if (this.collection.db.inDialect("sqlite")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    SET ${sortColumnName} = (
+      SELECT new_sequence_number
+      FROM (
+        SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+        FROM ${this.collection.quotedTableName()}
+        ${whereClause}
+      ) AS ordered_table
+      WHERE ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
+    );
+  `;
+      } else if (this.collection.db.inDialect("mysql") || this.collection.db.inDialect("mariadb")) {
+        sql = `
+    UPDATE ${this.collection.quotedTableName()}
+    JOIN (
+      SELECT *, ROW_NUMBER() OVER (${scopeKey2 ? `PARTITION BY ${queryInterface.quoteIdentifier(scopeKey2)}` : ""} ORDER BY ${quotedOrderField}) AS new_sequence_number
+      FROM ${this.collection.quotedTableName()}
+      ${whereClause}
+    ) AS ordered_table ON ${this.collection.quotedTableName()}.${quotedOrderField} = ordered_table.${quotedOrderField}
+    SET ${this.collection.quotedTableName()}.${sortColumnName} = ordered_table.new_sequence_number;
+  `;
+      }
+      await this.collection.db.sequelize.query(sql, {
+        transaction
+      });
+    }, "doInit");
+    const scopeKey = this.options.scopeKey;
+    if (scopeKey) {
+      const groups = await this.collection.repository.find({
+        attributes: [scopeKey],
+        group: [scopeKey],
+        raw: true,
+        transaction
+      });
+      const needInitGroups = [];
+      for (const group of groups) {
+        if (await needInit(scopeKey, group[scopeKey])) {
+          needInitGroups.push(group[scopeKey]);
+        }
+      }
+      if (needInitGroups.length > 0) {
+        await doInit(scopeKey, needInitGroups);
+      }
+    } else if (await needInit()) {
+      await doInit();
+    }
+  }, "initRecordsSortValue");
+  bind() {
+    super.bind();
+    this.on("afterSync", this.initRecordsSortValue);
+    this.on("beforeUpdate", this.onScopeChange);
+    this.on("beforeCreate", this.setSortValue);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeUpdate", this.onScopeChange);
+    this.off("beforeCreate", this.setSortValue);
+    this.off("afterSync", this.initRecordsSortValue);
+  }
+};
+__name(_SortField, "SortField");
+let SortField = _SortField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortField
+});

package/lib/fields/string-field.d.ts

@@ -0,0 +1,8 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class StringField extends Field {
+    get dataType(): DataTypes.StringDataTypeConstructor;
+}
+export interface StringFieldOptions extends BaseColumnFieldOptions {
+    type: 'string';
+}

package/lib/fields/string-field.js

@@ -0,0 +1,36 @@
+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_field_exports = {};
+__export(string_field_exports, {
+  StringField: () => StringField
+});
+module.exports = __toCommonJS(string_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _StringField = class _StringField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.STRING;
+  }
+};
+__name(_StringField, "StringField");
+let StringField = _StringField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringField
+});

package/lib/fields/text-field.d.ts

@@ -0,0 +1,8 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class TextField extends Field {
+    get dataType(): DataTypes.TextDataTypeConstructor;
+}
+export interface TextFieldOptions extends BaseColumnFieldOptions {
+    type: 'text';
+}

package/lib/fields/text-field.js

@@ -0,0 +1,36 @@
+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 text_field_exports = {};
+__export(text_field_exports, {
+  TextField: () => TextField
+});
+module.exports = __toCommonJS(text_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _TextField = class _TextField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.TEXT;
+  }
+};
+__name(_TextField, "TextField");
+let TextField = _TextField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TextField
+});

package/lib/fields/time-field.d.ts

@@ -0,0 +1,8 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class TimeField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+}
+export interface TimeFieldOptions extends BaseColumnFieldOptions {
+    type: 'time';
+}

package/lib/fields/time-field.js

@@ -0,0 +1,36 @@
+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 time_field_exports = {};
+__export(time_field_exports, {
+  TimeField: () => TimeField
+});
+module.exports = __toCommonJS(time_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _TimeField = class _TimeField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.TIME;
+  }
+};
+__name(_TimeField, "TimeField");
+let TimeField = _TimeField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeField
+});

package/lib/fields/uid-field.d.ts

@@ -0,0 +1,13 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class UidField extends Field {
+    get dataType(): DataTypes.StringDataTypeConstructor;
+    init(): void;
+    bind(): void;
+    unbind(): void;
+}
+export interface UidFieldOptions extends BaseColumnFieldOptions {
+    type: 'uid';
+    prefix?: string;
+    pattern?: string;
+}

package/lib/fields/uid-field.js

@@ -0,0 +1,63 @@
+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 uid_field_exports = {};
+__export(uid_field_exports, {
+  UidField: () => UidField
+});
+module.exports = __toCommonJS(uid_field_exports);
+var import_utils = require("@tachybase/utils");
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _UidField = class _UidField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.STRING;
+  }
+  init() {
+    const { name, prefix = "", pattern } = this.options;
+    const re = new RegExp(pattern || "^[A-Za-z0-9_][A-Za-z0-9_-]*$");
+    this.listener = async (instance) => {
+      const value = instance.get(name);
+      if (!value) {
+        instance.set(name, `${prefix}${(0, import_utils.uid)()}`);
+      } else if (re.test(value)) {
+        instance.set(name, value);
+      } else {
+        throw new Error(
+          `${this.collection.name}.${this.options.name} can only include A-Z, a-z, 0-9, _-*$, '${value}' is invalid`
+        );
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
+};
+__name(_UidField, "UidField");
+let UidField = _UidField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UidField
+});

package/lib/fields/uuid-field.d.ts

@@ -0,0 +1,9 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field, FieldContext } from './field';
+export declare class UuidField extends Field {
+    constructor(options?: any, context?: FieldContext);
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+}
+export interface UUIDFieldOptions extends BaseColumnFieldOptions {
+    type: 'uuid';
+}

package/lib/fields/uuid-field.js

@@ -0,0 +1,45 @@
+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 uuid_field_exports = {};
+__export(uuid_field_exports, {
+  UuidField: () => UuidField
+});
+module.exports = __toCommonJS(uuid_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _UuidField = class _UuidField extends import_field.Field {
+  constructor(options, context) {
+    super(
+      {
+        defaultValue: new import_sequelize.DataTypes.UUIDV4(),
+        ...options
+      },
+      context
+    );
+  }
+  get dataType() {
+    return import_sequelize.DataTypes.UUID;
+  }
+};
+__name(_UuidField, "UuidField");
+let UuidField = _UuidField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UuidField
+});

package/lib/fields/virtual-field.d.ts

@@ -0,0 +1,8 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class VirtualField extends Field {
+    get dataType(): DataTypes.VirtualDataTypeConstructor;
+}
+export interface VirtualFieldOptions extends BaseColumnFieldOptions {
+    type: 'virtual';
+}

package/lib/fields/virtual-field.js

@@ -0,0 +1,36 @@
+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 virtual_field_exports = {};
+__export(virtual_field_exports, {
+  VirtualField: () => VirtualField
+});
+module.exports = __toCommonJS(virtual_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _VirtualField = class _VirtualField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.VIRTUAL;
+  }
+};
+__name(_VirtualField, "VirtualField");
+let VirtualField = _VirtualField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VirtualField
+});

package/lib/filter-match.d.ts

@@ -0,0 +1 @@
+export declare function filterMatch(model: any, where: any): boolean;

package/lib/filter-match.js

@@ -0,0 +1,66 @@
+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 filter_match_exports = {};
+__export(filter_match_exports, {
+  filterMatch: () => filterMatch
+});
+module.exports = __toCommonJS(filter_match_exports);
+var import_mathjs = require("mathjs");
+function filterMatch(model, where) {
+  if (where.filter !== void 0) {
+    where = import_mathjs.filter;
+  }
+  const operatorFunctions = {
+    $eq: /* @__PURE__ */ __name((value, condition) => value === condition, "$eq"),
+    $not: /* @__PURE__ */ __name((value, condition) => !filterMatch(model, condition), "$not"),
+    $gt: /* @__PURE__ */ __name((value, condition) => value > condition, "$gt"),
+    $gte: /* @__PURE__ */ __name((value, condition) => value >= condition, "$gte"),
+    $lt: /* @__PURE__ */ __name((value, condition) => value < condition, "$lt"),
+    $lte: /* @__PURE__ */ __name((value, condition) => value <= condition, "$lte"),
+    $ne: /* @__PURE__ */ __name((value, condition) => value !== condition, "$ne"),
+    $in: /* @__PURE__ */ __name((value, condition) => condition.includes(value), "$in"),
+    $or: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).some((condition) => filterMatch(model2, condition)), "$or"),
+    $and: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).every((condition) => filterMatch(model2, condition)), "$and")
+  };
+  for (const [key, value] of Object.entries(where)) {
+    if (operatorFunctions[key] !== void 0) {
+      if (!operatorFunctions[key](model, value)) {
+        return false;
+      }
+    } else {
+      if (typeof value === "object") {
+        for (const [operator, condition] of Object.entries(value)) {
+          if (!operatorFunctions[operator](model[key], condition)) {
+            return false;
+          }
+        }
+      } else {
+        if (!operatorFunctions["$eq"](model[key], value)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+__name(filterMatch, "filterMatch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterMatch
+});

package/lib/filter-parser.d.ts

@@ -0,0 +1,21 @@
+import { ModelStatic } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import { Model } from './model';
+type FilterType = any;
+interface FilterParserContext {
+    collection: Collection;
+    app?: any;
+}
+export default class FilterParser {
+    collection: Collection;
+    database: Database;
+    model: ModelStatic<Model>;
+    filter: FilterType;
+    context: FilterParserContext;
+    constructor(filter: FilterType, context: FilterParserContext);
+    prepareFilter(filter: FilterType): any;
+    toSequelizeParams(): any;
+    private getFieldNameFromQueryPath;
+}
+export {};