Hey dev.to community! 👋 I'm excited to introduce you to FastSchema, a modern, Go-based web framework and headless CMS that combines flexibility, scalability, and ease of use. Whether you're building a simple website or managing dynamic content at scale, FastSchema has the tools to streamline your workflow.
Check out this quick video overview of FastSchema Headless CMS:
What is FastSchema?
FastSchema is a platform designed for developers and content managers alike. Built with Go for performance, it allows developers to extend functionality with Go code or JavaScript plugins, while offering non-developers a simple, no-code admin interface for managing content.
Here are some of the core features that make FastSchema stand out:
Dynamic Content Management: Manage content models and update your structure on the fly through the admin dashboard - no coding required.
Real-Time Updates: Any changes made to content are instantly propagated to all subscribed clients, ensuring real-time content delivery.
Flexible Plugin System: Developers can extend FastSchema's functionality using JavaScript plugins, allowing full customization.
Built-in File Management & OAuth2: Easily handle file uploads, storage, and serve files through the CMS, with OAuth2 support for authentication.
OpenAPI Support: Automatically generate OpenAPI documentation for your API endpoints, making it easier for your team to collaborate and integrate.
RBAC (Role-Based Access Control): Manage user permissions effectively with a flexible RBAC system that ensures the right users have the correct access levels.
Why Choose FastSchema?
FastSchema isn’t just another CMS. It’s built to be scalable, developer-friendly, and perfect for a wide range of projects. Here’s why you should consider it:
Performance: Powered by Go, FastSchema is built to handle heavy traffic with speed and efficiency.
Scalability: Whether you're working on a small site or scaling up for enterprise-level traffic, FastSchema adapts easily to your needs.
Portability: FastSchema runs smoothly in any environment, from on-premises setups to cloud or containerized infrastructures like Docker.
Developer-Friendly: Extend FastSchema with Go or JavaScript plugins without modifying the core codebase, letting you focus on building features.
Non-Developer Friendly: The clean, intuitive admin panel allows non-technical users to manage content, making it easy to collaborate with the whole team.
Getting Started with FastSchema
Here’s how you can install and start using FastSchema. Choose the method that works best for you:
Method 1: Using Docker
The easiest way to get started is via Docker. FastSchema provides a pre-built Docker image, so dependencies are handled for you.
- Step 1: Pull the Docker image...
docker pull ghcr.io/fastschema/fastschema:latest
- Step 2: Run the container...
mkdir data
docker run \
-u "$UID" \
-p 8000:8000 \
-v ./data:/fastschema/data \
ghcr.io/fastschema/fastschema:latest
You can now process the setting up by visiting http://localhost:8000?token={token}.
The setup token is displayed in the terminal.
Method 2: Download the Binary from GitHub Releases
If you prefer not to use Docker, you can download the pre-built binary from the FastSchema GitHub Releases page.
- Download the Binary:
- Navigate to the FastSchema GitHub Releases page.
- Select the latest release.
- Download the appropriate binary for your operating system (e.g., Linux, macOS, Windows). For example:
fastschema_0.5.0_linux_amd64.zip.
- Extract the Binary:
unzip fastschema_0.5.0_linux_amd64.zip
- Run the Binary:
- Open a terminal or command prompt.
- Navigate to the directory containing the downloaded binary.
- Run the following command:
./fastschema start
Method 3: Build from Source
For developers who want to customize FastSchema, building from source is a great option:
-
Clone the Repository:
git clone https://github.com/fastschema/fastschema.git cd fastschema git submodule update --init --recursive -
Build the Dashboard: (Optional)
cd pkg/dash yarn install && yarn build cd ../../ && mkdir -p private/tmp -
Build and run the Binary:
go build -o fastschema cmd/main.go ./fastschema startor run the development server:
make dev
Once installed, you can create a new content model directly from the admin dashboard. Simply define your content structure, save, and start managing data instantly!
Use FastSchema as a Web Framework
FastSchema is also a robust Go web framework, providing developers the tools to build dynamic applications. Here’s a simple example of how you can create a web app with FastSchema:
Installation
go get github.com/fastschema/fastschema
This is a basic example of how to use FastSchema to create a simple web application:
package main
import (
"github.com/fastschema/fastschema/fs"
"github.com/fastschema/fastschema"
)
func main() {
app, _ := fastschema.New(&fs.Config{
Port: "8000",
})
app.AddResource(fs.Get("/", func(c fs.Context, _ any) (string, error) {
_, err := db.Query[*schema.Entity](
ctx, app.DB(),
"SELECT * FROM users WHERE id = ?", 1,
)
return "Hello World", err
}))
app.Start()
}
Plugin system
FastSchema Plugin system that allows you to extend its core functionality with custom features and integrations.
Plugins are written in JavaScript and can be used to add new endpoints, hook into application events, query data, or perform any other custom logic.
Here’s an example of a simple plugin that adds a new endpoint and system schema:
const product = require('./schemas/product.json');
const { getRandomName, ping } = require('./utils');
const Config = config => {
// Add product schema
config.AddSchemas(product);
// Change the fastschema port to 9000
config.port = '9000';
}
const Init = plugin => {
// Create a group named 'hello' with two public resources (routes):
// - hello/ping
// - hello/world
plugin.resources
.Group('hello')
.Add(ping, { public: true })
.Add(world, { public: true });
}
const world = async ctx => {
const name = await getRandomName();
return `Hello, ${name}!`;
}
JavaScript SDK
FastSchema Javascript SDK (NPM) is a powerful tool that allows you to interact with the FastSchema API programmatically. It works in both Node.js and browser environments, making it easy to integrate FastSchema with your front-end applications.
Here’s a simple example of how you can use the SDK to fetch data from a FastSchema instance:
import { FastSchema } from "fastschema";
// Create a new instance of FastSchema
const fs = new FastSchema("https://localhost:8000");
// Login
await fs.auth().login({
login: "admin",
password: "123",
});
// Initialize: This must be called before any other operation
await fs.init();
// Create schema
await fs.schemas().create({
// ... schema definition
});
// Get content
fs.schema("tag").get<Tag>(params);
// Create content
const createdTag = await fs.schema("tag").create<Tag>({
name: "Tag 01",
description: "A description",
});
// and many more operations...
Adding Real-Time Updates
FastSchema allows you to subscribe to content changes in real time. Whether you’re running a news site, a real-time dashboard, or any other dynamic application, you can subscribe to updates as they happen.
The real-time updates api can be subscribed to using websockets or the JavaScript SDK.
Here’s a code example to illustrate how easy it is to subscribe to changes using the SDK:
const schemaTag = fs.schema("tag");
const cb1 = (data: T, event: EventType, error: Error) => {
console.log("Event:", event, "Data:", data, "Error:", error);
};
const cb2 = (data: T[], event: EventType, error: Error) => {
console.log("Event:", event, "Data:", data, "Error:", error);
};
const cb3 = (data: T | T[], event: EventType, error: Error) => {
console.log("Event:", event, "Data:", data, "Error:", error);
};
schemaTag.on("create", cb1);
schemaTag.on("update", cb2);
schemaTag.on("delete", cb2);
schemaTag.on("*", cb3);
And even more...
What’s Next?
FastSchema is still evolving, and we’re super excited to see how developers like you will use it to build powerful web apps and headless CMS solutions. Whether you’re working on a small project or a large-scale application, FastSchema has the tools to help you succeed.
Ready to Build?
🚀 Check out the official FastSchema website: fastschema.com
💻 Explore the source code and contribute: GitHub Repository
💬 Join the community and ask questions: Join FastSchema on Discord
We can’t wait to see what you create with FastSchema! Let’s build something amazing together! 🎉
Top comments (5)
I have used it for my own website development, it is really simple, convenient and very suitable for those who want to build a website quickly.
@tinkling19 Thank you for sharing your experience! We're glad to hear that FastSchema has been helpful for your website development. Simplicity and convenience are exactly what we're aiming for, especially for quick and efficient website building. If you have any feedback or suggestions, feel free to share, we're always looking to improve!
Awesome! Hope you will continue to develop even better versions in the future.
@conglam_2807 Thank you! We're committed to continuously improving FastSchema, and we have some exciting updates planned for the future. Stay tuned for even better features and enhancements!
Hello, is there an any documentation how to refresh JWT token for a user? @ngocphuongnb