1. Ideas
2. Design
3. UI Design
4. Implementation(code)
5. Testing
6. Publishing
7. Integration/deployment
8. debugging
9. upgrade
10. uninstall
Idea
This Section should explain how the idea of a plugin is born, what is the purpose of this plugin and the who all can use this plugin
Design
The implementation Design of the plugin
UI Design (portal/mobile)
The Proposed UI design has to be published
Implementation (Code)
The framework should provide an SDK which exposes the basic services that will be used by the plugin
UI based plugin(web/mobile)
To Load the Plugin.
Prerequisite from Framework
The framework should provide hooks so that the plugin can load its UI in the required position.
The framework should expose placeholders on the UI in different places like Homepage, Profile page, course page etc
The framework should provide a mechanism to load the file's of the plugin like Js, CSS, and any other asset
Data access from UI
Prerequisite form Framework
The framework should expose some of the services that plugin can access like,
1. HTTP service
2. logger service
3. Auth service
4. Eventbus service
5. listner service
the plugin should be able to get the data like who is the current logged in user and the currently active session details so as to use this to call the API to get the required data to the plugin.
JS will decorate the DOM
once the data is available from the service to the plugin, plugin JS will use this data to decorate the DOM and will use two-way data binding.
User Interaction with the pages
Once the DOM is created and updated with data now it will wait for user interaction or any event that is listened by the plugin.
Respond to the event
the framework will provide event handling and broadcasting mechanism that a plugin can use to call other plugins or to broadcast its event. the plugin must register to these events and handle accordingly.
the plugin can also emit events so that any dependant plugin can do a callback on that
Data Update from UI
once the user interaction is handled and all the data processing is done the data need to be persisted. plugin calls the services to do this process.
For plugins(web/server/mobile)
the external library used should be properly documented and should be able to easily upgrade.
Testing
The framework will provide the basic testing env required by any plugin to test the Integration of the plugin with the framework
unit testing
The plugin developer will list out all the possible use cases and will write unit test cases to fulfill the use cases
Integration Testing
The plugin will list all the touchpoints where the plugin can affect the application and any service it is using from the framework and will write the automated test for each of the use case.
The plugin will use the framework exposed system to do the automated integration testing.
Publishing
A standard process to build and publish the plugin will be exposed by the framework so that all plugin will follow the same process.
Integration/Deployment
The plugin will specify what is the purpose of the plugin and who all can use it like web/server/mobile. Depending on the use and need for the plugin the Adopter of the framework will use the plugin and integrate it with the endpoints.
Debugging
Debugging will be a key feature of any plugin. so each plugin should use an effective logging system which will provide all the logs in a central place.
in association with this, the framework will expose logging mechanism that each plugin can extend and use to log. this will help in debugging process.
Version Control
Plugins will be version controls this will help in keeping the history of the plugin and helps collaborate on the plugin with other developers
Upgrade
Each plugin should have a roadmap for self-upgrade. if the framework is upgraded then it should consider for plugins backward compatibility and an alert have to be sent to the plugin contributor so that the developer can plan for a plugin upgrade.
Upgrade-Alert
if a plugin is upgraded an alert should be shown to the Integrator to inform the upgrade and the release features and any bug fixes so that the integrator can take a call to upgrade the plugin in his instance or not.
Uninstall
The framework will expose some hook so that the plugin can uninstall any time by calling the methods.
and each plugin also should give some process to uninstall itself like Unregister from the framework.