@globalart/ddd 1.0.0

package/dist/index.js

@@ -0,0 +1,1044 @@
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let uuid = require("uuid");
+uuid = __toESM(uuid);
+let zod = require("zod");
+zod = __toESM(zod);
+let lodash = require("lodash");
+lodash = __toESM(lodash);
+let oxide_ts = require("oxide.ts");
+oxide_ts = __toESM(oxide_ts);
+let ts_pattern = require("ts-pattern");
+ts_pattern = __toESM(ts_pattern);
+let dequal = require("dequal");
+dequal = __toESM(dequal);
+let date_fns = require("date-fns");
+date_fns = __toESM(date_fns);
+let nanoid = require("nanoid");
+nanoid = __toESM(nanoid);
+
+//#region src/aggregate-root.ts
+var AggregateRoot = class {
+	#domainEvents = [];
+	get domainEvents() {
+		return this.#domainEvents;
+	}
+	set domainEvents(events) {
+		this.#domainEvents = events;
+	}
+	addDomainEvent(event) {
+		this.#domainEvents.push(event);
+	}
+	removeEvents(events) {
+		this.#domainEvents = this.#domainEvents.filter((event) => !events.includes(event));
+	}
+};
+
+//#endregion
+//#region src/command.ts
+var Command = class {
+	commandId;
+	correlationId;
+	causationId;
+	constructor(props) {
+		this.correlationId = props.correlationId ?? (0, uuid.v4)();
+		this.commandId = props.commandId ?? (0, uuid.v4)();
+	}
+};
+
+//#endregion
+//#region src/event.ts
+const eventSchema = (name, payload, meta) => zod.z.object({
+	id: zod.z.string().uuid(),
+	name: zod.z.literal(name),
+	operatorId: zod.z.string().optional(),
+	payload,
+	timestamp: zod.z.coerce.date(),
+	meta
+});
+var BaseEvent = class {
+	constructor(payload, operatorId, meta, id = (0, uuid.v4)(), timestamp = /* @__PURE__ */ new Date()) {
+		this.payload = payload;
+		this.operatorId = operatorId;
+		this.meta = meta;
+		this.id = id;
+		this.timestamp = timestamp;
+	}
+	toJSON() {
+		return {
+			id: this.id,
+			name: this.name,
+			operatorId: this.operatorId,
+			timestamp: this.timestamp.toISOString(),
+			payload: this.payload,
+			meta: this.meta
+		};
+	}
+};
+
+//#endregion
+//#region src/exception.base.ts
+var ExceptionBase = class extends Error {
+	correlationId;
+	/**
+	*
+	* @param message
+	* @param correlationId
+	* @param cause
+	* @param metadata
+	*/
+	constructor(message, correlationId, cause, metadata) {
+		super(message);
+		this.message = message;
+		this.cause = cause;
+		this.metadata = metadata;
+		Error.captureStackTrace(this, this.constructor);
+		this.correlationId = correlationId;
+	}
+	toJSON() {
+		return {
+			message: this.message,
+			code: this.code,
+			stack: this.stack,
+			correlationId: this.correlationId,
+			cause: JSON.stringify(this.cause),
+			metadata: this.metadata
+		};
+	}
+};
+
+//#endregion
+//#region src/filter/base.filter.ts
+const baseFilter = zod.z.object({
+	field: zod.z.string().min(1),
+	relation: zod.z.string().min(1).optional()
+});
+
+//#endregion
+//#region src/filter/conjunction.ts
+const $and = zod.z.literal("$and");
+const $or = zod.z.literal("$or");
+const $not = zod.z.literal("$not");
+const conjunctions = zod.z.union([
+	$and,
+	$or,
+	$not
+]);
+
+//#endregion
+//#region src/utils.ts
+function convertPropsToObject(props) {
+	const propsCopy = { ...props };
+	for (const prop in propsCopy) {
+		if (Array.isArray(propsCopy[prop])) propsCopy[prop] = propsCopy[prop].map((item) => {
+			return convertToPlainObject(item);
+		});
+		propsCopy[prop] = convertToPlainObject(propsCopy[prop]);
+	}
+	return propsCopy;
+}
+function convertToPlainObject(item) {
+	if (ValueObject.isValueObject(item)) return item.unpack();
+	return item;
+}
+
+//#endregion
+//#region src/value-objects/value-object.ts
+var ValueObject = class ValueObject {
+	constructor(props) {
+		this.props = props;
+	}
+	equals(vo) {
+		if (vo === null || vo === void 0) return false;
+		return (0, dequal.dequal)(vo, this);
+	}
+	static isValueObject(obj) {
+		return obj instanceof ValueObject;
+	}
+	unpack() {
+		if (this.isDomainPrimitive(this.props)) return this.props.value;
+		const propsCopy = convertPropsToObject(this.props);
+		return Object.freeze(propsCopy);
+	}
+	isDomainPrimitive(obj) {
+		if (Object.prototype.hasOwnProperty.call(obj, "value")) return true;
+		return false;
+	}
+};
+
+//#endregion
+//#region src/filter/fields/field-value.base.ts
+var FieldValueBase = class extends ValueObject {};
+
+//#endregion
+//#region src/filter/fields/date/date-field-value.ts
+var DateFieldValue = class extends FieldValueBase {
+	constructor(value) {
+		super({ value });
+	}
+	accept(visitor) {
+		visitor.date(this);
+	}
+	static fromNullableString(str) {
+		if (!str) return new this(null);
+		return new this(new Date(str));
+	}
+};
+
+//#endregion
+//#region src/filter/operators.ts
+const $eq = zod.z.literal("$eq");
+const $neq = zod.z.literal("$neq");
+const $contains = zod.z.literal("$contains");
+const $not_contains = zod.z.literal("$not_contains");
+const $starts_with = zod.z.literal("$starts_with");
+const $ends_with = zod.z.literal("$ends_with");
+const $regex = zod.z.literal("$regex");
+const $is_true = zod.z.literal("$is_true");
+const $is_false = zod.z.literal("$is_false");
+const $in = zod.z.literal("$in");
+const $nin = zod.z.literal("$nin");
+const $gt = zod.z.literal("$gt");
+const $lt = zod.z.literal("$lt");
+const $gte = zod.z.literal("$gte");
+const $lte = zod.z.literal("$lte");
+const $start_eq = zod.z.literal("$start_eq");
+const $start_neq = zod.z.literal("$start_neq");
+const $start_gt = zod.z.literal("$start_gt");
+const $start_lt = zod.z.literal("$start_lt");
+const $start_gte = zod.z.literal("$start_gte");
+const $start_lte = zod.z.literal("$start_lte");
+const $end_eq = zod.z.literal("$end_eq");
+const $end_neq = zod.z.literal("$end_neq");
+const $end_gt = zod.z.literal("$end_gt");
+const $end_lt = zod.z.literal("$end_lt");
+const $end_gte = zod.z.literal("$end_gte");
+const $end_lte = zod.z.literal("$end_lte");
+const $is_empty = zod.z.literal("$is_empty");
+const $is_not_empty = zod.z.literal("$is_not_empty");
+const $is_today = zod.z.literal("$is_today");
+const $is_not_today = zod.z.literal("$is_not_today");
+const $is_tomorrow = zod.z.literal("$is_tomorrow");
+const $is_yesterday = zod.z.literal("$is_yesterday");
+const $between = zod.z.literal("$between");
+const $has_file_type = zod.z.literal("$has_file_type");
+const $has_file_extension = zod.z.literal("$has_file_extension");
+const $is_root = zod.z.literal("$is_root");
+const $is_me = zod.z.literal("$is_me");
+const $is_not_me = zod.z.literal("$is_not_me");
+const operatorsWihtoutValue = zod.z.union([
+	$is_empty,
+	$is_not_empty,
+	$is_today,
+	$is_not_today,
+	$is_tomorrow,
+	$is_yesterday,
+	$is_root,
+	$is_me,
+	$is_not_me
+]);
+const isOperatorWithoutValue = (value) => operatorsWihtoutValue.safeParse(value).success;
+
+//#endregion
+//#region src/filter/fields/date/date.filter.ts
+const dateFilterOperators = zod.z.union([
+	$eq,
+	$neq,
+	$gt,
+	$gte,
+	$lt,
+	$lte,
+	$between,
+	$is_today,
+	$is_tomorrow,
+	$is_yesterday,
+	$is_not_today
+]);
+const dateFilterValue = zod.z.string().nullable().or(zod.z.tuple([zod.z.string(), zod.z.string()]));
+const dateFilter = zod.z.object({
+	type: zod.z.literal("date"),
+	operator: dateFilterOperators,
+	value: dateFilterValue
+}).merge(baseFilter);
+
+//#endregion
+//#region src/filter/fields/number/number-field-value.ts
+var NumberFieldValue = class extends FieldValueBase {
+	constructor(value) {
+		super({ value });
+	}
+	accept(visitor) {
+		visitor.number(this);
+	}
+};
+
+//#endregion
+//#region src/filter/fields/number/number.filter.ts
+const numberFilterOperators = zod.z.union([
+	$eq,
+	$neq,
+	$gt,
+	$gte,
+	$lt,
+	$lte,
+	$is_empty,
+	$is_not_empty
+]);
+const numberFilterValue = zod.z.number().nullable();
+const numberFilter = zod.z.object({
+	type: zod.z.literal("number"),
+	operator: numberFilterOperators,
+	value: numberFilterValue
+}).merge(baseFilter);
+
+//#endregion
+//#region src/filter/fields/string/string-field-value.ts
+var StringFieldValue = class extends FieldValueBase {
+	constructor(value) {
+		super({ value });
+	}
+	accept(visitor) {
+		visitor.string(this);
+	}
+};
+
+//#endregion
+//#region src/filter/fields/string/string.filter.ts
+const stringFilterOperators = zod.z.union([
+	$eq,
+	$neq,
+	$contains,
+	$not_contains,
+	$starts_with,
+	$ends_with,
+	$regex,
+	$is_empty,
+	$is_not_empty
+]);
+const stringFilterValue = zod.z.string().nullable();
+const stringFilter = zod.z.object({
+	type: zod.z.literal("string"),
+	operator: stringFilterOperators,
+	value: stringFilterValue
+}).merge(baseFilter);
+
+//#endregion
+//#region src/specification.ts
+var CompositeSpecification = class {
+	and(s) {
+		return new And(this, s);
+	}
+	or(s) {
+		return new Or(this, s);
+	}
+	not() {
+		return new Not(this);
+	}
+};
+var And = class extends CompositeSpecification {
+	constructor(left, right) {
+		super();
+		this.left = left;
+		this.right = right;
+	}
+	isSatisfiedBy(t) {
+		return this.left.isSatisfiedBy(t) && this.right.isSatisfiedBy(t);
+	}
+	mutate(t) {
+		return this.left.mutate(t).and(this.right.mutate(t));
+	}
+	accept(v) {
+		return this.left.accept(v).and(this.right.accept(v));
+	}
+};
+var Or = class extends CompositeSpecification {
+	constructor(left, right) {
+		super();
+		this.left = left;
+		this.right = right;
+	}
+	isSatisfiedBy(t) {
+		return this.left.isSatisfiedBy(t) || this.right.isSatisfiedBy(t);
+	}
+	mutate(t) {
+		return this.left.mutate(t).orElse(() => this.right.mutate(t));
+	}
+	accept(v) {
+		v.or(this.left, this.right);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var Not = class extends CompositeSpecification {
+	constructor(spec) {
+		super();
+		this.spec = spec;
+	}
+	isSatisfiedBy(t) {
+		return !this.spec.isSatisfiedBy(t);
+	}
+	mutate() {
+		throw new Error("[Not.mutate] Method not implemented.");
+	}
+	accept(v) {
+		return this.spec.accept(v.not());
+	}
+};
+const and = (...specs) => {
+	if (!specs.length) return oxide_ts.None;
+	let s = specs[0];
+	for (const spec of specs.slice(1)) s = s.and(spec);
+	return (0, oxide_ts.Some)(s);
+};
+const andOptions = (...specs) => {
+	return and(...specs.filter((spec) => spec.isSome()).map((spec) => spec.unwrap()));
+};
+const or = (...specs) => {
+	if (!specs.length) return oxide_ts.None;
+	let s = specs[0];
+	for (const spec of specs.slice(1)) s = s.or(spec);
+	return (0, oxide_ts.Some)(s);
+};
+
+//#endregion
+//#region src/filter/filter-specification.base.ts
+var BaseFilterSpecification = class extends CompositeSpecification {
+	constructor(field, value, relation) {
+		super();
+		this.field = field;
+		this.value = value;
+		this.relation = relation;
+	}
+	mutate(t) {
+		throw new Error("Method not implemented.");
+	}
+};
+
+//#endregion
+//#region src/filter/specifications/date.specification.ts
+var DateEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		return value instanceof DateFieldValue && value.equals(this.value);
+	}
+	accept(v) {
+		v.dateEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateGreaterThan = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const d1 = value.unpack();
+		const d2 = this.value.unpack();
+		return !!d1 && !!d2 && (0, date_fns.isAfter)(d1, d2);
+	}
+	accept(v) {
+		v.dateGreaterThan(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateLessThan = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const d1 = value.unpack();
+		const d2 = this.value.unpack();
+		return !!d1 && !!d2 && (0, date_fns.isBefore)(d1, d2);
+	}
+	accept(v) {
+		v.dateLessThan(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateGreaterThanOrEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const d1 = value.unpack();
+		const d2 = this.value.unpack();
+		return !!d1 && !!d2 && ((0, date_fns.isEqual)(d1, d2) || (0, date_fns.isAfter)(d1, d2));
+	}
+	accept(v) {
+		v.dateGreaterThanOrEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateLessThanOrEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const d1 = value.unpack();
+		const d2 = this.value.unpack();
+		return !!d1 && !!d2 && ((0, date_fns.isEqual)(d1, d2) || (0, date_fns.isBefore)(d1, d2));
+	}
+	accept(v) {
+		v.dateLessThanOrEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateIsToday = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && (0, date_fns.isToday)(date);
+	}
+	accept(v) {
+		v.dateIsToday(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateIsTomorrow = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && (0, date_fns.isTomorrow)(date);
+	}
+	accept(v) {
+		v.dateIsTomorrow(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateIsYesterday = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && (0, date_fns.isYesterday)(date);
+	}
+	accept(v) {
+		v.dateIsYesterday(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var DateBetween = class extends BaseFilterSpecification {
+	constructor(field, dateStart, dateEnd, relation) {
+		super(field, null, relation);
+		this.field = field;
+		this.dateStart = dateStart;
+		this.dateEnd = dateEnd;
+		this.relation = relation;
+	}
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && (0, date_fns.isWithinInterval)(date, {
+			start: this.dateStart,
+			end: this.dateEnd
+		});
+	}
+	accept(v) {
+		v.dateBetween(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+
+//#endregion
+//#region src/filter/specifications/number.specification.ts
+var NumberEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		return value instanceof NumberFieldValue && value.equals(this.value);
+	}
+	accept(v) {
+		v.numberEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var NumberGreaterThan = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof NumberFieldValue)) return false;
+		const n1 = value.unpack();
+		const n2 = this.value.unpack();
+		if (n1 === null && (0, lodash.isNumber)(n2)) return true;
+		return n1 !== null && n2 !== null && n1 > n2;
+	}
+	accept(v) {
+		v.numberGreaterThan(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var NumberLessThan = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof NumberFieldValue)) return false;
+		const n1 = value.unpack();
+		const n2 = this.value.unpack();
+		return n1 !== null && n2 !== null && n1 < n2;
+	}
+	accept(v) {
+		v.numberLessThan(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var NumberGreaterThanOrEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof NumberFieldValue)) return false;
+		const n1 = value.unpack();
+		const n2 = this.value.unpack();
+		if (n1 === null && (0, lodash.isNumber)(n2)) return true;
+		return n1 !== null && n2 !== null && n1 >= n2;
+	}
+	accept(v) {
+		v.numberGreaterThanOrEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var NumberLessThanOrEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof NumberFieldValue)) return false;
+		const n1 = value.unpack();
+		const n2 = this.value.unpack();
+		return n1 !== null && n2 !== null && n1 <= n2;
+	}
+	accept(v) {
+		v.numberLessThanOrEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var NumberEmpty = class extends BaseFilterSpecification {
+	constructor(field) {
+		super(field, new NumberFieldValue(null));
+		this.field = field;
+	}
+	isSatisfiedBy(value) {
+		return value instanceof NumberFieldValue && (0, lodash.isNil)(value.unpack());
+	}
+	accept(v) {
+		v.numberEmpty(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+
+//#endregion
+//#region src/filter/specifications/string.specification.ts
+var StringEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		return value instanceof StringFieldValue && this.value.equals(value);
+	}
+	accept(v) {
+		v.stringEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringNotEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		return value instanceof StringFieldValue && this.value.equals(value);
+	}
+	accept(v) {
+		v.stringNotEqual(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringContain = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof StringFieldValue)) return false;
+		const s1 = value.unpack();
+		const s2 = this.value.unpack();
+		return !!s1 && !!s2 && s1.includes(s2);
+	}
+	accept(v) {
+		v.stringContain(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringStartsWith = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof StringFieldValue)) return false;
+		const s1 = value.unpack();
+		const s2 = this.value.unpack();
+		return !!s1 && !!s2 && s1.startsWith(s2);
+	}
+	accept(v) {
+		v.stringStartsWith(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringEndsWith = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof StringFieldValue)) return false;
+		const s1 = value.unpack();
+		const s2 = this.value.unpack();
+		return !!s1 && !!s2 && s1.endsWith(s2);
+	}
+	accept(v) {
+		v.stringEndsWith(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringRegex = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof StringFieldValue)) return false;
+		const s1 = value.unpack();
+		const s2 = this.value.unpack();
+		return !!s1 && !!s2 && new RegExp(s2).test(s1);
+	}
+	accept(v) {
+		v.stringRegex(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+var StringEmpty = class extends BaseFilterSpecification {
+	constructor(field) {
+		super(field, new StringFieldValue(null));
+	}
+	isSatisfiedBy(value) {
+		if (value instanceof StringFieldValue) return !value.unpack();
+		return !value;
+	}
+	accept(v) {
+		v.stringEmpty(this);
+		return (0, oxide_ts.Ok)(void 0);
+	}
+};
+
+//#endregion
+//#region src/filter/filter.ts
+const filterRoorFilter = (filters) => {
+	const filterTuple = [filters[0], ...filters.slice(1)];
+	const filter$1 = zod.z.union(filterTuple);
+	const group$1 = zod.z.lazy(() => zod.z.object({
+		conjunction: conjunctions,
+		children: zod.z.union([group$1, filter$1]).array().nonempty().optional()
+	}));
+	const filterOrGroup$1 = filter$1.or(group$1);
+	const filterOrGroupList$1 = filterOrGroup$1.array();
+	return group$1.or(filterOrGroupList$1);
+};
+const filter = zod.z.discriminatedUnion("type", [
+	numberFilter,
+	stringFilter,
+	dateFilter
+]);
+const group = zod.z.lazy(() => zod.z.object({
+	conjunction: conjunctions,
+	children: zod.z.union([group, filter]).array().nonempty().optional()
+}));
+const filterOrGroup = filter.or(group);
+const filterOrGroupList = filterOrGroup.array();
+const rootFilter = filterOrGroup.or(filterOrGroupList);
+const isGroup = (filterOrGroup$1) => {
+	return Reflect.has(filterOrGroup$1, "conjunction");
+};
+const isFilter = (filterOrGroup$1) => {
+	return Reflect.has(filterOrGroup$1, "type") && Reflect.has(filterOrGroup$1, "operator");
+};
+const operators = zod.z.union([numberFilterOperators, stringFilterOperators]);
+const operatorsMap = { number: numberFilterOperators.options.map((v) => v.value) };
+const convertStringFilter = (filter$1) => {
+	if (filter$1.value === void 0) return oxide_ts.None;
+	switch (filter$1.operator) {
+		case "$eq": return (0, oxide_ts.Some)(new StringEqual(filter$1.field, new StringFieldValue(filter$1.value), filter$1.relation));
+		case "$neq": return (0, oxide_ts.Some)(new StringNotEqual(filter$1.field, new StringFieldValue(filter$1.value), filter$1.relation));
+		case "$contains": return (0, oxide_ts.Some)(new StringContain(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$not_contains": return (0, oxide_ts.Some)(new StringContain(filter$1.field, new StringFieldValue(filter$1.value)).not());
+		case "$starts_with": return (0, oxide_ts.Some)(new StringStartsWith(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$ends_with": return (0, oxide_ts.Some)(new StringEndsWith(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$regex": return (0, oxide_ts.Some)(new StringRegex(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$is_empty": return (0, oxide_ts.Some)(new StringEmpty(filter$1.field));
+		case "$is_not_empty": return (0, oxide_ts.Some)(new StringEmpty(filter$1.field).not());
+		default: return oxide_ts.None;
+	}
+};
+const convertNumberFilter = (filter$1) => {
+	if (filter$1 === void 0) return oxide_ts.None;
+	switch (filter$1.operator) {
+		case "$eq": return (0, oxide_ts.Some)(new NumberEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$neq": return (0, oxide_ts.Some)(new NumberEqual(filter$1.field, new NumberFieldValue(filter$1.value)).not());
+		case "$gt": return (0, oxide_ts.Some)(new NumberGreaterThan(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$gte": return (0, oxide_ts.Some)(new NumberGreaterThanOrEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$lt": return (0, oxide_ts.Some)(new NumberLessThan(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$lte": return (0, oxide_ts.Some)(new NumberLessThanOrEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$is_empty": return (0, oxide_ts.Some)(new NumberEmpty(filter$1.field));
+		case "$is_not_empty": return (0, oxide_ts.Some)(new NumberEmpty(filter$1.field).not());
+		default: return oxide_ts.None;
+	}
+};
+const convertDateFilter = (filter$1) => {
+	if (filter$1 === void 0) return oxide_ts.None;
+	switch (filter$1.operator) {
+		case "$eq": return (0, oxide_ts.Some)(new DateEqual(filter$1.field, DateFieldValue.fromNullableString(filter$1.value), filter$1.relation));
+		case "$between": return (0, oxide_ts.Some)(new DateBetween(filter$1.field, new Date(filter$1.value[0]), new Date(filter$1.value[1])));
+	}
+};
+const convertFilter = (filter$1) => {
+	return (0, ts_pattern.match)(filter$1).returnType().with({ type: "number" }, (f) => convertNumberFilter(f)).with({ type: "string" }, (f) => convertStringFilter(f)).with({ type: "date" }, (f) => convertDateFilter(f)).otherwise(() => oxide_ts.None);
+};
+const convertFilterOrGroup = (filterOrGroup$1) => {
+	if (isGroup(filterOrGroup$1)) return convertFilterOrGroupList(filterOrGroup$1.children, filterOrGroup$1.conjunction);
+	else if (isFilter(filterOrGroup$1)) return convertFilter(filterOrGroup$1);
+	return oxide_ts.None;
+};
+const convertFilterOrGroupList = (filterOrGroupList$1 = [], conjunction = "$and") => {
+	let spec = oxide_ts.None;
+	for (const filter$1 of filterOrGroupList$1) if (spec.isNone()) {
+		spec = convertFilterOrGroup(filter$1);
+		if (conjunction === "$not") return spec.map((s) => s.not());
+	} else if (isFilter(filter$1)) spec = spec.map((left) => {
+		const right = convertFilterOrGroup(filter$1);
+		if (right.isSome()) {
+			if (conjunction === "$and") return left.and(right.unwrap());
+			else if (conjunction === "$or") return left.or(right.unwrap());
+			return left.and(right.unwrap().not());
+		}
+		return left;
+	});
+	else if (isGroup(filter$1)) spec = convertFilterOrGroupList(filter$1.children, filter$1.conjunction);
+	return spec;
+};
+const convertFilterSpec = (filter$1) => {
+	if (Array.isArray(filter$1)) return convertFilterOrGroupList(filter$1);
+	return convertFilterOrGroup(filter$1);
+};
+const isEmptyFilter = (filter$1) => (0, lodash.isEmpty)(filter$1);
+
+//#endregion
+//#region src/filter/fields/date/date-field.type.ts
+const dateFieldValue = zod.z.date().nullable();
+
+//#endregion
+//#region src/filter/fields/number/number-field.type.ts
+const numberFieldValue = zod.z.number().or(zod.z.null());
+
+//#endregion
+//#region src/filter/fields/string/string-field.type.ts
+const stringFieldValue = zod.z.string().nullable();
+
+//#endregion
+//#region src/filter/root-filter.ts
+var RootFilter = class extends ValueObject {
+	get value() {
+		return this.props;
+	}
+	get group() {
+		if (Array.isArray(this.value)) return {
+			conjunction: "$and",
+			children: this.value
+		};
+		if (isGroup(this.value)) return this.value;
+		return {
+			conjunction: "$and",
+			children: [this.value]
+		};
+	}
+	getSpec() {
+		return convertFilterSpec(this.value);
+	}
+	toJSON() {
+		return this.props;
+	}
+};
+
+//#endregion
+//#region src/pagination.ts
+const paginationSchema = zod.z.object({
+	limit: zod.z.coerce.number().positive().int().optional(),
+	offset: zod.z.coerce.number().nonnegative().int().optional()
+});
+const paginatedResponseSchema = paginationSchema.extend({ total: zod.z.number().nonnegative().int() });
+
+//#endregion
+//#region src/query.ts
+var Query = class {};
+
+//#endregion
+//#region src/sort.ts
+const sortingSchema = zod.z.record(zod.z.string(), zod.z.enum(["ASC", "DESC"]));
+
+//#endregion
+//#region src/value-objects/boolean.vo.ts
+var BoolVO = class BoolVO extends ValueObject {
+	constructor(value) {
+		super({ value });
+	}
+	get value() {
+		return this.props.value;
+	}
+	static True() {
+		return new BoolVO(true);
+	}
+	static False() {
+		return new BoolVO(false);
+	}
+};
+
+//#endregion
+//#region src/value-objects/date.vo.ts
+var DateVO = class DateVO extends ValueObject {
+	constructor(value) {
+		const date = new Date(value);
+		super({ value: date });
+	}
+	get value() {
+		return this.props.value;
+	}
+	static now() {
+		return new DateVO(Date.now());
+	}
+};
+
+//#endregion
+//#region src/value-objects/id.vo.ts
+var ID = class extends ValueObject {
+	constructor(value) {
+		super({ value });
+	}
+	get value() {
+		return this.props.value;
+	}
+};
+
+//#endregion
+//#region src/value-objects/nanoid.vo.ts
+var NanoID = class NanoID extends ID {
+	static ALPHABETS = "0123456789abcdefghijklmnopqrstuvwxyz";
+	static createId(prefix = "", size = 5) {
+		const id = (0, nanoid.customAlphabet)(NanoID.ALPHABETS, size)();
+		return prefix + id;
+	}
+	get value() {
+		return this.props.value;
+	}
+};
+
+//#endregion
+//#region src/value-objects/string.vo.ts
+var StringVO = class StringVO extends ValueObject {
+	constructor(value) {
+		super({ value });
+	}
+	get value() {
+		return this.props.value;
+	}
+	static empty() {
+		return new StringVO("");
+	}
+};
+
+//#endregion
+exports.$between = $between;
+exports.$contains = $contains;
+exports.$end_eq = $end_eq;
+exports.$end_gt = $end_gt;
+exports.$end_gte = $end_gte;
+exports.$end_lt = $end_lt;
+exports.$end_lte = $end_lte;
+exports.$end_neq = $end_neq;
+exports.$ends_with = $ends_with;
+exports.$eq = $eq;
+exports.$gt = $gt;
+exports.$gte = $gte;
+exports.$has_file_extension = $has_file_extension;
+exports.$has_file_type = $has_file_type;
+exports.$in = $in;
+exports.$is_empty = $is_empty;
+exports.$is_false = $is_false;
+exports.$is_me = $is_me;
+exports.$is_not_empty = $is_not_empty;
+exports.$is_not_me = $is_not_me;
+exports.$is_not_today = $is_not_today;
+exports.$is_root = $is_root;
+exports.$is_today = $is_today;
+exports.$is_tomorrow = $is_tomorrow;
+exports.$is_true = $is_true;
+exports.$is_yesterday = $is_yesterday;
+exports.$lt = $lt;
+exports.$lte = $lte;
+exports.$neq = $neq;
+exports.$nin = $nin;
+exports.$not_contains = $not_contains;
+exports.$regex = $regex;
+exports.$start_eq = $start_eq;
+exports.$start_gt = $start_gt;
+exports.$start_gte = $start_gte;
+exports.$start_lt = $start_lt;
+exports.$start_lte = $start_lte;
+exports.$start_neq = $start_neq;
+exports.$starts_with = $starts_with;
+exports.AggregateRoot = AggregateRoot;
+exports.BaseEvent = BaseEvent;
+exports.BaseFilterSpecification = BaseFilterSpecification;
+exports.BoolVO = BoolVO;
+exports.Command = Command;
+exports.CompositeSpecification = CompositeSpecification;
+exports.DateBetween = DateBetween;
+exports.DateEqual = DateEqual;
+exports.DateFieldValue = DateFieldValue;
+exports.DateGreaterThan = DateGreaterThan;
+exports.DateGreaterThanOrEqual = DateGreaterThanOrEqual;
+exports.DateIsToday = DateIsToday;
+exports.DateIsTomorrow = DateIsTomorrow;
+exports.DateIsYesterday = DateIsYesterday;
+exports.DateLessThan = DateLessThan;
+exports.DateLessThanOrEqual = DateLessThanOrEqual;
+exports.DateVO = DateVO;
+exports.ExceptionBase = ExceptionBase;
+exports.FieldValueBase = FieldValueBase;
+exports.ID = ID;
+exports.NanoID = NanoID;
+exports.NumberEmpty = NumberEmpty;
+exports.NumberEqual = NumberEqual;
+exports.NumberFieldValue = NumberFieldValue;
+exports.NumberGreaterThan = NumberGreaterThan;
+exports.NumberGreaterThanOrEqual = NumberGreaterThanOrEqual;
+exports.NumberLessThan = NumberLessThan;
+exports.NumberLessThanOrEqual = NumberLessThanOrEqual;
+exports.Query = Query;
+exports.RootFilter = RootFilter;
+exports.StringContain = StringContain;
+exports.StringEmpty = StringEmpty;
+exports.StringEndsWith = StringEndsWith;
+exports.StringEqual = StringEqual;
+exports.StringFieldValue = StringFieldValue;
+exports.StringNotEqual = StringNotEqual;
+exports.StringRegex = StringRegex;
+exports.StringStartsWith = StringStartsWith;
+exports.StringVO = StringVO;
+exports.ValueObject = ValueObject;
+exports.and = and;
+exports.andOptions = andOptions;
+exports.baseFilter = baseFilter;
+exports.conjunctions = conjunctions;
+exports.convertFilterSpec = convertFilterSpec;
+exports.convertPropsToObject = convertPropsToObject;
+exports.dateFieldValue = dateFieldValue;
+exports.dateFilter = dateFilter;
+exports.dateFilterOperators = dateFilterOperators;
+exports.dateFilterValue = dateFilterValue;
+exports.eventSchema = eventSchema;
+exports.filterOrGroupList = filterOrGroupList;
+exports.filterRoorFilter = filterRoorFilter;
+exports.isEmptyFilter = isEmptyFilter;
+exports.isFilter = isFilter;
+exports.isGroup = isGroup;
+exports.isOperatorWithoutValue = isOperatorWithoutValue;
+exports.numberFieldValue = numberFieldValue;
+exports.numberFilter = numberFilter;
+exports.numberFilterOperators = numberFilterOperators;
+exports.numberFilterValue = numberFilterValue;
+exports.operators = operators;
+exports.operatorsMap = operatorsMap;
+exports.operatorsWihtoutValue = operatorsWihtoutValue;
+exports.or = or;
+exports.paginatedResponseSchema = paginatedResponseSchema;
+exports.paginationSchema = paginationSchema;
+exports.rootFilter = rootFilter;
+exports.sortingSchema = sortingSchema;
+exports.stringFieldValue = stringFieldValue;
+exports.stringFilter = stringFilter;
+exports.stringFilterOperators = stringFilterOperators;
+exports.stringFilterValue = stringFilterValue;
+//# sourceMappingURL=index.js.map