bajo 2.23.0 → 2.24.0

package/wiki/GETTING-STARTED.md

@@ -1,356 +0,0 @@
-# Getting Started
-
-This is the quickstart guide for getting started with Bajo, a framework for building robust and scalable applications. This section covers essential steps for beginners, including installation, setting up your project structure, and understanding basic configurations. You will be introduced to the core concepts of Bajo's plugin system and lifecycle, learning how to build your first "Hello World!" application and utilize the powerful hook system for custom extensions. This foundation will prepare you to dive into Bajo's specialized sub-frameworks, such as Dobo and Waibu, to further develop your application's capabilities.
-
-## Installation
-
-Create a new empty directory named ```my-project```. This will be your app directory throughout this tutorial. Now, ```cd``` into your newly created directory and type:
-
-```bash
-$ npm init
-```
-
-You'll be asked to name your project, provide its description, author info, etc. Please continue until the *package.json* file is created.
-
-Then, open it using your favorite editor, edit it, and insert the following lines:
-
-```javascript
-...
-  "type": "module",
-  "bajo": {
-    "type": "app"
-  },
-...
-```
-
-After completing these steps, install Bajo by running:
-
-```bash
-$ npm install bajo
-```
-
-Now, create your app's bootstrap file, ```index.js```, and add these lines:
-
-```javascript
-// index.js file
-import bajo from 'bajo'
-await bajo()
-```
-
-A Bajo-based app **ALWAYS** needs a data directory for its config files, etc. This directory can be located inside or outside your app directory. If this directory doesn't exist yet, Bajo will create a new one for you, named ```data```, in the same location as your ```index.js``` file. By default, Bajo will set this as your data directory.
-
-Bajo will also automatically create the ```main``` directory to serve as your main plugin if it doesn't already exist. A factory file named ```index.js``` will be added inside the ```main``` directory. More on this later in the next chapter.
-
-Now, run your app:
-
-```bash
-$ node index.js
-```
-
-Congratulations! Your Bajo-based app is up and running!
-
-## Playing Around
-
-By now, your directory structure should look like this:
-
-```
-.
-└── my-project
-    ├── data
-    │   └── config
-    ├── main
-    │   └── index.js
-    ├── node_modules
-    │   └── ...
-    ├── index.js
-    ├── package.json
-    └── package-lock.json
-```
-Your app runs in the ```dev``` environment by default. In this environment, the log level is set to ```debug```, which can be overridden using program arguments:
-
-```bash
-$ node index.js --log-level=trace --log-timeTaken --log-pretty
-```
-
-Now, Bajo will show you a bunch of pretty, colorful logs, including the time each step took. This is very useful for debugging and for finding out which activity takes the most time.
-
-But typing program arguments is tedious and boring. Let's use a config file to do some magic. Please create the JSON file ```data/config/bajo.json``` and add these lines to it:
-
-```json
-{
-  "env": "dev",
-  "log": {
-    "pretty": true,
-    "level": "trace",
-    "timeTaken": true
-  }
-}
-```
-
-Now, try simply running your app without any arguments:
-
-```bash
-$ node index.js
-```
-
-Much better! And hassle-free!
-
-You can mix and match config file and program arguments on any key-value pairs anytime you want. You can even utilize environment variables and a dotenv ```.env``` file if you really need to. Please read the *User Guide* for more in-depth information on this.
-
-## Your First Project
-
-Let's start with **Hello World!**, the Bajo way.
-
-The objectives of this short course are:
-1. reading values ​​from the configuration
-2. copying those values ​​into properties in the main plugin during initialization
-3. displaying values ​​while the program is running
-4. notifying if the program terminates
-
-Let's go!
-
-### Config Object
-
-Please open the ```data/config/main.json``` file or create a new one if it doesn't exist. This is the main plugin configuration file.
-
-Enter these lines:
-
-```json
-{
-  "firstName": "Tanjiro",
-  "lastName": "Kamado",
-  "age": 15
-}
-```
-
-Each Bajo plugin can be configured through the configuration file located at ```{dataDir}/config/{ns}.json```, where ```{dataDir}``` is the data directory location and ```{ns}``` is the namespace or plugin name. Please visit [User Guide](USER-GUIDE.md) for more info.
-
-As you may know now, in Bajo, you create everything through plugins. If your project is small or not very complicated, you can use the main plugin that's always ready and available. But over time, as your app gets bigger and bigger, you'll need to start thinking about breaking things into small pieces through independent plugins.
-
-If you intend to create your own customized plugin, refer to the [Developer Guide](DEV-GUIDE.md).
-
-### Plugin Factory
-
-Now let's open ```main/index.js``` and update it according to the example below.
-
-This file is the main plugin factory. It gets created automatically if it's not there.
-
-```javascript
-async function factory (pkgName) {
-  const me = this
-
-  return class Main extends this.app.baseClass.Base {
-    constructor () {
-      super(pkgName, me.app)
-      this.config = {}
-    }
-
-    init = async () =>  {
-      this.firstName = this.config.firstName
-      this.lastName = this.config.lastName
-      this.age = this.config.age
-    }
-
-    start = async () => {
-      this.log.info('First name: %s, Last name: %s, age: %d', this.firstName, this.lastName, this.age)
-    }
-
-    exit = async () => {
-      this.log.warn('Program aborted')
-    }
-  }
-}
-
-export default factory
-```
-
-A couple of things to note:
-
-- At boot, the main plugin reads its configuration file main.json and merges it with all program arguments and environment variables it can find which belong to it and builds its config object.
-- Then, plugin initialization happens. In this step, all code inside the asynchronous method ```init``` will be executed. In this example, all object config's key-value pairs will be assigned to the plugin's properties.
-- Then, the plugin will start. All code inside the asynchronous method ```start``` will be invoked. In this example, it simply writes the first name, last name, and age to the logger.
-- At program exit, the asynchronous method ```exit``` will be executed.
-
-That's the lifecycle of all Bajo plugins, including the main plugin.
-
-But unfortunately, if you run it now, you'll get an error. That's because the root keys of the config object from the configuration file (```firstName```, ```lastName```, and ```age```) aren't defined in ```this.config``` and are ignored during initialization.
-
-That's why we need to fix it first:
-
-```
-...
-    constructor () {
-      super(pkgName, me.app)
-      this.config = {
-        firstName: 'John',
-        lastName: 'Doe',
-        age: 50
-      }
-    }
-...
-```
-
-```this.config``` defined in the constructor serves as the default config object. During initialization, this will be merged with values from the configuration file. If one or more keys are missing from the configuration file, the related default values are used.
-
-If you run this now, you'll get a bunch of logs. Let's filter it with:
-
-```bash
-$ node index.js --log-level=info
-2025-09-12T00:09:38.946Z +97ms INFO: main First name: Tanjiro, Last name: Kamado, age: 15
-2025-09-12T00:09:38.949Z +3ms WARN: main Program aborted
-```
-
-Sweet!
-
-## The Hook System
-
-### Tapping a Hook
-
-Bajo offers you a hook system in which you can tap certain actions anywhere in the system with your own code. Let's go through the simplest one: running your code just after the boot process is completed.
-
-First, create ```main/extend/bajo/hook/bajo@after-boot-complete.js```. If you're curious about the reason for the unusual file name, please refer to the [User Guide](USER-GUIDE.md) on Hook's naming rules.
-
-```javascript
-async function afterBootComplete () {
-  this.log.info('Hook after boot complete')
-}
-
-export default afterBootComplete
-```
-
-Pretty easy, right?
-
-### Your Own Hook
-
-Now let's create your own hook. Even though it's silly to use a hook for such a simple program, its purpose is to demonstrate how easy it is to do it in Bajo.
-
-This time, we want to change the property ```lastName``` with hook.
-
-Open ```index.js``` and update it accordingly:
-
-```javascript
-...
-    init = async () => {
-      const { runHook } = this.app.bajo // add this line
-      this.firstName = this.config.firstName
-      this.lastName = this.config.lastName
-      this.age = this.config.age
-      await runHook('main:myHook') // and this line
-    }
-...
-```
-
-The above code should add a hook named ```main:myHook``` in the initialization step.
-
-Now, create a new file ```main/extend/bajo/hook/main@my-hook.js```:
-
-```javascript
-async function myHook () {
-  this.lastName = 'THE Daemon Slayer'
-}
-
-export default myHook
-```
-
-As every class method, hook, and function handler in Bajo is called within its own plugin scope, it is sufficient to set ```this.lastName``` directly inside a hook.
-
-Now run it. It should show you something like these:
-
-```bash
-2025-09-12T12:09:09.004Z +115ms INFO: main First name: Tanjiro, Last name: THE Daemon Slayer, age: 15
-2025-09-12T12:09:09.008Z +4ms INFO: main Hook after boot complete
-2025-09-12T12:09:09.009Z +1ms WARN: main Program aborted
-```
-
-## Using Plugins
-
-Bajo is designed to be an ecosystem with many small plugins. Think of Lego blocks: you build a structure just by picking up the right ones and sticking them together to create your very own structure.
-
-In this series, we'll learn how to use such plugins to extend our app.
-
-### File Format
-
-We love YAML format so much so let's use it for our configuration file:
-
-1. YAML support is part of the ```bajo-config``` plugin, so we need to install it first
-   ```bash
-   $ npm install bajo-config
-   ```
-2. Now, open the ```data/config/.plugins``` file and put ```bajo-config``` in it, line by line. If it doesn't exist yet, create it first. Don't worry about the order; Bajo will figure it out automatically if you have many plugins.
-3. Delete your old configuration file ```data/config/main.json``` and create a new ```data/config/main.yml```. By the way, it doesn't matter whether you use ```.yml``` or ```.yaml```. Both are supported.
-4. Enter the following lines, it should be the same object as before, just in YAML format:
-   ```yaml
-   firstName: Tanjiro
-   lastName: Kamado
-   age: 15
-   ```
-5. Run and check the output. It should be the exact same output as before, except for the log's timestamps.
-
-### Applet Mode
-
-**Applets** are small tools embedded in plugins that can be invoked when Bajo is running in **applet mode**. Their lifecycle is totally independent of the main program, but they can reuse the same resources and config objects.
-
-You can run Bajo in applet mode by using the ```--applet``` or ```-a``` switches:
-
-```bash
-$ node index.js -a
-```
-
-But applet mode requires you to install ```bajo-cli``` beforehand. So, please install it first:
-
-```bash
-$ npm install bajo-cli
-```
-
-Don't forget to add ```bajo-cli``` to the ```data/config/.plugins``` file. Again, the order doesn't really matter here.
-
-If you run it now, you'll see something like this on your terminal:
-
-```bash
-ℹ App runs in applet mode
-? Please select: (Use arrow keys)
-❯ bajoConfig
-  bajoCli
-```
-
-The first thing to notice is the information that the app is running in applet mode. It's a normal command-line application with a pretty decent UI, and all the logs are gone!
-
-By default, logs are turned off in applet mode to give you a clear and distraction-free console. However, during debugging, you might want to turn them on. How? Simply add the ```--log-applet``` switch to your invocation, and your logs will be printed everywhere again.
-
-Applets are a way for a Bajo plugin developer to help you by providing small tools for everyday life. It's up to the plugin developer to provide such applets, so don't be surprised if you don't get any built-in applets with some plugins.
-
-### System Info
-
-Let's install one more plugin: ```bajo-sysinfo```. This plugin is a thin wrapper around [systeminformation](https://github.com/sebhildebrandt/systeminformation) with a few twists:
-
-- It can be called directly as an applet.
-- It is also exported as Waibu REST API endpoints. We'll cover this later in the tutorial.
-
-If you try to run your app as shown below (yes, you can have a value for the applet switch; for more details, please [see here](https://github.com/ardhi/bajo-cli)), you'll see something like this after the loading spinner stops:
-
-```bash
-$ node index.js -a bajoSysinfo:battery
-ℹ App runs in applet mode
-ℹ Done!
-┌──────────────────┬─────────────────────┐
-│ hasBattery       │ true                │
-├──────────────────┼─────────────────────┤
-│ cycleCount       │ 0                   │
-├──────────────────┼─────────────────────┤
-│ isCharging       │ true                │
-├──────────────────┼─────────────────────┤
-│ designedCapacity │ 61998               │
-├──────────────────┼─────────────────────┤
-│ maxCapacity      │ 51686               │
-├──────────────────┼─────────────────────┤
-...
-```
-
-## More
-
-Bajo has a lot more to offer. Get ready to dive deeper by continuing your journey with Bajo's sub-frameworks:
-
-- [Dobo Database Management System](https://github.com/ardhi/dobo/wiki/GETTING-STARTED.md)
-- [Waibu Web Framework](https://github.com/ardhi/waibu/wiki/GETTING-STARTED.md)
-- [Sumba Biz Suites](https://github.com/ardhi/sumba/wiki/GETTING-STARTED.md)
-- [Masohi Messaging](https://github.com/ardhi/masohi/wiki/GETTING-STARTED.md)

package/wiki/USER-GUIDE.md

@@ -1,256 +0,0 @@
-# User Guide
-
-## Overview
-
-### Definitions
-
-Before proceeding, familiarize yourself with these terminologies used throughout this documentation:
-
-1. ```{appDir}```: The application's project directory where all your code residese.
-2. ```{dataDir}```: The directory for all data; defaults to ```{appDir}/data``` and is created automatically if missing.
-3. ```{tmpDir}```: The temporary directory, defaults to the OS temporary directory.
-4. ```{pkgName}```: The plugin's package name, typically matching its npm listing.
-5. ```{ns}```: The plugin name or namespace, which is the camel-cased version of the package name.
-6. ```{mainNs}```: The special main namespace and directory named main within your ```{appDir}```; this is where all application code should be written.
-
-### Directory Structure
-
-Your typical Bajo app directory structure should look like this:
-
-```
-.
-└── {appDir}
-    ├── {dataDir}
-    │   ├── config
-    │   │   ├── .plugin
-    │   │   ├── bajo.json
-    │   │   ├── main.json
-    │   │   └── ...
-    │   └── plugins
-    │       └── ...
-    ├── main
-    │   ├── extend
-    │   │   └── ...
-    │   ├── index.js
-    │   └── ...
-    ├── package.json
-    ├── index.js
-    └── ...
-```
-
-1. You can move ```{dataDir}``` out of ```{appDir}``` if you want, but you need to tell Bajo where to find it. For more on this, please follow along.
-2. ```{dataDir}``` should be the only place Bajo **writes** anything. Bajo and its plugins should **never** be allowed to write anything outside ```{dataDir}``` on their own.
-3. ```config``` is a special directory within ```{dataDir}``` where your configuration files should reside. Inside this directory, you should find:
-   - a special file named ```.plugins``` that tells Bajo which plugins should be loaded
-   - a file named ```bajo.json``` to configure global settings
-   - all plugin-specific config files, named after their namespace
-4. The ```main``` directory, or ```{mainNs}``` namespace, is the special plugin where you put your application code. And yes, it is actually a normal Bajo plugin! This means everything in there will be handled just like a regular plugin—it has the ability to extend other plugins, has its own config file, and more — with a few differences:
-   - it's always available and can't be disabled
-   - it's always the last one to start
-   - if this directory is missing, it will be created automatically on startup
-   - if the plugin's factory function is missing (```index.js```), it will be created dynamically
-5. ```index.js``` is the main entry point for your app.
-
-To set your ```{dataDir}``` somewhere else, you need to tell Bajo where to find it by using an argument switch.
-
-Assuming your data directory is ```my-data-dir``` at the same level as your app directory, run your app like this:
-
-```bash
-$ node index.js --dir-data=../my-data-dir
-```
-
-If using program arguments seems a bit like a hassle for you, just use Bajo's [dotenv](https://github.com/motdotla/dotenv) support. Create a ```.env``` file in your app directory and put this inside:
-
-```text
-DIR__DATA=../my-data-dir              # double underscores!!!
-```
-
-From now on, you can start the app just by typing:
-
-```bash
-$ node index.js
-```
-
-### Runtime
-
-Bajo should run perfectly fine on Node.js version 20 or higher. Using the latest stable runtime is recommended. Bajo-based apps are also known to run with **Bun** without any problems. But Bajo **cannot** run on Deno due to its heavy reliance on Node.js-specific libraries and environments. 
-
-Bajo is a pure ES6 framework that utilizes dynamic imports ```a lot```. Running on a system with a fast disk (e.g., SSD) and enough RAM is highly recommended, especially when you load a lot of plugins.
-
-## Configuration
-
-### General Rules
-
-- All configuration files must be placed in the ```{dataDir}/config``` subfolder.
-- Config files must be named after their plugin namespace.
-- The file format should be either ```.json``` or ```.js```. If a ```.js``` file is used, it must be in ES6 format and should export either a plain JavaScript object or a function. Both synchronous and asynchronous functions are supported. If it returns a function, this function will be called within its plugin scope and should return a plain JS object.
-- Other formats (```.yml```, ```.yaml```, and ```.toml```) can also be used by installing and loading the [bajoConfig](https://github.com/ardhi/bajo-config) plugin.
-- Other formats (```.yml```, ```.yaml``` and ```.toml```) can also be used by installing & loading [bajoConfig](https://github.com/ardhi/bajo-config) plugin
-- The order of precedence is ```.js``` > ```.json``` > ```.yml``` > ```.yaml``` > ```.toml```. This means that if a .js file exists, it will be used instead of a .json file or any other format.
-
-Example: bajo.json
-```json
-{
-  "env": "prod",
-  "log": {
-    "pretty": true,
-    "timeTaken": true
-  },
-  "lang": "id"
-}
-```
-
-### Using Plugins
-
-Plugins are what make the Bajo Framework so great and flexible: they extend app features and functionalities!
-
-To use plugins, follow these steps:
-
-1. Install it with ```npm install {package}```, where ```{package}``` is the plugin's package name. You can install as many plugins as you want; for a complete list of plugins, please [click here](ecosystem.md).
-2. Optionally, create ```{dataDir}/config/{ns}.json``` to customize the plugin's settings, where ```{ns}``` is the namespace or plugin name.
-3. Open or create ```{dataDir}/config/.plugins``` and list the plugin's ```{package}``` name in it, one per line.
-
-For example, the text below will load ```bajo-config```, ```bajo-extra```, and ```bajo-template```:
-
-```text
-# .plugin file
-bajo-config
-bajo-extra
-bajo-template
-```
-
-If you later decide to disable one or more plugins, you just need to remove them from the ```.plugins``` file or place a ```#``` hash mark in front of the package name and restart your app.
-
-> **Warning**: Please do not confuse ```{package}``` and ```{ns}```. The plugin package is the name of the JS package listed on npm, while ```{ns}``` is the namespace or plugin name, which is basically the camel-cased version of the plugin's package name.
-
-### Environment Support
-
-Configuration file support for different environments is also available. All you need to do is create a ```{ns}-{env}.json``` file in your ```{dataDir}/config```, where:
-
-- ```{ns}```: the namespace/plugin name
-- ```{env}```: your desired environment (```dev``` or ```prod```)
-- App-wide settings with ```bajo-{env}.json``` are also possible.
-
-Bajo is smart enough to select which config file will be used based on the following order of precedence:
-
-1. Use ```{ns}-{env}.json``` if the file exists.
-2. If not, use ```{ns}.json```.
-3. If that also doesn't exist, then use the plugin's default config values.
-
-### Runtime Override
-
-You can easily override ANY key-value pair setting with environment variables and program argument switches. Bajo also supports [dotenv](https://github.com/motdotla/dotenv) with a ```.env``` file.
-
-The order of precedence is: environment variable > argument switches > config files > default, built-in values.
-
-All values (whether they come from environment variables, argument switches, or config files) will be parsed using [dotenv-parse-variables](https://github.com/ladjs/dotenv-parse-variables), so please make sure you visit the repository to fully understand how it works.
-
-#### dotenv
-
-- Create or open ```{appDir}/.env```
-- Use ```__``` (double underscores) as replacement for dots in an object.
-- ```DIR__DATA```: Sets the ```{dataDir}``` data directory.
-- ```DIR__TMP```: Sets ```{tmpDir}``` temporary directory.
-- For every key in ```{ns|bajo}.json```, use its snake-cased, upper-cased version. For example:
-  - ```env: 'prod'``` → ```ENV=prod```
-  - ```log.dateFormat: 'YYYY-MM-DD'``` → ```LOG__DATE_FORMAT=YYYY-MM-DD```
-  - ```exitHandler: true``` → ```EXIT_HANDLER=true```
-- To override a plugin's config, prepend every key in the plugin's config with the snake-cased, upper-cased version of the namespace followed by a dot. For example:
-  - ```key``` in ```myPlugin``` → ```MY_PLUGIN.KEY=...```
-  - ```key.subKey.subSubKey``` in ```myPlugin``` → ```MY_PLUGIN.KEY__SUB_KEY__SUB_SUB_KEY=...```
-
-Example:
-```text
-# .env file
-ENV=prod
-LOG__PRETTY=true
-LOG__TIME_TAKEN=true
-LANG=id
-```
-
-#### Argument Switches
-
-- Use switches, for example: ```node index.js --xxx=one --yyy=two```
-- Use ```-``` as the replacement for dots in an object.
-- ```--dir-data```: Sets the ```{dataDir}``` data directory.
-- ```--dir-tmp```: Sets the ```{tmpDir}``` temporary directory.
-- For every key in ```{ns|bajo}.json```, add ```--``` prefix. For example:
-  - ```env: 'prod'``` → ```--env=prod```
-  - ```log.dateFormat: 'YYYY-MM-DD'``` → ```--log-dateFormat=YYYY-MM-DD```
-  - ```exitHandler: true``` → ```--exitHandler```
-- To override a plugin's config, prepend every key in the plugin's config with the plugin name followed by a colon ```:```. For example:
-  - ```key``` in ```myPlugin``` → ```--myPlugin:key=...```
-  - ```key.subKey.subSubKey``` in ```myPlugin``` → ```--myPlugin:key-subKey-subSubKey=...```
-
-Example:
-```bash
-$ node index.js --env=prod --log-pretty --log-timeTaken --lang=id
-```
-
-## System Hook
-
-A **hook** refers to a mechanism that allows you to inject a custom function to extend Bajo's functionality at specific points. These points are typically predefined by the framework, providing opportunities to execute code before, during, or after a particular operation.
-
-### Usage
-
-In Bajo, hooks can be created anywhere very easily. Simply call the ```runHook``` method followed by the parameters you want to pass.
-
-The hook name is always in the form of [TNsPairs](global.html#TNsPathPairs), while its parameters are a rest parameter. This means you can pass any number of parameters to the function, or none at all.
-
-Example:
-
-1. In your JavaScript file, add the following code snippet:
-
-   ```javascript
-   const { runHook } = this.app.bajo
-   await runHook('main:sayHello', 'Don', 'Meri', { movie: 'Jumbo', year: 2025 })
-   ````
-2. Go to directory ```{appDir}/main/extend/bajo/hook```. Create one if it doesn't exist yet.
-3. Create file ```main@say-hello.js``` in the directory above.
-4. Enter these lines:
-   ```javascript
-   async function sayHello (...params) {
-     const [mainChar, friend, payload] = params
-     console.log(mainChar, friend, payload) // output: Don, Meri, { movie: 'Jumbo', year: 2025 }
-   }
-
-   export default sayHello
-   ```
-
-Note the hook name and its associated file name:
-
-```main:sayHello``` → ```main@say-hello.js```
-
-Because a colon (```:```) is prohibited in a file name, Bajo replaces it with the ```@``` symbol.
-
-During the boot process, Bajo will scan for hook files and load them into the hook list. When your ```runHook``` is executed, Bajo will find its related object from the list. If such a hook exists, its function handler will be called.
-
-### Anatomy
-
-Many times, there are more than one handler listening for a particular hook name. Especially in a framework that uses plugins extensively like Bajo, many plugins can listen to one hook at the same time. This creates a problem with call order.
-
-To overcome this problem, Bajo gives you the opportunity to set a ```level```. Functions with a lower level will be called earlier. Functions with no level will be assigned level 999 by default.
-
-Now, change your ```main@say-hello.js``` file above to export an object instead of a function:
-
-```javascript
-const sayHello = {
-  level: 10, // <-- will get called early
-  handler: async function (...params) {
-    const [mainChar, friend, payload] = params
-    console.log(mainChar, friend, payload) // output: Don, Meri, { movie: 'Jumbo', year: 2025 }
-  }
-}
-```
-
-### Caveats
-
-Hooks give you a lot of flexibility and freedom, but you need to be aware of the following caveats:
-
-1. You need to use an **asynchronous** function. Even if your function is synchronous, it will be called as an asynchronous one—and as you know, there is a performance degradation when using asynchronous operations
-2. **Stay away** from using ```runHook``` inside a hook! Even though it's possible, your code will become unreadable and messy pretty soon.
-3. It's hard to trace errors in a hook. Because of its sequential nature, if a handler that's called earlier than yours throws an error, your hook won't be called at all.
-4. If you use so many plugins that use the hook system so extensively with so many files, your app's boot time can take much longer than it's supposed to.
-
-My advice is to **use it wisely**. Don't use hooks unless necessary; this will make your app or plugin clean and easy to understand.
-