awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
payloadcms avatar

payloadcms/payload

0
View on GitHub↗
43,053 Stars·3,806 Forks·TypeScript·MIT·19 Aufrufepayloadcms.com↗

Payload

Payload is a headless content management system and application framework that uses a code-first approach to define data schemas and administrative interfaces. By utilizing a centralized, type-safe configuration object, it automatically generates database schemas, API endpoints, and a fully customizable admin panel. The system is built on a database-agnostic architecture, allowing it to interface with various storage engines while providing a unified, type-safe API for server-side operations, REST, and GraphQL.

What distinguishes Payload is its deep extensibility and developer-centric design. It allows for the injection of custom React components, views, and widgets directly into the administrative interface, enabling tailored content-authoring workflows. The platform features a robust hook-based lifecycle system for executing custom logic, a comprehensive access control framework for granular field-level security, and a plugin-based architecture that supports complex features like ecommerce, multi-tenancy, and background job processing.

The system provides a broad capability surface, including built-in support for versioned document state management, internationalization, and automated database migrations. It also includes a rich text editor framework that supports custom blocks and markdown conversion, alongside tools for live content previews and media management with various cloud storage adapters.

Payload is designed for TypeScript-native development, automatically generating interfaces from the database schema to ensure type safety across the entire project. The system is configured through a single, fully-typed JavaScript object, and it supports deployment in production environments with features like database-less builds and security hardening.

Features

  • Headless Content Services - Exposes structured content via REST and GraphQL APIs for consumption by any frontend.
  • Application Configuration Frameworks - Provides a fully-typed configuration object for system-wide customization.
  • Ecommerce Management - Manages customers, products, carts, and orders through a unified plugin architecture.
  • Content Architecture and Modeling Tools - Defines the core data structures, access controls, and API endpoints for the application.
  • Static Site Generators - Defines data schemas and administrative interfaces through type-safe code.

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI
  • Data Schema Definitions - Defines core data structures and field types for the database schema.
  • Database Access Layers - Payload accesses the database interface directly via function arguments or by importing the initialized instance to perform server-side operations outside of standard REST or GraphQL endpoints.
  • Database Query Engines - Executes database queries consistently across Local, GraphQL, and REST APIs.
  • Document Management APIs - Performs CRUD operations on collections with support for localization and access control.
  • Job Queues - Organizes background tasks into named queues to manage execution priority and resource isolation.
  • Transpilers - Provides a type-safe backend engine for database interactions, hooks, and configuration.
  • Access Control Frameworks - Secures data by requiring authentication and allowing custom access control overrides.
  • Authentication Frameworks - Provides a flexible framework for implementing various authentication strategies including cookies, tokens, and API keys.
  • Authentication Login Handlers - Authenticates users via credentials and establishes secure HTTP-only session cookies.
  • Configuration-Driven Schemas - Transforms central configuration objects into database schemas, API endpoints, and administrative interfaces.
  • Content Management Platforms - Manages singleton content structures and their associated access controls.
  • Content Management Systems - Payload retrieves or updates global singleton documents by slug, supporting field population, localization, and access control overrides for server-side configuration management.
  • Database Abstraction Layers - Maps high-level data models to various database engines through interchangeable storage adapters.
  • Database Adapters - Decouples core application logic from specific database engines using a standardized storage interface.
  • Database Migration Management - Synchronizes application data structures with the database engine through managed migration files.
  • Document Filtering - Filters returned document fields to optimize database performance and reduce payload size.
  • Field Validation - Applies validation, access control, and hooks to manage data integrity across the application.
  • Postgres Adapters - Connects to Postgres databases with support for connection pooling and cloud-native configurations.
  • Type-Safe Data Abstractions - Provides a unified, type-safe interface for database operations across server-side, REST, and GraphQL.
  • Application Configuration Management - Manages core application preferences including authentication, components, and formatting in a central file.
  • Background Job Queues - Offloads expensive operations from the main request cycle by defining asynchronous background tasks.
  • Access Control Systems - Manages user sessions and security settings for any data collection.
  • Authentication Strategies - Executes login, logout, and password reset tasks through dedicated endpoints.
  • Cross-Origin Security Policies - Payload configures trusted origins and domains to prevent unauthorized cross-site requests and ensure that only permitted clients can interact with the API.
  • Production Security Policies - Implements production-grade security hardening including access control and rate limiting.
  • Data Schema Definitions - Stores nested data structures with custom validation and integrity rules.
  • Versioning Systems - Configures comprehensive versioning systems to track document history and state changes.
  • Editor Configurators - Configures the rich text editor by defining available features and field structures.
  • GraphQL APIs - Provides automated GraphQL access to data collections and globals.
  • REST API Services - Performs standard CRUD operations on collections via REST endpoints.
  • Serverless Functions - Payload executes backend operations securely from frontend components by defining server-side functions that interact directly with the database using the local API.
  • Inventory Management - Maintains stock levels and product information with support for variants and custom validation.
  • Payment Gateways - Configures secure payment processing through external provider adapters and webhook handlers.
  • Editorial Workflows - Payload interacts with draft versions using a dedicated parameter in API operations to control document validation, write locations, and retrieval of draft versus published content.
  • CMS Plugins - Allows developers to inject custom React components and widgets into the content management workflow.
  • Data Modeling - Organizes complex data structures by nesting fields under common properties for improved management.
  • Database Configurations - Configures production-grade database connections to ensure reliable data persistence and performance.
  • Document Versioning - Maintains historical changes and draft states through a dedicated versioning system.
  • File Upload Management - Enables file uploads for collections with integrated storage and image processing settings.
  • Migration Authoring - Defines database schema changes using TypeScript functions to ensure data integrity during updates.
  • Multi-Tenant Data Management - Isolates data by tenant across collections and provides administrative tools for tenant-aware data management.
  • Object-Relational Mappers - Provides type-safe database access and query execution through an integrated ORM.
  • Pagination - Paginates collection queries by specifying page numbers and document limits.
  • Query Operators - Filters documents using comparison, logical, and spatial operators to precisely match data.
  • Query Population - Controls the population depth of related documents in API queries to retrieve nested data.
  • Relationship Management - Links documents between collections with support for various reference types and validation.
  • Storage Adapters - Payload stores file uploads in Vercel Blob storage by configuring the plugin with your read/write token and specifying which collections should use the adapter.
  • Plugin Architectures - Payload defines a plugin using a factory function that automatically handles configuration, slug assignment, and execution ordering for consistent plugin development.
  • Task Schedulers - Payload automates periodic operations like report generation or system maintenance using cron expressions to trigger tasks without requiring manual user intervention.
  • Workflow Orchestrators - Payload creates multi-step workflows that track task outputs and resume from the point of failure, ensuring that completed steps are not re-executed during retries.
  • Access Control Policies - Restricts access to query presets using collection-level or document-level rules.
  • Field-Level Access Controls - Restricts field modification during document creation using custom boolean logic.
  • Field-Level Read Restrictions - Controls field visibility by evaluating user permissions during document read operations.
  • Field-Level Update Restrictions - Validates user authorization for modifying specific field values during document updates.
  • GraphQL Security - Protects GraphQL APIs by rejecting queries that exceed defined complexity thresholds.
  • Permission Management Systems - Retrieves user permissions to conditionally display features and UI elements.
  • Component Injection Systems - Allows developers to extend the administrative interface by registering custom React components.
  • Lifecycle Hooks - Executes custom validation and transformation logic at specific points in the document lifecycle.
  • Plugin Architectures - Enables modular system extension through cross-plugin communication and shared configuration management.
  • Custom UI Components - Supports building custom components that automatically integrate with system APIs and internationalization.
  • Form Builders - Defines complex form structures with support for various input types and custom configurations.
  • Live Preview Integrations - Implements custom live preview integration by subscribing to admin panel events and merging document state.
  • Rich Text Renderers - Renders rich text fields within custom components using schema-based paths.
  • Data Fetching Hooks - Performs reactive REST API requests with automatic handling of loading and error states.
  • GraphQL Extensions - Extends the GraphQL API with custom queries and mutations.
  • GraphQL Schema Configurations - Controls the generation and structure of the GraphQL API schema.
  • AI Agent Interfaces - Defines custom prompts, tools, and resources for interaction with AI clients.
  • Content Management Systems - TypeScript-based headless CMS and application framework.
  • Developer Tools and Frameworks - Fullstack framework for building headless CMS and applications.
  • Miscellaneous Tools - Headless CMS built with Node.js and TypeScript.
  • Ecommerce State Management - Manages ecommerce state like cart data and addresses via frontend context providers.
  • Shopping Carts - Handles cart operations including item updates and guest session support.
  • Rich Text Editors - Configures custom blocks by defining fields and React components.
  • Versioning & Change Tracking - Payload queries, retrieves, and restores historical document versions using REST, GraphQL, or local API methods to revert changes or audit past content states.
  • Internationalization & Localization - Defines supported languages and translation fallback preferences.
  • Database Configuration - Configures database adapters with connection settings, schema behavior, and transaction handling.
  • File Management Systems - Defines fields for storing and managing media file references.
  • Migration Lifecycle Tools - Provides a command-line interface to create, run, and roll back database schema migrations.
  • Query Performance Tuning - Optimizes query execution by configuring database indexes and limiting result sets.
  • Relational Mappings - Establishes relationships between collections with custom constraints and access control.
  • Extensibility Frameworks - Payload develops custom plugins by extending the configuration object, allowing for the addition of collections, globals, and custom initialization logic within a modular architecture.
  • Interface Localization - Supports over thirty languages with automatic detection and manual selection for the admin interface.
  • Plugin Systems - Extends core functionality by integrating modular plugins for features like SEO and payments.
  • Container Deployment - Deploys applications using containerization to ensure consistent environments and reliable scaling.
  • Job Execution Engines - Payload processes scheduled tasks using dedicated scripts, automatic configurations, or network endpoints to ensure operations run according to their defined time requirements.
  • Storage Management - Manages persistent and cloud-based file storage to ensure asset availability across restarts.
  • Image Processing - Generates multiple resized versions of uploaded images automatically.
  • API Client Connectors - Payload connects external MCP clients to your server by generating API keys and configuring client-specific settings to authenticate requests against the MCP endpoint.
  • API Key Authentication - Enforces access control policies using collection-specific API keys in request headers.
  • Brute Force Protections - Limits failed login attempts to prevent brute-force attacks against authentication endpoints.
  • CSRF Protection - Prevents cross-site request forgery by whitelisting trusted domains for authenticated requests.
  • Global Access Policies - Defines global data access constraints based on authenticated user identity.
  • Query Depth Restrictions - Restricts maximum query nesting depth to prevent resource-intensive recursive requests.
  • Token-based Authorization - Identifies users by extracting and validating JSON Web Tokens from the Authorization header.
  • User Profile Retrieval - Fetches the currently authenticated user's profile data and active session token.
  • Request Context Management - Passes custom data between hooks and middleware by attaching properties to the request context object.
  • Concurrency Management Systems - Prevents concurrent editing by locking records for active users.
  • Trash Managers - Provides an admin interface for managing trashed documents, including restoration and bulk deletion.
  • Admin Interface Customizations - Customizes the admin interface navigation and UI components.
  • Admin Interface Customizers - Customizes the admin panel interface by grouping navigation and defining list view columns.
  • Admin Panel Extensions - Extends the admin panel by inserting custom components into dashboards, menus, and headers.
  • Content Serializers - Renders stored JSON content into HTML or JSX by traversing the node tree.
  • Media Embedders - Embeds media files with custom fields and collection-specific access restrictions.
  • View Customizations - Enables complete replacement of default edit views for collections and globals with custom interfaces.
  • Visual Editing Tools - Links rendered interface elements directly to content fields for faster visual updates.
  • Custom API Endpoints - Defines custom REST API routes with handlers and middleware.
  • Form Field State Management - Connects custom components to the parent form's state management system for value updates.
  • Form Interaction Utilities - Triggers submissions and performs bulk operations on form state via the form instance.
  • GraphQL Schema Generation - Generates a GraphQL schema file from the application configuration.
  • Session Management - Synchronizes cart data and user information by managing authentication sessions.
  • Transaction Processing - Manages transaction states and lifecycle events throughout the checkout process.
  • Collaborative Editing Tools - Payload syncs front-end components with live document edits in the admin panel using framework-specific hooks for React or Vue to enable real-time content previewing.
  • Metadata Management - Configures automated SEO metadata generation for titles, descriptions, and images.
  • API Upload Interfaces - Supports programmatic file uploads via REST or local APIs using multipart form data.
  • Automated Migrations - Synchronizes database schemas with application configuration automatically during server startup.
  • Data Export Tools - Exports collection data to CSV or JSON formats via admin UI or API.
  • Data Import Utilities - Payload imports data from CSV or JSON files into collections using various modes like create, update, or upsert, with support for matching documents by custom fields.
  • Database Indexing - Optimizes query performance by allowing the creation of compound indexes on multiple fields.
  • Database Migrations - Automates schema updates and migration workflows for database development.
  • Field Selection - Defines default fields to return in API responses to minimize data transfer.
  • Query Configurations - Configures query presets with custom labels and filter constraints.
  • Query Interfaces - Queries related documents using filters and sorting across multiple API types.
  • API Route Customization - Allows customization of base paths for REST and GraphQL API endpoints.
  • Environment Variable Management - Manages environment variable access within the application configuration.
  • Transactional Emailing - Sends transactional emails by providing content to configured transport services.
  • Job Scheduling & Configuration - Schedules future tasks by assigning jobs to queues and attaching custom metadata logs.
  • Cross-Origin Resource Sharing - Restricts API access to trusted domains to ensure secure cross-origin communication.
  • Password Recovery Systems - Manages secure password reset workflows with configurable token expiration and custom email content.
  • Session Termination Services - Invalidates user sessions by clearing HTTP-only cookies with support for global logout.
  • Session Token Refreshers - Renews expiring authentication tokens and updates associated session cookies.
  • Upload Sanitization - Validates and sanitizes uploaded files to prevent the storage of malicious scripts.
  • Editor Migrators - Provides tools to migrate rich text content between different editor engines with preview and database update capabilities.
  • Hierarchical Data Structures - Configures hierarchical document relationships with automated parent and breadcrumb management.
  • Request Lifecycle Management - Controls request lifecycle blocking by managing promise resolution for synchronous or background operations.
  • Application Performance Monitoring - Monitors application errors and performance bottlenecks with stack traces and user breadcrumbs.
  • End-to-End and Integration Testing - Verifies plugin stability and behavior through automated test suites.
  • Accessibility Testing Tools - Integrates accessibility testing into development workflows for high content standards.
  • Dashboard Widget Frameworks - Defines custom dashboard widgets and their configuration fields.
  • Draft Management - Fetches and displays unpublished document versions based on status fields.
  • Hyperlink Managers - Creates links with custom metadata and supports internal collection-based linking.
  • Interface Overrides - Provides configurable navigation tabs and document layouts to tailor the administrative interface to specific workflows.
  • JSX Rendering Components - Renders rich text content as JSX by mapping nodes to React elements.
  • List View Extensions - Provides full control over the presentation of document lists by replacing default list views.
  • API Client SDKs - Provides a type-safe SDK for interacting with the REST API.
  • Editor Plugins - Extends rich text elements with plugins to control specific editing behaviors.
  • Editor Settings - Configures editor elements, formatting leaves, and custom metadata fields.
  • Form Field Subscriptions - Subscribes to specific field updates to ensure components only re-render when necessary.
  • Live Preview Systems - Payload refreshes server-side rendered routes automatically when document changes occur in the admin panel by integrating a specialized component into your front-end application.
  • Payment Adapters - Integrates third-party payment gateways by defining custom adapter methods.
  • Payment Synchronization - Synchronizes local collections with payment resources using automated field mapping and hooks.
  • Shipping Management - Integrates address validation and shipping configuration into the checkout process.
  • Content Migration Tools - Payload configures global and collection-specific settings for data import and export, including document limits, debug logging, and admin navigation visibility.
  • Document Processing and Conversion - Converts rich text editor state into plain text strings.
  • Cloud Storage Adapters - Integrates S3-compatible buckets for scalable file storage and retrieval.
  • Data Constraints - Enforces data uniqueness by applying unique indexes to specific fields.
  • Data Retrieval - Retrieves joined document data with built-in pagination and status tracking.
  • Data Seeding Utilities - Automates database population with custom collections and entries for development and testing.
  • Dynamic Filtering - Filters relationship options dynamically based on user context and request state.
  • Field-Level Depth Limits - Restricts population depth for specific fields to prevent excessive data nesting.
  • File Storage Adapters - Payload stores file uploads in Uploadthing by configuring the plugin with your access token and specifying the desired access control list for uploaded files.
  • Multi-Tenancy Filters - Provides automated data scoping and filtering based on tenant identifiers in database queries.
  • Pagination Metadata - Retrieves comprehensive metadata including total counts and navigation flags for pagination interfaces.
  • Population Depth Controls - Configures global default population depth to manage automatic resolution of related documents.
  • Query Optimizations - Optimizes list view performance by refining data retrieval queries.
  • Query Sorting - Sorts query results by document fields in ascending or descending order.
  • Search Configurations - Configures automated search indexing with support for localization and result prioritization.
  • Soft Deletion Systems - Enables soft deletion for collections by automatically tracking deletion timestamps.
  • Transaction Managers - Ensures atomic operations across multiple database calls via manual session control.
  • Admin Panel Routing Configurations - Allows customization of admin panel routes and file structure via configuration.
  • Email Delivery Services - Enables automated messaging by configuring email adapters and sender information.
  • Plugin Orchestration - Payload controls the execution sequence of plugins by assigning numeric order values, ensuring dependencies are met during the configuration resolution process.
  • CLI Job Runners - Runs background tasks using dedicated command-line scripts for resource isolation and independent scaling.
  • Cloud Storage Adapters - Stores file uploads in Azure Blob storage via a dedicated plugin.
  • Job Concurrency Controllers - Payload restricts concurrent execution of jobs sharing the same resource by defining a concurrency key to ensure that only one task with that key runs at once.
  • Webhook Handlers - Listens for and processes external webhook events to trigger custom application logic.
  • Type System Tools - Payload imports TypeScript definitions for plugin configuration, form structures, and submission types to ensure type safety when extending or interacting with the form builder.
  • Authentication Policy Enforcement - Restricts collection authentication to API keys by disabling default email and password strategies.
  • Cross-Domain Authentication - Configures cookie attributes to enable authentication when frontend and API reside on different domains.
  • Email Verification Services - Configures automated email verification workflows to reduce spam and ensure user identity.
  • Media Access Controls - Restricts access to uploaded files using collection-level access control functions.
  • Password Reset Initiators - Sends secure password reset tokens via email to initiate the account recovery flow.
  • Session Persistence Management - Enables automatic token refreshing to maintain persistent user sessions in the admin panel.
  • Boolean Fields - Captures boolean values in the database schema with custom validation and access control.
  • Date Fields - Configures date fields with support for validation, localization, and timezone selection.
  • Email Fields - Enforces valid email address formatting within data schemas.
  • Error Handling Strategies - Provides custom API error classes to abort operations and return specific feedback to clients.
  • Job Monitoring Tools - Inspects queued job status to identify completion results and error states.
  • Error Handling - Payload manages task failures by throwing errors within the handler, optionally preventing retries for specific error types and inspecting job logs to diagnose issues.
  • Admin Panel Visibility Controls - Manages admin panel UI visibility by executing access control functions during authentication.
  • Collection Metadata Overrides - Customizes titles and descriptions for specific collections or global views.
  • Component Replacements - Allows replacing individual interface elements like buttons and status indicators with custom components.
  • Content Block Editors - Enables insertion of complex, structured content blocks into documents via intuitive UI controls.
  • Content Previewing - Enables users to view unpublished document changes in a front-end environment before official publication.
  • Context Providers - Injects custom context providers to share state and data across administrative components.
  • Dashboard Widget Components - Renders custom dashboard widgets with database-backed data.
  • Rendering Overrides - Overrides default rendering of nodes and blocks with custom components for consistent display.
  • Theme Management Systems - Enables persistent light and dark mode themes for the admin interface.
  • View Metadata Overrides - Defines custom metadata directly within view configurations to override inherited settings.
  • Document Metadata Access - Retrieves metadata, permissions, and locking status for the document currently being edited.
  • GraphQL Schema Management - Controls GraphQL schema generation for global data structures.

    • Star-Verlauf

    Star-Verlauf für payloadcms/payloadStar-Verlauf für payloadcms/payload

    Open-Source-Alternativen zu Payload

    Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit Payload.
    • dokploy/dokployAvatar von Dokploy

      Dokploy/dokploy

      34,901Auf GitHub ansehen↗

      Dokploy is a self-hosted platform-as-a-service designed to simplify the deployment and management of containerized applications and databases. It provides a centralized control plane that decouples administrative management from application workloads, allowing users to oversee infrastructure across multiple server nodes through a unified web interface or a command-line tool. The platform distinguishes itself through an extensive library of pre-configured application templates, enabling the rapid deployment of databases, identity providers, and various productivity or development tools. It sup

      TypeScriptbackendbackupsdatabases
      Auf GitHub ansehen↗34,901
    • vapor/vaporAvatar von vapor

      vapor/vapor

      26,138Auf GitHub ansehen↗

      Vapor is a comprehensive server-side web framework designed for building scalable, high-performance applications and APIs in Swift. It provides a non-blocking, event-loop-based runtime that manages concurrent task processing, background job queues, and asynchronous request handling. The framework is built around a dependency injection container that manages the lifecycle and resolution of services, configurations, and database connections throughout the request pipeline. The framework distinguishes itself through a protocol-oriented design that emphasizes type safety across all layers of the

      Swiftframeworkhttphttp2
      Auf GitHub ansehen↗26,138
    • decaporg/decap-cmsAvatar von decaporg

      decaporg/decap-cms

      18,943Auf GitHub ansehen↗

      Decap CMS is a headless, Git-based content management system designed to provide a visual editing interface for static site workflows. By decoupling the administrative dashboard from the frontend, it allows users to manage content stored directly in version control repositories as structured data. The system maps visual form inputs to repository files, enabling non-technical contributors to update content without requiring direct code changes. The platform distinguishes itself through its Git-centric automation, which handles content lifecycles by creating commits, branches, and pull requests

      JavaScriptcmscontent-management-systemdecap-cms
      Auf GitHub ansehen↗18,943
    • fastapi/sqlmodelAvatar von fastapi

      fastapi/sqlmodel

      18,137Auf GitHub ansehen↗

      SQLModel is a type-safe object-relational mapping library for Python that integrates database schema definitions with data validation logic. By combining these two roles into a single class, it allows developers to manage relational data structures and enforce data integrity for web APIs simultaneously. The framework is built to support asynchronous database operations, enabling high-performance applications to execute queries and transactions without blocking the main execution thread. The library distinguishes itself by leveraging Python type hints to provide IDE autocompletion and compile-

      Pythonfastapijsonjson-schema
      Auf GitHub ansehen↗18,137
    Alle 30 Alternativen zu Payload anzeigen→

    Häufig gestellte Fragen

    Was macht payloadcms/payload?

    Payload is a headless content management system and application framework that uses a code-first approach to define data schemas and administrative interfaces. By utilizing a centralized, type-safe configuration object, it automatically generates database schemas, API endpoints, and a fully customizable admin panel. The system is built on a database-agnostic architecture, allowing it to interface with various storage engines while providing a unified, type-safe API for…

    Was sind die Hauptfunktionen von payloadcms/payload?

    Die Hauptfunktionen von payloadcms/payload sind: Headless Content Services, Application Configuration Frameworks, Ecommerce Management, Content Architecture and Modeling Tools, Static Site Generators, Data Schema Definitions, Database Access Layers, Database Query Engines.

    Welche Open-Source-Alternativen gibt es zu payloadcms/payload?

    Open-Source-Alternativen zu payloadcms/payload sind unter anderem: dokploy/dokploy — Dokploy is a self-hosted platform-as-a-service designed to simplify the deployment and management of containerized… vapor/vapor — Vapor is a comprehensive server-side web framework designed for building scalable, high-performance applications and… decaporg/decap-cms — Decap CMS is a headless, Git-based content management system designed to provide a visual editing interface for static… fastapi/sqlmodel — SQLModel is a type-safe object-relational mapping library for Python that integrates database schema definitions with… timgit/pg-boss — pg-boss is a background task scheduler and distributed task queue that uses PostgreSQL as a reliable message broker… tinacms/tinacms — TinaCMS is a headless content management framework that bridges local Git-based file storage with a visual, in-context…