initial commit

lerna.json

@@ -0,0 +1,11 @@
+{
+  "packages": [
+    "packages/*"
+  ],
+  "npmClient": "yarn",
+  "useWorkspaces": true,
+  "version": "independent",
+	"workspaces": [
+  	"packages/*"
+	]
+}

package.json

@@ -0,0 +1,22 @@
+
+{
+  "name": "root",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "lerna": "^3.22.1"
+  },
+  "dependencies": {
+    "typescript": "^4.0.3"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "start": "lerna exec yarn start",
+    "test": "lerna run test --parallel",
+    "boot": "yarn global add lerna && lerna bootstrap",
+    "release": "yarn install && lerna publish && yarn clean"
+  },
+  "license": "NONE"
+}

packages/event-sourced-cqrs-core/README.md

@@ -0,0 +1,11 @@
+# `event-sourced-cqrs-core`
+
+> TODO: description
+
+## Usage
+
+```
+const eventSourcedCqrsCore = require('event-sourced-cqrs-core');
+
+// TODO: DEMONSTRATE API
+```

packages/event-sourced-cqrs-core/__tests__/event-sourced-cqrs-core.test.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const eventSourcedCqrsCore = require('..');
+
+describe('event-sourced-cqrs-core', () => {
+    it('needs tests');
+});

packages/event-sourced-cqrs-core/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "event-sourced-cqrs-core",
+  "version": "1.0.0",
+  "description": "> TODO: description",
+  "author": "Thomas Léger <[email protected]>",
+  "homepage": "",
+  "license": "NONE",
+  "main": "lib/index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "type": "module",
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "registry": "http://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "private": true,
+  "dependencies": {
+    "ava": "^3.15.0",
+    "commitizen": "^4.2.4",
+    "luxon": "^1.27.0",
+    "semantic-release": "^17.4.4",
+    "typescript": "^4.3.2",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/luxon": "^1.26.5",
+    "@types/uuid": "^8.3.0",
+    "c8": "^7.7.3",
+    "coveralls": "^3.1.0",
+    "nyc": "^15.1.0"
+  }
+}

packages/event-sourced-cqrs-core/src/Aggregates/aggregate-reducers-definitions.repository.ts

@@ -0,0 +1,17 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 18:03:04 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:48:56
+ */
+
+import Aggregates from "./";
+import Events from "../Events"
+import Types from "../types";
+
+export interface AggregateReducersDefinitionsRepository {
+	create: (aggregateReducerDefinition: Aggregates.Reducers.Definitions.Definition) => Promise<Aggregates.Reducers.Definitions.Definition>;
+	get: (id: Types.UUID) => Promise<Aggregates.Reducers.Definitions.Definition[]>;
+	query: (event: Events.Event) => Promise<Aggregates.Reducers.Definitions.Definition[]>;
+	delete: (aggregateReducerDefinition: Aggregates.Reducers.Definitions.Definition) => Promise<void>;
+}

packages/event-sourced-cqrs-core/src/Aggregates/aggregate-reducers-definitions.service.ts

@@ -0,0 +1,24 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:40:11 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:50:53
+ */
+
+import Aggregates from "./";
+import Events from "../Events"
+import Types from "../types";
+
+export interface AggregateReducersDefinitionsServiceInterface {
+	create: (aggregateBuilderDefinition: Aggregates.Reducers.Definitions.Definition) => Promise<Aggregates.Reducers.Definitions.Definition>;
+	get: (id: Types.UUID) => Promise<Aggregates.Reducers.Definitions.Definition[]>;
+	query: (event: Events.Event) => Promise<Aggregates.Reducers.Definitions.Definition[]>;
+	delete: (aggregateBuilderDefinition: Aggregates.Reducers.Definitions.Definition) => Promise<void>;
+};
+
+export const AggregateReducersDefinitionsService = (repository: Aggregates.Reducers.Definitions.Repository): AggregateReducersDefinitionsServiceInterface => ({
+	create: (aggregateBuilderDefinition: Aggregates.Reducers.Definitions.Definition) => repository.create(aggregateBuilderDefinition),
+	get: (id: Types.UUID) => repository.get(id),
+	query: (event: Events.Event) => repository.query(event),
+	delete: (aggregateBuilderDefinition: Aggregates.Reducers.Definitions.Definition) => repository.delete(aggregateBuilderDefinition),
+});

packages/event-sourced-cqrs-core/src/Aggregates/aggregates-repositories.repository.ts

@@ -0,0 +1,15 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 20:15:10 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-23 23:10:47
+ */
+
+import Aggregates from "./";
+import Types from "../types";
+
+export interface AggregatesRepositoriesRepository {
+	create: (aggregate: Aggregates.Repository) => Promise<Aggregates.Repository>;
+	get: (aggregatesRepositoryId: Types.UUID) => Promise<Aggregates.Repository | null>;
+	delete: (id: Types.UUID) => Promise<void>;
+}

packages/event-sourced-cqrs-core/src/Aggregates/aggregates-services.service.ts

@@ -0,0 +1,23 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 20:11:15 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-23 23:17:05
+ */
+
+import Aggregates from "./";
+import Types from "../types";
+
+export interface AggregatesRepositoriesServiceInterface {
+	create: (aggregatesRepository: Aggregates.Repository) => Promise<Aggregates.ServiceInterface>;
+	get: (aggregateRepositoryId: Types.UUID) => Promise<Aggregates.ServiceInterface | null>;
+	// update: (aggregateBuilder: AggregateBuilderDomain) => Promise<AggregateBuilderDomain>;
+	delete: (aggregatesRepositoryId: Types.UUID) => Promise<void>;
+}
+
+export const AggregatesRepositoriesService = (repository: Aggregates.RepositoriesRepository): AggregatesRepositoriesServiceInterface => ({
+	create: (aggregatesRepository: Aggregates.Repository) => repository.create(aggregatesRepository).then(Aggregates.Service),
+	get: (aggregateRepositoryId: Types.UUID)=> repository.get(aggregateRepositoryId).then((repository) => repository === null ? null : Aggregates.Service(repository)),
+	// update: (aggregateBuilder: AggregateBuilderDomain) => repository.update(aggregateBuilder),
+	delete: (aggregatesRepositoryId: Types.UUID) => repository.delete(aggregatesRepositoryId)
+})

packages/event-sourced-cqrs-core/src/Aggregates/aggregates.reducer.ts

@@ -0,0 +1,36 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 19:07:34 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-23 23:19:45
+ */
+
+import Events from "../Events"
+import Aggregates from "./";
+
+export const AggregatesReducer = (event: Events.Event) =>
+	(aggregatesServicesService: Aggregates.ServicesServiceInterface) =>
+		(aggregateReducersDefinitionsService: Aggregates.Reducers.Definitions.ServiceInterface) =>
+				aggregateReducersDefinitionsService
+				.query(event)
+				.then((aggregateReducersDefinitions) =>
+					Promise.all(
+						[... new Set(
+							aggregateReducersDefinitions
+								.flatMap((aggregateBuildersDefinitions) => aggregateBuildersDefinitions.requiredAggregates)
+						)]
+						.map((requiredAggregate) => aggregatesServicesService.get(requiredAggregate.repositoryId).then((aggregatesService) => aggregatesService === null ? Promise.resolve(null) : aggregatesService.get(requiredAggregate.id)))
+					).then((aggregates) => {
+						if (aggregates.includes(null)) {
+							return Promise.reject("Failed resolving some aggregates")
+						}
+						return aggregates as Aggregates.Aggregate[]
+					}).then((aggregates) => 
+						Promise.all(
+							aggregateReducersDefinitions.map((aggregateReducerDefinition) =>
+								aggregateReducerDefinition
+									.reducer()
+									.then((aggregateBuilderReducer) => aggregateBuilderReducer(event)(aggregates))
+						))
+					).then((res) => res)
+				).then((aggregatesPromises) => aggregatesPromises.flatMap((aggregatePromise) => aggregatePromise));

packages/event-sourced-cqrs-core/src/Aggregates/domain/aggregate-reducer-definition.domain.ts

@@ -0,0 +1,17 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:24:49 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-19 18:09:15
+ */
+
+import Aggregates from "../";
+import Types from "../../types";
+
+export interface AggregateReducerDefinition {
+	id: Types.UUID;
+	creationDate: Types.DateTime;
+	triggeringEventId: Types.UUID;
+	requiredAggregates: { id: Types.UUID, repositoryId: Types.UUID }[];
+	reducer: () => Promise<Aggregates.Reducers.Reducer>
+}

packages/event-sourced-cqrs-core/src/Aggregates/domain/aggregate-reducer.domain.ts

@@ -0,0 +1,11 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:24:19 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:47:42
+ */
+
+import Aggregates from "./";
+import Events from "../../Events";
+
+export type AggregateReducer = (event: Events.Event) => (aggregates: Aggregates.Aggregate[])=> Aggregates.Aggregate;

packages/event-sourced-cqrs-core/src/Aggregates/domain/aggregate.domain.ts

@@ -0,0 +1,19 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:24:56 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:47:26
+ */
+
+
+import Types from "../../types";
+
+export interface AggregateDomain {
+	id: Types.UUID;
+	tracingId: Types.UUID;
+	creationDate: Types.DateTime;
+	updatedAt: Types.DateTime | null;
+	repositoryId: Types.UUID;
+	versionNumber: Types.Version;
+	value: Types.Payload;
+}

packages/event-sourced-cqrs-core/src/Aggregates/domain/aggregates-repository.domain.ts

@@ -0,0 +1,16 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:25:18 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:48:10
+ */
+
+import Aggregates from "../";
+import Types from "../../types";
+
+export interface AggregatesRepository {
+	id: Types.UUID,
+	create: (aggregate: Aggregates.Aggregate) => Promise<Aggregates.Aggregate>;
+	get: (id: Types.UUID) => Promise<Aggregates.Aggregate>;
+	delete: (id: Types.UUID) => Promise<void>;
+}

packages/event-sourced-cqrs-core/src/Aggregates/domain/aggregates-service.domain.ts

@@ -0,0 +1,23 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:25:23 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:50:41
+ */
+
+import Aggregates from "../";
+import Types from "../../types";
+
+export interface AggregatesServiceInterface {
+	repositoryId: Types.UUID;
+	create: (aggregate: Aggregates.Aggregate) => Promise<Aggregates.Aggregate>;
+	get: (id: Types.UUID) => Promise<Aggregates.Aggregate>;
+	delete: (id: Types.UUID) => Promise<void>;
+}
+
+export const AggregatesService = (repository: Aggregates.Repository): AggregatesServiceInterface => ({
+	repositoryId: repository.id,
+	create: (aggregate: Aggregates.Aggregate) => repository.create(aggregate),
+	get: (id: Types.UUID) => repository.get(id),
+	delete: (id: Types.UUID) => repository.delete(id),
+})

packages/event-sourced-cqrs-core/src/Aggregates/domain/index.ts

@@ -0,0 +1,23 @@
+/*
+* @Author: Thomas Léger 
+* @Date: 2021-06-11 16:25:02 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-12 22:29:35
+*/
+
+import * as AggregateDomain from "./aggregate.domain";
+import * as AggregateReducer from "./aggregate-reducer.domain";
+import * as AggregatesReducerDefintion from "./aggregate-reducer-definition.domain";
+import * as AggregatesRepository from "./aggregates-repository.domain";
+import * as AggregatesService from "./aggregates-service.domain";
+
+namespace Domain {
+	export import Aggregate = AggregateDomain.AggregateDomain;
+	export import Repository = AggregatesRepository.AggregatesRepository;
+	export import ServiceInterface = AggregatesService.AggregatesServiceInterface;
+	export import Service = AggregatesService.AggregatesService;
+	export import Reducer = AggregateReducer.AggregateReducer;
+	export import ReducerDefinition = AggregatesReducerDefintion.AggregateReducerDefinition;
+}
+
+export default Domain;

packages/event-sourced-cqrs-core/src/Aggregates/index.ts

@@ -0,0 +1,39 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 16:25:27 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 02:18:54
+ */
+
+import Domain from "./domain";
+import * as AggregateReducersDefinitionsRepository from "./aggregate-reducers-definitions.repository";
+import * as AggregateReducersDefinitionsService from "./aggregate-reducers-definitions.service";
+import * as AggregatesRepositoriesRepository from "./aggregates-repositories.repository";
+import * as AggregatesServicesService from "./aggregates-services.service";
+import * as AggregatesReducer from "./aggregates.reducer";
+
+export namespace Aggregates {
+	export import Aggregate = Domain.Aggregate;
+
+	export import Repository = Domain.Repository;
+	export import RepositoriesRepository = AggregatesRepositoriesRepository.AggregatesRepositoriesRepository;
+	export import ServicesServiceInterface = AggregatesServicesService.AggregatesRepositoriesServiceInterface;
+	export import ServicesService = AggregatesServicesService.AggregatesRepositoriesService;
+	export import ServiceInterface = Domain.ServiceInterface;
+	export import Service = Domain.Service;
+
+	export import Reducer = AggregatesReducer.AggregatesReducer;
+
+	export namespace Reducers {
+		export import Reducer = Domain.Reducer;
+
+		export namespace Definitions {
+			export import Definition = Domain.ReducerDefinition;
+			export import Repository = AggregateReducersDefinitionsRepository.AggregateReducersDefinitionsRepository;
+			export import ServiceInterface = AggregateReducersDefinitionsService.AggregateReducersDefinitionsServiceInterface;
+			export import Service = AggregateReducersDefinitionsService.AggregateReducersDefinitionsService;
+		}
+	}
+}
+
+export default Aggregates;

packages/event-sourced-cqrs-core/src/Commands/command-reducers-definitions.repository.ts

@@ -0,0 +1,16 @@
+/*
+ * @Author: Thomas Léger 
+ * @Date: 2021-06-11 18:26:08 
+ * @Last Modified by: Thomas Léger
+ * @Last Modified time: 2021-06-17 01:38:11
+ */
+
+import Commands from "./"
+import Types from "../types";
+
+export interface CommandReducersDefinitionsRepository {
+	create: (commandReducerDefinition: Commands.Reducers.Definitions.Definition) => Promise<Commands.Reducers.Definitions.Definition>;
+	get: (id: Types.UUID) => Promise<Commands.Reducers.Definitions.Definition[]>;
+	query: (command: Commands.Command) => Promise<Commands.Reducers.Definitions.Definition[]>;
+	delete: (commandReducerDefinition: Commands.Reducers.Definitions.Definition) => Promise<void>;
+}