@voltro/cli 0.29.0 → 0.30.1

package/templates/apps/api-collab/README.md

@@ -0,0 +1,70 @@
+# {{projectName}} / {{appName}}
+
+Voltro collaborative-editing backend (template: **api-collab**).
+
+Real-time **convergent** editing on a `crdtText()` column — concurrent edits
+from many clients merge without a last-write-wins loser, authoritatively on the
+server, then broadcast over the reactive engine. Zero infra (`store: 'memory'`):
+the merge and the broadcast are both in-process, so two browser tabs pointed at
+one `voltro dev` collaborate with no database and no external service.
+
+## Boot
+
+```bash
+pnpm install                # at the repo root
+pnpm --filter @{{projectName}}/{{appName}} dev
+# → http://localhost:4000
+# → ws://localhost:4000/ws
+```
+
+## Pair it with a frontend
+
+`api-collab` exposes the `documents.list` subscription + `documents.create` /
+`documents.setBody` mutations that [`frontend-collab`](../frontend-collab)
+binds a collaborative editor to. Scaffold both together:
+
+```bash
+voltro create-project collab --api=api-collab --web=frontend-collab
+```
+
+## What's in here
+
+| File | Role |
+|---|---|
+| `app.config.ts`                              | App declaration (`store: 'memory'`). |
+| `database/schema.ts`                         | `documents` table — a `crdtText()` `body`, plus `tenant()` + `localFirst()`. |
+| `mutations/documents.create.mutation.ts`     | Create a document (title only; `body` starts empty). |
+| `mutations/documents.setBody.mutation.ts`    | The CRDT write — a client's encoded update; the runtime merges it. |
+| `queries/documents.query.ts`                 | `documents.list` streaming subscription. |
+| `tests/documents.setBody.test.ts`            | Convergence proof — two concurrent edits merge, order-independently. |
+
+## How the CRDT merge works
+
+`body: crdtText()` stores the encoded CRDT state as an opaque `bytes` blob. A
+client edits its LOCAL handle and sends the encoded update to
+`documents.setBody`. The handler writes it like any column — but because `body`
+is CRDT-managed, the runtime's MutationStore intercepts the write, reads the
+stored state, and folds the incoming update in with `mergeCrdtStates` (from
+`@voltro/local-first`) **before** persisting. That authoritative server merge is
+the convergence guarantee; the reactive engine then pushes the merged row to
+every subscriber.
+
+```
+ Client A ──update A──►┐
+                       ├─► documents.setBody ─► store.update('documents', id, { body })
+ Client B ──update B──►┘                          └─ runtime folds update into STORED
+                                                     state (mergeCrdtStates) → converges
+                                                        └─► reactive delta ─► all subscribers
+```
+
+`tests/documents.setBody.test.ts` proves it with no database: `ctx.store` from
+`@voltro/testing` is the same mixin-wrapped store as production, so the merge
+runs exactly as it does at runtime.
+
+## Multi-tenancy note
+
+The dev `AuthMiddleware` resolves the tenant from the `x-tenant` header,
+defaulting to `'acme'`. The `documents` table carries the `tenant()` mixin, so
+reads/writes are auto-scoped and `documents.create` guards that the submitted
+`tenantId` matches the caller's (a typed `TenantMismatch` otherwise). Wire real
+auth before production (see the authentication docs).

package/templates/apps/api-collab/app.config.ts

@@ -0,0 +1,28 @@
+// Collaborative-editing backend for the {{projectName}} project. Read by `voltro dev`.
+//
+// This is the LOCAL-FIRST / CRDT template — it exposes a `documents` table
+// whose `body` is a `crdtText()` column. When two clients edit the same body
+// concurrently, the runtime folds each incoming update into the stored state
+// with an authoritative SERVER-SIDE CRDT merge (on the write path, before the
+// row is written) so their edits CONVERGE — no last-write-wins loser — and the
+// reactive engine broadcasts the merged result to every subscriber.
+//
+// `store: 'memory'` keeps it ZERO-INFRA: the merge + the broadcast are both
+// in-process, so two browser tabs pointed at one `voltro dev` collaborate with
+// no database, no Redis, no external service. Switch to `'postgres'` (or run
+// `voltro add redis` for a cross-instance broadcast) when you go distributed.
+import { defineEnv, envVar } from '@voltro/env'
+
+// Typed environment — declared once, validated at boot (fail-fast) and read on
+// the server via `serverEnv` / `getSecret` from '@voltro/env/server'. Run
+// `voltro env` for the manifest.
+export const env = defineEnv({
+  LOG_LEVEL: envVar.enum(['debug', 'info', 'warn', 'error'], { access: 'public', default: 'info' }),
+})
+
+export default {
+  type:  'api' as const,
+  name:  '{{capProjectName}}{{capAppName}}',
+  store: 'memory' as const,
+  env,
+}

package/templates/apps/api-collab/database/schema.ts

@@ -0,0 +1,63 @@
+// Schema for the {{projectName}} collaborative-editing backend.
+//
+// Tables are auto-discovered: every exported `table(...)` here (or in any
+// `*.entity.ts` / `*.schema.ts` file) is registered by `voltro dev` — no manual
+// barrel. `actors` + `tenants` are the framework's core tables the
+// `audit()` / `tenant()` mixins reference, so they must be declared.
+
+import {
+  crdtText,
+  databaseHandle,
+  id,
+  localFirst,
+  table,
+  text,
+  timestamp,
+  type InferRow,
+} from '@voltro/database'
+import { tenant } from '@voltro/plugin-multitenancy'
+
+// ---------- Core tables (required by the audit / tenant mixins) ----------
+
+export const actors = table('actors', {
+  id:          id(),
+  kind:        text().oneOf(['user', 'serviceAccount', 'apiKey', 'system']),
+  displayName: text().nullable(),
+  createdAt:   timestamp().default('now'),
+})
+
+export const tenants = table('tenants', {
+  id:        id(),
+  name:      text(),
+  createdAt: timestamp().default('now'),
+})
+
+// ---------- The collaborative document ----------
+
+// `body` is a `crdtText()` column — a CRDT-managed field stored as the encoded
+// CRDT state (an opaque `bytes` blob; BYTEA / BLOB / VARBINARY per dialect).
+// There is no special DDL: to the declarative differ it is an ordinary nullable
+// `bytes` column, so it plans + round-trips like any other.
+//
+// The convergence guarantee is AUTHORITATIVE and SERVER-SIDE: when a client
+// writes an encoded update to `body`, the runtime folds it into the STORED
+// state with `mergeCrdtStates` on the write path (see
+// `mutations/documents.setBody.mutation.server.ts`) — so two concurrent edits
+// both survive, regardless of the order the server processes them.
+//
+// `localFirst()` marks the table local-first (client mirror + bi-directional
+// sync + CRDT convergence for its `crdtText()` fields). It adds no column — it
+// is a property the framework reflects on (`isLocalFirst` / `hasLocalFirst`).
+export const documents = table('documents', {
+  id:    id({ prefix: 'doc' }),
+  title: text(),
+  body:  crdtText(), // CRDT-managed — Uint8Array | null; decode with decodeCrdtText()
+})
+  // tenant() pulls audit() transitively → adds tenantId + createdAt /
+  // updatedAt / createdBy / updatedBy (auto-stamped by the runtime), and
+  // auto-scopes every read/write to the caller's tenant.
+  .with(tenant(), localFirst())
+
+export type Document = InferRow<typeof documents>
+
+export const database = databaseHandle({ actors, tenants, documents })

package/templates/apps/api-collab/mutations/documents.create.mutation.server.ts

@@ -0,0 +1,19 @@
+import { assertOwnTenant } from '@voltro/plugin-multitenancy/guard'
+import type { AppContext } from '@voltro/runtime'
+
+const execute = async (
+  input: { tenantId: string; title: string },
+  ctx: AppContext,
+) => {
+  assertOwnTenant(input.tenantId, ctx.request.subject)
+  // Framework auto-injects a `doc_…` id from the table's id() decl. `body` is
+  // omitted — a `crdtText()` column is nullable and the first setBody write
+  // establishes the document.
+  return ctx.store.insert('documents', {
+    title: input.title,
+    tenantId: input.tenantId,
+    createdAt: new Date(),
+  })
+}
+
+export default execute

package/templates/apps/api-collab/mutations/documents.create.mutation.ts

@@ -0,0 +1,36 @@
+// Creates a document (title only — the CRDT `body` starts empty and is
+// established by the first `documents.setBody` write). The handler's
+// `assertOwnTenant` guard rejects cross-tenant spoofing: input.tenantId MUST
+// match the resolved subject's tenantId, else a typed `TenantMismatch`.
+
+import { defineMutation } from '@voltro/protocol'
+import { TenantMismatch } from '@voltro/plugin-multitenancy/guard'
+import { Schema } from 'effect'
+
+export const createDocument = defineMutation({
+  name: 'documents.create',
+  target: {
+    table: 'documents',
+    op: 'insert',
+    shape: (input: { tenantId: string; title: string }) => ({
+      title: input.title,
+      body: null,
+      tenantId: input.tenantId,
+      createdAt: new Date(),
+    }),
+  },
+  input: Schema.Struct({
+    tenantId: Schema.String,
+    title: Schema.NonEmptyString,
+  }),
+  output: Schema.Struct({
+    id: Schema.String,
+    title: Schema.String,
+    // The CRDT `body` rides the wire as its encoded bytes (nullable until the
+    // first edit establishes it). Decode with `decodeCrdtText()` on the client.
+    body: Schema.NullOr(Schema.Uint8ArrayFromBase64),
+    tenantId: Schema.String,
+    createdAt: Schema.Date,
+  }),
+  error: TenantMismatch,
+})

package/templates/apps/api-collab/mutations/documents.setBody.mutation.server.ts

@@ -0,0 +1,20 @@
+import type { AppContext } from '@voltro/runtime'
+
+// Write the incoming CRDT update to the `body` column. The handler looks like a
+// plain overwrite — but `body` is a `crdtText()` column, so the runtime's
+// MutationStore intercepts the write: it reads the STORED state and folds the
+// incoming update in with `mergeCrdtStates` (from @voltro/local-first) BEFORE
+// persisting. That authoritative server merge is what makes concurrent edits
+// converge; the reactive engine then broadcasts the merged row to every
+// subscriber. This handler stays a one-liner precisely because the convergence
+// lives in the write path, not here.
+const execute = async (
+  input: { id: string; update: Uint8Array },
+  ctx: AppContext,
+) => {
+  const row = await ctx.store.update('documents', input.id, { body: input.update })
+  if (row === null) throw { status: 404, message: `document ${input.id} not found` }
+  return row
+}
+
+export default execute

package/templates/apps/api-collab/mutations/documents.setBody.mutation.ts

@@ -0,0 +1,30 @@
+// The CRDT write. A client produces an encoded update from its local
+// `crdtText()` handle (`handle.encode()`) and sends it here. The server does
+// NOT overwrite `body` with it — the runtime folds the incoming update into the
+// STORED state with `mergeCrdtStates` on the write path (see the `.server.ts`
+// comment), so two clients that edited the same base CONVERGE. `update` is the
+// opaque encoded CRDT state/delta (`bytes`); the same wire shape a Yjs update
+// blob carries.
+//
+// `op: 'update'` targets the existing row by its primary key. There is no
+// tenant field in the input: the `tenant()` mixin auto-scopes the update to the
+// caller's tenant, so a foreign `id` simply matches no row.
+
+import { defineMutation } from '@voltro/protocol'
+import { Schema } from 'effect'
+
+export const setDocumentBody = defineMutation({
+  name: 'documents.setBody',
+  target: { table: 'documents', op: 'update' },
+  input: Schema.Struct({
+    id: Schema.NonEmptyString,
+    update: Schema.Uint8ArrayFromBase64,
+  }),
+  output: Schema.Struct({
+    id: Schema.String,
+    title: Schema.String,
+    // The MERGED body — what every subscriber now converges to.
+    body: Schema.NullOr(Schema.Uint8ArrayFromBase64),
+    tenantId: Schema.String,
+  }),
+})

package/templates/apps/api-collab/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@{{projectName}}/{{appName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "voltro dev .",
+    "lint": "voltro doctor .",
+    "migrate": "voltro migrate",
+    "test": "voltro test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.97.0",
+    "@effect/rpc": "^0.76.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/local-first": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
+    "effect": "^3.22.0"
+  },
+  "devDependencies": {
+    "@voltro/testing": "0.30.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  }
+}

package/templates/apps/api-collab/queries/documents.query.server.ts

@@ -0,0 +1,16 @@
+import type { AppContext } from '@voltro/runtime'
+
+// Oldest-first so `documents[0]` is stable across clients — the collab page
+// binds its editor to that first document, and every tab agrees on which one.
+const execute = (_input: Record<string, never>, _ctx: AppContext) => ({
+  descriptor: {
+    table: 'documents' as const,
+    predicate: undefined,
+    order: [{ column: 'createdAt' as const, direction: 'asc' as const }],
+    take: 100,
+    skip: undefined,
+    projection: undefined,
+  },
+})
+
+export default execute

package/templates/apps/api-collab/queries/documents.query.ts

@@ -0,0 +1,23 @@
+// Streaming subscription: every change to `documents` for the caller's tenant
+// lands as a delta — including the MERGED `body` after any client's CRDT write.
+// The runtime AND-merges tenant scope into the predicate via the `tenant()`
+// mixin on the table, so no manual `eq('tenantId', ...)` is needed.
+//
+// `body` crosses the wire as base64 (`Schema.Uint8ArrayFromBase64` — JSON-safe,
+// unlike raw bytes) and the rpc client decodes it back to a `Uint8Array`; the
+// web client then folds it into its local CRDT handle to converge.
+
+import { defineQuery } from '@voltro/protocol'
+import { Schema } from 'effect'
+
+export const listDocuments = defineQuery({
+  name: 'documents.list',
+  input: Schema.Struct({}),
+  output: Schema.Struct({
+    id: Schema.String,
+    title: Schema.String,
+    body: Schema.NullOr(Schema.Uint8ArrayFromBase64),
+    tenantId: Schema.String,
+    createdAt: Schema.Date,
+  }),
+})

package/templates/apps/api-collab/template.json

@@ -0,0 +1,6 @@
+{
+  "id": "api-collab",
+  "kind": "api",
+  "summary": "Real-time collaborative editing — a `documents` table whose `body` is a `crdtText()` column. Concurrent edits from many clients CONVERGE via the runtime's authoritative server-side CRDT merge on the write path (no last-write-wins loser), then broadcast over the reactive engine. Zero infra (`store: 'memory'`). Pairs with frontend-collab: scaffold both with `create-project --api=api-collab --web=frontend-collab`.",
+  "tags": ["api", "backend", "local-first", "crdt", "collaborative", "realtime", "reactive", "subscription", "mutation", "frontend-collab"]
+}

package/templates/apps/api-collab/tests/documents.setBody.test.ts

@@ -0,0 +1,89 @@
+// The property that matters for a `crdtText()` column is CONVERGENCE: two
+// clients that edit the same document body concurrently must end at the same
+// text, no matter which write the server processes first, with BOTH edits
+// surviving (no last-write-wins loser).
+//
+// This runs the real thing with no database and no server: `ctx.store` from
+// `makeTestContext` is the SAME `wrapStoreWithMixinBehaviour` store the handler
+// gets in production, so the authoritative server-side CRDT merge on the write
+// path executes exactly as at runtime — the mutation just writes the incoming
+// update bytes, and `ctx.store.update` folds them into the stored state.
+// Importing `../database/schema` registers `documents` / `actors` / `tenants`
+// so the store knows `body` is a CRDT-managed column. Run with `voltro test`.
+
+import { describe, it, expect } from 'vitest'
+import { makeTestContext, mockStore } from '@voltro/testing'
+import { crdtText, decodeCrdtText } from '@voltro/local-first'
+import '../database/schema' // registers documents / actors / tenants
+import createDocument from '../mutations/documents.create.mutation.server'
+import setBody from '../mutations/documents.setBody.mutation.server'
+
+const bodyText = (row: { body?: unknown }): string =>
+  decodeCrdtText(row.body as Uint8Array)
+
+const freshCtx = () =>
+  makeTestContext({
+    subject: { type: 'user', id: 'u1', tenantId: 'acme' },
+    store: mockStore({ documents: [] }),
+  })
+
+describe('documents.setBody — authoritative server-side CRDT merge', () => {
+  it('folds two concurrent edits together so BOTH survive', async () => {
+    const ctx = freshCtx()
+    const doc = await createDocument({ tenantId: 'acme', title: 'Design doc' }, ctx)
+
+    await setBody({ id: String(doc['id']), update: crdtText().insert(0, 'Hello ').encode() }, ctx)
+    const merged = await setBody({ id: String(doc['id']), update: crdtText().insert(0, 'World').encode() }, ctx)
+
+    const text = bodyText(merged)
+    expect(text).toContain('Hello')
+    expect(text).toContain('World')
+  })
+
+  it('converges to the SAME text whichever order the server processes the writes', async () => {
+    // Capture the two updates ONCE and replay the SAME bytes in both orders —
+    // reusing the encoded state (not re-generating it) is what makes the CRDT
+    // tie-break deterministic, so this asserts order-independence, not chance.
+    const clientA = crdtText().insert(0, 'Hello ').encode()
+    const clientB = crdtText().insert(0, 'World').encode()
+
+    const forward = freshCtx()
+    const d1 = await createDocument({ tenantId: 'acme', title: 'Doc' }, forward)
+    await setBody({ id: String(d1['id']), update: clientA }, forward)
+    const fwd = await setBody({ id: String(d1['id']), update: clientB }, forward)
+
+    const reverse = freshCtx()
+    const d2 = await createDocument({ tenantId: 'acme', title: 'Doc' }, reverse)
+    await setBody({ id: String(d2['id']), update: clientB }, reverse)
+    const rev = await setBody({ id: String(d2['id']), update: clientA }, reverse)
+
+    expect(bodyText(fwd)).toBe(bodyText(rev)) // order-independent convergence
+  })
+
+  it('is idempotent — re-applying an update already folded in changes nothing', async () => {
+    const ctx = freshCtx()
+    const doc = await createDocument({ tenantId: 'acme', title: 'Doc' }, ctx)
+
+    const update = crdtText().insert(0, 'once').encode()
+    const first = await setBody({ id: String(doc['id']), update }, ctx)
+    const again = await setBody({ id: String(doc['id']), update }, ctx)
+
+    expect(bodyText(again)).toBe(bodyText(first))
+    expect(bodyText(again)).toBe('once')
+  })
+
+  it('a first write establishes the document (no stored state yet)', async () => {
+    const ctx = freshCtx()
+    const doc = await createDocument({ tenantId: 'acme', title: 'Doc' }, ctx)
+
+    const merged = await setBody({ id: String(doc['id']), update: crdtText().insert(0, 'seed').encode() }, ctx)
+    expect(bodyText(merged)).toBe('seed')
+  })
+
+  it('404s a write to a document the caller cannot see (tenant auto-scoped)', async () => {
+    const ctx = freshCtx()
+    await expect(
+      setBody({ id: 'doc_does_not_exist', update: crdtText().insert(0, 'x').encode() }, ctx),
+    ).rejects.toMatchObject({ status: 404 })
+  })
+})

package/templates/apps/api-collab/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/apps/api-data-advanced/package.json

@@ -12,17 +12,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/plugin-governance": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/plugin-governance": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-durable/package.json

@@ -12,17 +12,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
-    "@voltro/workflow": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
+    "@voltro/workflow": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-feature-flags/package.json

@@ -13,18 +13,18 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/plugin-flags": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
-    "@voltro/sql-postgres": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/plugin-flags": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
+    "@voltro/sql-postgres": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-governance/package.json

@@ -13,17 +13,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/plugin-audit": "0.29.0",
-    "@voltro/plugin-governance": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/plugin-audit": "0.30.1",
+    "@voltro/plugin-governance": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-kv/package.json

@@ -12,17 +12,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/kv": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/kv": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-moderation/package.json

@@ -13,17 +13,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/env": "0.29.0",
-    "@voltro/plugin-moderation": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/env": "0.30.1",
+    "@voltro/plugin-moderation": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/templates/apps/api-observability/package.json

@@ -13,17 +13,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.29.0",
-    "@voltro/database": "0.29.0",
-    "@voltro/plugin-multitenancy": "0.29.0",
-    "@voltro/plugin-prometheus": "0.29.0",
-    "@voltro/plugin-sentry": "0.29.0",
-    "@voltro/protocol": "0.29.0",
-    "@voltro/runtime": "0.29.0",
+    "@voltro/cli": "0.30.1",
+    "@voltro/database": "0.30.1",
+    "@voltro/plugin-multitenancy": "0.30.1",
+    "@voltro/plugin-prometheus": "0.30.1",
+    "@voltro/plugin-sentry": "0.30.1",
+    "@voltro/protocol": "0.30.1",
+    "@voltro/runtime": "0.30.1",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.29.0",
+    "@voltro/testing": "0.30.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }