@globalart/ddd 1.0.0

package/dist/index.mjs

@@ -0,0 +1,902 @@
+import { v4 } from "uuid";
+import { z } from "zod";
+import { isEmpty, isNil, isNumber } from "lodash";
+import { None, Ok, Some } from "oxide.ts";
+import { match } from "ts-pattern";
+import { dequal } from "dequal";
+import { isAfter, isBefore, isEqual, isToday, isTomorrow, isWithinInterval, isYesterday } from "date-fns";
+import { customAlphabet } from "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 ?? v4();
+		this.commandId = props.commandId ?? v4();
+	}
+};
+
+//#endregion
+//#region src/event.ts
+const eventSchema = (name, payload, meta) => z.object({
+	id: z.string().uuid(),
+	name: z.literal(name),
+	operatorId: z.string().optional(),
+	payload,
+	timestamp: z.coerce.date(),
+	meta
+});
+var BaseEvent = class {
+	constructor(payload, operatorId, meta, id = 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 = z.object({
+	field: z.string().min(1),
+	relation: z.string().min(1).optional()
+});
+
+//#endregion
+//#region src/filter/conjunction.ts
+const $and = z.literal("$and");
+const $or = z.literal("$or");
+const $not = z.literal("$not");
+const conjunctions = 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 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 = z.literal("$eq");
+const $neq = z.literal("$neq");
+const $contains = z.literal("$contains");
+const $not_contains = z.literal("$not_contains");
+const $starts_with = z.literal("$starts_with");
+const $ends_with = z.literal("$ends_with");
+const $regex = z.literal("$regex");
+const $is_true = z.literal("$is_true");
+const $is_false = z.literal("$is_false");
+const $in = z.literal("$in");
+const $nin = z.literal("$nin");
+const $gt = z.literal("$gt");
+const $lt = z.literal("$lt");
+const $gte = z.literal("$gte");
+const $lte = z.literal("$lte");
+const $start_eq = z.literal("$start_eq");
+const $start_neq = z.literal("$start_neq");
+const $start_gt = z.literal("$start_gt");
+const $start_lt = z.literal("$start_lt");
+const $start_gte = z.literal("$start_gte");
+const $start_lte = z.literal("$start_lte");
+const $end_eq = z.literal("$end_eq");
+const $end_neq = z.literal("$end_neq");
+const $end_gt = z.literal("$end_gt");
+const $end_lt = z.literal("$end_lt");
+const $end_gte = z.literal("$end_gte");
+const $end_lte = z.literal("$end_lte");
+const $is_empty = z.literal("$is_empty");
+const $is_not_empty = z.literal("$is_not_empty");
+const $is_today = z.literal("$is_today");
+const $is_not_today = z.literal("$is_not_today");
+const $is_tomorrow = z.literal("$is_tomorrow");
+const $is_yesterday = z.literal("$is_yesterday");
+const $between = z.literal("$between");
+const $has_file_type = z.literal("$has_file_type");
+const $has_file_extension = z.literal("$has_file_extension");
+const $is_root = z.literal("$is_root");
+const $is_me = z.literal("$is_me");
+const $is_not_me = z.literal("$is_not_me");
+const operatorsWihtoutValue = 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 = z.union([
+	$eq,
+	$neq,
+	$gt,
+	$gte,
+	$lt,
+	$lte,
+	$between,
+	$is_today,
+	$is_tomorrow,
+	$is_yesterday,
+	$is_not_today
+]);
+const dateFilterValue = z.string().nullable().or(z.tuple([z.string(), z.string()]));
+const dateFilter = z.object({
+	type: 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 = z.union([
+	$eq,
+	$neq,
+	$gt,
+	$gte,
+	$lt,
+	$lte,
+	$is_empty,
+	$is_not_empty
+]);
+const numberFilterValue = z.number().nullable();
+const numberFilter = z.object({
+	type: 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 = z.union([
+	$eq,
+	$neq,
+	$contains,
+	$not_contains,
+	$starts_with,
+	$ends_with,
+	$regex,
+	$is_empty,
+	$is_not_empty
+]);
+const stringFilterValue = z.string().nullable();
+const stringFilter = z.object({
+	type: 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 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 None;
+	let s = specs[0];
+	for (const spec of specs.slice(1)) s = s.and(spec);
+	return Some(s);
+};
+const andOptions = (...specs) => {
+	return and(...specs.filter((spec) => spec.isSome()).map((spec) => spec.unwrap()));
+};
+const or = (...specs) => {
+	if (!specs.length) return None;
+	let s = specs[0];
+	for (const spec of specs.slice(1)) s = s.or(spec);
+	return 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 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 && isAfter(d1, d2);
+	}
+	accept(v) {
+		v.dateGreaterThan(this);
+		return 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 && isBefore(d1, d2);
+	}
+	accept(v) {
+		v.dateLessThan(this);
+		return 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 && (isEqual(d1, d2) || isAfter(d1, d2));
+	}
+	accept(v) {
+		v.dateGreaterThanOrEqual(this);
+		return 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 && (isEqual(d1, d2) || isBefore(d1, d2));
+	}
+	accept(v) {
+		v.dateLessThanOrEqual(this);
+		return Ok(void 0);
+	}
+};
+var DateIsToday = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && isToday(date);
+	}
+	accept(v) {
+		v.dateIsToday(this);
+		return Ok(void 0);
+	}
+};
+var DateIsTomorrow = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && isTomorrow(date);
+	}
+	accept(v) {
+		v.dateIsTomorrow(this);
+		return Ok(void 0);
+	}
+};
+var DateIsYesterday = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		if (!(value instanceof DateFieldValue)) return false;
+		const date = value.unpack();
+		return !!date && isYesterday(date);
+	}
+	accept(v) {
+		v.dateIsYesterday(this);
+		return 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 && isWithinInterval(date, {
+			start: this.dateStart,
+			end: this.dateEnd
+		});
+	}
+	accept(v) {
+		v.dateBetween(this);
+		return 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 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 && isNumber(n2)) return true;
+		return n1 !== null && n2 !== null && n1 > n2;
+	}
+	accept(v) {
+		v.numberGreaterThan(this);
+		return 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 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 && isNumber(n2)) return true;
+		return n1 !== null && n2 !== null && n1 >= n2;
+	}
+	accept(v) {
+		v.numberGreaterThanOrEqual(this);
+		return 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 Ok(void 0);
+	}
+};
+var NumberEmpty = class extends BaseFilterSpecification {
+	constructor(field) {
+		super(field, new NumberFieldValue(null));
+		this.field = field;
+	}
+	isSatisfiedBy(value) {
+		return value instanceof NumberFieldValue && isNil(value.unpack());
+	}
+	accept(v) {
+		v.numberEmpty(this);
+		return 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 Ok(void 0);
+	}
+};
+var StringNotEqual = class extends BaseFilterSpecification {
+	isSatisfiedBy(value) {
+		return value instanceof StringFieldValue && this.value.equals(value);
+	}
+	accept(v) {
+		v.stringNotEqual(this);
+		return 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 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 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 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 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 Ok(void 0);
+	}
+};
+
+//#endregion
+//#region src/filter/filter.ts
+const filterRoorFilter = (filters) => {
+	const filterTuple = [filters[0], ...filters.slice(1)];
+	const filter$1 = z.union(filterTuple);
+	const group$1 = z.lazy(() => z.object({
+		conjunction: conjunctions,
+		children: 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 = z.discriminatedUnion("type", [
+	numberFilter,
+	stringFilter,
+	dateFilter
+]);
+const group = z.lazy(() => z.object({
+	conjunction: conjunctions,
+	children: 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 = z.union([numberFilterOperators, stringFilterOperators]);
+const operatorsMap = { number: numberFilterOperators.options.map((v) => v.value) };
+const convertStringFilter = (filter$1) => {
+	if (filter$1.value === void 0) return None;
+	switch (filter$1.operator) {
+		case "$eq": return Some(new StringEqual(filter$1.field, new StringFieldValue(filter$1.value), filter$1.relation));
+		case "$neq": return Some(new StringNotEqual(filter$1.field, new StringFieldValue(filter$1.value), filter$1.relation));
+		case "$contains": return Some(new StringContain(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$not_contains": return Some(new StringContain(filter$1.field, new StringFieldValue(filter$1.value)).not());
+		case "$starts_with": return Some(new StringStartsWith(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$ends_with": return Some(new StringEndsWith(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$regex": return Some(new StringRegex(filter$1.field, new StringFieldValue(filter$1.value)));
+		case "$is_empty": return Some(new StringEmpty(filter$1.field));
+		case "$is_not_empty": return Some(new StringEmpty(filter$1.field).not());
+		default: return None;
+	}
+};
+const convertNumberFilter = (filter$1) => {
+	if (filter$1 === void 0) return None;
+	switch (filter$1.operator) {
+		case "$eq": return Some(new NumberEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$neq": return Some(new NumberEqual(filter$1.field, new NumberFieldValue(filter$1.value)).not());
+		case "$gt": return Some(new NumberGreaterThan(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$gte": return Some(new NumberGreaterThanOrEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$lt": return Some(new NumberLessThan(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$lte": return Some(new NumberLessThanOrEqual(filter$1.field, new NumberFieldValue(filter$1.value)));
+		case "$is_empty": return Some(new NumberEmpty(filter$1.field));
+		case "$is_not_empty": return Some(new NumberEmpty(filter$1.field).not());
+		default: return None;
+	}
+};
+const convertDateFilter = (filter$1) => {
+	if (filter$1 === void 0) return None;
+	switch (filter$1.operator) {
+		case "$eq": return Some(new DateEqual(filter$1.field, DateFieldValue.fromNullableString(filter$1.value), filter$1.relation));
+		case "$between": return Some(new DateBetween(filter$1.field, new Date(filter$1.value[0]), new Date(filter$1.value[1])));
+	}
+};
+const convertFilter = (filter$1) => {
+	return match(filter$1).returnType().with({ type: "number" }, (f) => convertNumberFilter(f)).with({ type: "string" }, (f) => convertStringFilter(f)).with({ type: "date" }, (f) => convertDateFilter(f)).otherwise(() => 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 None;
+};
+const convertFilterOrGroupList = (filterOrGroupList$1 = [], conjunction = "$and") => {
+	let spec = 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) => isEmpty(filter$1);
+
+//#endregion
+//#region src/filter/fields/date/date-field.type.ts
+const dateFieldValue = z.date().nullable();
+
+//#endregion
+//#region src/filter/fields/number/number-field.type.ts
+const numberFieldValue = z.number().or(z.null());
+
+//#endregion
+//#region src/filter/fields/string/string-field.type.ts
+const stringFieldValue = 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 = z.object({
+	limit: z.coerce.number().positive().int().optional(),
+	offset: z.coerce.number().nonnegative().int().optional()
+});
+const paginatedResponseSchema = paginationSchema.extend({ total: z.number().nonnegative().int() });
+
+//#endregion
+//#region src/query.ts
+var Query = class {};
+
+//#endregion
+//#region src/sort.ts
+const sortingSchema = z.record(z.string(), 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 = 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
+export { $between, $contains, $end_eq, $end_gt, $end_gte, $end_lt, $end_lte, $end_neq, $ends_with, $eq, $gt, $gte, $has_file_extension, $has_file_type, $in, $is_empty, $is_false, $is_me, $is_not_empty, $is_not_me, $is_not_today, $is_root, $is_today, $is_tomorrow, $is_true, $is_yesterday, $lt, $lte, $neq, $nin, $not_contains, $regex, $start_eq, $start_gt, $start_gte, $start_lt, $start_lte, $start_neq, $starts_with, AggregateRoot, BaseEvent, BaseFilterSpecification, BoolVO, Command, CompositeSpecification, DateBetween, DateEqual, DateFieldValue, DateGreaterThan, DateGreaterThanOrEqual, DateIsToday, DateIsTomorrow, DateIsYesterday, DateLessThan, DateLessThanOrEqual, DateVO, ExceptionBase, FieldValueBase, ID, NanoID, NumberEmpty, NumberEqual, NumberFieldValue, NumberGreaterThan, NumberGreaterThanOrEqual, NumberLessThan, NumberLessThanOrEqual, Query, RootFilter, StringContain, StringEmpty, StringEndsWith, StringEqual, StringFieldValue, StringNotEqual, StringRegex, StringStartsWith, StringVO, ValueObject, and, andOptions, baseFilter, conjunctions, convertFilterSpec, convertPropsToObject, dateFieldValue, dateFilter, dateFilterOperators, dateFilterValue, eventSchema, filterOrGroupList, filterRoorFilter, isEmptyFilter, isFilter, isGroup, isOperatorWithoutValue, numberFieldValue, numberFilter, numberFilterOperators, numberFilterValue, operators, operatorsMap, operatorsWihtoutValue, or, paginatedResponseSchema, paginationSchema, rootFilter, sortingSchema, stringFieldValue, stringFilter, stringFilterOperators, stringFilterValue };
+//# sourceMappingURL=index.mjs.map