1 line
74 KiB
JSON
1 line
74 KiB
JSON
{"ast":null,"code":"import { Observable } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nclass Key {\n token;\n stringKey;\n constructor(token) {\n this.token = token;\n this.stringKey = this.generateStringKey();\n }\n static from(token) {\n return new Key(token);\n }\n toString() {\n return this.stringKey;\n }\n generateStringKey() {\n if (typeof this.token !== 'string') {\n return this.token.toString().split(' ')[1] || '';\n } else {\n return this.token;\n }\n }\n}\nclass NotFoundKey extends Key {\n constructor(token) {\n super(token);\n }\n getError() {\n if (typeof this.token === 'string') {\n return 'Key not found for the token: ' + this.token;\n } else {\n return 'Key not found for the token: ' + this.token.toString();\n }\n }\n}\nclass KeyRegister {\n records = new Map();\n getKey(token) {\n const key = this.records.get(token);\n if (!key) {\n return new NotFoundKey(token);\n }\n return key;\n }\n getKeyAndTryRegister(token, provider) {\n if (!this.has(token)) {\n this.set(token, provider);\n }\n return this.getKey(token);\n }\n has(token) {\n return this.records.has(token);\n }\n set(token, _provider) {\n this.records.set(token, Key.from(token));\n }\n clear() {\n this.records.clear();\n }\n}\nclass ProviderManager {\n providers = new Map();\n get(key) {\n const recordFactory = this.providers.get(key);\n if (!recordFactory) {\n throw new Error(`There is no provider for ${key.toString()}.`);\n }\n return recordFactory;\n }\n has(key) {\n return this.providers.has(key);\n }\n set(key, recordFactory) {\n this.providers.set(key, recordFactory);\n }\n clear() {\n this.providers.clear();\n }\n}\nclass Dependency {\n serviceToken;\n constructor(serviceToken) {\n this.serviceToken = serviceToken;\n }\n getToken() {\n if (typeof this.serviceToken === 'object') {\n return this.serviceToken.inject;\n } else {\n return this.serviceToken;\n }\n }\n isOptional() {\n if (typeof this.serviceToken !== 'string' && typeof this.serviceToken === 'object' && this.serviceToken.optional !== undefined) {\n return this.serviceToken.optional;\n }\n return false;\n }\n /**\n * @deprecated\n */\n isCollection() {\n if (typeof this.serviceToken !== 'string' && typeof this.serviceToken === 'object' && this.serviceToken.collection) {\n return this.serviceToken.collection;\n }\n return false;\n }\n}\nclass RecordFactory {\n provider;\n constructor(provider) {\n this.provider = provider;\n }\n getDeps() {\n return (this.provider.services || []).map(service => new Dependency(service));\n }\n}\nclass ClassRecordFactory extends RecordFactory {\n constructor(provider) {\n super(provider);\n }\n create(depsInstances) {\n return new this.provider(...depsInstances);\n }\n}\nclass ValueRecordFactory extends RecordFactory {\n constructor(provider) {\n super(provider);\n }\n getDeps() {\n return [];\n }\n create(_depsInstances) {\n return this.provider;\n }\n}\nclass FactoryRecordFactory extends RecordFactory {\n constructor(provider) {\n super(provider);\n }\n getDeps() {\n return (this.provider.deps || []).map(service => new Dependency(service));\n }\n create(depsInstances) {\n return this.provider.create(...depsInstances);\n }\n}\nclass CollectionRecordFactory {}\nclass ClassCollectionRecordFactory extends CollectionRecordFactory {\n providers = [];\n getDeps() {\n return this.providers.map(provider => {\n return (provider.services || []).map(service => {\n return new Dependency(service);\n });\n });\n }\n create(setOfDeps) {\n return setOfDeps.map((deps, index) => {\n return new this.providers[index](...deps);\n });\n }\n addProvider(provider) {\n this.providers.push(provider);\n }\n}\nclass FactoryCollectionRecordFactory extends CollectionRecordFactory {\n providers = [];\n getDeps() {\n return this.providers.map(provider => {\n return (provider.deps || []).map(service => new Dependency(service));\n });\n }\n create(setOfDeps) {\n return setOfDeps.map((deps, index) => {\n return this.providers[index].create(...deps);\n });\n }\n addProvider(provider) {\n this.providers.push(provider);\n }\n}\nclass ValueCollectionRecordFactory extends CollectionRecordFactory {\n providers = [];\n getDeps() {\n return [];\n }\n create(_setOfDeps) {\n return [...this.providers];\n }\n addProvider(provider) {\n this.providers.push(provider);\n }\n}\nclass ContainerProvider {\n keyRegister;\n providerManager = new ProviderManager();\n collectionProviders = new Map();\n constructor(keyRegister) {\n this.keyRegister = keyRegister;\n }\n provide(token, provider) {\n if (provider === undefined) {\n return this.provide(token, token);\n } else {\n return this.provideClass(token, provider);\n }\n }\n provideClass(token, provider) {\n return this.addProvider(token, provider, provider => new ClassRecordFactory(provider));\n }\n provideValue(token, provider) {\n return this.addProvider(token, provider, provider => new ValueRecordFactory(provider));\n }\n provideFactory(token, provider) {\n return this.addProvider(token, provider, provider => new FactoryRecordFactory(provider));\n }\n provideCollection(token, provider) {\n return this.addCollectionProvider(token, provider, () => new ClassCollectionRecordFactory());\n }\n provideFactoryCollection(token, provider) {\n return this.addCollectionProvider(token, provider, () => new FactoryCollectionRecordFactory());\n }\n provideValueCollection(token, provider) {\n return this.addCollectionProvider(token, provider, () => new ValueCollectionRecordFactory());\n }\n clear() {\n this.providerManager.clear();\n this.collectionProviders.clear();\n }\n getRecordFactory(key) {\n return this.providerManager.get(key);\n }\n getCollectionRecordFactory(key) {\n return this.collectionProviders.get(key);\n }\n addProvider(token, provider, provideMethod) {\n const key = this.keyRegister.getKeyAndTryRegister(token, provider);\n this.providerManager.set(key, provideMethod(provider));\n }\n addCollectionProvider(token, provider, createFactory) {\n const key = this.keyRegister.getKeyAndTryRegister(token, provider);\n if (this.collectionProviders.has(key)) {\n const multiFactory = this.collectionProviders.get(key);\n if (multiFactory) {\n multiFactory.addProvider(provider);\n }\n } else {\n const multiFactory = createFactory();\n multiFactory.addProvider(provider);\n this.collectionProviders.set(key, multiFactory);\n }\n }\n}\nclass RecordManager {\n records = new Map();\n get(key) {\n return this.records.get(key);\n }\n has(key) {\n return this.records.has(key);\n }\n set(key, record) {\n this.records.set(key, record);\n }\n clear() {\n this.records.clear();\n }\n}\nclass ContainerRecord {\n keyRegister;\n containerProvider;\n recordManager = new RecordManager();\n collectionRecords = new Map();\n constructor(keyRegister, containerProvider) {\n this.keyRegister = keyRegister;\n this.containerProvider = containerProvider;\n }\n resolve(token) {\n return this.innerResolve(token);\n }\n resolveCollection(token) {\n return this.innerResolveCollection(token);\n }\n clear() {\n this.recordManager.clear();\n this.collectionRecords.clear();\n }\n resolveDependencies(provider) {\n const deps = provider.getDeps();\n return deps.map(dep => {\n if (dep.isCollection()) {\n return this.innerResolveCollection(dep.getToken(), dep.isOptional());\n } else {\n return this.resolveDependency(dep);\n }\n });\n }\n resolveDependency(dep) {\n return this.innerResolve(dep.getToken(), dep.isOptional());\n }\n innerResolve(token, isOptional) {\n const key = this.keyRegister.getKey(token);\n if (key instanceof NotFoundKey) {\n if (isOptional) {\n return null;\n } else {\n throw new Error(key.getError());\n }\n }\n if (!this.recordManager.has(key)) {\n const recordFactory = this.containerProvider.getRecordFactory(key);\n const depsInstances = this.resolveDependencies(recordFactory);\n const instance = recordFactory.create(depsInstances);\n this.recordManager.set(key, instance);\n }\n return this.recordManager.get(key);\n }\n innerResolveCollection(token, isOptional = false) {\n const key = this.keyRegister.getKey(token);\n if (key instanceof NotFoundKey) {\n if (isOptional) {\n return null;\n } else {\n throw new Error(key.getError());\n }\n }\n if (!this.collectionRecords.has(key)) {\n const multiFactory = this.containerProvider.getCollectionRecordFactory(key);\n if (multiFactory) {\n const arrayOfDeps = multiFactory.getDeps().map(deps => {\n return deps.map(dep => {\n if (dep.isCollection()) {\n return this.innerResolveCollection(dep.getToken(), dep.isOptional());\n } else {\n return this.resolveDependency(dep);\n }\n });\n });\n const instances = multiFactory.create(arrayOfDeps);\n this.collectionRecords.set(key, instances);\n }\n }\n return this.collectionRecords.get(key);\n }\n}\nclass ContainerFacade {\n keyRegister = new KeyRegister();\n containerProvider = new ContainerProvider(this.keyRegister);\n containerRecord = new ContainerRecord(this.keyRegister, this.containerProvider);\n resolve(token) {\n return this.containerRecord.resolve(token);\n }\n resolveCollection(token) {\n return this.containerRecord.resolveCollection(token);\n }\n provide(token, provider) {\n this.containerProvider.provide(token, provider);\n return this;\n }\n provideClass(token, provider) {\n this.containerProvider.provideClass(token, provider);\n return this;\n }\n provideValue(token, provider) {\n this.containerProvider.provideValue(token, provider);\n return this;\n }\n provideFactory(token, provider) {\n this.containerProvider.provideFactory(token, provider);\n return this;\n }\n provideCollection(token, provider) {\n this.containerProvider.provideCollection(token, provider);\n return this;\n }\n provideFactoryCollection(token, provider) {\n this.containerProvider.provideFactoryCollection(token, provider);\n return this;\n }\n provideValueCollection(token, provider) {\n this.containerProvider.provideValueCollection(token, provider);\n return this;\n }\n clear() {\n this.keyRegister.clear();\n this.containerProvider.clear();\n this.containerRecord.clear();\n }\n clearOnlyRecords() {\n this.containerRecord.clear();\n }\n}\nfunction createContainer() {\n return new ContainerFacade();\n}\nclass HermesSubscription {\n subscriber;\n closed = false;\n constructor(subscriber, isClosed) {\n this.subscriber = subscriber;\n if (isClosed !== undefined && isClosed !== null) {\n this.closed = isClosed;\n }\n }\n unsubscribe() {\n if (this.closed) {\n return;\n }\n this.closed = true;\n this.subscriber.unsubscribe();\n }\n getFinalize() {\n return this.subscriber.getFinalize();\n }\n}\nclass HermesSubscriber {\n observer;\n // eslint-disable-next-line\n finalize = () => {};\n completed = false;\n closed = false;\n constructor(config) {\n this.observer = config;\n }\n next(value) {\n if (this.isCompleted()) {\n return;\n }\n if (this.observer && this.observer.next) {\n this.observer.next(value);\n }\n }\n error(error) {\n if (this.completed) {\n return;\n }\n if (this.observer && this.observer.error) {\n this.observer.error(error);\n }\n this.unsubscribe();\n }\n complete() {\n if (this.completed) {\n return;\n }\n this.completed = true;\n if (this.observer && this.observer.complete) {\n this.observer.complete();\n }\n this.unsubscribe();\n }\n unsubscribe() {\n if (this.closed) {\n return;\n }\n this.closed = true;\n this.completed = true;\n this.finalize();\n }\n setFinalize(finalize) {\n if (finalize && typeof finalize === 'function') {\n this.finalize = finalize;\n } else {}\n }\n getFinalize() {\n return this.finalize;\n }\n isCompleted() {\n return this.completed;\n }\n isClosed() {\n return this.closed;\n }\n getObserver() {\n return this.observer;\n }\n}\nclass HermesObservable {\n generatorFn;\n source;\n // private operator: HermesObservable<T>;\n // eslint-disable-next-line\n generatorFinalize;\n constructor(generator) {\n this.generatorFn = generator;\n }\n pipe(...operations) {\n this.source = this;\n for (const operation of operations) {\n this.source = this.innerPipe(operation, this.source);\n }\n return this.source;\n }\n subscribe(arg) {\n let subscriber;\n if (arg instanceof HermesSubscriber) {\n subscriber = arg;\n } else if (arg !== null && this.isObserver(arg)) {\n const {\n next,\n error,\n complete\n } = arg;\n subscriber = this.createSubscriber(next, error, complete);\n } else {\n subscriber = this.createSubscriber(arguments[0], arguments[1], arguments[2]);\n }\n if (this.generatorFn) {\n this.generatorFinalize = this.generatorFn(subscriber);\n subscriber.setFinalize(this.generatorFinalize);\n }\n return this.getSubscription(subscriber);\n }\n createSubscriber(next, error, complete) {\n return new HermesSubscriber({\n next,\n error,\n complete\n });\n }\n getSubscription(subscriber) {\n return new HermesSubscription(subscriber);\n }\n innerPipe(operation, stream$) {\n return (input => {\n return operation(input);\n })(stream$);\n }\n isObserver(observer) {\n return typeof observer === 'object';\n }\n}\nfunction hermesEmptySubscription() {\n return new HermesSubscription(new HermesSubscriber({}), true);\n}\nclass HermesSubject extends HermesObservable {\n /**\n * After error\n */\n thrownError = null;\n /**\n * After complete\n */\n isCompleted = false;\n /**\n * After unsubscribe\n */\n isClosed = false;\n subscribers = [];\n constructor() {\n super();\n }\n next(value) {\n this.verifyNotClosed();\n if (this.isCompleted || this.thrownError !== null) {\n return;\n }\n for (const subs of this.subscribers) {\n subs.next(value);\n }\n }\n error(error) {\n this.verifyNotClosed();\n if (this.isCompleted) {\n return;\n }\n this.thrownError = error;\n for (const subs of this.subscribers) {\n subs.error(error);\n }\n this.subscribers.length = 0;\n }\n complete() {\n this.verifyNotClosed();\n if (this.isCompleted) {\n return;\n }\n this.isCompleted = true;\n for (const subs of this.subscribers) {\n subs.complete();\n }\n this.subscribers.length = 0;\n }\n subscribe(arg) {\n this.verifyNotClosed();\n let subscriber;\n if (arg instanceof HermesSubscriber) {\n subscriber = arg;\n } else {\n subscriber = this.createSubscriber(arguments[0], arguments[1], arguments[2]);\n }\n if (this.thrownError !== null) {\n subscriber.error(this.thrownError);\n return hermesEmptySubscription();\n } else if (this.isCompleted) {\n subscriber.complete();\n return hermesEmptySubscription();\n } else {\n this.subscribers.push(subscriber);\n return this.getSubscription(subscriber);\n }\n }\n unsubscribe() {\n this.isCompleted = true;\n this.isClosed = true;\n this.subscribers.length = 0;\n }\n toObservable() {\n return new HermesObservable(observer => {\n const subscription = this.subscribe(v => observer.next(v), error => observer.error(error), () => observer.complete());\n return () => subscription.unsubscribe();\n });\n }\n verifyNotClosed() {\n if (this.isClosed) {\n throw new Error('Observable already closed');\n }\n }\n}\nclass DomainEventStream extends HermesSubject {\n // constructor(private readonly eventStore: DomainEventStore) {\n constructor() {\n super();\n }\n}\nlet RandomStringGenerator = /*#__PURE__*/(() => {\n class RandomStringGenerator {\n static index = 0;\n static generate() {\n return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15) + `${RandomStringGenerator.index++}`;\n }\n }\n return RandomStringGenerator;\n})();\nclass Message {\n aggregateId;\n messageType;\n messageId;\n constructor(aggregateId, messageType, messageId = RandomStringGenerator.generate()) {\n this.aggregateId = aggregateId;\n this.messageType = messageType;\n this.messageId = messageId;\n }\n getMessageType() {\n return this.messageType;\n }\n getAggregateId() {\n return this.aggregateId;\n }\n getMessageId() {\n return this.messageId;\n }\n toString() {\n return this.messageType;\n }\n equalsByType(message) {\n return this.getMessageType() === message.getMessageType();\n }\n equals(message) {\n return this.getMessageType() === message.getMessageType() && this.messageId === message.messageId;\n }\n ofMessageType(arg) {\n if (Array.isArray(arg)) {\n const found = arg.find(messageType => this.isMessageType(messageType));\n return !!found;\n } else {\n return this.isMessageType(arg);\n }\n }\n isMessageType(messageType) {\n return this.getMessageType() === messageType;\n }\n}\nclass DomainEvent extends Message {\n payload;\n constructor(aggregateId, payload, messageType) {\n super(aggregateId, messageType);\n this.payload = payload;\n }\n isSameType(event) {\n return this.constructor.name === event.constructor.name;\n }\n getPayload() {\n return this.payload;\n }\n}\nfunction hermesOf(...args) {\n return new HermesObservable(observer => {\n args.forEach(value => {\n observer.next(value);\n });\n observer.complete();\n });\n}\nfunction hermesEmpty() {\n return new HermesObservable(observer => {\n observer.complete();\n });\n}\nfunction hermesTake(valuesNumber) {\n return source => {\n if (valuesNumber === 0) {\n return hermesEmpty();\n }\n return new HermesObservable(observer => {\n let index = 0;\n const subscriber = new HermesSubscriber({\n next: () => {},\n error: e => observer.error(e),\n complete: () => observer.complete()\n });\n subscriber.observer.next = function (v) {\n if (index < valuesNumber) {\n observer.next(v);\n index++;\n if (index === valuesNumber) {\n subscriber.complete();\n }\n }\n };\n const subscription = source.subscribe(subscriber);\n return subscription.getFinalize();\n });\n };\n}\nfunction subscriberForOperator(observer, next, complete) {\n const nextFn = next ? next : v => {\n observer.next(v);\n },\n completeFn = complete ? complete : () => {\n observer.complete();\n };\n return new HermesSubscriber({\n next: nextFn,\n error: e => observer.error(e),\n complete: completeFn\n });\n}\nfunction subscriberFromObserver(observer) {\n return new HermesSubscriber({\n next: v => observer.next(v),\n error: e => observer.error(e),\n complete: () => observer.complete()\n });\n}\nfunction hermesFilter(operation) {\n return source => {\n return new HermesObservable(observer => {\n const subscriber = subscriberForOperator(observer, value => {\n if (operation(value)) {\n observer.next(value);\n }\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nclass DomainEventStore {\n domainEvents = [];\n domainEvents$ = new HermesSubject();\n next(event) {\n this.domainEvents.push(event);\n this.domainEvents$.next(event);\n }\n findEventByType(eventType) {\n const events = this.getEvents();\n return events.reverse().find(event => {\n return event.constructor.name === eventType;\n });\n }\n /**\n * First tries to find event in the history,\n * then method waits for future occurrences of the event.\n */\n waitForEvent(eventType) {\n // find in a history\n const event = this.findEventByType(eventType);\n if (event) {\n return hermesOf(event);\n }\n // wait for future occurrence\n return this.waitForNextEventOccurrence(eventType);\n }\n waitForNextEventOccurrence(arg) {\n let eventType;\n if (arg instanceof DomainEvent) {\n eventType = arg.constructor.name;\n } else if (typeof arg === 'string') {\n eventType = arg;\n } else {\n return new HermesObservable(observer => {\n observer.error(new Error('Unsupported argument type.'));\n });\n // return throwError(new Error('Unsupported argument type.'));\n }\n return this.domainEvents$.toObservable().pipe(hermesFilter(event => event.constructor.name === eventType), hermesTake(1));\n }\n getEvents() {\n return this.domainEvents;\n }\n}\nclass CommandStream extends HermesSubject {\n constructor() {\n super();\n }\n}\nlet CommandBus = /*#__PURE__*/(() => {\n class CommandBus extends HermesObservable {\n commandsStream;\n constructor(commandsStream) {\n super();\n this.commandsStream = commandsStream;\n }\n static services = [CommandStream];\n subscribe() {\n return this.commandsStream.toObservable().subscribe(arguments[0], arguments[1], arguments[2]);\n }\n ofCommandHandler(...handlers) {\n return this.commandsStream.toObservable().pipe(hermesFilter(command => {\n return handlers.some(handler => {\n return handler.forCommand(command);\n });\n }));\n }\n ofCreateAggregateHandler(...handlers) {\n return this.commandsStream.toObservable().pipe(hermesFilter(command => {\n return handlers.some(handler => {\n return handler.forCommand(command);\n });\n }));\n }\n ofNullHandler(handlers, aggregateCommandHandlers) {\n return this.commandsStream.toObservable().pipe(hermesFilter(command => {\n if (!handlers && !aggregateCommandHandlers) {\n return true;\n }\n let foundHandlerForCommand = true;\n if (handlers) {\n foundHandlerForCommand = !handlers.some(handler => {\n return handler.forCommand(command);\n });\n }\n if (aggregateCommandHandlers) {\n foundHandlerForCommand = foundHandlerForCommand && !aggregateCommandHandlers.some(handler => {\n return handler.forCommand(command);\n });\n }\n return foundHandlerForCommand;\n }));\n }\n }\n return CommandBus;\n})();\nclass Optional {\n value;\n constructor(value) {\n if (Optional.isValueEmpty(value)) {\n this.value = null;\n } else {\n this.value = value;\n }\n return this;\n }\n static empty() {\n return new Optional(null);\n }\n static of(value) {\n return new Optional(value);\n }\n static isValueEmpty(value) {\n return typeof value === 'undefined' || value === null;\n }\n isEmpty() {\n return Optional.isValueEmpty(this.value);\n }\n isPresent() {\n return !this.isEmpty();\n }\n filter(filterer) {\n if (this.isPresent() && filterer(this.value)) {\n return this;\n }\n return Optional.empty();\n }\n forEach(callback) {\n if (this.isPresent()) {\n callback(this.value);\n }\n }\n map(mapper) {\n if (this.isPresent()) {\n return new Optional(mapper(this.value));\n }\n return Optional.empty();\n }\n /**\n * @deprecated\n */\n getValueOrNullOrThrowError() {\n return this.value;\n }\n getOrThrow() {\n if (this.isEmpty()) {\n throw new Error('Called getOrThrow on an empty Optional');\n }\n return this.value;\n }\n getOrElse(other) {\n if (this.isPresent()) {\n return this.value;\n }\n return other();\n }\n ifPresent(method) {\n if (this.isPresent()) {\n method(this.value);\n }\n }\n ifEmpty(method) {\n if (this.isEmpty()) {\n method();\n }\n }\n orElse(other) {\n if (this.isPresent()) {\n return this;\n }\n return other();\n }\n}\nclass AggregateFactoryArchive {\n map = new Map();\n constructor() {}\n add(key, factory) {\n this.map.set(key, factory);\n }\n get(key) {\n return Optional.of(this.map.get(key));\n }\n has(key) {\n return this.map.has(key);\n }\n}\nclass AggregateRepositoryArchive {\n map = new Map();\n constructor() {}\n add(key, repository) {\n this.map.set(key, repository);\n }\n get(key) {\n return Optional.of(this.map.get(key));\n }\n has(key) {\n return this.map.has(key);\n }\n}\nclass AggregateDefinitionInitializer {\n aggregateFactoryArchive = CoreContainer.resolve(AggregateFactoryArchive);\n aggregateRepositoryArchive = CoreContainer.resolve(AggregateRepositoryArchive);\n constructor() {}\n register(definedAggregate) {\n if (definedAggregate) {\n const set = new Set();\n const filteredDefinitions = [];\n definedAggregate.filter(def => {\n if (!set.has(def.key)) {\n set.add(def.key);\n filteredDefinitions.push(def);\n }\n });\n filteredDefinitions.forEach(def => {\n const factory = CoreContainer.resolve(def.factory),\n repository = CoreContainer.resolve(def.repository);\n if (!this.aggregateFactoryArchive.has(def.key)) {\n this.aggregateFactoryArchive.add(def.key, factory);\n }\n if (!this.aggregateRepositoryArchive.has(def.key)) {\n this.aggregateRepositoryArchive.add(def.key, repository);\n }\n });\n // console.log('Registered aggregate definition:' + filteredDefinitions.length);\n // console.log('Registered aggregate definition:', filteredDefinitions);\n }\n }\n}\nfunction hermesTakeUntil(notifier) {\n return source => {\n return new HermesObservable(observer => {\n const subscriber = subscriberFromObserver(observer);\n const notifierSubscriber = new HermesSubscriber({\n next: () => subscriber.complete()\n });\n notifier.subscribe(notifierSubscriber);\n const subscription = source.subscribe(subscriber);\n return subscription.getFinalize();\n });\n };\n}\nfunction toRxJsObservable(source$) {\n return new Observable(observer => {\n const subscription = source$.subscribe(value => observer.next(value), error => observer.error(error), () => observer.complete());\n return () => subscription.unsubscribe();\n });\n}\nclass Reactive {\n hermesUnsubscribe$ = new HermesSubject();\n constructor() {}\n onDestroy() {\n this.hermesUnsubscribe();\n }\n takeUntil() {\n return takeUntil(toRxJsObservable(this.hermesUnsubscribe$));\n }\n hermesUnsubscribe() {\n this.hermesUnsubscribe$.next();\n this.hermesUnsubscribe$.complete();\n }\n hermesTakeUntil() {\n return hermesTakeUntil(this.hermesUnsubscribe$);\n }\n isNotStopped() {\n return !this.hermesUnsubscribe$.isCompleted;\n }\n}\nclass CommandHandlerInitializer extends Reactive {\n commandBus = CoreContainer.resolve(CommandBus);\n constructor() {\n super();\n }\n register(commandHandlers) {\n if (commandHandlers) {\n const set = new Set();\n const filteredHandlers = [];\n commandHandlers.filter(handler => {\n if (!set.has(handler.commandHandler)) {\n set.add(handler.commandHandler);\n filteredHandlers.push(handler);\n }\n });\n filteredHandlers.forEach(handler => {\n this.commandBus.ofCommandHandler(handler).pipe(this.hermesTakeUntil()).subscribe(command => {\n handler.handleCommand(command);\n });\n });\n }\n }\n registerAggregateCommandHandlers(aggregateCommandHandlers) {\n if (aggregateCommandHandlers) {\n const set = new Set();\n const filteredHandlers = [];\n aggregateCommandHandlers.filter(handler => {\n if (!set.has(handler.createAggregateCommandHandler)) {\n set.add(handler.createAggregateCommandHandler);\n filteredHandlers.push(handler);\n }\n });\n filteredHandlers.forEach(handler => {\n this.commandBus.ofCreateAggregateHandler(handler).pipe(this.hermesTakeUntil()).subscribe(command => {\n handler.handleCommand(command);\n });\n });\n }\n }\n}\nlet DomainEventBus = /*#__PURE__*/(() => {\n class DomainEventBus extends HermesObservable {\n eventStream;\n constructor(eventStream) {\n super();\n this.eventStream = eventStream;\n }\n static services = [DomainEventStream];\n subscribe() {\n return this.eventStream.toObservable().subscribe(arguments[0], arguments[1], arguments[2]);\n }\n ofEvents(events) {\n return this.eventStream.toObservable().pipe(hermesFilter(domainEvent => {\n return events.some(event => {\n const eventInstance = this.createEventInstance(event);\n return eventInstance.equalsByType(domainEvent);\n });\n }));\n }\n ofEventHandlers(handlers) {\n return this.eventStream.toObservable().pipe(hermesFilter(event => {\n return handlers.some(handler => handler.forEvents([event]));\n }));\n }\n createEventInstance(event) {\n const args = [],\n argumentLength = event.constructor.length;\n args.fill(undefined, 0, argumentLength);\n if (args.length === 0) {\n return new event();\n } else if (args.length === 1) {\n return new event(args[0]);\n } else if (args.length === 2) {\n return new event(args[0], args[1]);\n } else if (args.length === 3) {\n return new event(args[0], args[1], args[2]);\n } else if (args.length === 4) {\n return new event(args[0], args[1], args[2], args[3]);\n } else if (args.length === 5) {\n return new event(args[0], args[1], args[2], args[3], args[4]);\n } else {\n throw new Error('DomainEventBus constructor out of arguments');\n }\n }\n }\n return DomainEventBus;\n})();\nlet DomainEventHandlerInitializer = /*#__PURE__*/(() => {\n class DomainEventHandlerInitializer extends Reactive {\n domainEventBus;\n unsub$ = new HermesSubject();\n constructor(domainEventBus) {\n super();\n this.domainEventBus = domainEventBus;\n }\n static services = [DomainEventBus];\n init(eventHandlers) {\n if (eventHandlers) {\n const set = new Set();\n const filteredHandlers = [];\n eventHandlers.filter(handler => {\n if (!set.has(handler.domainEventHandler)) {\n set.add(handler.domainEventHandler);\n filteredHandlers.push(handler);\n }\n });\n filteredHandlers.forEach(handler => {\n this.domainEventBus.ofEventHandlers([handler]).pipe(hermesTakeUntil(this.unsub$), this.hermesTakeUntil()).subscribe(event => {\n handler.handleEvent(event);\n });\n });\n // console.log('Registered event handlers:', filteredHandlers.length)\n // console.log('Registered event handlers:', filteredHandlers)\n }\n }\n reinit(eventHandlers) {\n this.stop();\n this.init(eventHandlers);\n }\n stop() {\n this.unsub$.next();\n this.unsub$.complete();\n this.unsub$ = new HermesSubject();\n }\n }\n return DomainEventHandlerInitializer;\n})();\nconst COMMAND_LOGGER_ENABLED = 'GUI - COMMAND_LOGGER_ENABLED';\nconst EVENT_LOGGER_ENABLED = 'GUI - EVENT_LOGGER_ENABLED';\nclass Logger {\n domainName;\n setDomain(domainName) {\n this.domainName = domainName;\n }\n log(message) {\n if (this.shouldPrint(message)) {\n this.print(message);\n }\n }\n shouldPrint(message) {\n if (!this.domainName) {\n return true;\n }\n const log = message.toString();\n return log.includes(this.domainName);\n }\n}\nclass CommandLogger extends Logger {}\nclass ConsoleCommandLogger extends CommandLogger {\n enabled = false;\n unsubscribe$ = new HermesSubject();\n commandBus = CoreContainer.resolve(CommandBus);\n constructor() {\n super();\n this.commandBus.pipe(hermesFilter(() => this.enabled), hermesTakeUntil(this.unsubscribe$)).subscribe(command => {\n this.log(command);\n });\n }\n onDestroy() {\n this.unsubscribe$.next();\n this.unsubscribe$.complete();\n }\n start() {\n this.enabled = true;\n }\n stop() {\n this.enabled = false;\n }\n print(command) {\n // eslint-disable-next-line no-console\n console.log(command.toString(), command);\n }\n}\nclass NoopCommandLogger extends CommandLogger {\n start() {}\n stop() {}\n print(_command) {}\n}\nclass DomainEventLogger extends Logger {\n constructor() {\n super();\n }\n}\nclass NoopEventLogger extends DomainEventLogger {\n constructor() {\n super();\n }\n start() {}\n stop() {}\n print(_event) {}\n}\nclass AggregateStoreRegister {\n stores = [];\n register(store) {\n this.stores.push(store);\n }\n captureAggregatesSnapshot(aggregateId) {\n if (!aggregateId) {\n return {};\n }\n const aggregates = {};\n this.stores.forEach(store => {\n const aggregate = store.findById(aggregateId);\n if (aggregate) {\n const aggregateName = aggregate.constructor.name;\n aggregates[aggregateName] = aggregate;\n }\n });\n return this.cloneAggregates(aggregates);\n }\n cloneAggregates(aggregates) {\n // return JSON.parse(JSON.stringify(aggregates));\n return aggregates;\n }\n}\nclass ConsoleEventLogger extends DomainEventLogger {\n enabled = false;\n unsubscribe$ = new HermesSubject();\n eventBus = CoreContainer.resolve(DomainEventBus);\n aggregateStoreRegister = CoreContainer.resolve(AggregateStoreRegister);\n constructor() {\n super();\n this.eventBus.pipe(hermesFilter(() => this.enabled), hermesTakeUntil(this.unsubscribe$)).subscribe(domainEvent => {\n this.log(domainEvent);\n });\n }\n onDestroy() {\n this.unsubscribe$.next();\n this.unsubscribe$.complete();\n }\n start() {\n this.enabled = true;\n }\n stop() {\n this.enabled = false;\n }\n print(domainEvent) {\n const aggregateId = domainEvent.getAggregateId(),\n aggregates = this.aggregateStoreRegister.captureAggregatesSnapshot(aggregateId);\n // eslint-disable-next-line no-console\n console.log(domainEvent.toString(), domainEvent, aggregates);\n }\n}\nconst aggregateDefinitionToken = 'Hermes - aggregateDefinitionToken';\nconst DOMAIN_EVENT_HANDLERS = 'HERMES - DOMAIN_EVENT_HANDLERS_TOKEN';\n\n/**\n * ngc for grid package for some reasons doesn't allow to use injection token\n */\nconst CREATE_AGGREGATE_COMMAND_HANDLERS = 'HERMES - CREATE_AGGREGATE_COMMAND_HANDLERS';\nconst COMMAND_HANDLERS = 'HERMES - COMMAND_HANDLERS_TOKEN';\nlet HermesRunner = /*#__PURE__*/(() => {\n class HermesRunner extends Reactive {\n aggregateDefinitionInitializer;\n commandHandlerInitializer;\n domainEventHandlerInitializer;\n commandBus;\n definedAggregate;\n eventHandlers;\n aggregateCommandHandlers;\n commandHandlers;\n started = false;\n constructor(aggregateDefinitionInitializer, commandHandlerInitializer, domainEventHandlerInitializer, commandBus, definedAggregate, eventHandlers, aggregateCommandHandlers, commandHandlers) {\n super();\n this.aggregateDefinitionInitializer = aggregateDefinitionInitializer;\n this.commandHandlerInitializer = commandHandlerInitializer;\n this.domainEventHandlerInitializer = domainEventHandlerInitializer;\n this.commandBus = commandBus;\n this.definedAggregate = definedAggregate;\n this.eventHandlers = eventHandlers;\n this.aggregateCommandHandlers = aggregateCommandHandlers;\n this.commandHandlers = commandHandlers;\n if (this.eventHandlers === null) {\n this.eventHandlers = [];\n }\n if (this.aggregateCommandHandlers === null) {\n this.aggregateCommandHandlers = [];\n }\n if (this.commandHandlers === null) {\n this.commandHandlers = [];\n }\n }\n static services = [AggregateDefinitionInitializer, CommandHandlerInitializer, DomainEventHandlerInitializer, CommandBus, {\n inject: aggregateDefinitionToken,\n collection: true\n }, {\n inject: DOMAIN_EVENT_HANDLERS,\n collection: true,\n optional: true\n }, {\n inject: CREATE_AGGREGATE_COMMAND_HANDLERS,\n collection: true,\n optional: true\n }, {\n inject: COMMAND_HANDLERS,\n collection: true,\n optional: true\n }];\n run() {\n if (this.started) {\n return;\n }\n this.checkNullCommand(this.commandHandlers, this.aggregateCommandHandlers);\n this.checkCommandHandlerIsCollection(this.commandHandlers);\n this.checkDomainEventHandlerIsCollection(this.eventHandlers);\n this.aggregateDefinitionInitializer.register(this.definedAggregate);\n this.commandHandlerInitializer.register(this.commandHandlers);\n this.commandHandlerInitializer.registerAggregateCommandHandlers(this.aggregateCommandHandlers);\n this.domainEventHandlerInitializer.init(this.eventHandlers);\n this.started = true;\n }\n destroy() {\n this.commandHandlerInitializer.onDestroy();\n this.domainEventHandlerInitializer.onDestroy();\n }\n checkNullCommand(commandHandlers, aggregateCommandHandlers) {\n this.commandBus.ofNullHandler(commandHandlers, aggregateCommandHandlers).pipe(this.hermesTakeUntil()).subscribe(command => {\n // eslint-disable-next-line no-console\n console.error(`Command ${command.toString()} was not intercepted by any CommandHandler.`);\n });\n }\n checkCommandHandlerIsCollection(commandHandlers) {\n if (commandHandlers && !Array.isArray(commandHandlers)) {\n // eslint-disable-next-line no-console\n console.warn('You might provided commandHandler without specifying \"multi: true\".');\n }\n }\n checkDomainEventHandlerIsCollection(eventHandlers) {\n if (eventHandlers && !Array.isArray(eventHandlers)) {\n // eslint-disable-next-line no-console\n console.warn('You might provided eventHandler without specifying \"multi: true\".');\n }\n }\n }\n return HermesRunner;\n})();\nfunction commandLoggerFactory(enabled, consoleCommandLogger, noopCommandLogger) {\n if (enabled) {\n return consoleCommandLogger;\n } else {\n return noopCommandLogger;\n }\n}\nfunction eventLoggerFactory(enabled, consoleEventLogger, noopEventLogger) {\n if (enabled) {\n return consoleEventLogger;\n } else {\n return noopEventLogger;\n }\n}\nfunction runHermes() {\n CoreContainer.resolve(HermesRunner).run();\n}\nclass CommandDispatcher {\n commandStream = CoreContainer.resolve(CommandStream);\n dispatch(command) {\n this.commandStream.next(command);\n }\n}\nlet DomainEventPublisher = /*#__PURE__*/(() => {\n class DomainEventPublisher {\n eventStream;\n constructor(eventStream) {\n this.eventStream = eventStream;\n }\n static services = [DomainEventStream];\n publish(args) {\n if (Array.isArray(args)) {\n for (const arg of args) {\n this.publishEvent(arg);\n }\n } else {\n this.publishEvent(args);\n }\n }\n publishFromAggregate(aggregate) {\n const events = [...aggregate.getEvents()];\n events.forEach(aggregateEvent => {\n this.publish(aggregateEvent.toDomainEvent());\n });\n }\n publishEvent(event) {\n if (!event) {\n // eslint-disable-next-line no-console\n console.error(`${event} is not defined`);\n }\n if (!(event instanceof DomainEvent)) {\n // throw new Error(`${event} is not a DomainEvent`);\n // eslint-disable-next-line no-console\n console.error(`${event} is not a DomainEvent`);\n }\n this.eventStream.next(event);\n }\n }\n return DomainEventPublisher;\n})();\nconst CoreContainer = createContainer();\nCoreContainer.provideValue(EVENT_LOGGER_ENABLED, true);\nCoreContainer.provideValue(COMMAND_LOGGER_ENABLED, true);\nCoreContainer.provide(ConsoleCommandLogger);\nCoreContainer.provide(NoopCommandLogger);\nCoreContainer.provide(NoopEventLogger);\nCoreContainer.provide(ConsoleEventLogger);\nCoreContainer.provide(DomainEventBus);\nCoreContainer.provide(AggregateStoreRegister);\nCoreContainer.provideFactory(CommandLogger, {\n create: commandLoggerFactory,\n deps: [COMMAND_LOGGER_ENABLED, ConsoleCommandLogger, NoopCommandLogger]\n});\nCoreContainer.provideFactory(DomainEventLogger, {\n create: eventLoggerFactory,\n deps: [EVENT_LOGGER_ENABLED, ConsoleEventLogger, NoopEventLogger]\n});\nCoreContainer.provide(AggregateFactoryArchive, AggregateFactoryArchive);\nCoreContainer.provide(DomainEventPublisher);\nCoreContainer.provide(AggregateRepositoryArchive);\nCoreContainer.provide(DomainEventStream, DomainEventStream);\nCoreContainer.provide(DomainEventStore, DomainEventStore);\nCoreContainer.provide(CommandBus, CommandBus);\nCoreContainer.provide(CommandStream);\nCoreContainer.provide(CommandDispatcher);\nCoreContainer.provide(AggregateDefinitionInitializer, AggregateDefinitionInitializer);\nCoreContainer.provide(CommandHandlerInitializer, CommandHandlerInitializer);\nCoreContainer.provide(DomainEventHandlerInitializer, DomainEventHandlerInitializer);\nCoreContainer.provide(HermesRunner);\nconst resetCoreContainer = () => {\n CoreContainer.clearOnlyRecords();\n};\nclass Command extends Message {}\nconst MessageType = Function;\nconst CommandType = MessageType;\nclass AggregateFactory {}\nclass AggregateEvent {\n aggregateId;\n type;\n constructor(aggregateId, type) {\n this.aggregateId = aggregateId;\n this.type = type;\n }\n getAggregateId() {\n return this.aggregateId;\n }\n getType() {\n return this.type;\n }\n equals(event) {\n return this.equalsByType(event) && this.getAggregateId().equals(event.getAggregateId());\n }\n equalsByType(event) {\n return this.getType() === event.getType();\n }\n}\nconst AggregateEventType = MessageType;\nclass AggregateRepository {}\nclass AggregateStore {}\nclass AggregateRoot {\n type;\n aggregateId;\n events;\n constructor(aggregateId, type) {\n this.type = type;\n this.aggregateId = aggregateId;\n this.events = [];\n }\n getId() {\n return this.aggregateId;\n }\n getType() {\n return this.type;\n }\n getEvents() {\n return this.events;\n }\n addEvent(args) {\n if (Array.isArray(args)) {\n for (const event of args) {\n this.events.push(event);\n }\n } else {\n this.events.push(args);\n }\n }\n clearEvents() {\n this.events.length = 0;\n }\n equals(aggregate) {\n return aggregate.getId().toString() === this.getId().toString();\n }\n}\nclass HermesId {\n uid;\n constructor(uid) {\n this.uid = uid;\n }\n getId() {\n return this.uid;\n }\n equals(hermesId) {\n return this.uid === hermesId.getId();\n }\n}\nclass AggregateId extends HermesId {\n constructor(uid) {\n super(uid);\n }\n toString() {\n return super.getId();\n }\n}\nconst DomainEventType = MessageType;\nclass ReactiveService extends Reactive {\n constructor() {\n super();\n }\n onDestroy() {\n this.hermesUnsubscribe();\n }\n}\nclass KeyMap {\n keys = new Map();\n values = new WeakMap();\n find(key) {\n const internalKey = this.getInternalKey(key);\n if (internalKey !== undefined) {\n return Optional.of(this.values.get(internalKey));\n } else {\n return Optional.empty();\n }\n }\n has(key) {\n const internalKey = this.getInternalKey(key);\n return this.values.has(internalKey);\n }\n set(key, value) {\n this.keys.set(key.toString(), key);\n this.values.set(key, value);\n }\n size() {\n return this.keys.size;\n }\n remove(key) {\n if (this.hasInternalKey(key)) {\n this.keys.delete(key.toString());\n this.values.delete(key);\n }\n }\n removeAll() {\n this.keys.forEach(value => {\n this.values.delete(value);\n });\n this.keys.clear();\n }\n getInternalKey(key) {\n return this.keys.get(key.toString());\n }\n hasInternalKey(key) {\n return this.keys.has(key.toString());\n }\n}\nfunction hermesMap(convert) {\n return source => {\n return new HermesObservable(observer => {\n let index = 0;\n const subscriber = subscriberForOperator(observer, value => {\n observer.next(convert(value, index++));\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nfunction hermesDistinctUntilChanged(compareFn) {\n const compare = compareFn ? compareFn : defaultCompareFn;\n return source => {\n return new HermesObservable(observer => {\n let previousValue = null;\n const subscriber = subscriberForOperator(observer, value => {\n if (previousValue === null || !compare(previousValue, value)) {\n previousValue = value;\n observer.next(value);\n }\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nfunction defaultCompareFn(a, b) {\n return a === b;\n}\nclass HermesBehaviorSubject extends HermesSubject {\n lastValue;\n constructor(defaultValue) {\n super();\n this.lastValue = defaultValue;\n }\n next(value) {\n this.lastValue = value;\n super.next(value);\n }\n subscribe() {\n const subscription = super.subscribe(arguments[0], arguments[1], arguments[2]);\n super.next(this.lastValue);\n return subscription;\n }\n}\nclass HermesReplaySubject extends HermesSubject {\n bufferSize;\n values = [];\n constructor(bufferSize = 1) {\n super();\n this.bufferSize = bufferSize;\n }\n pipe(...operations) {\n return super.pipe(...operations);\n }\n next(value) {\n this.values.push(value);\n if (this.bufferSize < this.values.length) {\n this.values.shift();\n }\n super.next(value);\n }\n subscribe() {\n let subscriber;\n if (arguments[0] instanceof HermesSubscriber) {\n subscriber = arguments[0];\n } else {\n subscriber = this.createSubscriber(arguments[0], arguments[1], arguments[2]);\n }\n const subscription = super.subscribe(subscriber);\n for (const value of this.values) {\n subscriber.next(value);\n }\n return subscription;\n }\n}\nclass HermesArchiveSubject extends HermesSubject {\n constructor() {\n super();\n }\n static of(value) {\n if (value !== undefined) {\n return new HermesBehaviorSubject(value);\n } else {\n return new HermesReplaySubject(1);\n }\n }\n}\nclass HermesSingleSubscriber extends HermesSubscriber {\n next(value) {\n if (this.isCompleted()) {\n return;\n }\n const observer = this.getObserver();\n if (observer && observer.next) {\n observer.next(value);\n this.complete();\n }\n }\n}\nclass HermesSingle extends HermesObservable {\n createSubscriber(next, error, complete) {\n return new HermesSingleSubscriber({\n next,\n error,\n complete\n });\n }\n}\nfunction singleFromObservable(source) {\n return new HermesSingle(observer => {\n const subscriber = new HermesSubscriber({\n next: value => observer.next(value),\n error: error => observer.error(error),\n complete: () => {}\n });\n const subscription = source.subscribe(subscriber);\n return subscription.getFinalize();\n });\n}\nclass KeyArchive extends ReactiveService {\n archive = new KeyMap();\n archive$;\n defaultValue = Optional.empty();\n constructor(defaultValue) {\n super();\n this.archive$ = HermesArchiveSubject.of();\n if (defaultValue !== undefined && defaultValue !== null) {\n this.defaultValue = Optional.of(defaultValue);\n }\n }\n on(key) {\n this.tryToInitDefault(key);\n return this.archive$.toObservable().pipe(hermesFilter(() => this.isNotStopped()), hermesMap(map => {\n return map.find(key);\n }), hermesFilter(value => value.isPresent()), hermesMap(value => value.getValueOrNullOrThrowError()), hermesDistinctUntilChanged(this.equals), this.hermesTakeUntil());\n }\n once(key) {\n return singleFromObservable(this.on(key));\n }\n find(key) {\n this.tryToInitDefault(key);\n return this.archive.find(key);\n }\n next(key, value) {\n this.archive.set(key, value);\n this.archive$.next(this.archive);\n }\n equals(a, b) {\n return a === b;\n }\n createDefaultValue(defaultValue) {\n return defaultValue;\n }\n tryToInitDefault(key) {\n this.defaultValue.ifPresent(value => {\n if (!this.archive.has(key)) {\n this.next(key, value);\n }\n });\n }\n}\nclass AggregateArchive extends KeyArchive {\n constructor(defaultValue) {\n super(defaultValue);\n }\n}\nclass EventDrivenRepository extends AggregateArchive {\n constructor(defaultValues) {\n super(defaultValues);\n }\n handle(event) {\n this.next(event.getAggregateId(), event.getPayload());\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelEntity {\n entityId;\n constructor(gui) {\n this.entityId = gui;\n }\n getId() {\n return this.entityId;\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelEntityId {\n uid;\n constructor(uid) {\n this.uid = uid;\n }\n toString() {\n return this.uid;\n }\n getId() {\n return this.uid;\n }\n equals(entityId) {\n return this.uid === entityId.getId();\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelRoot {\n rootId;\n constructor(gui) {\n this.rootId = gui;\n }\n getId() {\n return this.rootId;\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelRootId {\n uid;\n constructor(uid) {\n this.uid = uid;\n }\n toString() {\n return this.uid;\n }\n getId() {\n return this.uid;\n }\n equals(entityId) {\n return this.uid === entityId.getId();\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelRootRepository extends Reactive {\n domainEventBus = CoreContainer.resolve(DomainEventBus);\n constructor() {\n super();\n this.domainEventBus.ofEvents(this.forEvents()).pipe(this.hermesTakeUntil()).subscribe(event => {\n try {\n this.subscribe(event);\n } catch (e) {\n // eslint-disable-next-line no-console\n console.error(e);\n }\n });\n }\n}\n\n/**\n * @deprecated\n */\nclass ReadModelStore {}\nclass EventRepository extends ReactiveService {\n domainEventBus = CoreContainer.resolve(DomainEventBus);\n constructor() {\n super();\n }\n onEvent(aggregateId, eventType) {\n return this.domainEventBus.ofEvents([eventType]).pipe(hermesFilter(event => event.getAggregateId().toString() === aggregateId.toString()));\n }\n}\nclass Entity {\n entityId;\n constructor(id) {\n this.entityId = id;\n }\n getId() {\n return this.entityId;\n }\n equals(entity) {\n return this.entityId.equals(entity.getId());\n }\n}\nclass EntityId extends HermesId {}\nfunction ValueObject(_target) {}\nfunction DomainObject(_target) {}\nfunction ReadModelObject(_target) {}\nclass FeatureModule {}\nfunction hermesNever() {\n return new HermesObservable(() => {});\n}\nfunction hermesInterval(interval) {\n let counter = 0;\n return new HermesObservable(observer => {\n const id = setInterval(() => {\n observer.next(counter++);\n }, interval);\n return () => {\n clearInterval(id);\n observer.complete();\n };\n });\n}\nfunction hermesTimer(time) {\n return new HermesObservable(observer => {\n const id = setTimeout(() => {\n observer.next(0);\n }, time);\n return () => {\n clearTimeout(id);\n observer.complete();\n };\n });\n}\nfunction hermesFromEvent(element, type) {\n return new HermesObservable(observer => {\n const listener = event => {\n observer.next(event);\n };\n element.addEventListener(type, listener);\n return () => {\n element.removeEventListener(type, listener);\n };\n });\n}\nfunction hermesThrowError(error) {\n return new HermesObservable(observer => {\n observer.error(error);\n });\n}\nfunction hermesSkip(valuesNumber) {\n return source => {\n return new HermesObservable(observer => {\n let index = 0;\n const subscriber = subscriberForOperator(observer, value => {\n if (index >= valuesNumber) {\n observer.next(value);\n }\n index++;\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nfunction hermesSwitchMap(operation) {\n return source => {\n return new HermesObservable(observer => {\n let isOuterCompleted = false;\n let innerSubscriber = null;\n const tryToComplete = function () {\n if (isOuterCompleted && !innerSubscriber) {\n observer.complete();\n }\n };\n const outerSubscriber = subscriberForOperator(observer, v => {\n if (innerSubscriber) {\n innerSubscriber.unsubscribe();\n }\n const subscriber = new HermesSubscriber({\n next: v2 => observer.next(v2),\n error: e => observer.error(e),\n complete: () => {\n innerSubscriber = null;\n tryToComplete();\n }\n });\n innerSubscriber = subscriber;\n const innerSubscription = operation(v).subscribe(subscriber);\n return innerSubscription.getFinalize();\n }, () => {\n isOuterCompleted = true;\n tryToComplete();\n });\n return source.subscribe(outerSubscriber).getFinalize();\n });\n };\n}\nfunction hermesTap(operation) {\n return source => {\n return new HermesObservable(observer => {\n const subscriber = subscriberForOperator(observer, value => {\n operation(value);\n observer.next(value);\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nfunction hermesToArray() {\n return source => {\n return new HermesObservable(observer => {\n const values = [];\n const subscriber = subscriberForOperator(observer, value => {\n values.push(value);\n }, () => {\n if (values.length > 0) {\n observer.next(values);\n }\n observer.complete();\n });\n return source.subscribe(subscriber).getFinalize();\n });\n };\n}\nfunction fromRxJsObservable(source$) {\n return new HermesObservable(observer => {\n const subscription = source$.subscribe(value => observer.next(value), error => observer.error(error), () => observer.complete());\n return () => subscription.unsubscribe();\n });\n}\nclass Archive {\n archive$;\n constructor(value) {\n this.archive$ = HermesArchiveSubject.of(value);\n }\n on() {\n return this.archive$.toObservable().pipe(hermesDistinctUntilChanged(this.compare));\n }\n next(value) {\n this.archive$.next(value);\n }\n compare(one, two) {\n return one === two;\n }\n}\nlet RandomIdGenerator = /*#__PURE__*/(() => {\n class RandomIdGenerator {\n static index = 0;\n static generate() {\n RandomIdGenerator.index++;\n return RandomIdGenerator.index;\n }\n }\n return RandomIdGenerator;\n})();\nclass PersistAnemia {\n readModelRootId;\n constructor(uid) {\n this.readModelRootId = uid;\n }\n getReadModelRootId() {\n return this.readModelRootId;\n }\n getId() {\n return this.getReadModelRootId().toString();\n }\n}\nclass PersistStateStore {\n state = new Map();\n set(anemia) {\n this.state.set(anemia.getId(), anemia);\n }\n setMany(anemias) {\n anemias.forEach(anemia => {\n this.set(anemia);\n });\n }\n get(aggregateId) {\n return Optional.of(this.state.get(aggregateId.toString()));\n }\n getAll() {\n return Array.from(this.state.values());\n }\n clear() {\n this.state.clear();\n }\n}\nclass PersistReadModelStore extends ReadModelStore {\n stateStore;\n constructor(stateStore) {\n super();\n this.stateStore = stateStore;\n }\n getById(aggregateId) {\n return this.getValue(aggregateId);\n }\n getAll() {\n return this.getAllValues();\n }\n getAllValues() {\n return this.stateStore.getAll().map(anemia => this.toReadModel(anemia));\n }\n getValue(aggregateId) {\n const optAnemia = this.stateStore.get(aggregateId);\n return optAnemia.map(this.toReadModel);\n }\n}\nclass PersistAggregateStore extends AggregateStore {\n stateStore;\n aggregateStoreRegister = CoreContainer.resolve(AggregateStoreRegister);\n constructor(stateStore) {\n super();\n this.stateStore = stateStore;\n this.aggregateStoreRegister.register(this);\n }\n save(aggregate) {\n this.saveValue(aggregate);\n }\n findById(aggregateId) {\n return this.getValue(aggregateId);\n }\n saveValue(aggregate) {\n const anemia = this.toAnemia(aggregate);\n this.stateStore.set(anemia);\n }\n getValue(aggregateId) {\n const optAnemia = this.stateStore.get(aggregateId);\n return optAnemia.map(this.fromAnemia);\n }\n}\nclass InMemoryAggregateStore extends AggregateStore {\n inMemoryStore;\n aggregateStoreRegister = CoreContainer.resolve(AggregateStoreRegister);\n constructor(inMemoryStore) {\n super();\n this.inMemoryStore = inMemoryStore;\n this.aggregateStoreRegister.register(this);\n }\n save(arg) {\n if (Array.isArray(arg)) {\n arg.forEach(aggregate => {\n this.inMemoryStore.set(aggregate);\n });\n } else {\n const aggregate = arg;\n this.inMemoryStore.set(aggregate);\n }\n }\n findById(aggregateId) {\n const optAggregate = this.inMemoryStore.get(aggregateId);\n optAggregate.ifPresent(a => a.clearEvents());\n return optAggregate;\n }\n remove(aggregateId) {\n this.inMemoryStore.delete(aggregateId);\n }\n}\nclass InMemoryReadModelStore extends ReadModelStore {\n inMemoryStore;\n constructor(inMemoryStore) {\n super();\n this.inMemoryStore = inMemoryStore;\n }\n getById(aggregateId) {\n return this.getValue(aggregateId);\n }\n getValue(aggregateId) {\n const optAggregate = this.inMemoryStore.get(aggregateId);\n return optAggregate.map(this.toReadModel.bind(this));\n }\n}\nclass InMemoryStore {\n state = new Map();\n set(aggregate) {\n this.state.set(aggregate.getId().toString(), aggregate);\n }\n setMany(aggregates) {\n aggregates.forEach(aggregate => {\n this.set(aggregate);\n });\n }\n get(aggregateId) {\n return Optional.of(this.state.get(aggregateId.toString()));\n }\n getAll() {\n return Array.from(this.state.values()).map(v => Optional.of(v));\n }\n has(aggregateId) {\n return this.state.has(aggregateId.toString());\n }\n delete(aggregateId) {\n this.state.delete(aggregateId.toString());\n }\n clear() {\n this.state.clear();\n }\n}\nfunction assertDomainEvents(actualEvents, expectedEvents) {\n expect(actualEvents.length).toEqual(expectedEvents.length);\n for (const actualEvent of actualEvents) {\n const expectedEvent = expectedEvents.find(event => {\n return event.equalsByType(actualEvent);\n });\n expect(expectedEvent).toBeDefined();\n expect(actualEvent.equalsByType(expectedEvent)).toBeTruthy();\n // expect(actualEvent.aggregateId).toEqual(expectedEvent.aggregateId, 'Events aggregateId should be the same');\n expect(actualEvent.getPayload()).toEqual(expectedEvent.getPayload(), 'Events payload should be the same');\n }\n}\nfunction assertAggregateEvents(actualEvents, expectedEvents) {\n expect(actualEvents.length).toEqual(expectedEvents.length, 'Aggregate events');\n for (const actualEvent of actualEvents) {\n const expectedEvent = expectedEvents.find(event => {\n return event.equals(actualEvent);\n });\n expect(expectedEvent).toBeDefined();\n }\n}\nfunction testEventRepositoryIsEmptyOnStart(createStream, desc) {\n it('should be no ' + desc + ' events on start', () => {\n expect.assertions(3);\n // given\n const nextFn = jest.fn(),\n errorFn = jest.fn(),\n completeFn = jest.fn();\n // when\n createStream().subscribe(() => nextFn(), err => errorFn(err), () => completeFn());\n // then\n expect(nextFn).not.toHaveBeenCalled();\n expect(errorFn).not.toHaveBeenCalled();\n expect(completeFn).not.toHaveBeenCalled();\n });\n}\nfunction onDefaultValuesWarehouseTest(createStream, defaultValue, desc) {\n it('should have default value ' + desc, () => {\n expect.assertions(4);\n // given\n const nextFn = jest.fn(),\n errorFn = jest.fn(),\n completeFn = jest.fn();\n // when\n createStream().subscribe(value => nextFn(value), err => errorFn(err), () => completeFn());\n // then\n expect(nextFn).toHaveBeenCalledWith(defaultValue);\n expect(nextFn).toHaveBeenCalledTimes(1);\n expect(errorFn).not.toHaveBeenCalled();\n expect(completeFn).not.toHaveBeenCalled();\n });\n}\nfunction onceDefaultValuesWarehouseTest(createStream, defaultValue, desc) {\n it('should have default value ' + desc, () => {\n expect.assertions(4);\n // given\n const nextFn = jest.fn(),\n errorFn = jest.fn(),\n completeFn = jest.fn();\n // when\n createStream().subscribe(value => nextFn(value), err => errorFn(err), () => completeFn());\n // then\n expect(nextFn).toHaveBeenCalledWith(defaultValue);\n expect(nextFn).toHaveBeenCalledTimes(1);\n expect(errorFn).not.toHaveBeenCalled();\n expect(completeFn).toHaveBeenCalledTimes(1);\n });\n}\nfunction onWarehouseEmpty(createStream, desc) {\n it('should be empty ' + desc, () => {\n expect.assertions(3);\n // given\n const nextFn = jest.fn(),\n errorFn = jest.fn(),\n completeFn = jest.fn();\n // when\n createStream().subscribe(value => nextFn(value), err => errorFn(err), () => completeFn());\n // then\n expect(nextFn).not.toHaveBeenCalled();\n expect(errorFn).not.toHaveBeenCalled();\n expect(completeFn).not.toHaveBeenCalled();\n });\n}\nfunction findDefaultValuesWarehouseTest(createValue, defaultValue, desc) {\n it('should find default value' + desc, function () {\n expect.assertions(1);\n expect(createValue()).toEqual(Optional.of(defaultValue));\n });\n}\nfunction commandInterceptedByHandlerTest(dispatch, handlerType) {\n it('should trigger command handler', () => {\n expect.assertions(1);\n // given\n const handler = CoreContainer.resolve(handlerType),\n handlerSpy = jest.spyOn(handler, 'handle');\n // when\n dispatch();\n // then\n expect(handlerSpy).toHaveBeenCalled();\n });\n}\nfunction commandPublishEventTest(dispatch, eventType) {\n it('should dispatch event', () => {\n expect.assertions(1);\n // given\n CoreContainer.resolve(DomainEventBus).subscribe(event => {\n // then\n if (event instanceof eventType) {\n expect(event instanceof eventType).toEqual(true);\n }\n });\n // when\n dispatch();\n });\n}\nfunction commandTriggersHandlerAndPublishEventTest(dispatch, handlerType, eventType) {\n commandInterceptedByHandlerTest(dispatch, handlerType);\n commandPublishEventTest(dispatch, eventType);\n}\nclass CreateAggregateCommand extends Command {\n constructor(aggregateId, type) {\n super(aggregateId, type);\n }\n}\nconst hermesApi = 'hermesApi';\nfunction initHermesApi() {\n const cl = CoreContainer.resolve(CommandLogger),\n del = CoreContainer.resolve(DomainEventLogger);\n const api = () => {\n return {\n set loggers(enabled) {\n if (enabled) {\n // api.commandLogger.start(); TO FIX\n // api.eventLogger.start();\n } else {\n // api.commandLogger.stop(); // TO FIX\n // api.eventLogger.stop();\n }\n },\n set domain(domainName) {\n if (domainName) {\n cl.setDomain(domainName);\n del.setDomain(domainName);\n }\n }\n };\n };\n window[hermesApi] = api();\n window[hermesApi].loggers = false;\n}\nfunction enableHermesLoggers(domainName, windowObject) {\n const winRef = windowObject ? windowObject : window;\n if (domainName) {\n winRef[hermesApi].domain = domainName;\n }\n winRef[hermesApi].loggers = true;\n}\nfunction disableHermesLoggers(windowObject) {\n const winRef = windowObject ? windowObject : window;\n delete winRef[hermesApi].domain;\n winRef[hermesApi].loggers = false;\n}\nfunction createAggregateCommandHandlerFactory(createAggregateCommandHandler, aggregateName) {\n return new CreateAggregateCommandHandlerImpl(createAggregateCommandHandler, aggregateName);\n}\nclass CreateAggregateCommandHandlerImpl {\n createAggregateCommandHandler;\n aggregateType;\n aggregateFactoryArchive = CoreContainer.resolve(AggregateFactoryArchive);\n aggregateRepositoryArchive = CoreContainer.resolve(AggregateRepositoryArchive);\n domainEventPublisher = CoreContainer.resolve(DomainEventPublisher);\n commandType;\n constructor(createAggregateCommandHandler, aggregateType) {\n this.createAggregateCommandHandler = createAggregateCommandHandler;\n this.aggregateType = aggregateType;\n this.commandType = this.createCommandInstance().getMessageType();\n }\n handleCommand(command) {\n const aggregateId = command.getAggregateId();\n const optFactory = this.aggregateFactoryArchive.get(this.aggregateType);\n optFactory.ifPresent(factory => {\n const aggregate = factory.create(aggregateId);\n const type = aggregate.getType(),\n createCommandConstructor = aggregate.createEvent();\n const createCommand = new createCommandConstructor(aggregateId, type);\n aggregate.addEvent(createCommand);\n const optRepository = this.aggregateRepositoryArchive.get(this.aggregateType);\n optRepository.ifPresent(repo => {\n repo.save(aggregate);\n this.domainEventPublisher.publishFromAggregate(aggregate);\n });\n });\n }\n forCommand(command) {\n return this.commandType === command.getMessageType();\n }\n createCommandInstance() {\n const args = [],\n argumentLength = this.createAggregateCommandHandler.forCommand().constructor.length;\n args.fill(undefined, 0, argumentLength);\n if (args.length === 0) {\n return new (this.createAggregateCommandHandler.forCommand())();\n } else if (args.length === 1) {\n return new (this.createAggregateCommandHandler.forCommand())(args[0]);\n } else if (args.length === 2) {\n return new (this.createAggregateCommandHandler.forCommand())(args[0], args[1]);\n } else if (args.length === 3) {\n return new (this.createAggregateCommandHandler.forCommand())(args[0], args[1], args[2]);\n } else if (args.length === 4) {\n return new (this.createAggregateCommandHandler.forCommand())(args[0], args[1], args[2], args[3]);\n } else if (args.length === 5) {\n return new (this.createAggregateCommandHandler.forCommand())(args[0], args[1], args[2], args[3], args[4]);\n } else {\n throw new Error('CreateAggregateCommandHandlerImpl constructor out of arguments');\n }\n }\n}\nfunction commandHandlerFactory(commandHandler, aggregateName) {\n return new CommandHandlerImpl(commandHandler, aggregateName);\n}\nclass CommandHandlerImpl {\n commandHandler;\n aggregateType;\n aggregateRepositoryArchive = CoreContainer.resolve(AggregateRepositoryArchive);\n domainEventPublisher = CoreContainer.resolve(DomainEventPublisher);\n commandType;\n constructor(commandHandler, aggregateType) {\n this.commandHandler = commandHandler;\n this.aggregateType = aggregateType;\n this.commandType = this.createCommandInstance().getMessageType();\n }\n publishDomainEvents(aggregate, command) {\n if (this.commandHandler.publish) {\n this.commandHandler.publish(aggregate, command);\n } else {\n this.domainEventPublisher.publishFromAggregate(aggregate);\n }\n }\n handleCommand(command) {\n const aggregateId = command.getAggregateId();\n const optRepository = this.aggregateRepositoryArchive.get(this.aggregateType);\n optRepository.ifPresent(repo => {\n const optAggregate = repo.findById(aggregateId);\n optAggregate.ifPresent(aggregate => {\n this.commandHandler.handle(aggregate, command);\n this.publishDomainEvents(aggregate, command);\n });\n });\n }\n forCommand(command) {\n return this.commandType === command.getMessageType();\n }\n createCommandInstance() {\n const args = [],\n argumentLength = this.commandHandler.forCommand().constructor.length;\n args.fill(undefined, 0, argumentLength);\n if (args.length === 0) {\n return new (this.commandHandler.forCommand())();\n } else if (args.length === 1) {\n return new (this.commandHandler.forCommand())(args[0]);\n } else if (args.length === 2) {\n return new (this.commandHandler.forCommand())(args[0], args[1]);\n } else if (args.length === 3) {\n return new (this.commandHandler.forCommand())(args[0], args[1], args[2]);\n } else if (args.length === 4) {\n return new (this.commandHandler.forCommand())(args[0], args[1], args[2], args[3]);\n } else if (args.length === 5) {\n return new (this.commandHandler.forCommand())(args[0], args[1], args[2], args[3], args[4]);\n } else {\n throw new Error('CommandHandlerImpl constructor out of arguments');\n }\n }\n}\nfunction domainEventHandlerFactoryAsFactory(domainEventHandlerType) {\n return CoreContainer.resolve(domainEventHandlerType);\n}\nfunction domainEventHandlerFactory(domainEventHandler) {\n return new DomainEventHandlerImpl(domainEventHandler, [domainEventHandler.forEvent()]);\n}\nfunction multiDomainEventHandlerFactory(domainEventHandler) {\n return new DomainEventHandlerImpl(domainEventHandler, domainEventHandler.forEvents());\n}\nclass DomainEventHandlerImpl {\n domainEventHandler;\n events;\n eventTypes;\n constructor(domainEventHandler, events) {\n this.domainEventHandler = domainEventHandler;\n this.events = events;\n this.eventTypes = this.createDomainEventTypes();\n }\n handleEvent(event) {\n this.domainEventHandler.handle(event);\n }\n forEvents(events) {\n return events.some(event => {\n return this.eventTypes.some(type => {\n return type === event.getMessageType();\n });\n });\n }\n createDomainEventTypes() {\n const types = [];\n for (const event of this.events) {\n const instance = this.createDomainEventInstance(event);\n types.push(instance.getMessageType());\n }\n return types;\n }\n createDomainEventInstance(eventType) {\n const args = [],\n argumentLength = eventType.constructor.length;\n args.fill(undefined, 0, argumentLength);\n if (args.length === 0) {\n return new eventType();\n } else if (args.length === 1) {\n return new eventType(args[0]);\n } else if (args.length === 2) {\n return new eventType(args[0], args[1]);\n } else if (args.length === 3) {\n return new eventType(args[0], args[1], args[2]);\n } else if (args.length === 4) {\n return new eventType(args[0], args[1], args[2], args[3]);\n } else if (args.length === 5) {\n return new eventType(args[0], args[1], args[2], args[3], args[4]);\n } else {\n throw new Error('DomainEventHandler constructor out of arguments');\n }\n }\n}\nclass DomainInitializer {\n api;\n domain;\n container = CoreContainer;\n initialized = false;\n constructor(api, domain) {\n this.api = api;\n this.domain = domain;\n }\n init() {\n if (this.initialized) {\n return;\n }\n this.defineAggregate();\n this.registerApiProviders();\n this.registerDomainProviders();\n this.registerCommandHandlers();\n this.registerEventHandlers();\n this.registerMultiEventHandlers();\n this.initialized = true;\n }\n defineAggregate() {\n const definition = this.domain.defineAggregate();\n if (definition) {\n this.container.provide(definition.factory);\n this.container.provide(definition.repository);\n this.container.provideValue(definition.aggregateKey, definition.aggregateKey);\n this.container.provideValueCollection(aggregateDefinitionToken, {\n key: definition.aggregateKey,\n factory: definition.factory,\n repository: definition.repository\n });\n this.container.provide(definition.createCommandHandler);\n this.container.provideFactoryCollection(CREATE_AGGREGATE_COMMAND_HANDLERS, {\n create: createAggregateCommandHandlerFactory,\n deps: [definition.createCommandHandler, definition.aggregateKey]\n });\n }\n }\n registerApiProviders() {\n this.api.registerProviders(this.container);\n }\n registerDomainProviders() {\n this.domain.registerProviders(this.container);\n }\n registerCommandHandlers() {\n this.domain.registerCommandHandlers().forEach(ch => {\n this.container.provide(ch);\n this.container.provideFactoryCollection(COMMAND_HANDLERS, {\n create: commandHandlerFactory,\n deps: [ch, this.domain.registerKey(this.container)]\n });\n });\n }\n registerEventHandlers() {\n this.domain.registerDomainEventHandler().forEach(eh => {\n this.container.provide(eh);\n this.container.provideFactoryCollection(DOMAIN_EVENT_HANDLERS, {\n create: domainEventHandlerFactory,\n deps: [eh]\n });\n });\n }\n registerMultiEventHandlers() {\n this.domain.registerMultiDomainEventHandler().forEach(eh => {\n this.container.provide(eh);\n this.container.provideFactoryCollection(DOMAIN_EVENT_HANDLERS, {\n create: multiDomainEventHandlerFactory,\n deps: [eh]\n });\n });\n }\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { AggregateArchive, AggregateEvent, AggregateEventType, AggregateFactory, AggregateId, AggregateRepository, AggregateRoot, AggregateStore, AggregateStoreRegister, Archive, COMMAND_LOGGER_ENABLED, Command, CommandDispatcher, CommandLogger, CommandType, CoreContainer, CreateAggregateCommand, DomainEvent, DomainEventBus, DomainEventPublisher, DomainEventType, DomainInitializer, DomainObject, EVENT_LOGGER_ENABLED, Entity, EntityId, EventDrivenRepository, EventRepository, FeatureModule, HermesArchiveSubject, HermesBehaviorSubject, HermesId, HermesObservable, HermesReplaySubject, HermesRunner, HermesSingle, HermesSubject, HermesSubscription, InMemoryAggregateStore, InMemoryReadModelStore, InMemoryStore, KeyMap, Optional, PersistAggregateStore, PersistAnemia, PersistReadModelStore, PersistStateStore, RandomIdGenerator, RandomStringGenerator, Reactive, ReactiveService, ReadModelEntity, ReadModelEntityId, ReadModelObject, ReadModelRoot, ReadModelRootId, ReadModelRootRepository, ReadModelStore, ValueObject, assertAggregateEvents, assertDomainEvents, commandInterceptedByHandlerTest, commandPublishEventTest, commandTriggersHandlerAndPublishEventTest, createContainer, disableHermesLoggers, enableHermesLoggers, findDefaultValuesWarehouseTest, fromRxJsObservable, hermesDistinctUntilChanged, hermesEmpty, hermesFilter, hermesFromEvent, hermesInterval, hermesMap, hermesNever, hermesOf, hermesSkip, hermesSwitchMap, hermesTake, hermesTakeUntil, hermesTap, hermesThrowError, hermesTimer, hermesToArray, initHermesApi, onDefaultValuesWarehouseTest, onWarehouseEmpty, onceDefaultValuesWarehouseTest, resetCoreContainer, runHermes, singleFromObservable, testEventRepositoryIsEmptyOnStart, toRxJsObservable };\n//# sourceMappingURL=generic-ui-hermes.mjs.map","map":null,"metadata":{},"sourceType":"module","externalDependencies":[]} |