From 1bcc6c8b2b923b4d4b1662f990d86b190ce73342 Mon Sep 17 00:00:00 2001 From: undergroundwires Date: Sat, 29 Jan 2022 15:47:44 +0100 Subject: [PATCH] Improve documentation for architecture - Simplify `README.md` by creating and moving some documentation to `architecture.md`. - Add more documentation for state handling between layers. - Improve some documentation to use clearer language. --- CONTRIBUTING.md | 2 +- README.md | 30 ++----------- docs/application.md | 59 ++++++++++++------------- docs/architecture.md | 68 +++++++++++++++++++++++++++++ docs/presentation.md | 70 +++++++++++++++++------------- img/architecture/app-state.drawio | 1 + img/architecture/app-state.png | Bin 0 -> 25586 bytes 7 files changed, 143 insertions(+), 87 deletions(-) create mode 100644 docs/architecture.md create mode 100644 img/architecture/app-state.drawio create mode 100644 img/architecture/app-state.png diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 8eb6d2a6..20b12993 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -31,4 +31,4 @@ By contributing, you agree that your contributions will be licensed under its [G - See [tests](./docs/tests.md) for testing - See [extend script](./README.md#extend-scripts) for quick steps to extend scripts -- See [architecture overview](./README.md#architecture-overview) to deep dive into privacy.sexy codebase +- See [architecture overview](./docs/architecture.md) to deep dive into privacy.sexy codebase diff --git a/README.md b/README.md index a0fe223e..ba198322 100644 --- a/README.md +++ b/README.md @@ -128,32 +128,8 @@ ## Development -See [docs/development.md](./docs/development.md) for Docker usage, running/building application, development best-practices along with other information related to development. +See [development.md](./docs/development.md) for Docker usage, running/building application, development best-practices along with other information related to development of this project. -## Architecture overview +## Architecture -### Application - -- Powered by **TypeScript**, **Vue.js** and **Electron** 💪 - - and driven by **Domain-driven design**, **Event-driven architecture**, **Data-driven programming** concepts. -- Application uses highly decoupled models & services in different DDD layers. -- 📖 Read more on • [Presentation](./docs/presentation.md) • [Application](./docs/application.md) - -![DDD + vue.js](img/architecture/app-ddd.png) - -### AWS Infrastructure - -[![AWS solution](img/architecture/aws-solution.png)](https://github.com/undergroundwires/aws-static-site-with-cd) - -- It uses infrastructure from the following repository: [aws-static-site-with-cd](https://github.com/undergroundwires/aws-static-site-with-cd) - - Runs on AWS 100% serverless and automatically provisioned using [GitHub Actions](.github/workflows/). - - Maximum security & automation and minimum AWS costs are the highest priorities of the design. - -#### GitOps: CI/CD to AWS - -- CI/CD is fully automated for this repo using different GIT events & GitHub actions. - - Versioning, tagging, creation of `CHANGELOG.md` and releasing is automated using [bump-everywhere](https://github.com/undergroundwires/bump-everywhere) action -- Everything that's merged in the master goes directly to production. -- 📖 Read more on [CI/CD pipelines](./docs/ci-cd.md) - -[![CI/CD to AWS with GitHub Actions](img/architecture/gitops.png)](.github/workflows/) +Check [architecture.md](./docs/architecture.md) for an overview of design and how different parts and layers work together. You can refer to [application.md](./docs/application.md) for a closer look at application layer codebase and [presentation.md](./docs/presentation.md) for code related to GUI layer. [collection-files.md](./docs/collection-files.md) explains the YAML files that are the core of the application and [templating.md](./docs/templating.md) documents how to use templating language in those files. In [ci-cd.md](./docs/ci-cd.md), you can read more about the pipelines that automates maintenance tasks and ensures you get what see. diff --git a/docs/application.md b/docs/application.md index c2be5230..1949caac 100644 --- a/docs/application.md +++ b/docs/application.md @@ -1,44 +1,45 @@ # Application -- It's mainly responsible for - - creating and event based [application state](#application-state) - - [parsing](#parsing) and [compiling](#compiling) [application data](#application-data) -- Consumed by [presentation layer](./presentation.md) +Application layer is mainly responsible for: + +- creating an event-based and mutable [application state](#application-state), +- [parsing and compiling](#parsing-and-compiling) the [application data](#application-data). + +📖 Refer to [architecture.md | Layered Application](./architecture.md#layered-application) to read more about the layered architecture. ## Structure -- [`/src/` **`application/`**](./../src/application/): Contains all application related code. - - [**`collections/`**](./../src/application/collections/): Holds [collection files](./collection-files.md) - - [**`Common/`**](./../src/application/Common/): Contains common functionality that is shared in application layer. - - `..`: other classes are categorized using folders-by-feature structure +Application layer code exists in [`/src/application`](./../src/application/) and includes following structure: + +- [**`collections/`**](./../src/application/collections/): Holds [collection files](./collection-files.md). +- [**`Common/`**](./../src/application/Common/): Contains common functionality in application layer. +- `...`: rest of the application layer source code organized using folders-by-feature structure. ## Application state -- [ApplicationContext.ts](./../src/application/Context/ApplicationContext.ts) holds the [CategoryCollectionState](./../src/application/Context/State/CategoryCollectionState.ts) for each OS -- Uses [state pattern](https://en.wikipedia.org/wiki/State_pattern) -- Same instance is shared throughout the application to ensure consistent state -- 📖 See [Application State | Presentation layer](./presentation.md#application-state) to read more about how the state should be managed by the presentation layer. -- 📖 See [ApplicationContext.ts](./../src/application/Context/ApplicationContext.ts) to start diving into the state code. +It uses [state pattern](https://en.wikipedia.org/wiki/State_pattern) with context and state objects. [`ApplicationContext.ts`](./../src/application/Context/ApplicationContext.ts) the "Context" of state pattern provides an instance of [`CategoryCollectionState.ts`](./../src/application/Context/State/CategoryCollectionState.ts) (the "State" of the state pattern) for every supported collection. + +Presentation layer uses a singleton (same instance of) [`ApplicationContext.ts`](./../src/application/Context/ApplicationContext.ts) throughout the application to ensure consistent state. + +📖 Refer to [architecture.md | Application State](./architecture.md#application-state) to get an overview of event handling and [presentation.md | Application State](./presentation.md#application-state) for deeper look into how the presentation layer manages state. ## Application data -- Compiled to [`Application`](./../src/domain/Application.ts) domain object. -- The scripts are defined and controlled in different data files per OS -- Enables [data-driven programming](https://en.wikipedia.org/wiki/Data-driven_programming) and easier contributions -- Application data is defined in collection files and -- 📖 See [Application data | Presentation layer](./presentation.md#application-data) to read how the application data is read by the presentation layer. -- 📖 See [collection files documentation](./collection-files.md) to read more about how the data files are structured/defined and see [collection yaml files](./../src/application/collections/) to directly check the code. +Application data is collection files using YAML. You can refer to [collection-files.md](./collection-files.md) to read more about the scheme and structure of application data files. You can also check the source code [collection yaml files](./../src/application/collections/) to directly see the application data using that scheme. + +Application layer [parses and compiles](#parsing-and-compiling) application data into [`Application`](./../src/domain/Application.ts)). Once parsed, application layer provides the necessary functionality to presentation layer based on the application data. You can read more about how presentation layer consumes the application data in [presentation.md | Application Data](./presentation.md#application-data). + +Application layer enables [data-driven programming](https://en.wikipedia.org/wiki/Data-driven_programming) by leveraging the data to the rest of the source code. It makes it easy for community to contribute on the project by using a declarative language used in collection files. + +### Parsing and compiling + +Application layer parses the application data to compile the domain object [`Application.ts`](./../src/domain/Application.ts). -## Parsing +A webpack loader loads (or injects) application data ([collection yaml files](./../src/application/collections/)) into the application layer in compile time. Application layer ([`ApplicationFactory.ts`](./../src/application/ApplicationFactory.ts)) parses and compiles this data in runtime. -- Application data is parsed to domain object [`Application.ts`](./../src/domain/Application.ts) -- Steps - 1. (Compile time) Load application data from [collection yaml files](./../src/application/collections/) using webpack loader - 2. (Runtime) Parse and compile application and make it available to presentation layer by [`ApplicationFactory.ts`](./../src/application/ApplicationFactory.ts) +Application layer compiles templating syntax during parsing to create the end scripts. You can read more about templating syntax in [templating.md](./templating.md) and how application data uses them through functions in [collection-files.md | Function](./collection-files.md#function). -### Compiling +The steps to extend the templating syntax: -- Parsing the application files includes compiling scripts using [collection file defined functions](./collection-files.md#function) -- To extend the syntax: - 1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more. - 2. Register your in [CompositeExpressionParser](./../src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts) +1. Add a new parser under [SyntaxParsers](./../src/application/Parser/Script/Compiler/Expressions/SyntaxParsers) where you can look at other parsers to understand more. +2. Register your in [CompositeExpressionParser](./../src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts). diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 00000000..f9c97851 --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,68 @@ +# Architecture overview + +This repository consists of: + +- A [layered application](#layered-application). +- [AWS infrastructure](#aws-infrastructure) as code and instructions to host the website. +- [GitOps](#gitops) practices for development, maintenance and deployment. + +## Layered application + +Application is + +- powered by **TypeScript**, **Vue.js** and **Electron** 💪, +- and driven by **Domain-driven design**, **Event-driven architecture**, **Data-driven programming** concepts. + +Application uses highly decoupled models & services in different DDD layers: + +- presentation layer (see [presentation.md](./presentation.md)), +- application layer (see [application.md](./application.md)), +- and domain layer. + +Application layer depends on and consumes domain layer. [Presentation layer](./presentation.md) consumes and depends on application layer along with domain layer. Application and presentation layers can communicate through domain model. + +![DDD + vue.js](./../img/architecture/app-ddd.png) + +### Application state + +State handling uses an event-driven subscription model to signal state changes and special functions to register changes. It does not depend on third party packages. + +Each layer treat application layer differently. + +![State](./../img/architecture/app-state.png) + +*[Presentation layer](./presentation.md)*: + +- Each component holds their own state about presentation-related data. +- Components register shared state changes into application state using functions. +- Components listen to shared state changes using event subscriptions. +- 📖 Read more: [presentation.md | Application state](./presentation.md#application-state). + +*[Application layer](./application.md)*: + +- Stores the application-specific state. +- The state it exposed for read with getter functions and set using setter functions, setter functions also fire application events that allows other parts of application and the view in presentation layer to react. +- So state is mutable, and fires related events when mutated. +- 📖 Read more: [application.md | Application state](./application.md#application-state). + +It's comparable with flux ([`redux`](https://redux.js.org/)) or flux-like ([`vuex`](https://vuex.vuejs.org/)) patterns. Flux component "view" is [presentation layer](./presentation.md) in Vue. Flux functions "dispatcher", "store" and "action creation" functions lie in the [application layer](./application.md). A difference is that application state in privacy.sexy is mutable and lies in single flux "store" that holds app state and logic. The "actions" mutate the state directly which in turns act as dispatcher to notify its own event subscriptions (callbacks). + +## AWS infrastructure + +The web-site runs on serverless AWS infrastructure. Infrastructure is open-source and deployed as code. [aws-static-site-with-cd](https://github.com/undergroundwires/aws-static-site-with-cd) project includes the source code. + +[![AWS solution](../img/architecture/aws-solution.png)](https://github.com/undergroundwires/aws-static-site-with-cd) + +The design priorities highest security then minimizing cloud infrastructure costs. + +This project includes [GitHub Actions](../.github/workflows/) to automatically provision the infrastructure with zero-touch and without any "hidden" steps, ensuring everything is open-source and transparent. Git repositories includes all necessary instructions and automation with [GitOps](#gitops) practices. + +## GitOps + +CI/CD is fully automated using different Git events and GitHub actions. This repository uses [bump-everywhere](https://github.com/undergroundwires/bump-everywhere) to automate versioning, tagging, creation of [`CHANGELOG.md`](./../CHANGELOG.md) and GitHub releases. A dedicated [workflow](./../.github/workflows/release.desktop.yaml) creates desktop installers and executables and attaches them into GitHub releases. + +Everything that's merged in the master goes directly to production. + +📖 Refer to [ci-cd.md](./ci-cd.md) to read more on CI/CD pipelines. + +[![CI/CD to AWS with GitHub Actions](../img/architecture/gitops.png)](../.github/workflows/) diff --git a/docs/presentation.md b/docs/presentation.md index 4a1e59a5..7f0b5f15 100644 --- a/docs/presentation.md +++ b/docs/presentation.md @@ -1,53 +1,63 @@ # Presentation layer -- Consists of Vue.js components and other UI-related code. -- Desktop application is created using [Electron](https://www.electronjs.org/). -- Event driven as in components simply listens to events from the state and act accordingly. +Presentation layer consists of UI-related code. It uses Vue.js as JavaScript framework and includes Vue.js components. It also includes [Electron](https://www.electronjs.org/) to provide functionality to desktop application. + +It's designed event-driven from bottom to top. It listens user events (from top) and state events (from bottom) to update state or the GUI. + +📖 Refer to [architecture.md (Layered Application)](./architecture.md#layered-application) to read more about the layered architecture. ## Structure - [`/src/` **`presentation/`**](./../src/presentation/): Contains all presentation related code including Vue and Electron configurations - [**`bootstrapping/`**](./../src/presentation/bootstrapping/): Registers Vue global objects including components and plugins. - [**`components/`**](./../src/presentation/components/): Contains all Vue components and their helper classes. - - [**`Shared/`**](./../src/presentation/components/Shared): Contains Vue components and component helpers that are shared across other components. - - [**`assets/`**](./../src/presentation/assets/styles/): Contains assets that will be processed by webpack. + - [**`Shared/`**](./../src/presentation/components/Shared): Contains Vue components and component helpers that other components share. + - [**`assets/`**](./../src/presentation/assets/styles/): Contains assets that webpack will process. - [**`fonts/`**](./../src/presentation/assets/fonts/): Contains fonts - [**`styles/`**](./../src/presentation/assets/styles/): Contains shared styles used throughout different components. - - [**`components/`**](./../src/presentation/assets/styles/components): Contains styles that are reusable and tightly coupled a Vue/HTML component. + - [**`components/`**](./../src/presentation/assets/styles/components): Contains reusable styles coupled to a Vue/HTML component. - [**`vendors-extensions/`**](./../src/presentation/assets/styles/third-party-extensions): Contains styles that override third-party components used. - - [**`main.scss`**](./../src/presentation/assets/styles/main.scss): Primary Sass file, passes along all other styles, should be the only file used from other components. + - [**`main.scss`**](./../src/presentation/assets/styles/main.scss): Primary Sass file, passes along all other styles, should be the single file used from other components. - [**`main.ts`**](./../src/presentation/main.ts): Application entry point that mounts and starts Vue application. - [**`electron/`**](./../src/presentation/electron/): Electron configuration for the desktop application. - [**`main.ts`**](./../src/presentation/main.ts): Main process of Electron, started as first thing when app starts. -- [**`/public/`**](./../public/): Contains static assets that will directly be copied and not go through webpack. -- [**`/vue.config.js`**](./../vue.config.js): Global Vue CLI configurations loaded by `@vue/cli-service` -- [**`/postcss.config.js`**](./../postcss.config.js): PostCSS configurations that are used by Vue CLI internally -- [**`/babel.config.js`**](./../babel.config.js): Babel configurations for polyfills used by `@vue/cli-plugin-babel` +- [**`/public/`**](./../public/): Contains static assets that are directly copied and do not go through webpack. +- [**`/vue.config.js`**](./../vue.config.js): Global Vue CLI configurations loaded by `@vue/cli-service`. +- [**`/postcss.config.js`**](./../postcss.config.js): PostCSS configurations used by Vue CLI internally. +- [**`/babel.config.js`**](./../babel.config.js): Babel configurations for polyfills used by `@vue/cli-plugin-babel`. ## Application data -- Components and should use [ApplicationFactory](./../src/application/ApplicationFactory.ts) singleton to reach the application domain. -- [Application.ts](../src/domain/Application.ts) domain model is the stateless application representation including - - available scripts, collections as defined in [collection files](./collection-files.md) - - package information as defined in [`package.json`](./../package.json) -- 📖 See [Application data | Application layer](./presentation.md#application-data) where application data is parsed and compiled. +Components (should) use [ApplicationFactory](./../src/application/ApplicationFactory.ts) singleton to reach the application domain to avoid [parsing and compiling](./application.md#parsing-and-compiling) the application again. + +[Application.ts](../src/domain/Application.ts) is an immutable domain model that represents application state. It includes: + +- available scripts, collections as defined in [collection files](./collection-files.md), +- package information as defined in [`package.json`](./../package.json). + +You can read more about how application layer provides application data to he presentation in [application.md | Application data](./application.md#application-data). ## Application state -- Stateful components mutate or/and react to state changes in [ApplicationContext](./../src/application/Context/ApplicationContext.ts). -- Stateless components that does not handle state extends `Vue` -- Stateful components that depends on the collection state such as user selection, search queries and more extends [`StatefulVue`](./../src/presentation/components/Shared/StatefulVue.ts) -- The single source of truth is a singleton of the state created and made available to presentation layer by [`StatefulVue`](./../src/presentation/components/Shared/StatefulVue.ts) -- `StatefulVue` includes abstract `handleCollectionState` that is fired once the component is loaded and also each time [collection](./collection-files.md) is changed. -- Do not forget to subscribe from events when component is destroyed or if needed [collection](./collection-files.md) is changed. - - 💡 `events` in base class [`StatefulVue`](./../src/presentation/components/Shared/StatefulVue.ts) makes lifecycling easier -- 📖 See [Application state | Application layer](./presentation.md#application-state) where the state is implemented using using state pattern. +Inheritance of a Vue components marks whether it uses application state . Components that does not handle application state extends `Vue`. Stateful components mutate or/and react to state changes (such as user selection or search queries) in [ApplicationContext](./../src/application/Context/ApplicationContext.ts) extend [`StatefulVue`](./../src/presentation/components/Shared/StatefulVue.ts) class to access the context / state. + +[`StatefulVue`](./../src/presentation/components/Shared/StatefulVue.ts) functions include: + +- Creating a singleton of the state and makes it available to presentation layer as single source of truth. +- Providing virtual abstract `handleCollectionState` callback that it calls when + - the Vue loads the component, + - and also every time when state changes. +- Providing `events` member to make lifecycling of state subscriptions events easier because it ensures that components unsubscribe from listening to state events when + - the component is no longer used (destroyed), + - an if [ApplicationContext](./../src/application/Context/ApplicationContext.ts) changes the active [collection](./collection-files.md) to a different one. + +📖 Refer to [architecture.md | Application State](./architecture.md#application-state) to get an overview of event handling and [application.md | Application State](./presentation.md#application-state) for deeper look into how the application layer manages state. ## Modals -- [Dialog.vue](./../src/presentation/components/Shared/Dialog.vue) is a shared component that can be used to show modal windows -- Simply wrap the content inside of its slot and call `.show()` method on its reference. -- Example: +[Dialog.vue](./../src/presentation/components/Shared/Dialog.vue) is a shared component that other components used to show modal windows. + +You can use it by wrapping the content inside of its `slot` and call `.show()` function on its reference. For example: ```html @@ -58,15 +68,15 @@ ## Sass naming convention -- Use lowercase for variables/functions/mixins e.g. +- Use lowercase for variables/functions/mixins, e.g.: - Variable: `$variable: value;` - Function: `@function function() {}` - Mixin: `@mixin mixin() {}` -- Use - for a phrase/compound word e.g. +- Use - for a phrase/compound word, e.g.: - Variable: `$some-variable: value;` - Function: `@function some-function() {}` - Mixin: `@mixin some-mixin() {}` -- Grouping and name variables from generic to specific e.g. +- Grouping and name variables from generic to specific, e.g.: - ✅ `$border-blue`, `$border-blue-light`, `$border-blue-lightest`, `$border-red` - ❌ `$blue-border`, `$light-blue-border`, `$lightest-blue-border`, `$red-border` \ No newline at end of file diff --git a/img/architecture/app-state.drawio b/img/architecture/app-state.drawio new file mode 100644 index 00000000..0d27680b --- /dev/null +++ b/img/architecture/app-state.drawio @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/img/architecture/app-state.png b/img/architecture/app-state.png new file mode 100644 index 0000000000000000000000000000000000000000..524179385f5e6bf68f1e5661831fcde1d8e0f43e GIT binary patch literal 25586 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