repository·main·Indexed 40 days ago
https://github.com/godaddy/gasketA robust, pluggable, and render-agnostic framework for rapid delivery of modern JavaScript web applications. Gasket uses a plugin-based architecture to provide commands, lifecycles, and structures for building complex apps, featuring a core lifecycle system (init, configure, prepare, ready) and a CLI for application creation via templates and presets.
Gasket v7 introduces several architectural shifts designed to increase transparency and flexibility:
lifecycles directory have been removed to reduce complexity and increase transparency.Gasket is a tooling ecosystem designed to help developers compose Node.js frameworks by assembling reusable elements into feature-rich applications. Instead of using static starter repos or monolithic generators, Gasket uses a modular approach based on Plugins and Presets.
build, start, and create.create lifecycle) that plugins can hook into to execute logic, install libraries, or generate code.create command, the resulting app is pre-configured with all the features defined by those plugins.Gasket is a framework maker designed to provide a platform of patterns, integrations, and functionality for building JavaScript web applications and APIs. It uses a plugin architecture where functionality is added via plugins.
Presets are predefined collections of plugins bundled together for specific project types. The Gasket API Preset is specifically designed for creating APIs. It includes plugins for:
@gasket/data package is now the primary way to access server-side data and configurations from the client side without requiring a Redux store. This is supported by the @gasket/nextjs package, which injects a GasketData script into the DOM to make server-side data available to the browser.Gasket executes a sequence of lifecycles during instantiation. There are two synchronous lifecycles followed by two asynchronous lifecycles. To ensure the application only proceeds once the instance is fully initialized, wait for the isReady promise to resolve.
init (Sync): Earliest entry point. Used for setting up initial state.configure (Sync): Allows registered plugins to adjust the configuration object before proceeding.prepare (Async): Used for setup requiring asynchronous operations (e.g., fetching remote config).ready (Async): The final lifecycle. Signals the instance is fully initialized.import gasket from './gasket.js';
gasket.isReady.then(() => {
// The instance is now fully initialized
gasket.actions.doSomething();
});import gasket from './gasket.js';
gasket.isReady.then(() => {
gasket.actions.doSomething();
});If your Next.js app uses nextServerType: 'customServer' or nextDevProxy: true, the plugin generates a tsconfig.server.json. This file provides a separate configuration for server-side TypeScript compilation to distinguish it from client-side bundling.
Key characteristics of tsconfig.server.json:
NodeNext (optimized for Node.js runtime) instead of bundler.dist/ (enables emission).Plugins can implement the metadata lifecycle hook to describe their own metadata and the metadata of their supporting modules. The object returned by this hook will replace the existing metadata for that plugin. This allows plugins to modify their own metadata at runtime.
// gasket-plugin-example.js
export default {
name: 'example',
hooks: {
/**
* @param {Gasket} gasket - The Gasket API
* @param {PluginData} data - This plugin's initial metadata
* @returns {Object}
*/
async metadata(gasket, data) {
return {
...data,
// adding extra data to this plugin's metadata
extra: 'information',
// add metadata for details of this plugin
lifecycles: [{
name: 'some-data',
description: 'Allows plugins to do something with data',
method: 'exec',
parent: 'start'
}],
// Metadata for these modules will be loaded
// Declare as strings or objects with additional data
modules: [
{
name: 'module-name',
version: '7.0.0',
description: 'module-name description',
link: 'README.md'
}
]
}
},
/**
* An example lifecycle hook which utilizes metadata
*
* @param {Gasket} gasket - The Gasket API
*/
async example(gasket) {
const { metadata } = gasket;
if (metadata.plugins.find(pluginData => pluginData.name === 'gasket-plugin-something')) {
// only perform some action if a certain plugin is also registered
}
}
}
}The serviceWorkerCacheKey lifecycle hook allows plugins to define how the service worker content is cached. By providing functions that return a string based on the req (request) and res (response) objects, you can prevent unnecessary recompositions for every unique request. If the generated key matches an existing cache entry, the cached content is returned directly.
// Shorthand example: Cache based on a 'market' cookie
export default {
name: 'sample-plugin',
hooks: {
serviceWorkerCacheKey: () => (req, res) => req.cookies.market || 'en-US'
}
}docusaurus.config.js file in your Docusaurus root directory if one does not already exist. You can use this file to apply any standard Docusaurus configuration/customization options directly.@gasket/plugin-typescript is a create-time only plugin. It is NOT installed in the final application. Instead, it is used by Gasket presets during the create-gasket-app process to configure TypeScript, generate necessary configuration files (like tsconfig.json), and set up scripts. Once the application is created, the plugin is discarded.In this monorepo, Changesets automatically updates peer dependency versions from ranges (e.g., ^7) to specific versions (e.g., ^7.3.5) during the release process. This is a built-in behavior designed to ensure version consistency across the monorepo and cannot be disabled via configuration.
Example Behavior:
If @gasket/plugin-logger is at version 7.3.5, a package with the following dependency:
"peerDependencies": {
"@gasket/plugin-logger": "^7"
}will be automatically updated to:
"peerDependencies": {
"@gasket/plugin-logger": "^7.3.5"
}Workarounds:
changeset version to revert the specific version changes.