@tachybase/database 0.23.8

package/lib/model.js

@@ -0,0 +1,152 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var model_exports = {};
+__export(model_exports, {
+  Model: () => Model
+});
+module.exports = __toCommonJS(model_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_sync_runner = require("./sync-runner");
+const _ = import_lodash.default;
+const _Model = class _Model extends import_sequelize.Model {
+  _changedWithAssociations = /* @__PURE__ */ new Set();
+  _previousDataValuesWithAssociations = {};
+  get db() {
+    return this.constructor.database;
+  }
+  static async sync(options) {
+    const runner = new import_sync_runner.SyncRunner(this);
+    return runner.runSync(options);
+  }
+  // TODO
+  toChangedWithAssociations() {
+    this._changedWithAssociations = /* @__PURE__ */ new Set([...this._changedWithAssociations, ...this._changed]);
+    this._previousDataValuesWithAssociations = this._previousDataValues;
+  }
+  changedWithAssociations(key, value) {
+    if (key === void 0) {
+      if (this._changedWithAssociations.size > 0) {
+        return Array.from(this._changedWithAssociations);
+      }
+      return false;
+    }
+    if (value === true) {
+      this._changedWithAssociations.add(key);
+      return this;
+    }
+    if (value === false) {
+      this._changedWithAssociations.delete(key);
+      return this;
+    }
+    return this._changedWithAssociations.has(key);
+  }
+  clearChangedWithAssociations() {
+    this._changedWithAssociations = /* @__PURE__ */ new Set();
+  }
+  toJSON() {
+    const handleObj = /* @__PURE__ */ __name((obj, options) => {
+      const handles = [
+        (data) => {
+          if (data instanceof _Model) {
+            return data.toJSON();
+          }
+          return data;
+        },
+        this.hiddenObjKey
+      ];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
+    }, "handleObj");
+    const handleArray = /* @__PURE__ */ __name((arrayOfObj, options) => {
+      const handles = [this.sortAssociations];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
+    }, "handleArray");
+    const opts = {
+      model: this.constructor,
+      collection: this.constructor.collection,
+      db: this.constructor.database
+    };
+    const traverseJSON = /* @__PURE__ */ __name((data, options) => {
+      const { model, db, collection } = options;
+      data = handleObj(data, options);
+      const result = {};
+      for (const key of Object.keys(data)) {
+        if (model.hasAlias(key)) {
+          const association = model.associations[key];
+          const opts2 = {
+            model: association.target,
+            collection: db.getCollection(association.target.name),
+            db,
+            key,
+            field: collection.getField(key)
+          };
+          if (["HasMany", "BelongsToMany"].includes(association.associationType)) {
+            result[key] = handleArray(data[key], opts2).map((item) => traverseJSON(item, opts2));
+          } else {
+            result[key] = data[key] ? traverseJSON(data[key], opts2) : null;
+          }
+        } else {
+          result[key] = data[key];
+        }
+      }
+      return result;
+    }, "traverseJSON");
+    return traverseJSON(super.toJSON(), opts);
+  }
+  hiddenObjKey(obj, options) {
+    const hiddenFields = Array.from(options.collection.fields.values()).filter((field) => field.options.hidden).map((field) => field.options.name);
+    return import_lodash.default.omit(obj, hiddenFields);
+  }
+  sortAssociations(data, { field }) {
+    const sortBy = field.options.sortBy;
+    return sortBy ? this.sortArray(data, sortBy) : data;
+  }
+  sortArray(data, sortBy) {
+    if (!import_lodash.default.isArray(sortBy)) {
+      sortBy = [sortBy];
+    }
+    const orderItems = [];
+    const orderDirections = [];
+    sortBy.forEach((sortItem) => {
+      orderDirections.push(sortItem.startsWith("-") ? "desc" : "asc");
+      orderItems.push(sortItem.replace("-", ""));
+    });
+    return import_lodash.default.orderBy(data, orderItems, orderDirections);
+  }
+};
+__name(_Model, "Model");
+__publicField(_Model, "database");
+__publicField(_Model, "collection");
+let Model = _Model;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Model
+});

package/lib/operators/array.d.ts

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

package/lib/operators/array.js

@@ -0,0 +1,158 @@
+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 array_exports = {};
+__export(array_exports, {
+  default: () => array_default
+});
+module.exports = __toCommonJS(array_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_utils = require("./utils");
+const getFieldName = /* @__PURE__ */ __name((ctx) => {
+  const fieldName = ctx.fieldName;
+  return fieldName;
+}, "getFieldName");
+const escape = /* @__PURE__ */ __name((value, ctx) => {
+  const sequelize = ctx.db.sequelize;
+  return sequelize.escape(value);
+}, "escape");
+const getQueryInterface = /* @__PURE__ */ __name((ctx) => {
+  const sequelize = ctx.db.sequelize;
+  return sequelize.getQueryInterface();
+}, "getQueryInterface");
+const sqliteExistQuery = /* @__PURE__ */ __name((value, ctx) => {
+  const fieldName = getFieldName(ctx);
+  const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+  const sqlArray = `(${value.map((v) => `'${v}'`).join(", ")})`;
+  const subQuery = `exists (select * from json_each(${name}) where json_each.value in ${sqlArray})`;
+  return subQuery;
+}, "sqliteExistQuery");
+const emptyQuery = /* @__PURE__ */ __name((ctx, operator) => {
+  const fieldName = getFieldName(ctx);
+  let funcName = "json_array_length";
+  let ifNull = "IFNULL";
+  if ((0, import_utils.isPg)(ctx)) {
+    funcName = "jsonb_array_length";
+    ifNull = "coalesce";
+  }
+  if ((0, import_utils.isMySQL)(ctx)) {
+    funcName = "json_length";
+  }
+  return `(select ${ifNull}(${funcName}(${fieldName}), 0) ${operator} 0)`;
+}, "emptyQuery");
+var array_default = {
+  $match(value, ctx) {
+    const fieldName = getFieldName(ctx);
+    if ((0, import_utils.isPg)(ctx)) {
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      const queryValue = escape(JSON.stringify(value), ctx);
+      return import_sequelize.Sequelize.literal(`${name} @> ${queryValue}::JSONB AND ${name} <@ ${queryValue}::JSONB`);
+    }
+    value = escape(JSON.stringify(value.sort()), ctx);
+    if ((0, import_utils.isMySQL)(ctx)) {
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return import_sequelize.Sequelize.literal(`JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name})`);
+    }
+    return {
+      [import_sequelize.Op.eq]: import_sequelize.Sequelize.literal(`json(${value})`)
+    };
+  },
+  $notMatch(value, ctx) {
+    const fieldName = getFieldName(ctx);
+    value = escape(JSON.stringify(value), ctx);
+    if ((0, import_utils.isPg)(ctx)) {
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      return import_sequelize.Sequelize.literal(`not (${name} <@ ${value}::JSONB and ${name} @> ${value}::JSONB)`);
+    }
+    if ((0, import_utils.isMySQL)(ctx)) {
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return import_sequelize.Sequelize.literal(`not (JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name}))`);
+    }
+    return {
+      [import_sequelize.Op.ne]: import_sequelize.Sequelize.literal(`json(${value})`)
+    };
+  },
+  $anyOf(value, ctx) {
+    const fieldName = getFieldName(ctx);
+    value = import_lodash.default.castArray(value);
+    if ((0, import_utils.isPg)(ctx)) {
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      return import_sequelize.Sequelize.literal(
+        `${name} ?| ${escape(
+          value.map((i) => `${i}`),
+          ctx
+        )}`
+      );
+    }
+    if ((0, import_utils.isMySQL)(ctx)) {
+      value = escape(JSON.stringify(value), ctx);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return import_sequelize.Sequelize.literal(`JSON_OVERLAPS(${name}, ${value})`);
+    }
+    const subQuery = sqliteExistQuery(value, ctx);
+    return import_sequelize.Sequelize.literal(subQuery);
+  },
+  $noneOf(value, ctx) {
+    let where;
+    value = import_lodash.default.castArray(value);
+    if ((0, import_utils.isPg)(ctx)) {
+      const fieldName = getFieldName(ctx);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      where = import_sequelize.Sequelize.literal(
+        `not (${name} ?| ${escape(
+          value.map((i) => `${i}`),
+          ctx
+        )})`
+      );
+    } else if ((0, import_utils.isMySQL)(ctx)) {
+      const fieldName = getFieldName(ctx);
+      value = escape(JSON.stringify(value), ctx);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      where = import_sequelize.Sequelize.literal(`NOT JSON_OVERLAPS(${name}, ${value})`);
+    } else {
+      const subQuery = sqliteExistQuery(value, ctx);
+      where = import_sequelize.Sequelize.literal(`not ${subQuery}`);
+    }
+    return {
+      [import_sequelize.Op.or]: [where, { [import_sequelize.Op.is]: null }]
+    };
+  },
+  $arrayEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, "=");
+    return {
+      [import_sequelize.Op.and]: [import_sequelize.Sequelize.literal(`${subQuery}`)]
+    };
+  },
+  $arrayNotEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, ">");
+    return {
+      [import_sequelize.Op.and]: [import_sequelize.Sequelize.literal(`${subQuery}`)]
+    };
+  }
+};

package/lib/operators/association.d.ts

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

package/lib/operators/association.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 association_exports = {};
+__export(association_exports, {
+  default: () => association_default
+});
+module.exports = __toCommonJS(association_exports);
+var import_sequelize = require("sequelize");
+var association_default = {
+  $exists(value, ctx) {
+    return {
+      [import_sequelize.Op.not]: null
+    };
+  },
+  $notExists(value, ctx) {
+    return {
+      [import_sequelize.Op.is]: null
+    };
+  }
+};

package/lib/operators/boolean.d.ts

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

package/lib/operators/boolean.js

@@ -0,0 +1,38 @@
+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 boolean_exports = {};
+__export(boolean_exports, {
+  default: () => boolean_default
+});
+module.exports = __toCommonJS(boolean_exports);
+var import_sequelize = require("sequelize");
+var boolean_default = {
+  $isFalsy() {
+    return {
+      [import_sequelize.Op.or]: {
+        [import_sequelize.Op.is]: null,
+        [import_sequelize.Op.eq]: false
+      }
+    };
+  },
+  $isTruly() {
+    return {
+      [import_sequelize.Op.eq]: true
+    };
+  }
+};

package/lib/operators/child-collection.d.ts

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

package/lib/operators/child-collection.js

@@ -0,0 +1,67 @@
+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 child_collection_exports = {};
+__export(child_collection_exports, {
+  default: () => child_collection_default
+});
+module.exports = __toCommonJS(child_collection_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+const mapVal = /* @__PURE__ */ __name((values, db) => values.map((v) => {
+  const collection = db.getCollection(v);
+  return import_sequelize.Sequelize.literal(`'${collection.tableNameAsString()}'::regclass`);
+}), "mapVal");
+const filterItems = /* @__PURE__ */ __name((values, db) => {
+  return import_lodash.default.castArray(values).map((v) => {
+    const collection = db.getCollection(v);
+    if (!collection) return null;
+    return `'${collection.tableNameAsString()}'::regclass`;
+  }).filter(Boolean);
+}, "filterItems");
+const joinValues = /* @__PURE__ */ __name((items) => items.join(", "), "joinValues");
+var child_collection_default = {
+  $childIn(values, ctx) {
+    const db = ctx.db;
+    const items = filterItems(values, db);
+    if (items.length) {
+      return import_sequelize.Sequelize.literal(`"${ctx.model.name}"."tableoid" IN (${joinValues(items)})`);
+    } else {
+      return import_sequelize.Sequelize.literal(`1 = 2`);
+    }
+  },
+  $childNotIn(values, ctx) {
+    const db = ctx.db;
+    const items = filterItems(values, db);
+    if (items.length) {
+      return import_sequelize.Sequelize.literal(`"${ctx.model.name}"."tableoid" NOT IN (${joinValues(items)})`);
+    } else {
+      return import_sequelize.Sequelize.literal(`1 = 1`);
+    }
+  }
+};

package/lib/operators/date.d.ts

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

package/lib/operators/date.js

@@ -0,0 +1,140 @@
+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 date_exports = {};
+__export(date_exports, {
+  default: () => date_default
+});
+module.exports = __toCommonJS(date_exports);
+var import_utils = require("@tachybase/utils");
+var import_sequelize = require("sequelize");
+function isDate(input) {
+  return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+}
+__name(isDate, "isDate");
+const toDate = /* @__PURE__ */ __name((date) => {
+  if (isDate(date)) {
+    return date;
+  }
+  return new Date(date);
+}, "toDate");
+var date_default = {
+  $dateOn(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.eq]: toDate(r)
+      };
+    }
+    if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0]) }, { [import_sequelize.Op.lt]: toDate(r[1]) }]
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateNotOn(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.ne]: toDate(r)
+      };
+    }
+    if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.or]: [{ [import_sequelize.Op.lt]: toDate(r[0]) }, { [import_sequelize.Op.gte]: toDate(r[1]) }]
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateBefore(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.lt]: toDate(r)
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.lt]: toDate(r[0])
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateNotBefore(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.gte]: toDate(r)
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.gte]: toDate(r[0])
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateAfter(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.gt]: toDate(r)
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.gte]: toDate(r[1])
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateNotAfter(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (typeof r === "string") {
+      return {
+        [import_sequelize.Op.lte]: toDate(r)
+      };
+    } else if (Array.isArray(r)) {
+      return {
+        [import_sequelize.Op.lt]: toDate(r[1])
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  },
+  $dateBetween(value, ctx) {
+    const r = (0, import_utils.parseDate)(value, {
+      timezone: ctx.db.options.timezone
+    });
+    if (r) {
+      return {
+        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0]) }, { [import_sequelize.Op.lt]: toDate(r[1]) }]
+      };
+    }
+    throw new Error(`Invalid Date ${JSON.stringify(value)}`);
+  }
+};

package/lib/operators/empty.d.ts

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