@constructive-io/cli 0.0.3 → 5.1.1

package/README.md

@@ -1,310 +1,383 @@
-# **constructive — Platform for building Schemas, APIs, and Apps**
+# Constructive CLI
 
-**A unified cloud platform for data, APIs, and application development.**
+> Build secure, role-aware GraphQL backends powered by PostgreSQL with database-first development
 
-`constructive` brings together everything teams need to model data, ship APIs, and deploy modern applications. It provides a modular foundation for defining schemas, automating infrastructure, and delivering fast, secure experiences—without the complexity of traditional backend stacks.
+Constructive CLI is a comprehensive command-line tool that transforms your PostgreSQL database into a powerful GraphQL API. With automated schema generation, sophisticated migration management, and robust deployment capabilities, you can focus on building great applications instead of boilerplate code.
 
 ## ✨ Features
 
-* 🧱 **Modular Building Blocks** — Compose your app from reusable modules for data, logic, storage, and services. Swap, version, and extend components without rewriting your backend.
-* 🔄 **Automated Schema & API Generation** — Define your data and relationships once; get auto-generated APIs, migrations, types, and client code across languages.
-* ☁️ **Zero-Config Cloud Deployments** — Push code, get production. Deploy databases, APIs, functions, and frontends with instant environments and built-in rollout safety.
-* 🏗️ **Full-Stack Workspaces** — `constructive init` creates a complete workspace with data models, API routes, auth, edge functions, and CI/CD already wired together.
-* 📊 **Versioned Infrastructure** — Every schema, API, and service change is tracked and versioned, enabling reproducible deployments and safe rollbacks.
-* 🌐 **Portable by Design** — Built on open standards and SQL-first workflows, your app runs anywhere—from the constructive cloud to your own infra.
-* 🚀 **Optimized Developer Experience** — Type-safe SDKs, hot reloading for data and APIs, local-first dev, and zero boilerplate to get from idea → production fast.
+- 🚀 **Database-First Development** - Design your database, get your GraphQL API automatically
+- 🔐 **Built-in Security** - Role-based access control and security policies
+- 📦 **Module System** - Reusable database modules with dependency management
+- 🛠️ **Developer Experience** - Hot-reload development server with GraphiQL explorer
+- 🏗️ **Production Ready** - Deployment plans, versioning, and rollback support
 
 ## 🚀 Quick Start
 
-### Install & Setup
+### Installation
 
 ```bash
-# Install constructive globally
 npm install -g @constructive-io/cli
-
-# Start local Postgres (via Docker) and export env vars
-constructive docker start
-eval "$(constructive env)"
 ```
 
-> **Tip:** Already running Postgres? Skip the Docker step and just export your PG* vars.
-
----
-
-### Create a Workspace and Install a Package
+### Create Your First Project
 
 ```bash
-# 1. Create a workspace
-constructive init --workspace
-cd my-app
+# Initialize a new workspace
+cnc init workspace
+cd my-project
 
-# 2. Create your first module
-constructive init
-cd packages/your-module
+# Create your first module
+cnc init
 
-# 3. Install a package
-constructive install @pgpm/faker
+# Deploy to your database
+cnc deploy --createdb
 
-# 4. Deploy everything
-constructive deploy --createdb --database mydb1
-psql -d mydb1 -c "SELECT faker.city('MI');"
->  Ann Arbor
+# Start the development server
+cnc server
 ```
 
-## 🛠️ Commands
+Visit `http://localhost:5555` to explore your GraphQL API!
 
-### Getting Started
+## 📖 Core Concepts
 
-- `constructive init` - Initialize a new module
-- `constructive init --workspace` - Initialize a new workspace
+### Workspaces and Modules
 
-### Development Setup
+- **Workspace**: A collection of related database modules
+- **Module**: A self-contained database package with migrations, functions, and types
+- **Dependencies**: Modules can depend on other modules, creating reusable building blocks
 
-- `constructive docker start` - Start PostgreSQL container (via Docker)
-- `constructive docker stop` - Stop PostgreSQL container
-- `constructive env` - Print PostgreSQL environment variables for shell export
+### Database-First Workflow
 
-### Database Operations
+1. **Design** your database schema using SQL migrations
+2. **Deploy** changes with `cnc deploy`
+3. **Develop** against the auto-generated GraphQL API
+4. **Version** and **package** your modules for distribution
 
-- `constructive deploy` - Deploy database changes and migrations
-- `constructive verify` - Verify database state matches expected migrations
-- `constructive revert` - Safely revert database changes
-
-### Migration Management
-
-- `constructive migrate` - Comprehensive migration management
-- `constructive migrate init` - Initialize migration tracking
-- `constructive migrate status` - Check migration status
-- `constructive migrate list` - List all changes
-- `constructive migrate deps` - Show change dependencies
+## 🛠️ Commands
 
-### Module Management
+### Getting Started
 
-- `constructive install` - Install database modules as dependencies
-- `constructive extension` - Interactively manage module dependencies
-- `constructive tag` - Version your changes with tags
+#### `cnc init`
 
-### Packaging and Distribution
+Initialize a new Constructive workspace or module.
 
-- `constructive plan` - Generate deployment plans for your modules
-- `constructive package` - Package your module for distribution
+```bash
+# Create a new workspace
+cnc init workspace
 
-### Utilities
+# Create a new module (run inside workspace)
+cnc init
 
-- `constructive add` - Add a new database change
-- `constructive remove` - Remove a database change
-- `constructive export` - Export migrations from existing databases
-- `constructive clear` - Clear database state
-- `constructive kill` - Clean up database connections
-- `constructive analyze` - Analyze database structure
-- `constructive rename` - Rename database changes
-- `constructive admin-users` - Manage admin users
+# Use templates from GitHub repository (defaults to constructive-io/pgpm-boilerplates.git)
+cnc init workspace --repo owner/repo
+cnc init --repo owner/repo --from-branch develop
 
-## 💡 Common Workflows
+# Use templates from custom paths
+cnc init workspace --template-path ./custom-templates
+cnc init --template-path ./custom-templates/module
+```
 
-### Starting a New Project and Adding a Change
+**Options:**
 
-```bash
-# 1. Create workspace
-constructive init --workspace
-cd my-app
+- `--repo <repo>` - Template repo (default: `https://github.com/constructive-io/pgpm-boilerplates.git`)
+- `--template-path <path>` - Template sub-path (defaults to `workspace`/`module`) or local path override
+- `--from-branch <branch>` - Branch/tag when cloning the template repo
 
-# 2. Create your first module
-constructive init
-cd packages/new-module
+Templates are cached for one week under the `pgpm` tool namespace. Run `cnc cache clean` if you need to refresh the boilerplates.
 
-# 3. Add some SQL migrations to sql/ directory
-constructive add some_change
+### Development
 
-# 4. Deploy to database
-constructive deploy --createdb
-```
+#### `cnc server`
 
-### Working with Existing Projects
+Start the GraphQL development server with hot-reload.
 
 ```bash
-# 1. Navigate to your module
-cd packages/your-module
+# Start with defaults (port 5555)
+cnc server
 
-# 2. Install a package
-constructive install @pgpm/faker
-
-# 3. Deploy all installed modules
-constructive deploy --createdb --database mydb1
-psql -d mydb1 -c "SELECT faker.city('MI');"
->  Ann Arbor
+# Custom port and options
+cnc server --port 8080 --no-postgis
 ```
 
-### Testing a module in a workspace
+#### `cnc explorer`
 
-```bash
-# 1. Install workspace dependencies
-pnpm install
+Launch GraphiQL explorer for your API.
 
-# 2. Enter the packages/<yourmodule>
-cd packages/yourmodule
+```bash
+# Launch explorer
+cnc explorer
 
-# 3. Test the module in watch mode
-pnpm test:watch
+# With custom CORS origin
+cnc explorer --origin http://localhost:3000
 ```
 
+## 🔄 Updates
+
+The CLI performs a lightweight npm version check at most once per week (skipped in CI or when `PGPM_SKIP_UPDATE_CHECK` is set). Use `cnc update` to install the latest release (installs `pgpm` by default; pass `--package @constructive-io/cli` to target the CLI package).
+
 ### Database Operations
 
-#### `constructive deploy`
+#### `cnc deploy`
 
 Deploy your database changes and migrations.
 
 ```bash
 # Deploy to selected database
-constructive deploy
+cnc deploy
 
 # Create database if it doesn't exist
-constructive deploy --createdb
+cnc deploy --createdb
 
 # Deploy specific package to a tag
-constructive deploy --package mypackage --to @v1.0.0
+cnc deploy --package mypackage --to @v1.0.0
 
 # Fast deployment without transactions
-constructive deploy --fast --no-tx
+cnc deploy --fast --no-tx
 ```
 
-#### `constructive verify`
+#### `cnc verify`
 
 Verify your database state matches expected migrations.
 
 ```bash
 # Verify current state
-constructive verify
+cnc verify
 
 # Verify specific package
-constructive verify --package mypackage
+cnc verify --package mypackage
 ```
 
-#### `constructive revert`
+#### `cnc revert`
 
 Safely revert database changes.
 
 ```bash
 # Revert latest changes
-constructive revert
+cnc revert
 
 # Revert to specific tag
-constructive revert --to @v1.0.0
+cnc revert --to @v1.0.0
 ```
 
 ### Migration Management
 
-#### `constructive migrate`
+#### `cnc migrate`
 
 Comprehensive migration management.
 
 ```bash
 # Initialize migration tracking
-constructive migrate init
+cnc migrate init
 
 # Check migration status
-constructive migrate status
+cnc migrate status
 
 # List all changes
-constructive migrate list
+cnc migrate list
 
 # Show change dependencies
-constructive migrate deps
+cnc migrate deps
 ```
 
 ### Module Management
 
-#### `constructive install`
+#### `cnc install`
 
-Install database modules as dependencies.
+Install PGPM modules as dependencies.
 
 ```bash
 # Install single package
-constructive install @pgpm/base32
+cnc install @constructive-io/auth
 
 # Install multiple packages
-constructive install @pgpm/base32 @pgpm/faker
+cnc install @constructive-io/auth @constructive-io/utils
 ```
 
-#### `constructive extension`
+#### `cnc extension`
 
 Interactively manage module dependencies.
 
 ```bash
-constructive extension
+cnc extension
 ```
 
-#### `constructive tag`
+#### `cnc tag`
 
 Version your changes with tags.
 
 ```bash
 # Tag latest change
-constructive tag v1.0.0
+cnc tag v1.0.0
 
 # Tag with comment
-constructive tag v1.0.0 --comment "Initial release"
+cnc tag v1.0.0 --comment "Initial release"
 
 # Tag specific change
-constructive tag v1.1.0 --package mypackage --changeName my-change
+cnc tag v1.1.0 --package mypackage --changeName my-change
 ```
 
 ### Packaging and Distribution
 
-#### `constructive plan`
+#### `cnc plan`
 
 Generate deployment plans for your modules.
 
 ```bash
-constructive plan
+cnc plan
 ```
 
-#### `constructive package`
+#### `cnc package`
 
 Package your module for distribution.
 
 ```bash
 # Package with defaults
-constructive package
+cnc package
 
 # Package without deployment plan
-constructive package --no-plan
+cnc package --no-plan
 ```
 
 ### Utilities
 
-#### `constructive export`
+#### `cnc export`
 
 Export migrations from existing databases.
 
 ```bash
-constructive export
+cnc export
 ```
 
-#### `constructive kill`
+#### `cnc kill`
 
 Clean up database connections and optionally drop databases.
 
 ```bash
 # Kill connections and drop databases
-constructive kill
+cnc kill
 
 # Only kill connections
-constructive kill --no-drop
+cnc kill --no-drop
 ```
 
-## ⚙️ Configuration
+## 💡 Common Workflows
 
-### Environment Variables
+### Starting a New Project
+
+```bash
+# 1. Create workspace
+mkdir my-app && cd my-app
+cnc init workspace
+
+# 2. Create your first module
+cnc init
+
+# 3. Add some SQL migrations to sql/ directory
+# 4. Deploy to database
+cnc deploy --createdb
+
+# 5. Start developing
+cnc server
+```
 
-`constructive` uses standard PostgreSQL environment variables (`PGHOST`, `PGPORT`, `PGDATABASE`, `PGUSER`, `PGPASSWORD`).
+### Using Custom Templates
+
+You can use custom templates from GitHub repositories or local paths:
 
-**Quick setup** (recommended):
 ```bash
-eval "$(constructive env)"
+# Initialize workspace with templates from GitHub
+cnc init workspace --repo owner/repo
+
+# Initialize workspace with templates from local path
+cnc init workspace --template-path ./my-custom-templates
+
+# Initialize module with custom templates
+cnc init --template-path ./my-custom-templates
+
+# Use specific branch from GitHub repository
+cnc init workspace --repo owner/repo --from-branch develop
 ```
 
-**Manual setup** (if you prefer):
+**Template Structure:**
+Custom templates should follow the same structure as the default templates:
+
+- For workspace: `boilerplates/workspace/` directory
+- For module: `boilerplates/module/` directory
+- Or provide direct path to `workspace/` or `module/` directory
+
+### Working with Existing Projects
+
+```bash
+# 1. Clone and enter project
+git clone <repo> && cd <project>
+
+# 2. Install dependencies
+cnc install
+
+# 3. Deploy to local database
+cnc deploy --createdb
+
+# 4. Start development server
+cnc server
+```
+
+### Production Deployment
+
+```bash
+# 1. Create deployment plan
+cnc plan
+
+# 2. Package module
+cnc package
+
+# 3. Deploy to production
+cnc deploy --package myapp --to @production
+
+# 4. Verify deployment
+cnc verify --package myapp
+```
+
+### Get Graphql Schema
+
+Fetch and output your GraphQL schema in SDL.
+
+  - Option 1 – Programmatic builder (from database schemas):
+  - Write to file:
+    - `cnc get-graphql-schema --database constructive --schemas myapp,public --out ./schema.graphql`
+  - Print to stdout:
+    - `cnc get-graphql-schema --database constructive --schemas myapp,public`
+
+  - Option 2 – Fetch from running server (via endpoint introspection):
+  - Write to file:
+    - `cnc get-graphql-schema --endpoint http://localhost:3000/graphql --headerHost meta8.localhost --out ./schema.graphql`
+  - Print to stdout:
+    - `cnc get-graphql-schema --endpoint http://localhost:3000/graphql --headerHost meta8.localhost`
+
+Options:
+- `--database <name>` (Option 1)
+- `--schemas <list>` (Option 1; comma-separated)
+- `--endpoint <url>` (Option 2)
+- `--headerHost <hostname>` (Option 2; optional custom HTTP Host header for vhost-based local setups)
+- `--auth <token>` (Option 2; optional; sets Authorization header)
+- `--header <name: value>` (Option 2; optional; repeatable; adds request headers, last value wins on duplicates)
+- `--out <path>` (optional; if omitted, prints to stdout)
+
+Notes:
+- If your local dev server routes by hostname (e.g., `meta8.localhost`), but is reachable at `http://localhost:<port>`, use:
+  - `cnc get-graphql-schema --endpoint http://localhost:3000/graphql --headerHost meta8.localhost`
+- You can repeat `--header` to add multiple headers, e.g.: `--header 'X-Mode: fast' --header 'Authorization: Bearer abc123'`
+
+Tip:
+- For Option 1, include only the schemas you need (e.g., `myapp,public`) to avoid type naming conflicts when multiple schemas contain similarly named tables.
+
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Constructive respects standard PostgreSQL environment variables:
+
 ```bash
 export PGHOST=localhost
 export PGPORT=5432
@@ -313,22 +386,17 @@ export PGUSER=postgres
 export PGPASSWORD=password
 ```
 
-**Supabase local development:**
-```bash
-eval "$(constructive env --supabase)"
-```
-
-## Getting Help
+## 🆘 Getting Help
 
 ### Command Help
 
 ```bash
 # Global help
-constructive --help
+cnc --help
 
 # Command-specific help
-constructive deploy --help
-constructive tag -h
+cnc deploy --help
+cnc server -h
 ```
 
 ### Common Options
@@ -338,10 +406,135 @@ Most commands support these global options:
 - `--help, -h` - Show help information
 - `--version, -v` - Show version information
 - `--cwd <dir>` - Set working directory
+### Codegen
+
+Generate types, operations, and SDK from a schema or endpoint.
+
+```bash
+# From SDL file
+cnc codegen --schema ./schema.graphql --out ./codegen
+
+# From endpoint with Host override
+cnc codegen --endpoint http://localhost:3000/graphql --headerHost meta8.localhost --out ./codegen
+```
+
+Options:
+- `--schema <path>` or `--endpoint <url>`
+- `--out <dir>` output root (default: `graphql/codegen/dist`)
+- `--format <gql|ts>` documents format
+- `--convention <dashed|underscore|camelcase|camelUpper>` filenames
+- `--headerHost <host>` optional HTTP Host header for endpoint requests
+- `--auth <token>` Authorization header value (e.g., `Bearer 123`)
+- `--header "Name: Value"` repeatable headers
+- `--emitTypes <bool>` `--emitOperations <bool>` `--emitSdk <bool>` `--emitReactQuery <bool>`
+- `--config ./config.json` Use customized config file 
+
+
+Config file (JSON/YAML):
+
+```bash
+# Use a JSON config to override defaults
+cnc codegen --config ./my-options.json
+```
+
+Example `my-options.json`:
+
+```json
+{
+  "input": {
+    "schema": "./schema.graphql",
+    "headers": { "Host": "meta8.localhost" }
+  },
+  "output": {
+    "root": "graphql/codegen/dist/codegen-config",
+    "reactQueryFile": "react-query.ts"
+  },
+  "documents": {
+    "format": "gql",
+    "convention": "dashed",
+    "excludePatterns": [".*Module$", ".*By.+And.+$"]
+  },
+  "features": {
+    "emitTypes": true,
+    "emitOperations": true,
+    "emitSdk": true,
+    "emitReactQuery": true
+  },
+  "reactQuery": {
+    "fetcher": "graphql-request"
+  }
+}
+```
+
+---
+
+## Education and Tutorials
+
+ 1. 🚀 [Quickstart: Getting Up and Running](https://constructive.io/learn/quickstart)
+Get started with modular databases in minutes. Install prerequisites and deploy your first module.
+
+ 2. 📦 [Modular PostgreSQL Development with Database Packages](https://constructive.io/learn/modular-postgres)
+Learn to organize PostgreSQL projects with pgpm workspaces and reusable database modules.
+
+ 3. ✏️ [Authoring Database Changes](https://constructive.io/learn/authoring-database-changes)
+Master the workflow for adding, organizing, and managing database changes with pgpm.
+
+ 4. 🧪 [End-to-End PostgreSQL Testing with TypeScript](https://constructive.io/learn/e2e-postgres-testing)
+Master end-to-end PostgreSQL testing with ephemeral databases, RLS testing, and CI/CD automation.
+
+ 5. ⚡ [Supabase Testing](https://constructive.io/learn/supabase)
+Use TypeScript-first tools to test Supabase projects with realistic RLS, policies, and auth contexts.
+
+ 6. 💧 [Drizzle ORM Testing](https://constructive.io/learn/drizzle-testing)
+Run full-stack tests with Drizzle ORM, including database setup, teardown, and RLS enforcement.
+
+ 7. 🔧 [Troubleshooting](https://constructive.io/learn/troubleshooting)
+Common issues and solutions for pgpm, PostgreSQL, and testing.
+
+## Related Constructive Tooling
+
+### 🧪 Testing
+
+* [pgsql-test](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [supabase-test](https://github.com/constructive-io/constructive/tree/main/postgres/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
+* [graphile-test](https://github.com/constructive-io/constructive/tree/main/graphile/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [pg-query-context](https://github.com/constructive-io/constructive/tree/main/postgres/pg-query-context): **🔒 Session context injection** to add session-local context (e.g., `SET LOCAL`) into queries—ideal for setting `role`, `jwt.claims`, and other session settings.
+
+### 🧠 Parsing & AST
+
+* [pgsql-parser](https://www.npmjs.com/package/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [libpg-query-node](https://www.npmjs.com/package/libpg-query): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [pg-proto-parser](https://www.npmjs.com/package/pg-proto-parser): **📦 Protobuf parser** for parsing PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+* [@pgsql/enums](https://www.npmjs.com/package/@pgsql/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
+* [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
+* [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
+* [pg-ast](https://www.npmjs.com/package/pg-ast): **🔍 Low-level AST tools** and transformations for Postgres query structures.
+
+### 🚀 API & Dev Tools
+
+* [@constructive-io/graphql-server](https://github.com/constructive-io/constructive/tree/main/graphql/server): **⚡ Express-based API server** powered by PostGraphile to expose a secure, scalable GraphQL API over your Postgres database.
+* [@constructive-io/graphql-explorer](https://github.com/constructive-io/constructive/tree/main/graphql/explorer): **🔎 Visual API explorer** with GraphiQL for browsing across all databases and schemas—useful for debugging, documentation, and API prototyping.
+
+### 🔁 Streaming & Uploads
+
+* [etag-hash](https://github.com/constructive-io/constructive/tree/main/streaming/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
+* [etag-stream](https://github.com/constructive-io/constructive/tree/main/streaming/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
+* [uuid-hash](https://github.com/constructive-io/constructive/tree/main/streaming/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
+* [uuid-stream](https://github.com/constructive-io/constructive/tree/main/streaming/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
+* [@constructive-io/s3-streamer](https://github.com/constructive-io/constructive/tree/main/streaming/s3-streamer): **📤 Direct S3 streaming** for large files with support for metadata injection and content validation.
+* [@constructive-io/upload-names](https://github.com/constructive-io/constructive/tree/main/streaming/upload-names): **📂 Collision-resistant filenames** utility for structured and unique file names for uploads.
+
+### 🧰 CLI & Codegen
+
+* [pgpm](https://github.com/constructive-io/constructive/tree/main/pgpm/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+* [@constructive-io/cli](https://github.com/constructive-io/constructive/tree/main/packages/cli): **🖥️ Command-line toolkit** for managing Constructive projects—supports database scaffolding, migrations, seeding, code generation, and automation.
+* [@constructive-io/graphql-codegen](https://github.com/constructive-io/constructive/tree/main/graphql/codegen): **✨ GraphQL code generation** (types, operations, SDK) from schema/endpoint introspection.
+* [@constructive-io/query-builder](https://github.com/constructive-io/constructive/tree/main/packages/query-builder): **🏗️ SQL constructor** providing a robust TypeScript-based query builder for dynamic generation of `SELECT`, `INSERT`, `UPDATE`, `DELETE`, and stored procedure calls—supports advanced SQL features like `JOIN`, `GROUP BY`, and schema-qualified queries.
+* [@constructive-io/graphql-query](https://github.com/constructive-io/constructive/tree/main/graphql/query): **🧩 Fluent GraphQL builder** for PostGraphile schemas. ⚡ Schema-aware via introspection, 🧩 composable and ergonomic for building deeply nested queries.
 
 ## Credits
 
-🛠 Built by Constructive — if you like our tools, please checkout and contribute to [our github ⚛️](https://github.com/constructive-io)
+**🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**
 
 ## Disclaimer