@voltro/database 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -39,6 +39,26 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.3.0] — 2026-07-18
+
+### ⚠ BREAKING
+
+- **@voltro/cli** — `voltro build` precompiles the whole serve path (framework + effect + `@voltro` inlined, app modules as lazy chunks) into a single **serve bundle**, and `voltro serve` boots from it in-process — cutting `serve: ready` from ~1000 ms to ~180 ms (5–6×; the win is larger on a cold scale-to-zero container). The app's declared SQL driver is inlined (only the native leaf like `pg` stays external, resolved at runtime so it survives the deploy relocation). **Production now serves ONLY from the bundle and NEVER transpiles on demand:** the bundle build externalises unresolvable optional peers (e.g. `@react-email/render` behind `@voltro/plugin-mail`) so it always builds; a bundle-build failure is **fatal** (`voltro build` exits non-zero); and an unbuilt production `voltro serve` fails loud instead of falling back to tsx. The build toolchain (`tsx`, `esbuild`, `vite`, `@vitejs/plugin-react`, `@tailwindcss/vite` + their native tree: rolldown/lightningcss/postcss/jiti) moves to **`optionalDependencies`** of `@voltro/cli`, so `pnpm --prod --no-optional deploy` yields a serve image with none of it — a prod API image's `node_modules` drops ~305 MB → ~131 MB, structurally, with no fragile prune list. `voltro dev` and a non-production local `voltro serve` are unchanged (still tsx). **Migration:** in production (`NODE_ENV=production`) run `voltro build` before `voltro serve`. The generated Dockerfiles already do; a custom Dockerfile / start script adds a `voltro build .` step before `voltro serve .` (`voltro update` prints this — see the 0.3.0 codemod note).
+
+### Added
+
+- **@voltro/protocol, @voltro/runtime, @voltro/plugin-rbac** — Declarative authorization `guards:` on `defineMutation` / `defineQuery` / `defineAction`. The framework enforces the declared scope(s) in the dispatch spine BEFORE the executor (for a mutation, before the transaction opens), fails with a typed `ScopeError`, and auto-merges `ScopeError` into the wire error union so the client decodes the denial typed. Guards are browser-safe DATA (scope strings + a pure `resource: (input) => id` extractor). Checks run against the caller's EFFECTIVE scope set — raw subject scopes ∪ `@voltro/plugin-rbac` role-derived scopes — via a new canonical effective-scope seam in `@voltro/protocol` (`effectiveScopes` / `setEffectiveScopes` / `checkGuards`), which rbac now publishes to (so a role-granted scope satisfies a `guards:` entry and the in-handler `permission()` identically). Adds `ctx.access` (`has` / `hasAny` / `require` / `scopes`) — the cast-free typed authorization slice on every handler context. Enforcement is single-sourced in the shared serve pipeline, so `voltro dev` and `voltro serve` can't drift.
+- **@voltro/protocol, @voltro/client** — Nested / path-targeted auto-optimistic. A mutation `target` can now patch a nested array INSIDE a query's value — a JSON array column (`snapshot.projects`) or a computed/shaped result — at item granularity, via `path` (dot-path to the array), `by` (item key, default `id`), and `match` (a pure predicate that scopes the patch to the entries whose current value satisfies it, preventing a patch bleeding across sibling subscriptions that share a source table). Previously auto-optimistic only patched the flat top-level row array keyed by `id`; nested values needed a hand-written `.withOptimistic` reducer. `path`/`by`/`match` are browser-safe descriptor data (a dot-path string + pure predicate), same discipline as `identify`/`shape`. A path insert is applied even on a computed entry (it targets a known document, not a blind top-level add).
+- **@voltro/runtime** — `ctx.store.applyDefined(input, keys)` (and a standalone `applyDefined` export from `@voltro/runtime`) — builds a partial-update patch keeping only the listed keys whose value the caller actually provided (`!== undefined`; a defined falsy value like `0`/`''`/`false` is kept). Collapses the per-field `if (input.x !== undefined) patch.x = input.x` idiom every partial-update mutation hand-writes.
+- **@voltro/database** — `.uniqueActive([cols], opts?)` on the table builder — a portable partial-UNIQUE constraint that holds only among the rows matching a predicate (default `"deletedAt" IS NULL`, pairing with `.softDelete()`). Emits `CREATE UNIQUE INDEX … WHERE` on postgres / sqlite / mssql, so a soft-deleted row leaves the active set and a NEW row with the same key inserts cleanly — no hand-written `generatedAs("CASE WHEN …")` column and no resurrection footgun. On mysql / mariadb (no partial-index support) it FAILS LOUDLY at migrate time rather than silently emitting a full unique index that would forbid re-creating a soft-deleted key — the generated-STORED-column lowering for those dialects is a follow-up. Kept out of the declarative index snapshot (the incremental planner is predicate-blind and would misclassify a unique+partial index as a full constraint), so the fresh-schema DDL path is its sole emitter and there is no re-diff churn. Live-verified against postgres.
+- **@voltro/cli** — `voltro update` upgrades an app to the latest framework: it bumps every `@voltro/*` dependency, installs with the detected package manager, and runs the codemods shipped with the target version. Codemods are authored with `defineCodemod` + an import-scoped ts-morph helper toolkit (`renameImport`, `renameModuleSpecifier`, `renameJsxProp`, `renameObjectKey`, `add`/`removeImport`, structural `changeCallArgs`/`wrapCall`, `annotate`) and run against the app source; a `manual` kind surfaces written steps for changes that can't be automated. Breaking public-API changes now ship a codemod (or an explicit `codemod: none`), enforced by the changelog gate. Framework-owned `_voltro_*` table changes continue to ride the declarative differ on `voltro db apply` / `voltro dev` boot — `update` does not touch the database.
+
+### Fixed
+
+- **@voltro/database** — The core-table registry (`registerCoreTables` / `requireActors` / `requireTenants`) now stores its state on a process-global `Symbol.for` singleton, the same mechanism the main table registry already uses — instead of module-local `let` bindings. Module-local state splits when the `@voltro/database` module is duplicated in a process (e.g. resolved through both the `.` and `./sql` entry points, or a bundled framework copy alongside an externally-resolved one): one instance's `registerCoreTables` becomes invisible to the instance that reads it, surfacing as a spurious `core 'actors' table not registered` at store construction. Pinning it to `globalThis` makes every copy share one store, matching the table registry's already-global behaviour.
+
+---
+
 ## [0.2.2] — 2026-07-17
 
 ### Added

package/dist/{fileBased-cc9IzIjU.js → fileBased-CRXgPJkv.js}

@@ -530,6 +530,30 @@ var r = class e {
 				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
 			});
 		}),
+		uniqueActive: ((...t) => {
+			let n, r, i, a = Array.isArray(t[0]);
+			if (a ? (r = t[0], i = t[1], n = z(e.tableName, r)) : (n = t[0], r = t[1], i = t[2]), r.length === 0) throw Error(`uniqueActive '${n}' on table '${e.tableName}' has no fields — a partial UNIQUE must cover at least one column.`);
+			if (y(e.tableName, n, a, r), e.appliedIndexes.some((e) => e.name === n)) throw Error(`duplicate index '${n}' on table '${e.tableName}': each index name must be unique within a table (uniqueActive shares the index namespace).`);
+			let o = i?.where ?? "\"deletedAt\" IS NULL";
+			return V({
+				tableName: e.tableName,
+				fields: e.fields,
+				isReactive: e.isReactive,
+				appliedMixins: e.appliedMixins,
+				appliedIndexes: [...e.appliedIndexes, {
+					name: n,
+					fields: [...r],
+					where: o,
+					unique: !0
+				}],
+				appliedUniques: e.appliedUniques,
+				appliedFullText: e.appliedFullText,
+				appliedChecks: e.appliedChecks,
+				appliedPrimaryKey: e.appliedPrimaryKey,
+				...e.insertSchema === void 0 ? {} : { insertSchema: e.insertSchema },
+				...e.validatePatchSchema === void 0 ? {} : { validatePatchSchema: e.validatePatchSchema }
+			});
+		}),
 		check: ((t, n) => {
 			if (n.trim().length === 0) throw Error(`CHECK '${t}' on table '${e.tableName}' has an empty expression.`);
 			if (y(e.tableName, t, !1, []), e.appliedChecks.some((e) => e.name === t)) throw Error(`duplicate CHECK '${t}' on table '${e.tableName}': each constraint name must be unique within a table.`);

package/dist/index.d.ts

@@ -4532,6 +4532,37 @@ export declare interface Table<Name extends string, Fields extends Record<string
             dedup?: TableUnique['dedup'];
         }): Table<Name, Fields, Reactive, IxNames>;
     };
+    /**
+     * Declare a **partial UNIQUE** constraint that holds only among the rows
+     * matching a predicate — the portable answer to "unique among the rows that
+     * aren't soft-deleted". Emits a `CREATE UNIQUE INDEX … WHERE` on postgres /
+     * sqlite / mssql.
+     *
+     * ```ts
+     * table('project_roadmaps', { id, projectId, year, deletedAt, ... })
+     *   .softDelete()
+     *   .uniqueActive(['projectId', 'year'])            // one ACTIVE roadmap per (project, year)
+     * ```
+     *
+     * By default the predicate is `"deletedAt" IS NULL` (pairs with
+     * `.softDelete()`); override with `{ where }` for a custom active-set
+     * (`"status" = 'open'`). A soft-deleted row leaves the active set, so a NEW
+     * row with the same key is allowed — no hand-written
+     * `generatedAs("CASE WHEN …")` column, no resurrection footgun.
+     *
+     * **mysql / mariadb:** these engines have no partial-index support, so
+     * `.uniqueActive()` FAILS LOUDLY at migrate time (a full unique index would
+     * silently forbid re-creating a soft-deleted row). Use a generated STORED
+     * column + `.unique()` there until the framework lowers it for you.
+     */
+    uniqueActive: {
+        <const F extends readonly [keyof Fields & string, ...Array<keyof Fields & string>]>(fields: F, options?: {
+            where?: string;
+        }): Table<Name, Fields, Reactive, IxNames>;
+        <const IxName extends string, const F extends readonly [keyof Fields & string, ...Array<keyof Fields & string>]>(name: IxName, fields: F, options?: {
+            where?: string;
+        }): Table<Name, Fields, Reactive, IxNames | IxName>;
+    };
     /**
      * Declare a named table-level `CHECK` constraint — a DB-ENFORCED
      * invariant that holds regardless of which client writes the row
@@ -4700,6 +4731,20 @@ export declare interface TableIndex {
      * efConstruction, opclass}`). Ignored for kinds that don't read it.
      */
     readonly kindOptions?: IndexKindOptions;
+    /**
+     * UNIQUE partial index — set ONLY by `.uniqueActive(...)`. Emits
+     * `CREATE UNIQUE INDEX … WHERE <where>` on postgres / sqlite / mssql, so
+     * uniqueness holds only among rows matching `where` (e.g. the non-soft-
+     * deleted rows). Distinct from `.index(..., { where })` (non-unique) and
+     * from `.unique(...)` (a full constraint with no predicate). Because a
+     * unique+partial index has no `information_schema` constraint form and the
+     * declarative planner is predicate-blind, these are emitted by the
+     * fresh-schema DDL path (like every partial predicate) and kept OUT of the
+     * declarative index snapshot. mysql/mariadb have no partial-index support —
+     * `.uniqueActive()` fails loudly there (use a generated column) rather than
+     * silently dropping the predicate into a full unique index.
+     */
+    readonly unique?: boolean;
 }
 
 export declare interface TableLike {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as e, A as t, B as n, C as r, Ct as i, D as a, Dt as o, E as s, Et as c, F as l, G as u, H as d, I as f, J as p, K as m, L as h, M as g, N as _, O as ee, Ot as v, P as y, Q as b, R as x, S as te, St as S, T as C, Tt as ne, U as re, V as ie, W as ae, X as oe, Y as se, Z as ce, _ as le, _t as ue, a as de, at as fe, b as pe, bt as me, c as he, ct as ge, d as _e, dt as ve, et as ye, f as be, ft as xe, g as Se, gt as Ce, h as we, ht as Te, i as w, it as Ee, j as De, k as Oe, kt as ke, l as Ae, lt as je, m as Me, mt as Ne, n as Pe, nt as Fe, o as Ie, ot as Le, p as Re, pt as ze, q as Be, r as Ve, rt as He, s as Ue, st as We, t as Ge, tt as Ke, u as qe, ut as Je, v as Ye, vt as T, w as Xe, wt as Ze, x as Qe, xt as E, y as $e, yt as D, z as et } from "./fileBased-cc9IzIjU.js";
+import { $ as e, A as t, B as n, C as r, Ct as i, D as a, Dt as o, E as s, Et as c, F as l, G as u, H as d, I as f, J as p, K as m, L as h, M as g, N as _, O as ee, Ot as v, P as y, Q as b, R as x, S as te, St as S, T as C, Tt as ne, U as re, V as ie, W as ae, X as oe, Y as se, Z as ce, _ as le, _t as ue, a as de, at as fe, b as pe, bt as me, c as he, ct as ge, d as _e, dt as ve, et as ye, f as be, ft as xe, g as Se, gt as Ce, h as we, ht as Te, i as w, it as Ee, j as De, k as Oe, kt as ke, l as Ae, lt as je, m as Me, mt as Ne, n as Pe, nt as Fe, o as Ie, ot as Le, p as Re, pt as ze, q as Be, r as Ve, rt as He, s as Ue, st as We, t as Ge, tt as Ke, u as qe, ut as Je, v as Ye, vt as T, w as Xe, wt as Ze, x as Qe, xt as E, y as $e, yt as D, z as et } from "./fileBased-CRXgPJkv.js";
 import { Chunk as tt, Data as nt, Effect as rt, Option as O, Stream as it } from "effect";
 import { ansi as k } from "@voltro/logger";
 //#region src/arrayCodec.ts

package/dist/sql.d.ts

@@ -1754,6 +1754,37 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
             dedup?: TableUnique['dedup'];
         }): Table<Name, Fields, Reactive, IxNames>;
     };
+    /**
+     * Declare a **partial UNIQUE** constraint that holds only among the rows
+     * matching a predicate — the portable answer to "unique among the rows that
+     * aren't soft-deleted". Emits a `CREATE UNIQUE INDEX … WHERE` on postgres /
+     * sqlite / mssql.
+     *
+     * ```ts
+     * table('project_roadmaps', { id, projectId, year, deletedAt, ... })
+     *   .softDelete()
+     *   .uniqueActive(['projectId', 'year'])            // one ACTIVE roadmap per (project, year)
+     * ```
+     *
+     * By default the predicate is `"deletedAt" IS NULL` (pairs with
+     * `.softDelete()`); override with `{ where }` for a custom active-set
+     * (`"status" = 'open'`). A soft-deleted row leaves the active set, so a NEW
+     * row with the same key is allowed — no hand-written
+     * `generatedAs("CASE WHEN …")` column, no resurrection footgun.
+     *
+     * **mysql / mariadb:** these engines have no partial-index support, so
+     * `.uniqueActive()` FAILS LOUDLY at migrate time (a full unique index would
+     * silently forbid re-creating a soft-deleted row). Use a generated STORED
+     * column + `.unique()` there until the framework lowers it for you.
+     */
+    uniqueActive: {
+        <const F extends readonly [keyof Fields & string, ...Array<keyof Fields & string>]>(fields: F, options?: {
+            where?: string;
+        }): Table<Name, Fields, Reactive, IxNames>;
+        <const IxName extends string, const F extends readonly [keyof Fields & string, ...Array<keyof Fields & string>]>(name: IxName, fields: F, options?: {
+            where?: string;
+        }): Table<Name, Fields, Reactive, IxNames | IxName>;
+    };
     /**
      * Declare a named table-level `CHECK` constraint — a DB-ENFORCED
      * invariant that holds regardless of which client writes the row
@@ -1920,6 +1951,20 @@ declare interface TableIndex {
      * efConstruction, opclass}`). Ignored for kinds that don't read it.
      */
     readonly kindOptions?: IndexKindOptions;
+    /**
+     * UNIQUE partial index — set ONLY by `.uniqueActive(...)`. Emits
+     * `CREATE UNIQUE INDEX … WHERE <where>` on postgres / sqlite / mssql, so
+     * uniqueness holds only among rows matching `where` (e.g. the non-soft-
+     * deleted rows). Distinct from `.index(..., { where })` (non-unique) and
+     * from `.unique(...)` (a full constraint with no predicate). Because a
+     * unique+partial index has no `information_schema` constraint form and the
+     * declarative planner is predicate-blind, these are emitted by the
+     * fresh-schema DDL path (like every partial predicate) and kept OUT of the
+     * declarative index snapshot. mysql/mariadb have no partial-index support —
+     * `.uniqueActive()` fails loudly there (use a generated column) rather than
+     * silently dropping the predicate into a full unique index.
+     */
+    readonly unique?: boolean;
 }
 
 declare interface TableLike {

package/dist/sql.js

@@ -1,4 +1,4 @@
-import { L as e, R as t, V as n, a as r, c as i, et as a, i as o, n as s, ot as c, r as l, t as u } from "./fileBased-cc9IzIjU.js";
+import { L as e, R as t, V as n, a as r, c as i, et as a, i as o, n as s, ot as c, r as l, t as u } from "./fileBased-CRXgPJkv.js";
 import { Effect as d } from "effect";
 import { createLogger as f } from "@voltro/logger";
 import { SqlClient as p } from "@effect/sql";
@@ -347,11 +347,11 @@ var _ = (e, t, n, r = 400) => {
 			return `(${t.expr})`;
 		});
 		return n !== void 0 && i.length === 1 ? `${i[0]} ${n}` : i.join(", ");
-	}, d = (e, n, a, o, s, c = "") => {
-		let d = l(e, n, o, s);
-		if (d.skip) return "";
-		let f = u(a, d.opclass), p = `${d.withSuffix}${c}`, m = pe(n, r, i);
-		return r === "mssql" ? `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '${e}') CREATE INDEX ${t(e, r)} ON ${m}${d.using} (${f})${p};` : r === "mysql" ? `CREATE INDEX ${t(e, r)} ON ${m}${d.using} (${f})${p};` : `CREATE INDEX IF NOT EXISTS ${t(e, r)} ON ${m}${d.using} (${f})${p};`;
+	}, d = (e, n, a, o, s, c = "", d = !1) => {
+		let f = l(e, n, o, s);
+		if (f.skip) return "";
+		let p = u(a, f.opclass), m = `${f.withSuffix}${c}`, h = pe(n, r, i), g = d ? "UNIQUE " : "";
+		return r === "mssql" ? `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '${e}') CREATE ${g}INDEX ${t(e, r)} ON ${h}${f.using} (${p})${m};` : r === "mysql" ? `CREATE ${g}INDEX ${t(e, r)} ON ${h}${f.using} (${p})${m};` : `CREATE ${g}INDEX IF NOT EXISTS ${t(e, r)} ON ${h}${f.using} (${p})${m};`;
 	};
 	for (let n of e.appliedFullText ?? []) if (r === "postgres") {
 		let i = n.config ?? "english", o = `${n.name}_tsv`, s = n.columns.map((e) => {
@@ -369,9 +369,10 @@ var _ = (e, t, n, r = 400) => {
 			D(`[voltro:migrate] json-path index '${t.name}' on '${e.tableName}': ${r} cannot index a JSON expression directly — skipping. For an indexed JSON path on ${r}, add a generated column for the path (text().generatedAs(...) / .stored()) and .index([...]) it, then filter on that column instead of jsonField(...).`);
 			continue;
 		}
+		if (t.unique && t.where !== void 0 && t.where.length > 0 && (r === "mysql" || r === "mariadb")) throw Error(`@voltro/migrate: uniqueActive index '${t.name}' on '${e.tableName}' cannot be expressed on ${r} — it has no partial (WHERE) index support, and a full UNIQUE index would forbid re-creating a soft-deleted row. Use a generated STORED column (text().generatedAs("CASE WHEN \`deletedAt\` IS NULL THEN <key> ELSE NULL END", { stored: true })) + .unique([...]) on ${r}, or move this table to postgres/sqlite/mssql.`);
 		let n = "";
 		t.where !== void 0 && t.where.length > 0 && (r === "mysql" || r === "mariadb" ? D(`[voltro:migrate] partial index '${t.name}' on '${e.tableName}': ${r} does not support WHERE clauses on indexes — emitting a full index`) : n = ` WHERE ${t.where}`);
-		let i = d(t.name, e.tableName, t.fields, t.kind, t.kindOptions, n);
+		let i = d(t.name, e.tableName, t.fields, t.kind, t.kindOptions, n, t.unique === !0);
 		i !== "" && a.push(i), t.fields.every((e) => typeof e == "string") && s.add(c(t.fields));
 	}
 	for (let [t, n] of Object.entries(e.fields)) {
@@ -660,6 +661,7 @@ BEGIN
 	});
 	let o = e.appliedIndexes ?? [];
 	for (let t of o) {
+		if (t.unique && t.where) continue;
 		let n = t.fields.map((e) => typeof e == "string" ? e : "jsonPath" in e ? `(json:${e.jsonPath.column}->${e.jsonPath.path.join(".")}${e.jsonPath.numeric ? "::num" : ""})` : `(${e.expr})`), i = t.fields.some((e) => typeof e != "string");
 		r({
 			name: t.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/database",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Browser-safe schema DSL, query builder, and cross-dialect migration planner for Voltro — one schema, every SQL backend.",
   "keywords": [
     "voltro",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@effect/sql": "^0.51.1",
-    "@voltro/logger": "0.2.2",
+    "@voltro/logger": "0.3.0",
     "typeid-js": "^1.2.0",
     "ulidx": "^2.4.1"
   },