Documentation for the various components of FOLIO is in continuous development. Since the system is composed of many separate components, each component is documented individually. The best places to start are the early chapters of the Okapi Guide and Reference, which describe the system as a whole and explain how the parts fit together.
In the context of those early chapters, you may then wish to go on to:
Community and contribution
The community section explains how to be involved, provides the contribution guidelines, lists the various collaboration tools and has some recommendations about when to use each.
The most important technical document is the Okapi Guide and Reference, which after the introductory sections already described, goes into detail about the Okapi API Gateway that controls a FOLIO system.
With that background understanding, see the documentation for each server-side module.
The FOLIO user-interface toolkit is called Stripes. It is described in the Stripes README, which leads to the related documentation.
With that background understanding, see the documentation for each client-side module, especially the “ui-users”.
- Background orientation
- Setup and configuration
- Getting started
- Reference documentation
- Fundamental documentation
- Module development bases
- Development tips
- Development management
- Development operations
- Other topics
Refer to the Guidelines section.
Other orientation guides:
- Navigation of commits and CI via GitHub and Jenkins.
- Search dev.folio.org and other search and report facilities.
Setup and configuration
- Some tips to assist developers to configure their local workstation setup.
- Documentation at GitHub for getting started, including creating an account, introduction to using GitHub, and increased productivity via keyboard shortcuts.
- Built artifacts – released and snapshot FOLIO artifacts in various formats. Configurations for accessing.
- Source code – explanation of each repository.
Refer to the Start section.
- Overview high-level summary of “getting started” points for a new developer – an onboarding guide.
- Having followed that getting started documentation and understanding the fundamental documentation, then follow Running a local FOLIO system.
- The Commence a module - structure and configuration guide explains a consistent layout for back-end and front-end modules.
- Overiew of all technical reference documentation.
- The set of automatically generated API documentation and the associated list of endpoints.
These are listed in the Start section.
Module development bases
There are various libraries and frameworks that provide the basis for module development.
Front-end module basis
FOLIO Stripes is the basis for front-end module development. This is introduced at the Primer for front-end development.
Back-end module bases
For back-end module development there are various options. These are introduced at the Primer for back-end development.
Some more detail is provided via other introductory documentation:
- The FOLIO Spring-Way Framework is the recommended approach for development of FOLIO modules using the Spring framework and Spring projects and OpenAPI (OAS).
- The FOLIO Vert.x library is a lightweight FOLIO module development library for Vert.x that supports OpenAPI (OAS). It is the recommended library for development of FOLIO modules with Vert.x OpenAPI.
- The RAML Module Builder (RMB) framework, is a special FOLIO module using RAML that abstracts much functionality and enables the developer to focus on implementing business functions. It also exposes a Vert.x based runtime library. Note: RAML Module Builder is no longer being extended with new functionality and is in maintenance mode only.
- Manage notifications to keep abreast.
- Conduct troubleshooting.
- Code analysis and linting facilities explains ESLint, SonarQube, other lint tools, and preparing for pull requests.
- For Contextual Query Language (CQL) examples, see the Glossary, the FOLIO CQL to PostgreSQL JSON converter, the API docs, and the debug output for tests in each backend module.
- Use “api-lint” to assess API descriptions, schema, and examples – both RAML and OpenAPI (OAS).
- Use “api-doc” to generate API documentation from API descriptions, schema, and examples – both RAML and OpenAPI (OAS).
- Conduct API testing using Postman collections and Newman against a running module.
- Describe schema and properties.
- Explain ModuleDescriptors and default LaunchDescriptors.
- Conduct cross-module joins via their APIs.
- Working with dates and times.
- How to check for a valid UUID.
- User experience design.
- Accessible Routing in FOLIO explains assisted navigation.
- FOLIO App Information, Tips, and Tricks. Provides overview information for each app. Includes Settings documentation for each individual app. Note that much of that documentation is being moved to the docs.folio.org site. There are links to specific relevant docs for some modules via the Source-code map.
- Branding abilities via stripes.config.js are explained here and here.
- Performance optimization.
- Using a FOLIO virtual machine – Explains how to utilise a FOLIO virtual machine (VM).
- Release procedures.
- Regular FOLIO releases.
- Search and report facilities (e.g. open pull requests needing review).
- Technical Designs and Decisions. Wiki space to document feature-level designs and decisions: Decision log.
- Create a new FOLIO module and do initial setup and when ready install it to platform and reference environments for snapshot builds.
- Rename a module.
- Archive a GitHub repository.
- Increase visibility of module documentation.
- Raise a FOLIO DevOps Jira ticket.
- Maintain tidy repositories.
- The overview and the current FOLIO Roadmap and the FOLIO Project Roadmap Process including the development and milestone plan for Version 1 and the feature backlog, and the FOLIO Vision, Strategic Objectives and Initiatives, and the FOLIO Development Process Overview, and other important documents and resources are listed at the Wiki.
For people assisting with the FOLIO development operations infrastructure (DevOps), there are various notes. For example regarding operation, enhancement, and configuration of Jenkins continuous integration.
- DevOps introduction.
- DevOps - Verify task acceptance criteria.
- DevOps - Install a new back-end module to reference environments.
- Which forum to use for communication.
- Special Interest Groups (SIGs).
- Guidelines for Contributing Code.
- Best practices for Dockerfiles.
- The FOLIO build, test, and deployment infrastructure.
- A proposal for error response formats.
- Events and presentations.
Brief explanations of various topics.