@cosmicmind/domainjs
Version:
A domain-driven design framework for scalable systems.
265 lines (264 loc) • 10.1 kB
JavaScript
var __defProp = Object.defineProperty;
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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { FoundationError, guard } from "@cosmicmind/foundationjs";
import { Observable as Observable$1 } from "@cosmicmind/patternjs";
const _EntityError = class _EntityError extends FoundationError {
};
__name(_EntityError, "EntityError");
let EntityError = _EntityError;
const defineEntity = /* @__PURE__ */ __name((handler = {}) => (entity) => makeEntity(entity, handler), "defineEntity");
function makeEntityHandler(handler) {
return {
set(target, key, value) {
var _a, _b, _c, _d;
const property = (_a = handler.properties) == null ? void 0 : _a[key];
if (false === ((_b = property == null ? void 0 : property.validator) == null ? void 0 : _b.call(property, value, target))) {
throwError$2(`${JSON.stringify(target)} ${JSON.stringify(key)} is invalid`, handler);
}
(_c = property == null ? void 0 : property.updated) == null ? void 0 : _c.call(property, value, target[key], target);
const result = Reflect.set(target, key, value);
(_d = handler.trace) == null ? void 0 : _d.call(handler, target);
return result;
}
};
}
__name(makeEntityHandler, "makeEntityHandler");
function throwError$2(message, handler) {
var _a;
const error = new EntityError(message);
(_a = handler.error) == null ? void 0 : _a.call(handler, error);
throw error;
}
__name(throwError$2, "throwError$2");
function makeEntity(target, handler = {}) {
var _a, _b, _c, _d;
if (guard(target)) {
const properties = handler.properties;
if (guard(properties)) {
const entity = new Proxy(target, makeEntityHandler(handler));
for (const [key, property] of Object.entries(properties)) {
if (property.required) {
if (!(key in target)) {
throwError$2(`${JSON.stringify(target)} ${key} is required`, handler);
}
if (false === ((_a = property.validator) == null ? void 0 : _a.call(property, target[key], entity))) {
throwError$2(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
} else if (key in target && "undefined" !== typeof target[key]) {
if (guard(property, "validator") && false === ((_b = property.validator) == null ? void 0 : _b.call(property, target[key], entity))) {
throwError$2(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
}
}
(_c = handler.created) == null ? void 0 : _c.call(handler, entity);
(_d = handler.trace) == null ? void 0 : _d.call(handler, entity);
return entity;
}
}
throwError$2(`${JSON.stringify(target)} is invalid`, handler);
}
__name(makeEntity, "makeEntity");
const _Observable = class _Observable extends Observable$1 {
};
__name(_Observable, "Observable");
let Observable = _Observable;
const _EventObservable = class _EventObservable extends Observable {
};
__name(_EventObservable, "EventObservable");
let EventObservable = _EventObservable;
const _EventError = class _EventError extends FoundationError {
};
__name(_EventError, "EventError");
let EventError = _EventError;
const defineEvent = /* @__PURE__ */ __name((handler = {}) => (event) => makeEvent(event, handler), "defineEvent");
function makeEventHandler(handler) {
return {
set() {
throwError$1("cannot modify event properties", handler);
}
};
}
__name(makeEventHandler, "makeEventHandler");
function throwError$1(event, handler) {
var _a;
const error = new EventError(event);
(_a = handler.error) == null ? void 0 : _a.call(handler, error);
throw error;
}
__name(throwError$1, "throwError$1");
function makeEvent(target, handler = {}) {
var _a, _b, _c;
if (guard(target)) {
const properties = handler.properties;
if (guard(properties)) {
const event = new Proxy(target, makeEventHandler(handler));
for (const [key, property] of Object.entries(properties)) {
if (property.required) {
if (!(key in target)) {
throwError$1(`${JSON.stringify(target)} ${key} is required`, handler);
}
if (false === ((_a = property.validator) == null ? void 0 : _a.call(property, target[key], event))) {
throwError$1(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
} else if (key in target && "undefined" !== typeof target[key]) {
if (guard(property, "validator") && false === ((_b = property.validator) == null ? void 0 : _b.call(property, target[key], event))) {
throwError$1(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
}
}
(_c = handler.created) == null ? void 0 : _c.call(handler, event);
return event;
}
}
throw new EventError(`${String(target)} is invalid`);
}
__name(makeEvent, "makeEvent");
const _Aggregate = class _Aggregate extends EventObservable {
constructor(root) {
super();
__publicField(this, "root");
this.root = "function" === typeof this.prepare ? this.prepare(root) : root;
}
};
__name(_Aggregate, "Aggregate");
let Aggregate = _Aggregate;
function defineAggregate(_class, handler = {}) {
const createEntity = defineEntity(handler);
return (root) => new _class(createEntity(root));
}
__name(defineAggregate, "defineAggregate");
const _MessageObservable = class _MessageObservable extends Observable {
};
__name(_MessageObservable, "MessageObservable");
let MessageObservable = _MessageObservable;
const _MessageError = class _MessageError extends FoundationError {
};
__name(_MessageError, "MessageError");
let MessageError = _MessageError;
const defineMessage = /* @__PURE__ */ __name((handler = {}) => (message) => makeMessage(message, handler), "defineMessage");
function makeMessageHandler(handler) {
return {
set() {
throwError("cannot modify message properties", handler);
}
};
}
__name(makeMessageHandler, "makeMessageHandler");
function throwError(message, handler) {
var _a;
const error = new MessageError(message);
(_a = handler.error) == null ? void 0 : _a.call(handler, error);
throw error;
}
__name(throwError, "throwError");
function makeMessage(target, handler = {}) {
var _a, _b, _c;
if (guard(target)) {
const properties = handler.properties;
if (guard(properties)) {
const message = new Proxy(target, makeMessageHandler(handler));
for (const [key, property] of Object.entries(properties)) {
if (property.required) {
if (!(key in target)) {
throwError(`${JSON.stringify(target)} ${key} is required`, handler);
}
if (false === ((_a = property.validator) == null ? void 0 : _a.call(property, target[key], message))) {
throwError(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
} else if (key in target && "undefined" !== typeof target[key]) {
if (guard(property, "validator") && false === ((_b = property.validator) == null ? void 0 : _b.call(property, target[key], message))) {
throwError(`${JSON.stringify(target)} ${key} is invalid`, handler);
}
}
}
(_c = handler.created) == null ? void 0 : _c.call(handler, message);
return message;
}
}
throw new MessageError(`${String(target)} is invalid`);
}
__name(makeMessage, "makeMessage");
const _Value = class _Value {
/**
* Creates a new instance of the constructor.
*
* @template V - The type of the value to create.
* @param {V} value - The initial value for the instance.
*/
constructor(value) {
/**
* Represents the value of a variable.
*
* @description The type can be any valid JavaScript data type.
*/
__publicField(this, "_value");
this._value = "function" === typeof this.prepare ? this.prepare(value) : value;
}
/**
* Retrieves the value stored in the instance of the class.
*
* @returns {V} The value stored in the instance.
*/
get value() {
return this._value;
}
};
__name(_Value, "Value");
let Value = _Value;
const _ValueError = class _ValueError extends FoundationError {
};
__name(_ValueError, "ValueError");
let ValueError = _ValueError;
const defineValue = /* @__PURE__ */ __name((_class, handler = {}) => (value) => createValue(new _class(value), value, handler), "defineValue");
function createValueHandler(handler) {
return {
set(target, key, value) {
var _a;
if ("value" === key && false === ((_a = handler.validator) == null ? void 0 : _a.call(handler, value, target))) {
throw new ValueError(`${String(key)} is invalid`);
}
return Reflect.set(target, key, value);
}
};
}
__name(createValueHandler, "createValueHandler");
function throwErrorAndTrace(message, handler) {
var _a;
const error = new ValueError(message);
(_a = handler.error) == null ? void 0 : _a.call(handler, error);
throw error;
}
__name(throwErrorAndTrace, "throwErrorAndTrace");
function createValue(target, value, handler = {}) {
var _a, _b, _c;
if (guard(target)) {
const vo = new Proxy(target, createValueHandler(handler));
if (false === ((_a = handler.validator) == null ? void 0 : _a.call(handler, value, vo))) {
const className = target.constructor.name;
throwErrorAndTrace(`${className} is invalid: ${JSON.stringify(value)}`, handler);
}
(_b = handler.created) == null ? void 0 : _b.call(handler, vo);
(_c = handler.trace) == null ? void 0 : _c.call(handler, vo);
return vo;
}
throwErrorAndTrace(`${JSON.stringify(target)} is invalid`, handler);
}
__name(createValue, "createValue");
export {
Aggregate,
EntityError,
EventError,
EventObservable,
MessageError,
MessageObservable,
Observable,
Value,
ValueError,
defineAggregate,
defineEntity,
defineEvent,
defineMessage,
defineValue
};