@plutocms/pluto 0.0.1-alpha.4 → 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/.github/workflows/release.yml +82 -0
  2. package/CHANGELOG.md +462 -0
  3. package/README.md +114 -75
  4. package/bun.lock +206 -76
  5. package/package.json +1 -1
  6. package/skills-lock.json +45 -0
  7. package/layers/sql/.env.example +0 -5
  8. package/layers/sql/nuxt.config.ts +0 -26
package/README.md CHANGED
@@ -1,114 +1,153 @@
1
1
  <img width="335" height="105" alt="image" src="https://github.com/user-attachments/assets/1cf11470-ea54-416e-a940-7221fffef1e2" />
2
2
 
3
- # Pluto
3
+ # Pluto CMS
4
+
5
+ A layer-based CMS powered by [Nuxt](https://nuxt.com/).
4
6
 
5
7
  > [!WARNING]
6
- > 🚧 Work In Progress: Pluto is experimental. Breaking changes are expected. Not production ready yet.
8
+ > Pluto CMS is currently in **alpha** and at a very early stage. Expect breaking changes, incomplete features, and rough edges.
9
+ >
10
+ > Also note: **npm is still not supported** due to layer dependencies not being installed correctly. It is strongly recommended to use modern package managers like **pnpm** or **bun**.
11
+
12
+ Pluto CMS is designed to be modular, extensible, and developer-friendly. Instead of a monolithic system, it lets you compose your CMS using layers. You only install what you need.
13
+
14
+ ## Features
15
+
16
+ * Layer-based architecture using Nuxt Layers
17
+ * Modern SSR + SPA hydration with Nuxt
18
+ * TypeScript-first developer experience
19
+ * Opt-in features instead of global plugin mutations
20
+ * Deployment-friendly (Edge and Serverless ready)
21
+ * Works as a full CMS or as a headless backend
7
22
 
8
- Pluto is a modular, layer-driven Content Management System (CMS) built with Nuxt. A modern alternative to monolithic systems like WordPress. Extend functionality through Nuxt Layers: choose only what is needed (auth, storage, e-commerce, blog, database connectors, etc.).
23
+ ## Requirements
9
24
 
10
- ## Highlights
25
+ * Node.js (22+) or Bun
26
+ * pnpm or Bun
11
27
 
12
- - Nuxt + Nuxt Layers architecture
13
- - Headless-first: consume via API (_with typed routes!_) or built-in composables (like `useAuth` or `useProduct`)
14
- - Opt-in feature layers (Supabase, Blog, Shop, DB connectors, etc.)
15
- - Core primitives: Content Types, Taxonomies, Custom Fields, Media, Permissions
16
- - Deploy anywhere: Node, Edge, Serverless, Static (hybrid), Docker
17
- - Developer-focused: composables, typed schemas, minimal core
18
- - Dashboard is owned: fork as needed or just use it as is
28
+ > npm is not supported at this stage and may cause unexpected issues.
19
29
 
20
- ## Getting Started
30
+ ## Getting started
21
31
 
22
- First, install `typescript` as a dev dependency if you haven't already. This is required for Nuxt Layers to function properly.
32
+ Create a new Pluto project using the CLI:
23
33
 
24
34
  ```bash
25
- npm i -D typescript
35
+ npm create pluto@latest
36
+
37
+ # or
38
+ pnpm create pluto@latest
39
+
40
+ # or
41
+ bun create pluto@latest
26
42
  ```
27
43
 
28
- Then, extend your Nuxt configuration to include the Pluto layer, setting the install option to true, so Pluto's dependencies are installed automatically.
44
+ This will launch an interactive setup wizard where you can:
29
45
 
30
- ```ts
31
- // nuxt.config.ts
32
- export default defineNuxtConfig({
33
- extends: [
34
- ['github:plutocms/pluto', { install: true }],
46
+ * Choose a database provider
47
+ * Configure database credentials (all stored locally on your project's .env)
48
+ * Select a starter template (blog, store, etc.)
35
49
 
36
- // Then, add any additional layers you want to use here
37
- ['github:plutocms/supabase', { install: true }],
38
- ['github:plutocms/blog', { install: true }],
39
- ['github:plutocms/shop', { install: true }],
40
- ],
41
- })
50
+ Then:
51
+
52
+ ```bash
53
+ cd your-project
54
+ bun install # or pnpm install
55
+ bun run dev # or pnpm dev
42
56
  ```
43
57
 
44
- ## Core Concepts
58
+ ## Architecture overview
45
59
 
46
- - Content Types: Define structured entities (e.g. Post, Product, Page)
47
- - Fields: Primitive & custom (string, rich text, media, relation, JSON, computed)
48
- - Taxonomies: Hierarchical or flat classification
49
- - Media: Pluggable storage (e.g. Supabase, S3, local)
50
- - Auth & Identity: Provided by optional layers (e.g. Supabase)
51
- - Policies: Role / capability mapping (planned)
60
+ Pluto CMS is built around **layers**, each responsible for a specific concern.
52
61
 
53
- ## Layer Examples (Planned / In Progress)
62
+ ### Core layer (`@plutocms/pluto`)
54
63
 
55
- | Layer | Purpose |
56
- | ------------------------- | ----------------------------------------------- |
57
- | core | Base CMS engine + schema registry |
58
- | supabase | Auth, file storage, row-level security hooks |
59
- | blog | Post model, categories, tags, markdown pipeline |
60
- | shop | Product model, pricing, inventory abstraction |
61
- | mysql / postgres / sqlite | Database connectors |
62
- | analytics | Basic event/log capture |
63
- | search | Index + query adapters (e.g. Meilisearch) |
64
+ The core layer provides the foundation for your CMS:
64
65
 
65
- > [!NOTE]
66
- > Actual availability depends on roadmap progress.
66
+ - `<PlutoRoot>`: Wraps your entire app (used in `app.vue`). Includes `NuxtLayout`, `NuxtLoadingIndicator`, and base styles.
67
+ - `<ColorModeButton>`: Light/dark mode toggle with zero configuration.
68
+ - Built-in auth and admin layouts
69
+ - `<PlutoNavbarAdmin>` and `<PlutoNavbarAdminActions>`
70
+ Provide structure for injecting actions from other layers
67
71
 
68
- For now, some layers are being developed (`/layers` directory) in this same repository, but will eventually be extracted into their own packages.
72
+ ### Backend layers
69
73
 
70
- > [!NOTE]
71
- > Optional layers may require environment variables; see ./env.example when added.
74
+ Backend layers handle data, authentication, and APIs.
72
75
 
73
- ## Roadmap (Subject to Change)
76
+ Examples:
74
77
 
75
- Check [the roadmap here](https://github.com/ojvribeiro/pluto/issues/47).
78
+ - `@plutocms/supabase`
79
+ Provides Supabase integration (database, auth, users, etc.)
80
+ - Future possibilities:
81
+ - Custom database providers (MySQL, MongoDB, etc.)
82
+ - Other backend-as-a-service providers (Convex, Neon, Firebase, etc.)
76
83
 
77
- ## Contributing
84
+ ### Feature layers
78
85
 
79
- - Open issues for design discussion before large PRs
80
- - Keep layers isolated and opt-in
81
- - Prefer typed contracts and explicit interfaces
82
- - Add tests where possible (testing stack TBD)
86
+ Feature layers add domain-specific functionality on top of backend layers.
83
87
 
84
- ## Philosophy
88
+ Examples:
85
89
 
86
- - Minimal core, everything is a layer
87
- - Transparent, hackable dashboard (no locked UI bundle)
88
- - Declarative schemas
89
- - Runtime flexibility: choose infra, not dictated by core
90
+ - `@plutocms/supabase-shop`
91
+ Adds e-commerce features like:
92
+ - Products
93
+ - Media
94
+ - Cart
95
+ - Other possible layers:
96
+ - Blog
97
+ - Portfolio
98
+ - Analytics
99
+ - Payments
90
100
 
91
- ## Why Not Just WordPress?
101
+ > Feature layers depend on backend layers. For example, `@plutocms/supabase-shop` requires `@plutocms/supabase`.
92
102
 
93
- - Modern SSR + SPA hydration via Nuxt
94
- - TypeScript-first developer experience
95
- - Layer-based opt-in features instead of plugin global mutations
96
- - Deployment portability (Edge / Serverless friendly)
97
- - Headless usage is primary, not an afterthought
98
- - If you're a Vue developer, you'll feel right at home.
103
+ ## Using Pluto in existing Nuxt projects
99
104
 
100
- ## Security
105
+ Pluto is not limited to new projects.
101
106
 
102
- Do not deploy to production yet. No security audit performed. Auth / ACL model incomplete.
107
+ You can extend an existing Nuxt app using layers:
103
108
 
104
- ## License
109
+ ```ts
110
+ // nuxt.config.ts
111
+ export default defineNuxtConfig({
112
+ extends: [
113
+ '@plutocms/pluto'
114
+ // Then add any backend or feature layers you need.
115
+ ]
116
+ })
117
+ ```
118
+
119
+ ## Dashboard & headless usage
120
+
121
+ Although Pluto is built on Nuxt, it is not limited to Nuxt-only consumption.
105
122
 
106
- TBD (likely MIT). Not final.
123
+ - The admin dashboard can run as a standalone app on providers like Vercel or Netlify
124
+ - Data can be consumed via:
125
+ - Composables (within Nuxt apps)
126
+ - REST APIs exposed by layers
107
127
 
108
- ## Status
128
+ This allows you to:
109
129
 
110
- Experimental. Expect refactors.
130
+ - Use Pluto as a headless CMS
131
+ - Power web apps (any stack)
132
+ - Power mobile apps
133
+
134
+ ## Why not just WordPress?
135
+
136
+ - Modern SSR and SPA hydration via Nuxt
137
+ - TypeScript-first experience
138
+ - Better control through Vue composables or REST APIs
139
+ - Deployment flexibility (Vercel, Cloudflare, Netlify, etc.)
140
+
141
+ If you're a Vue developer, you'll feel right at home.
142
+
143
+ ## Roadmap ideas
144
+
145
+ - More official backend layers
146
+ - Rich ecosystem of feature layers
147
+ - Better developer tooling and DX improvements
148
+ - Community layers are very welcome! ❤️
149
+
150
+ ## License
111
151
 
112
- ## Naming Note
152
+ MIT (planned)
113
153
 
114
- "Pluto" is a working name; subject to rename if conflicts arise.