ednet_core

Description:

ednet core

DISCLAIMER: Not production ready, very volatile API! But with locked versions one can already develop full-blown domain models. #
Init EDNet Core v0.0.1+2 #
Credentials:

Based on Dartling

Collaboration: #
Start your collaboration by visiting and taking participation in RFC
0.0.1+2 RFC state #
Proposal for Collaboration on EDNetCore: A Meta Framework for Rapid Definition of Domain Models #
Introduction: #
This document presents a proposal for collaboration on an open-source project to develop a meta framework for rapid
definition of domain models called EDNetCore. This framework is built on top of the Domain-Driven Design (DDD) and
EventStorming methodologies and enables the encapsulation of reusable parts of semantic implementation for generic
repositories and UI default renderings.
Motivation: #
The software development industry is experiencing a shift towards highly abstract and conceptual thinking in
architectural terms, as evidenced by the disruptive advance of no-code platforms and solutions. This trend demands a
focus on the concepts of solutions, their contextual role, and relationships, rather than the implementation details
such as UI or persistence concerns. This shift places pressure on the industry to compete in creativity at a higher
level, where the minority of highly specialized developers will act as maintainers of sub-stacks with similar knowledge
of systems and subsystems as the modern average developer.
The pressure of the analog-to-digital transition is immense and will utilize every novel niche with disrupting potential
and fulfill it. The shortage of endemic highly skilled developers is continuous and omnipresent, and this project aims
to democratize the no-code approach by empowering developers to focus on what matters, the Domain Model.
Framework Description: #
EDNetDSL #
is used to describe any domain model.
EDNetCMS interprets it on various platforms using appropriate default model interpreters,
by only manipulating a YAML file of user stories high-level concepts and their basic relationships,
as not more complex as a basic ER diagram, we can generate an entire well-structured, evolveable MVP of domain model in
discussion and deploy it on the platform of our choosing.
concepts:
- name: User
entry: true
attributes:
- sequence: 1
name: username

- sequence: 2
name: password
sensitive: true

- sequence: 3
name: email

- sequence: 4
name: name

- name: Address
attributes:
- sequence: 1
name: zip

- sequence: 2
name: city

- sequence: 3
name: street

- sequence: 4
name: number

- name: Country
attributes:
- sequence: 1
name: name

- sequence: 2
name: iso

relations:
- from: Address
fromToName: country
to: Country
toFromName: addresses
id:
from: false
to: false
fromToCardinality:
min: 1
max: 1
toFromCardinality:
min: 0
max: N
category: relationship
internal: false

- from: User
fromToName: company
to: Company
toFromName: employees
id:
from: true
to: false
fromToCardinality:
min: 1
max: 1

toFromCardinality:
min: 0
max: N
category: relationship
internal: false
copied to clipboard
EDNetCore #
is an instance implementation of EDNetDSL meta framework for rapid definition of domain models and is an abstraction on top of DDD and
EventStorming, implementing their semantic and lingo. It enables the encapsulation of reusable parts of implementation
for generic repositories and UI default renderings. In combination with other open-source initiatives, EDNetCore can
generate almost everything infrastructural and have default Flutter material interpreter app for multi-platform
deployment or default React material interpreter app optimized for web deployment of EDNetCore domain models.
import 'package:ednet_core/ednet_core.dart';

/// Entities and Value objects
class Vote extends Entity<Vote> {}

class Votes extends Entities<Vote> {}

class Initiative extends Entity<Initiative> {}

class Citizen extends Entity<Citizen> {}

class Proposal extends Entity<Proposal> {}

class Address extends ValueObject<Address> {}
// ...

/// Commands
class VoteForProposalCommand extends IEntitiesCommand {}

class VoteAgainstProposalCommand extends IEntitiesCommand {}

class CommentProposalCommand extends IEntitiesCommand {}
// ...

/// Side effects as Command reactions - Events
class ProposalCommentedReaction implements ICommandReaction {}
// ...

/// Events
class VotedForProposalEvent extends IEntitiesEvent {}

class VotedAgainstProposalEvent extends IEntitiesEvent {}
// ...
copied to clipboard
Project Ambition: #
The project's ambition is not small, and there is a job to be done across all levels of seniority. There are amounts of
legacy Dart 1 code waiting to be transformed into modern mixins and extensions. Large scale architectural concerns
around performant peer-to-peer capabilities with universal platform as a constraint must be addressed. Furthermore, the
definition, implementation, and concrete specialization of the rest of DDD and EventStorming artifacts, such as policies
and events, aggregate roots, systems, etc., are yet to be integrated.
ECMA Script transpilation and hooking publishing to npmjs for web development
Backend use case specifics and examples of usage EDNetCore as domain model framework for custom backend with dart or
nodejs and integration with existing ecosystem of popular technologies missing domain model opinion as Remix and
similar.
One domain model framework integrating backend and frontend implementation at the end generating optionally different
levels of the architecture for the integration.
Extensive documentation for existing API and architecture of EDNetCore in form of C4.
The implementation of code generation for our DSL will empower higher stakeholders like Product managers to take more
direct responsibility for the implementation on the software design level fully. They will understand how we derived our
language and serve as active participants in the process.
Working with highly structured graphs like are metamodels of domain models have bound us to utilize resources like
DBPedia for generic interpretation or at least building of library of highly contextualized specializations of available
public semantic models. Or, in plain language - we can and shall use public knowledge dbs and their ontologies to model
all that there is, or to spark a life in our structured knowledge so that we persist our custom interactions of our
custom contexts.
EaaS, Everything as a service, we have to pay special attention to deployment capabilities and support all major cloud providers in unified way
Conclusion: #
The EDNetCore meta framework for rapid definition of domain models, built on top of DDD and EventStorming, aims to
democratize the no-code approach to software development by empowering developers to focus on what matters, the Domain
Model. This open-source initiative offers the potential to generate almost everything infrastructural, and with the
implementation of code generation for our DSL, we will enable higher stakeholders to take more direct responsibility for
the implementation of software design.