Changelog
What changed in each release, newest first: a section for each, an alpha, a beta or a release candidate as much as a final release. An alpha (0.1.0-alpha.1) is for trying a version early: it may still change before that version is released. A beta (0.1.0-beta.1) is the version complete enough to use before it is released: it may still change where using it shows a need. Before 1.0, a minor release (0.2.0) may change the policy language, the authz.* functions, the SDKs and the file formats: what to do about it is under Upgrading. Each release from 0.1.0-beta.1 on upgrades from the one before it. How releases are numbered and made: RELEASING.md.
Unreleased
0.1.0-beta.5 (2026-11-18)
Added
authz.login_jwttakes a token an identity provider signs with its RSA key (RS256), checked in plain SQL against the provider's keys. The owner stores them withauthz.set_jwks(jwks), the key set as the provider serves it, and again when its keys change: a row for each key says whether it was added, replaced, kept, removed, or skipped and why; a set that leaves no key is refused and the stored keys stay (AZ719). What a token says of itself chooses its check: an HS256 token is checked againstjwt_secretalone, an RS256 one against the stored keys alone, the one itskidnames. Keys of 2048 to 4096 bits; a check takes about 2 ms at 2048 bits and 7 ms at 4096, once for a token on a connection: the same token signing in there again takes 0.3 ms, as an HS256 token does. ES256 and EdDSA tokens still go through the backend (Identity).rowstile jwks URLfetches the key set an identity provider serves atURLand stores it withauthz.set_jwks, for a scheduled job or a deploy step: run it again when the provider's keys change. It fetches over https, from that server alone, 64 KB and ten seconds at most.--checkstores nothing and exits 1 if the stored keys are no longer the provider's; without a URL it lists the stored keys (Tools).- A SCIM endpoint for an identity provider's users and groups (Okta, Microsoft Entra ID), answered in SQL:
authz.scim(method, path, query, body, token)takes a request as a route got it and answers a status, a body and a location. Groups are read, listed, found bydisplayName,externalIdorid, patched as Microsoft Entra ID and Okta write it (members added, removed, replaced), replaced, and made, renamed and deleted through a function the app gives. Members are written asauthz.sync_memberswrites them, with its line in the audit trail. Users are read and found byuserName,externalIdorid, and made, changed, deactivated and deleted through a function the app gives, which gets the user as the request leaves it and never a password. Lists answer by pages (startIndex,count), andServiceProviderConfig,ResourceTypesandSchemassay what is served.authz.set_scim(settings), the owner's, names what it reads: the principal whose API key signs the provider in, the relation that holds the groups, the columns of its table and of the users', the app's functions; each is checked when set (AZ720), andauthz.lint()says when one no longer holds. A request without that key is answered 401, and a refusal is SCIM's error body (AZ721). The Python SDK mounts it for FastAPI:Rowstile(app, engine, ...).mount_scim("/scim/v2")passes each request on and sends the answer back, with the address of what was made (Location). The token alone says who asks:user(request)isn't asked about these requests and their transaction signs nobody in. The body goes on as it was sent: the database says when it is no JSON, once the key says who asks, so nothing a stranger sends is an error. An error is answered 500 in SCIM's words and logged (the loggerrowstile). On another framework,rowstile.sqlalchemy.scim()andscim_sync()ask the database the same way. The TypeScript SDK has it for Next.js:export const { GET, POST, PUT, PATCH, DELETE } = scimRoutes({ calls: db.$authz })in a catch-all route (app/scim/v2/[...scim]/route.ts) answers the same way, an error logged withconsole.error; the address of what was made is on the host the provider asked (x-forwarded-host). On another framework,scim(method, path, query, body, token)of each driver's calls (db.$authz,authz(pool)) asks the database. The other SDKs have no route yet (Identity; the setup step by step, from apps the tests run: FastAPI, Next.js).
Changed
- A read through an inherited permission is faster for a reader who isn't an admin of what they read. Where the permission starts for the reader is asked in one query, and that query now works out who is signed in and which groups they are in once; each relation used to ask for itself, so the docs example worked out a member's teams six times for one read. On a GitHub runner (20,000 folders 20 levels deep, the two builds in turn on the one machine), an ordinary member opens a file in 2.2 ms where it took 2.8, and a folder in 2.4 ms where it took 3.0: a fifth less. An admin's reads,
authz.listand writes take what they took. Nothing to do: the nextapplyor migration writes the functions again. - A write to a tree (a folder made, moved, linked or deleted, where folders inherit from folders) is faster. The functions that keep the stored inheritance take arrays, and Postgres planned each of their statements again on every write; they now plan them once for a connection. On GitHub runners (50,000 folders 20 levels deep, the two builds in turn on one machine, two rounds, run twice), one client does 236 tree writes a second where it did 177 to 199, and ten clients 270 to 287 where they did 229 to 241; at fifty clients one run gave a fifth more (229 against 188) and the other the same (196 against 200). A write of more than a thousand rows still gets plans made for it, as a big move needs: one of 17,000 folders takes what it took (0.82 s against 0.79). Nothing to do: the next
applyor migration writes the functions again, and each inheritance is worked out again with them (see Upgrading). - Tree writes to one type no longer wait for each other unless they meet. A write that changes who inherits from whom (a folder made, moved, linked, shared into another or deleted) locked its whole type, so writes to unrelated parts of a tree queued one behind the other. It now locks what it touches: the rows it changes with everything below them, and the rows those hang under. Two writes that meet still wait in READ COMMITTED, and in REPEATABLE READ the later one fails with a serialization error only when what it touches changed since its snapshot (before: when any tree write to its type had). In SERIALIZABLE a tree write still takes its whole type: there Postgres keeps what each transaction read until every one beside it ends, and sixteen writers that didn't wait for each other ran the server out of room for it (
out of shared memory). The trees of one type (a folder's inheritance of edit and of view, say) take their locks once for a statement on the type's table. On GitHub runners (50,000 folders 20 levels deep, the two builds in turn on one machine), ten clients do 1.5 to 2.3 times the tree writes they did, and fifty 1.6 to 2.6 times, writers all in one part of the tree included; one client alone does as many, and a write, a move of 14,000 folders and an admin's check while writes run take what they took, within what two runs of one build differ by. A write of more than 1,000 rows takes its whole type, as before, and so does every tree write to a type that inherits through another type too or whose inheritance condition reads other rows. The number is a setting:INSERT INTO authz.settings VALUES ('tree_lock_limit', '5000'), or'0'for one tree write at a time to a type (Limits). @rowstile/nextwants Next.js 16.4.6 or a later 16 (it took 16.4.3): from 16.3.0 to 16.4.4, a'use cache'function called throughunstable_cache()could show one root param's data to another (CVE-2026-119790). The checks run 16.4.6.- The Python the npm packages bring is python-build-standalone 20261110's CPython 3.13.18, with zlib 1.4, expat 2.10.0 and musl 1.2.6 (it was 20261026's).
Fixed
- A write rule that inherits through a link table asks about the row being written, whatever the link table's columns are called (
update : editwithcan edit = owner or parent.editandparent : doc = app.doc_links(child -> parent)). The rule's check is a function written in SQL that named its parameterp_id, and in such a function Postgres takes a bare name for a column of a table in scope before it takes it for a parameter. So on a link table with a column namedp_idthe check compared every link row with itself: the rule could let a write through on a row the user holds nothing on, or refuse one the policy allows. Reads,authz.canandauthz.explainwere not affected, nor a link table without a column of that name. The functions written in SQL that read a table of the app's now write their parameters by position ($1), which no column can be: this check, the candidatesauthz.whostarts from, the functions that work out an inheritance's rows and the sync index's keys (where a column namedp_id,p_idsorp_typeswas read in the parameter's place too), and a rule'scurrent_user(a column namedauthz__roletook its place). (GHSA-vr76-9g97-h5p3) - A governed table may have a column called
n,o,x,f,neworold. Where rowstile hands a row on whole, it named the row by its alias alone (to_jsonb(n)), and Postgres takes a bare name for a column of a table in scope before it takes it for a row. On a table with a columnnorowhose type has a condition that names a column, everyUPDATEfailed (column reference "n" is ambiguous). With a columnneworold, a policy with a rule on a column did not apply. With a columnx,authz.explain_ruleon a table with a masked column explained a row of NULLs, or failed; with a columnforn, a mirror of the sync index was not filled with the table's rows. A row handed on whole is now writtenn.*, which is the row whatever the columns are called. (GHSA-mj6p-w78q-hxf6) - A governed table may have a column named as a generated function names something of its own (
p_id,p_ids,ids,n1,v_bigint,tg_op). In PL/pgSQL, Postgres refuses a bare name that is both a column of a table in scope and a parameter or a variable of the function (column reference "p_id" is ambiguous). So on a table that merely had a columnp_id,authz.shareandauthz.explainfailed; with a columnv_bigint,authz.canandauthz.who; withn1, any write the change feed follows; withp_ids, a write to a table an inheritance follows. Each was an error, never a wrong answer. Where a statement reads the app's tables, a generated function now writes a parameter by position ($1) and a variable by its block's label (authz__.v_bigint), which no column can be. Andauthz.whocalled each candidatexinside a query on the users table: on a users table with a columnxit failed, or listed nobody; it calls itc.idnow. - A condition may name a column called as PL/pgSQL or rowstile calls something of its own (
found,new,old,p_id): wherever a condition goes, the bare name is the row's column. Where the function that holds the condition is written in PL/pgSQL, Postgres refused such a name as ambiguous: a link table whose relation saidwhere {found}took no insert, and a type'swhere, a permission, a rule or ashared ifthat named such a column failed when the policy was applied or when it was asked. Every generated PL/pgSQL function that reads the app's columns now says that a column wins there (#variable_conflict use_column), its own names being written apart (above). Writingthis.foundwas the way round, and still works. - The sync index's mirrors (a preview) are compared with their tables row by row whatever the columns are called. On a mirrored table with columns called both
xandm, bringing its mirror up to date (when the policy is applied, or the index worked out again) compared two columns of one row in the rows' place: the mirror could keep rows as they were, with the readers they had, or be written again whole, andauthz.sync_verifycould say a mirror matches when it doesn't. The triggers that keep a mirror as rows change were not concerned. (GHSA-mj6p-w78q-hxf6) - A PowerSync mirror (the sync index, a preview) holds each row as its table has it once a statement is done, also when the row was written more than once before the mirror's trigger ran. One statement can write a row twice: a row that refers to itself through a foreign key with
ON UPDATE CASCADE, when its key changes. Such a statement failed withduplicate key value violates unique constraint "<type>__mirror_pkey". And a trigger of the app's can write the row again: the mirror then kept the row as it was before that write, or, where the trigger deleted the row, kept it with no readers, and a row made later with that key failed the same way. The readers of a row were right in each case. The mirror's trigger now reads the table again for the keys a statement's rows name.authz.sync_verify()says false for a mirror left so, androwstile reapply --forcewrites its rows again. authz.set_role_permissionslets the caller add a permission they hold on an object the role is given on, even where they may not select its row, asauthz.sharelets them give the role there. It askedauthz.can, which answers only for rows the caller may select, and refused: "you cannot give role reviewer on a folder you cannot see".- A policy with a rule on the row after a change (
update status after : ...) applies to a table with a generated column, and the rule reads that column. Applying stopped there on Postgres's own words (BEFORE trigger's WHEN condition cannot reference NEW generated columns): with aSTOREDcolumn, and on PostgreSQL 18 with anyGENERATED ALWAYS AS (...)column, which is virtual there unless it saysSTORED. On such a table the rule is checked once the row is written, after Postgres's own checks on the row; on every other table before the update, as it was (Limits). - A key of a
numeric, a float or abyteacolumn is refused when the policy is compiled (AZ206), as a date or an interval is: ids are kept as text, and these write one value several ways.authz.share(..., 'user', '2.0')found user 2, stored2.0and gave them nothing, and the share stayed when their row went, for a later row written2.0. - A key whose type isn't one of Postgres's own (an extension's, as
citext; a domain; an enum) is refused when applying (AZ629). It applied, and then every sign-in failed:type "citext" does not exist. authz.lint()reports an app role that may make triggers on a governed table, on a partition of one or on a table that holds relationships: theTRIGGERprivilege, whichGRANT ALLgives besideTRUNCATE, which lint already reported. A foreign key's action that writes the table's rows runs such a trigger's function as the tables' owner, whom no rule holds. The line says what to take back (REVOKE TRIGGER ON app.files FROM app_user).authz.who_amongasks first that who is signed in is to be believed, as every other function does. Called withauthz.user_idchanged by hand after a sign-in, or set with nobody signed in, it signed those settings at its end, and the transaction went on as that user. It answers AZ702 there now, and AZ701 where nobody signed in.- The threat model and the identity reference say what a signature holds. They said the app role can't leave view-as by setting the settings: a session can put back the settings an earlier sign-in of the same transaction signed, with that signature, and is believed. That is a state rowstile signed there, and gives the backend nothing
authz.sign_out()and a sign-in don't; a state no sign-in signed stays an error. authz.revoke_api_keyin a session limited by scopes (a key's, a token's) revokes only a key no wider than the session: one that has scopes, each of them the session's, asauthz.create_api_keyholds a new key to. A key whose scope holds a write command could revoke its user's other keys, one with every scope too. It answers AZ704 there now. (GHSA-xxg2-j2vj-v993)- A table that inherits (
CREATE TABLE ... INHERITS) with a generated column of its own gets its copy of a rule on the row after a change made after the update, by its own columns. Where the table above had no such column, the next migration, orrowstile apply, stopped there on Postgres's own words. authz.lint()says two more things, as infos: an app role that may make foreign keys to a governed table or to a partition of one (REFERENCES, whichGRANT ALLgives: a foreign key tells whether the row it names is there, whoever may see it), and a table whose rule on the row after a change is checked once the row is written (it has a generated column), where a unique index or a foreign key of the table speaks first.- A text key compared by a collation that isn't deterministic (a case-insensitive one) is refused when applying (AZ630): two texts are one key there, and two ids to rowstile, as
2and2.0were. authz.shareandauthz.unshareread a subject relation given as NULL as none, as''is. The share failed on Postgres's own words (a column that takes no NULL), and the unshare removed nothing.- A condition that limits inheritance, or that the sync index reads, is refused when it calls the clock or reads the session by a name written in quotes too (
pg_catalog."now"()), where the condition reads another table and Postgres isn't asked (AZ305, AZ804, AZ805). authz.view_asin a session limited by scopes that hold a write command (a key's or a token's:update,app.files.update) is read-only, as it says: the rules now refuse every write while a session views as someone, whatever its scopes hold. Since 0.1.0-beta.2 such a session kept its scopes while viewing, and the rules asked the scopes alone, so it could change rows as the user it viewed as. A session signed in withauthz.act_aswas not affected. A rule's explanation says so (no the session views as someone else: it may not update on app.files). (GHSA-47r9-v6p6-mc95)- A condition that calls the app's code without its text showing the call ran it with the app role's rights where a rule is checked: a function of the row written as a column of it (
{this.blocked}forblocked(docs), a computed column), a cast to a type of the app's,OPERATOR(app.=). Such a function read of a table with rules only what the signed-in user may see, sonot {this.blocked}let through rowsauthz.canrefused. Applying now asks Postgres what the rules and the views they read call, and refuses a function of the app's there that may read data (AZ628), and so does every migration. A call written by its name with parentheses runs with the policy's rights, as before. (GHSA-62w9-42x3-hqcm) - On PostgreSQL 16.16, 17.12 and 18.7 (released on 2026-11-12), an app's migration could no longer add a column
NOT NULLwith a default, add a stored generated column, or change a column's type, on a table with rules on writes or on a column:cannot alter table "files" because function authz_gen."app.files:insert:items"(app.files) uses its row type. Those releases refuse it where a function's body kept parsed (BEGIN ATOMIC) or a trigger'sWHENholds a value of the table's row type (CVE-2026-6460). The functions that check a rule on a row are now bodies Postgres keeps no parse of, run as the policy's owner, reading only that row, and the triggers hand them the row as JSON. A condition'scurrent_userthere is still the role that writes. - The Go SDK asks for
golang.org/x/textv0.41.0 or newer, which fixes an infinite loop and a panic on crafted input (GO-2026-5970, GO-2026-6629). The Elixir SDK is checked against Ecto 3.14.3, which bounds a query cache that could grow without end (EEF-CVE-2026-118391).
Upgrading
- Apply the policy with this release (
rowstile apply, or the migrationsrowstile migratewrites) for tree writes to lock what they touch: each inheritance is worked out again, androwstile migratewrites two migrations, one that builds the new tables beside the ones in use and one that swaps them in. A write that runs while the policy is applied ends with AZ723 (40001), to retry. An app that writes a tree in transactions of several statements, or with one statement that writes several trees (a cascade to rows that are links,MERGE,INSERT ... ON CONFLICT DO UPDATE), may now see a deadlock (40P01) where two such transactions meet: retry it, as40001(Retrying a write). - A table the policy names can't have a name that starts with
authz__(AZ113): the functions rowstile writes call their own variablesauthz__.name. Name a view of the table instead. - Apply the policy with this release (
rowstile apply, or the migrationsrowstile migratewrites) for the fix to the write rules that inherit through a link table. The functions that work out an inheritance's rows changed with it, so each inheritance is worked out again:rowstile migratewrites two migrations, one that builds the new tables beside the ones in use and one that swaps them in. Until then, a link table a policy names should have no column calledp_id. - A policy with a type keyed by a
numeric, a float or abyteacolumn no longer compiles (AZ206): key the type by a column of integers, text or uuid. authz.who_amongin a transaction where nobody signed in now answers AZ701, as any other question does: sign in first, as nobody where no one is asking (authz.act_as(NULL, NULL); the SDKs' transactions do).authz.lint()has a new error where the app role holdsTRIGGERon a table the policy governs (an app set up withGRANT ALL):rowstile lintthen exits 1 until it is taken back.- A session limited by scopes no longer revokes a key with other scopes, or with none (AZ704): revoke keys from a session without scopes, as the app's own sign-in is.
- A policy with a type keyed by a text column under a collation that isn't deterministic no longer applies (AZ630): key the type by a column under a deterministic collation.
- A policy whose condition reads a function of the row as a column, where the function isn't IMMUTABLE, no longer applies (AZ628): call it by its name on the row's columns,
{app.blocked_doc(this.id)}, or mark it IMMUTABLE if it reads nothing. - On Postgres 16.16, 17.12 or 18.7, or before upgrading to them, apply the policy with this release (
rowstile apply, or the migrationrowstile migratewrites): what an earlier release applied stops the migrations above there.
0.1.0-beta.4 (2026-11-09)
Added
- The Go module has versions: each release tags its commit
sdk/go/vX.Y.Z, sogo get github.com/rowstile/rowstile/sdk/gotakes the newest release's, and@vX.Y.Znames one (Go). rowstile client ts-sdk: the policy's names alone, registered with the TypeScript SDK, asked for by name. It is what[clients] tswrites in an app on the SDK;rowstile client tsis the client forpgwithout it.authz.sign_out(): nobody is signed in in the transaction afterwards, and it may sign in again, as anyone. It is for a test's transaction that acts for one person, then another, and is rolled back at the end; the SDKs' test modes call it (Identity).- The Go, Rust and PHP SDKs write a principal as text and read it back, as the other SDKs do and as the audit trail names who acted (
42,service:3,nobody):Stringandrowstile.ParsePrincipalin Go,DisplayandFromStrin Rust,__toStringandPrincipal::parsein PHP. In Laravel's logs a principal readsservice:3. - The Spring starter's
Problems.problem(e)andProblems.response(problem): rowstile's answer to an error, for a catch-all@ExceptionHandler(Exception.class)of the app's own, which comes before the starter's advice and would take its errors too (Spring). - The Rust SDK's
rowstile::axum::SignedIn: an extractor for who a request acts for, with no connection yet, for a handler that reads a body;who.begin()begins its transaction once the body is read. ATxholds a connection, its transaction open, from the moment Axum extracts it, and Axum reads the body last. - The helpdesk, a third example app (examples/helpdesk): several companies' support desks on one database, each company's workspace kept apart by the policy, with teams inside teams, custom roles, internal notes, the vendor's staff by break glass, and live updates through Electric. Next.js, Prisma and the TypeScript SDK.
Changed
- The database holds a transaction to one principal:
authz.act_as,authz.login_keyandauthz.login_jwtrefuse to sign in a transaction signed in as someone else already (nobody included), or one that views as someone or is limited by scopes, which a new sign-in would end (AZ716). A first sign-in afteract_as(NULL, NULL)is still fine, and so is the same principal again.view_as, andwho,explain,who_amongand the invariants, which ask as others and put back the caller, aren't held to it, nor are the sessions of the policy's owner and superusers. - The Rust SDK's
rowstile::testing::per_binaryrefuses an app role's URL that isn't a Postgres URL, instead of giving it back as it was. - The Rust SDK's
per_binarygives each slot of cargo-nextest (NEXTEST_TEST_GLOBAL_SLOT) a copy of its own, as each binary has undercargo test. - Seeing who has access to an object (
authz.who,authz.list_shares,authz.list_links,authz.explainfor someone else,authz.start_review) takesshareon a row the user may select, andauthz.who_amonglists those for whomauthz.cansays yes (below). What acts on an object still asks the permission itself: sharing, roles, API keys,authz.view_asandauthz.break_glass, which works on a row the user can't see. So doauthz.who's answers, the first line ofauthz.explain,rowstile whyand a test'suser X can PERM TYPE ID. The access previews (rowstile diff, the review's access,rowstile dev,rowstile snapshot) still list every permission gained or lost, on rows the user can't select too. rowstile reviewandrowstile provework out what their small worlds read of a policy once, not in each world, and prove makes each world once for all the invariants: on the docs app's policy, reviewing a refactor takes a third less time, and proving four invariants a quarter of the time it did.rowstile initwith--dband anotherDATABASE_URLwritesdatabase = "env:ROWSTILE_OWNER_DSN"inrowstile.toml, the name the stack pages give the tables' owner's connection, instead ofROWSTILE_DATABASE_URL. Its next steps name the variablerowstile.tomlreads, not alwaysDATABASE_URL.authz.review_deciderefuses a decision after the review's deadline, thecloses_atofauthz.start_review(two weeks after it starts unless the call says otherwise; NULL: none), and says when it was (AZ718).authz.close_reviewstill applies the decisions made in time. Before, the deadline was kept and never read.- A page with a cursor and no size is every row after the cursor in every SDK: Go's
Page{After: x}(aLimitof 0) no longer asks for an empty page, and the Rust SDK'sPage.limitis anOption<i32>(None: no size). The Rust SDK'scomposite_keyof one field is that field's value, as a key of one column is. - The Go SDK's
Middlewareanswers 401 forrowstile.Unauthorized(detail)(new), the error the app'suserfunction gives for a bad token, and answers any other error from it asHandlerdoes: rowstile's own as its page says, anything else logged and a 500, without its words. Before, every error was a 401 that showed the error's text, so a session store that was down signed everyone out. - The Python SDK's
rowstile.fastapiloads SQLAlchemy only for an engine: an app on psycopg or asyncpg alone,Rowstile(app, None, user=...), runs without SQLAlchemy installed. - The Python SDK's
assert_refused(fn, command=...)asks for the rule by its whole name:command="up"fails for a refusal of the update rule, where it passed. authzRoutes()(@rowstile/next) answers 400 to a request that names no type, and to a body that isn't a JSON object, instead of an error, a 500.- In the TypeScript SDK, a transaction begun inside another for the same principal (
transaction(fn)in@rowstile/pgand@rowstile/drizzle,begin(fn)in@rowstile/postgres) is a savepoint of it, on its connection, as in the Python and Go SDKs: it sees what the outer one wrote, and one that fails is rolled back to its savepoint. Before, it took another connection, and on a pool of one it waited forever. Through Prisma,db.$authz(andtx.$authz) inside$transaction(async (tx) => ...)asks in that transaction, as the other packages' calls do in theirs; before, it asked on another connection. - The .NET SDK's helpers its EF Core package alone calls are no longer public:
Keys,Verdicts,RowAsked,RowAnswer,RowstileNpgsql.ActAs,ActAsArgs,ActAsParametersandAskAsync, andStale.Record. Its README lists what is (.NET). - The Ruby SDK needs Active Record 8.1 (
~> 8.1), the version its suite runs: it hooks into parts of Active Record that change between minor releases, and it was never run on 8.0. - The Ruby SDK's
assert_refused(command:)asks for the rule's whole word (select,insert,updateordelete), as the Kotlin and Elixir SDKs do. Before, the beginning of one passed ("up", or""). - The Rust SDK's
SignIn::principalis async and takes the request's parts mutably, so it can look a session up in a database, fetch a key set, or run another extractor on the request: an app's impl writesasync fn principal(&self, request: &mut Parts) -> Result<Principal, Error>. - The Elixir SDK's
Rowstile.Testing.assert_refused(result, command)takes the rule's whole name (insert,update,delete,select): a part of it, such as"up", or"", fails the test. Before, any start of the name passed. - The PHP SDK's
assertRefused($fn, $command)asks for the rule's command itself (select,insert,updateordelete). Before, any start of it passed:'ins', and''for any refusal. - The PHP SDK's
php artisan rowstile:checkrefuses a connection that signs no transaction in: a pgsql connection another package's class made instead of rowstile's.Rowstile\Laravel\SignsInis the trait that signs them in, for a class of the app's that extends that package's. - In a Laravel app, a model whose update or delete changed no row is asked about in the transaction the statement ran in, one of its own when none is open. Before, outside
DB::transaction, the question ran in a second transaction, and its answer was about the row as it was then. - The PHP SDK's
permittedcompares a uuid key (a model withHasUuids) as uuid, so its index is used. Before, it cast the column to text, and the query read the whole table. - The VS Code extension (0.1.5) works in Restricted Mode:
.authzfiles are highlighted there, and the language server starts once the folder is trusted (it runs the programrowstile.commandnames). The extension was turned off there, its highlighting too. - The playground serves Pyodide and PGlite from its own site, at the versions its
package.jsonpins, instead of loading them from jsDelivr. Mermaid still comes from jsDelivr, checked against its hash as Studio checks it, and the page's Content-Security-Policy lets scripts run from the site and that file alone. - The npm package's launcher exits 2 when it can't run the command (no Python to run on, a
ROWSTILE_PYTHONthat isn't one, a path too long for Windows), as the command's own exit codes say of what it couldn't do; it exited 1.
Removed
rowstile review --json:access.users_in_data, which was always null.
Fixed
- The VS Code extension (0.1.5) sends the language server files only, and new ones not saved yet. The left side of a diff has the file's path, and while it was open the test files were checked against the policy as committed, not as typed. The language server keeps to the file too when another editor sends such a view of it.
- VS Code leaves a relation named with a block's first word (
scope : user shared) where it is typed. It moved it back to the margin, where the compiler refused it. rowstile init --rolerefuses a name the policy's app role line can't hold (a space, a quote), before connecting. Before, it wrote a draft that didn't compile and aCREATE ROLEfor another name.rowstile initwithout--schemaleaves out the sync index's schema,authz_sync: its tables were drafted as the app's, and the roles granted them counted when it chose the app role.rowstile initreadspyproject.tomlas TOML: its dependencies, optional ones, dependency groups and Poetry's tables. Before, each line's first word counted as a package, so anypyproject.tomlmade the app a Python one. It reads Alembic'sscript_locationas Alembic does (%(here)swithout a slash, a folder written with\), and for a package's (myapp:migrations) leaves[migrations]out, saying why. The paths it writes inrowstile.tomlare TOML strings, so a quote or a backslash in one no longer makes the file unreadable.rowstile client LANGwith no file is of the policyrowstile.tomlnames, asrowstile graphis and the reference says, with no database (butpowersync, which reads the databaserowstile.tomlnames); before, it connected and wrote the client of the policy in force. A language it doesn't write, or none with no[clients], is refused before connecting. With no language, it says of each file that it wrote it or that it was up to date.[clients] tsis the names alone when the package.json nearest the client's file depends on@rowstile/*(frontend/package.jsonforfrontend/src/authz.ts), looked for up to the git repository's top. Before, the one inrowstile.toml's folder decided, or one above it, even above the repository. A package.json with a byte order mark is read.rowstile client powersync, a preview: a table the policy mirrors and the database doesn't yet is said, with what to do (apply or push first), instead of a traceback. Each stream's alias, the table's name on the client, is quoted, so a table named with a keyword (app.order) gives a stream the service takes. Two mirrored tables of one name in two schemas, which a client would name alike, are refused (AZ811).rowstile graphdraws the user type's own relations: an arrow through one (owner.manager) pointed at a box the diagram didn't have.rowstile client go,csharp,ruby,rbsandelixirgive no name to a type or a permission whose name there would be one the file or the SDK uses already, as for two names spelled the same: Go'sObjectType(object'stype), C#'s classesPermissionandObjectType(which hid the SDK's) and the names of object's own members (ToString,GetHashCode,GetType,Equals: a class hid them), Ruby's modulesRowstile,Hash,ArrayandString, and Elixir'sRowstileandKernel. Before, the file didn't compile.rowstile client zeronames the readers tables of two types camelCase spells the same (a_b,aB) as each type is written.authz.ctx(key)is NULL for a key the transaction didn't set, also on a connection where an earlier transaction set it (Postgres then reads it as''), and for a key set to'': a condition or a caveat that reads the request context answers the same on a pooled connection as on a new one. (GHSA-q9m7-hm63-2wmc)rowstile lspsends, when it reads the table and column names, the password inrowstile.toml's database string orPGPASSWORDin.envbeside it, not the editor's ownPGPASSWORD: the folder opened names the host. (GHSA-7pm7-3h78-3vv7)rowstile lsp: in a test file with a mistake, hover, go to definition and find references still answer on its other lines. An included file's outline is its own types, not the policy's. Find references reads a--inside a condition's string as text, and completion offers a condition's columns on its later lines too. Aftershutdowna request is refused, andexitwithoutshutdownends the server with status 1, as the protocol says.rowstile mcp:whyrefuses an id the command would read as an option (-hprinted its help; a negative number is still an id), andtestrefuses acoveragethat isn't true or false (the text"false"turned it on). A call stopped after 600 seconds keeps what the command printed before it, so the agent sees where it was.- The sync index, a preview: a PowerSync mirror (
mirrored) is made again when the policy masks a column of its table since, so the masked column leaves the mirror and the sync engine's role can't read it;authz.sync_verify()says false, andauthz.lint()reports an error, while a mirror holds a masked column. (GHSA-42v7-x658-h6vv) - The sync index, a preview:
rowstile applychanges a PowerSync mirror in place when its table's columns changed since (a column added, dropped, or of another type), so thepowersyncpublication keeps it; before, apply saidunchanged, androwstile reapplymade the mirror again out of the publication.authz.lint()warns of such a mirror. Apply also makes again a mirror, or the table of what waits after commit, that was dropped since (the table's writes failed until then), and warns of each publication a readers table made again (its type's key changed) is no longer in. - The sync index, a preview: a
TRUNCATEof one partition of a mirrored table, or of a table that inherits from it, takes the rows stored there out of the PowerSync mirror, and the index works out the type's readers again. Before, the mirror kept them, and PowerSync kept syncing rows the app had deleted. - The sync index, a preview: in READ COMMITTED, writers whose work meets no longer end in a deadlock (40P01) at commit. Three writers could: two waiting for a third, then each reaching what the other held once it committed. A lock row the work needs below one it holds is now taken only if nobody holds it; else the work lets go of them all and takes them again in order.
- The sync index, a preview: applying refuses a superuser as the sync role saying so (AZ808), not that it is a member of the role applying the policy;
authz.lint()reports a sync role made a superuser since once, not as a member of the app role that owns every governed table. Lint still reports another role's privileges onauthz_syncwhile the sync role is gone (renamed or dropped since). - A condition that calls a function by its three-part name (
mydb.app.f(id)), or a function namedfilter,within,overoris, is read as calling the app's code, as one writtenapp.f(id)is: it runs with the policy's rights wherever it is checked, the change feed watches every column of its row, and the sync index refuses it (AZ806). (GHSA-m547-pwr6-2vfx) - A condition that limits inheritance can't read who asks or the session through
pg_has_role(),has_table_privilege()and the otherhas_*_privilege(),row_security_active(),inet_client_addr()and the otherinet_*functions,current_schemas(),pg_my_temp_schema(),pg_trigger_depth(),nextval(),currval()orlastval(): compiling refuses it (AZ305), in a condition that reads another table too, where applying can't ask Postgres. A synced permission that reads them is refused (AZ805). [review] snapshot, the[clients]paths and[migrations] dirinrowstile.tomlstay in the git repository it is in (the first folder up with a.git), or in its folder when it is in none:rowstile snapshot(with or without--check),rowstile client,rowstile devandrowstile migraterefuse a path outside it, or a link out of it, and name it (exit 2). A monorepo's../frontend/src/authz.tsstill works.--outand--dirare still the caller's. (GHSA-c27j-v832-rfwh)- Each view the compiler makes for a relation or a permission has a name of its own: a relation's view of its sources other than columns is now
doc__r:ext, apart from the view of an arrow to a permission namedext(r.ext,doc__r__ext), and an arrow followed to some of its types joins them with__(__on_a__b). The compiler fails rather than give one name to two views. (GHSA-8wgc-xvw3-m3gm) - The sync index, a preview: a share that starts or ends while a writer's transaction is open is worked out again by the first
authz.sync_tick()after that transaction commits, even when a tick ran meanwhile. Before, the index kept what the writer worked out (a reader whose share had ended, or none for one that had begun) until something else changed that object. The index keeps each object's next share start or end inauthz_sync.due; applying works the index out once again to fill it. (GHSA-r9mx-55hw-gf9q) - A caveat that calls a function or an operator of the app's runs with the policy's rights wherever its share is checked, as a condition does: a select on the table and its masked view say what
authz.canandauthz.listsay. (GHSA-wf6p-c49j-575h) - The Elixir SDK:
Rowstile.transactinside a transaction it didn't begin (aRepo.transactionof the app's, a Postgrex transaction's connection) raises aRuntimeErrorbefore anything is sent, as the Python and PHP SDKs do, instead of signing that transaction in.Rowstile.acting_assays, in its docs, that inside atransactthe statements still run as that transaction's principal. (GHSA-x4hg-m454-w962) - The Go SDK:
rowstile.LoginKey(ctx, tx, key)androwstile.LoginJWTsign a request in with an API key or a token insideTx, andTxfollows whom the transaction is signed in as from then on: a nestedTxfor the key's principal is a savepoint, and anyone else's is refused. A login made with SQL insideTxleftTxanswering for the principal it began with (Go). - The .NET SDK: an EF Core context on a connection where
BeginSignedInAsyncbegan a transaction, not brought to it withUseTransaction, no longer signs that transaction in again as whoever the code acts for (Npgsql runs the context's commands in it). Its work runs there as it is while the code acts for the transaction's principal, and is refused for anyone else with anInvalidOperationException, before anything is sent. In aTransactionScopethe connection takes part in, the context's work is refused, as that transaction's sign-in can't be known (ASP.NET Core and EF Core). (GHSA-x4hg-m454-w962) - Every SDK's test helper keeps the copy's name within Postgres's 63 bytes: a longer one is shortened to its first 54 bytes (fewer, not to cut a character in two),
_, and the first 8 hex digits of the SHA-256 of the whole name. Postgres cut it before, so a long name could stand for the original, which the helper then dropped, or for another worker's copy. - The Go SDK's
rowstiletest.PerPackagesays so of a URL that doesn't parse, the app role's too, instead of failing on it or leaving the app role's URL out. - The Rust SDK's
per_binarynames the copy in an app role's URL that names no database, and reads a name the URL percent-encodes; the Java SDK'sWorkerDatabase.copyreads it too, and writes the copy's so. - The Elixir SDK's
database_per_partitionconnects with SSL when the URL'ssslmodeasks for it, and the PHP SDK'sDatabasespass the URL's settings (?sslmode=require) to libpq. - The Python SDK's
database_per_workerkeeps a URL whose host is in its settings (postgresql:///app?host=...) as it is written. - The change feed is in the order of transactions:
authz.changes_since(pos)gives the entries after the one atpos, and only those of transactions older than every one still open, so a reader that goes on from the last entry it read hears of every entry, even one whose transaction ended after a later one's. The newest entries show up once the transactions before them end.authz.changes_position()says where the feed is, for a reader that starts; a position no entry has gets AZ712, as one trimmed does.authz.trim_changes()removes the oldest entries in that order. (GHSA-v7cp-x44m-qfg2) rowstile applycomputes an inheritance table again, instead of keeping it, when its table or link table has other tables under it than at the last apply: a partition attached, detached, made or dropped, or a table that inherits made or dropped. The rows such a change brings or takes away, which no trigger saw, are then in the table, and an apply of the same policy no longer answersunchangedafter a partition is detached. The migrationsrowstile migratewrites do the same for each inheritance table they keep. (GHSA-84mf-ch68-55hg)authz.explainfor another user (its fourth argument) says only what the one asking may see: its walk stops at an object or a team they can't see, as it does when they ask for themselves, and a share's maker, end, start and caveat show only where they may list that object's shares (authz.list_shares). It saysshared with themandthey are member thereof that user, notyou. (GHSA-rq22-3c72-68vg)authz.set_role_permissionsrefuses to add a permission the caller doesn't hold on each object the role is given on, asauthz.sharerefuses to give the role there (AZ705): "you cannot give role reviewer on folder 2: you do not hold archive", or "on a folder you cannot see" for one they can't see. Taking a permission out still needs onlymanage_roles, and a role given to nobody may still be changed freely. A share of the role made meanwhile waits for the change, and weighs what the role gives then. (GHSA-34jx-5ch8-mgqw)authz.break_glassrefuses, naming the share (AZ717), when the caller holds a share of that relation that starts later or holds only while a caveat does, instead of replacing it with one that held from now, without the caveat, until that share's end. The emergency access ends when its time does; a share that lets the caller in now is left as it is. (GHSA-c9xj-8fcj-qvgr)- Each migration
rowstile migratewrites turns row-level security on for the partitions of each table with rules, and the tables that inherit from one, as each apply does: a partition made or attached since is read and written through its table from then on, also when the migration doesn't change that table's rules. (GHSA-fgwq-mp37-w8mf) TRUNCATE ONLYon a type's table that other tables inherit from keeps the shares, API keys and pending access requests of the rows stored in those tables. Before, it removed them all, as emptying the whole table does.TRUNCATErun directly on a partition of a watched table, or on a table that inherits from one, removes the shares, API keys and pending access requests of the rows it empties, and rebuilds the inheritance trees they are in. Before, it ran none of those triggers: the shares stayed until the next apply, a row made later with one of the ids got them, and a tree kept rows under a parent that was gone.authz.lint()counts a privilege on one column as it counts one on the table: it reports a membership table without rules that the app role may insert into or update one column of, a partition it may use that way, a view that runs with its owner's rights of which it may read one column, and the notes that go with them.authz.connection_check()reports a login that is a member of a table's owner without inheriting its rights: it maySET ROLEto the owner.authz.lint()counts a privilege on one column as it counts one on the table: it reports a membership table without rules that the app role may insert into or update one column of, a partition it may use that way, a view that runs with its owner's rights of which it may read one column, and the notes that go with them.authz.connection_check()reports a login that is a member of a table's owner without inheriting its rights: it maySET ROLEto the owner. It also reports a login that switched to the app role withSET ROLEand owns a table with rules, or is a member of its owner:RESET ROLEleaves the rules.rowstile fmtlays out a file that starts with a byte order mark as any other, and leaves the mark out. Before, it didn't line up the relations and permissions of the file's first block.rowstile testruns a test whose name, or an id in quotes on one of its lines, holds a dollar quote's tag such as$authz_tests$. Before, the tag ended the function the tests are compiled into, and Postgres gave a syntax error that named nothing of the policy.- A test's id in quotes is the text in them,
$or not:user 1 can view file '$x'asks about the file whose id is$x, where'$x'was read as the name$x; anda$bis that text, where it was refused as naming$b. An id without quotes that starts with$and is no name ($x$) is refused with its line (AZ106), where compiling the tests failed with a Python error. - A
$namein a string or a comment of a test's SQL is text:given {INSERT ... VALUES (9001, 'Ann $smith')}was refused ("$smith is not named yet", AZ501), or had the name's value put inside the string. - A test file holding a
syncline, a masked view (rules app.files view ...) or acascade fromline is refused (AZ106), as one holding a type is: a test file holds only named tests. Before, those lines did nothing, and nothing said so. - A string, a quoted name or a dollar quote in a named test's statement (
given {...},as ... {...}) that goes over several lines holds them as written: its line breaks, its spaces and a--in it. Before, its lines were joined by a space.rowstile fmtleaves those lines as written. In a condition elsewhere, such a quote is refused with its line (AZ114), where its text was changed the same way. - An included file that is there and can't be read says why, in the editor and in the suites' compiler as in
rowstile check: it isn't UTF-8, say. Before, the editor andcompile_policy.pysaid they couldn't find it.parse_policycalled with neither a path nor the files reads no included file from the current folder. - A mistake in an included file whose name has a space (
include "my roles.authz") is shown where it is: on that file and its words in the editor, with its line inrowstile dev, with its file and line in the MCP server'scheck, in the review and in the playground. Before, the editor put it on the policy's first line, and the others lost its place. rowstile applyremakes a trigger the policy made that is gone when a write rule's condition reads a column namedbegin, instead of sayingunchanged: reading the compiled SQL back, abeginin parentheses no longer opens a block, as psql reads it. Migrations for Drizzle Kit keep one statement between breakpoints there too.- A migration that removes an inheritance tree drops the tree's index by its schema (
authz_int), not by its name alone on the search path, where an index of the app's with that name would have gone instead. The lock file names those indexes with their schema from the next migration on; one written before needs no migration. - A migration of a policy whose text ends in
$authz_policy(a comment, with no newline after it) runs: the quote it records the text in no longer ends early. authz.create_api_keyandauthz.list_api_keysrefuse a principal type given without its id (AZ710), instead of taking it for the caller's own keys, andauthz.create_api_keyrefuses a key with no name or a blank one (AZ710), instead of Postgres's own not-null error.authz.explainfor another user names them as the rest of the API does (user 5, asked as'05'), andauthz.sync_membersrecords the group's id in the audit trail as its shares hold it (10, synced as'010').- The signature
authz.act_as, the logins andauthz.view_asput inauthz.sessionsigns the settings as a list that can be read only one way. Before, they were joined with a separator a user id or a token's subject could hold, so two different settings could sign alike. rowstile reviewreads a policy with sync lines (sync role,sync app.files : view,sync after commit) and shows each one that changed under Meaning, instead of stopping with an error.rowstile reviewflags under Risk a sync line added, one that finds its rows' readers by another permission (: viewto: edit), or one mirrored now: the sync engine is given rows, and who may read them, it wasn't.rowstile reviewreads a backslash in anE'...'string as escaping the quote after it, so a change to the text after it is a change, not spacing. A condition it can't read (a subquery), respaced outside its quotes, is the same condition in its small worlds: a permission turned round and respaced is no longer said to widen.rowstile prove,rowstile reviewandrowstile whyread{user = 'alice'},{current_date is null}and conditions on SQL's other such words as the database does: the role, the session or the clock, not a column of the row ({this.user = 'alice'}and{"user" = 'alice'}still name one).rowstile review's listed small worlds keep the rows of a type whosewherereads a relation's column (where {owner_id is not null}): they read it from the row's link, where before no such row was ever kept and the type was never tried.rowstile reviewandrowstile provegive each value to the other columns a condition reads beside a relation's column ({owner_id = authz.uid() and not locked}), in the listed worlds and in the corners, so a change behind a longandin such a condition shows.rowstile reviewandrowstile provetry, beside a number a condition compares a column with in order, the numbers halfway to one less and one more: a numeric column holds 1.5, where{level > 1}and{level >= 2}differ. A whole number past 8,388,607 so compared is left to the database (a real column rounds the half).rowstile reviewandrowstile provegive their small worlds a row whose id is one a condition compares a relation's column with ({owner_id <> 7}: a user 7;{parent_id = 0}: a folder 0), and the ids either side of one compared in order. Such a condition held on every row or on none there, so the review called a change that lets everyone edit user 7's folders unchanged, and prove missed the row that breaks an invariant.rowstile helpsays what each code refuses today: AZ607's page tells each migration tool how to record a migration the database holds already, AZ203's no longer namesshared byand scopes (AZ207, AZ404), AZ107's namesroles, and AZ208's message and page name the same uses: a permission, a rule, an invariant, a group or a roles line'sfrom.- AZ607's page gives Flyway's and sqlx's own commands for recording a migration as applied, and the row Drizzle Kit reads to know one ran. It said those three tools could only make the database again from the migrations.
authz.can,authz.list,authz.permsandauthz.perms_ofanswer for the rows the user may select: on a table with a select rule, a row its rule doesn't let them select reads as a missing one (false, left out of the list, no permissions). A permission made of conditions on the row, such as the deny the docs teach (can hidden = {hidden} or parent.hidden), is held by everyone on the rows it marks, and these answers named those rows. A table without a select rule answers as before. (GHSA-mfxg-m24m-gfmg)rowstile diffwaits for an apply, push or remove running at once, as they wait for each other, instead of the two meeting in the middle and one stopping with "deadlock detected". The docs now say that it holds the app's tables locked while it runs: run it on a copy or a staging database, not on production at its busiest.- A migration run a statement at a time (
psql -fwithout-1), refused (AZ615) with its session made read-only, puts the session's setting back in its last statement: a pooler's connection doesn't go on to the next client read-only. - The second of two migrations, which swaps in an inheritance table built beside the one in use, computes the table again when the change feed was trimmed meanwhile of the entries of a transaction still open when the first one ran. Before, it could miss what that transaction changed.
authz.trim_changes()records the transaction its trim ended at (changes_trimmed_txidinauthz.settings). - A relation whose two
sharedlines name the same subject with anothershared bypermission or anothershared ifcondition is refused when compiling, with its line (AZ212). Such a policy failed to apply withduplicate key value violates unique constraint "shared_relations_pkey"when the permissions differed, and otherwise kept only the first line'sshared if. - A share with
anyoneis stored with the id*, whatever idauthz.sharewas given: sharing with''and with'*'makes one share,authz.unsharewith either id removes it, andauthz.whocounts one made with''. Applying gives the shares with anyone stored before the id*, two of one share kept once. - Applying after a type's key changed type (text to bigint, say) is refused while shares of rows gone before name ids the new key can't read, with the line of the type and how many (AZ627, whose page gives the statement that deletes them). It failed with
invalid input syntax for type bigint, and nothing said which shares or what to do. Applying right after deleting them, while a transaction that began before is still open, is refused too, and says to apply again once it ends: Postgres builds the index from the rows that transaction still sees. - A share with
anyoneis stored with the id*and no relation, whateverauthz.sharewas given: sharing with''and with'*'makes one share,authz.unsharewith any id removes it (also once the policy no longer shares with anyone), andauthz.whocounts one made with''. Applying gives the shares with anyone stored before the id*and no relation, two of one share kept once. rowstile reviewreads an included file's name that holds spaces: a mistake's line there (--json:base_mistake.line), and each flag's annotation, on that file and line.--annotationsescapes the%,:and,of a path, as GitHub reads them. Deploy names a quoted table with a space in its name whole, and counts an app schema whose name starts withauthzas the app's. The comment's table escapes a|in every cell, an invariant's own text too, and a counterexample doubles a quote in a text, as SQL writes it.- The world
rowstile reviewandrowstile proveshow a difference or a counterexample in leaves out the rows that play no part, as it does links and values: one found among 2 users and 4 folders shows the user and the folder it is about, not all six. rowstile reviewlists 12,000 small worlds at most (60 for each drawn one), even before it has listed every world with one link: rows whose conditions give many answers made that many grow fourfold with each condition, and a review run for minutes. It then says how far it got ("with no link, and some with one").rowstile reviewlists the small worlds where a column compared withauthz.uid()names a user other than the one its row links to (two folders, each made by the other's owner): it took them for the same world with the users renamed, which changes whose id the column holds.rowstile initbeside arowstile.tomlthere already, in its folder or above, that names another policy says that no command reads the draft until it does, and the note inAGENTS.mdnames the policy and the testsrowstile.tomlnames. Before, it named the draft's.- An
UPDATEofauthz.sharesmade by hand is recorded with what the share was (detail'swas: its object, relation, subject and times), and announces the object it left also when only its type changed. AnUPDATEofauthz.role_permissionsis recorded (the permission removed, the one added) and announces the objects the role is given on. Before, neither was recorded or announced. - Deleting a row finds the pending access requests and the API keys that name it by index (
authz.requestshas indexes of its pending requests, by object and by requester, andauthz.api_keysone by principal): it no longer reads every request ever decided. authz.announce_timed_shares()keeps each object's next share start or end (authz.shares_due, which each write of a share puts in) instead of the time of its last run: a clock set back no longer hides the shares that end or begin after it until the clock is past that time again. A run waits for a writer adding a share to one of the objects it announces, and reads the shares as it left them.- A
TRUNCATErun directly on a partition of a watched table, or on a table that inherits from one, is in the audit trail, one line naming that table, and the change feed announces every object of its type. ATRUNCATEof the table above is still one line, naming it. Before, neither heard of the one below. - A policy with a permission or relation named
tree, ortree_and more (tree_links), applies: the closure table that an inheritance makes takes another name (folder__parent__tree2) where the view of an arrow to that name would have had the table's. rowstile migratenames a file of the migration tool's it can't read and exits 2, where it printed a traceback: a Drizzle Kit journal or snapshot that isn't JSON (a merge's conflict markers left in it), a journal entry without itsidxortag, a Django migration that isn't Python, and any of the tool's files, or the lock file, that isn't UTF-8. A Drizzle Kit snapshot it can't read leaves no migration file behind.- The command refuses an option it doesn't take in last place on a line that has
sqlas a value (rowstile migrate --tool sql --check --bogus): it left the last word out, as it does forrowstile sql's statement. A number option given digits of another script (--worlds ²) is a usage mistake (exit 2), not a traceback. rowstile.tomlrefuses a[migrations] write_afterbelow 0, which maderowstile devwrite the migration at every save instead of once you stop editing.- The command run from the source (
core/cli/rowstile) on a Python older than 3.11 says it needs 3.11 or newer, and exits 2, where it stopped with a traceback. - Ctrl-C stops any command with
stoppedand exit 130: one that reads no database (a longrowstile prove,review,migrate), or one still connecting, printed a traceback, as didrowstile devstopped in its first pass.rowstile devends with 0 on Ctrl-C whenever it comes, as it did once watching;dev --oncewith 130. - The command signs in with a SCRAM password that mixes right-to-left letters (Hebrew, Arabic) with others, or that is made only of characters SCRAM drops, as psql does. It prepared such a password other than Postgres had, and the server refused it.
- A
#, a?or a[in a URL's password is the password's, as libpq reads it. Before, the command refused it, or with digits before it connected to the user's name as a host (postgresql://u:2024#x@h/db). A message about the connection string no longer repeats a piece of a password that wasn't quoted or escaped: a word after the password that looked like a setting (password=my secret=x), or what came before a/in a URL's password. - A URL's parameter a letter away from a libpq setting (
?sslmod=require,?chanel_binding=require) is refused, as a typo, naming the setting meant. Before, it was left alone as an ORM's own, and the command connected without what it asked for. An ORM's parameters (?schema=,?pgbouncer=) are still left alone. - Studio's grid, on a partitioned table or one that other tables inherit from, marked a row visible when the person could see another row stored at the same place in another partition or table. It now tells the tables apart.
- Studio's grid shows a table's columns in the table's order (it put short names first): the first eight, any masked column after them, and the names of the others. It counts a table's rows up to 10,000, and says "more than 10,000" past that: each page of a big table no longer reads all of it twice.
- Studio's "Make a test" copies json values as the row holds them: a string, a number, a boolean or null in a json column made a test that failed. A key that is not a number, text or a uuid is copied as it is, and the test says to give the copy a key of its own.
- Studio's access diff no longer says the policy file is the one in force when only an included file changed.
- Studio's page: after the person viewed as changes, the Shares tab's buttons name the new person, and each button acts as the person it names. A table's rows that come after rows asked for since are dropped. A graph node the policy doesn't name (a permission's inheritance before a deny, a permission's custom roles) shows what it is.
- The lines that show how to use the review for CI (the reference's workflow, the action's and the GitLab template's comments) name the newest release,
v0.1.0-beta.3. Onmainbetween releases they named its-devversion, which has no tag to use. rowstile plansno longer says an index is missing on each partition of a partitioned table it reads (or on each table that inherits from it): those scans are the read itself.rowstile benchtimes updates of rows the person may update. Before, it picked among the table's first rows whoever was signed in, and most of the updates it timed matched no row.rowstile indexessays that Prisma's and Drizzle's line takes the fields that map the columns, where a model names them otherwise, and, for goose and dbmate, that dropping an index a failed build left goes in a migration of its own outside a transaction, as the index's line does.rowstile whyand Studio judge ashared ifas the first 20 of those who may share the object, and say so when there are more. Before, they signed in as each of them in turn, for each share they looked at, which took seconds on an object a thousand people may share. They also count up to 1,000 objects of a type that someone holds a permission on, before and after a change: past that, the permission is said as not counted ("not counted: view on folders, past 1000"), not as a number.- Every SDK reads rowstile's code from the error's HINT alone, never from its message, which may quote the request's input: an id of
rowstile help AZ708cast by the app's SQL is the app's error (a 500), not a 404. The PHP SDK reads the HINT libpq writes after the message, and the severity in the server's language. - Every SDK takes a 28000 as the not-signed-in error only with code AZ701: Postgres's own refusal to connect (a role that isn't there,
pg_hba.conf) stays a database error, instead of namingauthz.act_as. - Every SDK but PHP's reads Postgres's own row-level security refusal on a server whose messages aren't English as a refusal (403, naming no table), by the function that raised it. The Ruby SDK reads the English words at the message's start alone, as the others do, and the TypeScript and PHP SDKs a refusal's rule at its start.
- Nobody has one spelling in every SDK: a principal without an id (none, or empty), whatever its type, is the SDK's nobody, as the database signs it in. Work for nobody inside a transaction begun for another spelling of it runs, instead of being refused; Django's guard and Ruby's take code that acts for no one, in a transaction signed in as nobody, as nobody's work. In Java,
Rowstile.actingAs(null, ...)acts for nobody, not for whoever the request is. - Every SDK writes a key as Postgres writes the row, a field quoted for ASCII's six spaces alone: the Python, TypeScript, Java and .NET SDKs quoted a field holding a no-break space or an em space, so a hidden row's id and a refusal's message spelled it another way than
authz.list. - Every SDK takes a key of several columns as any of its language's arrays, lists or tuples: Go any slice or array (
[]int64{1, 2}), .NET any array or list (long[]), Java and Kotlin any array or collection (long[],arrayOf(1, 2)), Elixir a tuple. Before, those were sent as the language's own text ([1 2],System.Int64[]), andcananswered false. The Go SDK sends no key as NULL, writes pgtype's values and pointers as their values, and refuses a value whose text in Go isn't Postgres's (atime.Time, a[]byte) before anything is sent. - The TypeScript and Java SDKs word a hidden row as the others do:
row 7 not foundwithout the table andnot foundwith neither, instead ofthe row 7 not foundandnull 7 not found. - The Elixir and TypeScript SDKs take a null cursor (
after: nil) as the first page. Elixir sent"", which the database refused (AZ710). - The Go SDK: a transaction
Txbegan on a pool no longer forgets the next transaction's sign-in. pgxpool'sCommitputs the connection back in the pool before it returns, and the next transaction on it could begin beforeTxforgot the first: its own nestedTx, a savepoint, was then refused as work in a transactionTxdidn't begin. rowstile.alembicleaves the sync index's schema alone too (authz_sync, made by a policy withsynclines), soalembic checkshows no change and autogenerate writes nodrop_tablefor its tables.- The Python SDK's jobs (
rowstile.job) leave nothing in the context they run in: a worker that ran many jobs in one thread held a little memory for each. - The Python SDK asks the database about the row an ORM update named, when the update was refused: by the key the row had (an update may change it), and with joined-table inheritance in the table the change went to. Before, it asked about the new key (and answered 404) or the subclass's table (and answered 409, or 500).
rowstile.sqlalchemy.install(engine)keeps no engine alive once the app lets it go.- The Python SDK's
expect()reads a table written with quotes ("app"."notes") as the database does, and Django'sexpect()andsave()answer 403 or 404 for a model whosedb_tablenames its schema that way ('app"."notes'), where they failed with AZ707. @rowstile/jestnamesexpect, whose types it adds the matchers to, as a peer: with pnpm's strict layout,toBeRefusedandtoBeNotFoundwere untyped.electricShape(@rowstile/client, a preview) finds no filter for a principal type named like a member every object has (constructor): it answers 403, as for any type the shape doesn't sync.@rowstile/drizzle'sids(type, perm, keyType)takes a type's name and nothing else: one word, or one of Postgres's names of several words (double precision,timestamp(3) with time zone). Before, it took any words with spaces between them, and refusedtimestamp(3) with time zone.- The TypeScript SDK reads a refusal by a restrictive policy of the app's own, which Postgres names in its message (
new row violates row-level security policy "p" for table "t"), asRefused, a 403; before, it was no refusal, a 500. - Every other SDK does too (Python, Go, Java and Kotlin, .NET, Ruby, Rust, Elixir, PHP): a refusal by a restrictive policy of the app's own, which Postgres names, is
Refused, a 403, in Postgres's words, with no command but an upsert'supdate, and the table it names. Before, it was a refusal that named no table, or in PHP, whose driver doesn't say which function raised it, no refusal (a 500). - Go's
rowstiletest.Refused(t, err, command)asks for the rule's whole command: before, any start of it passed ("up", for an update's refusal). - PHP: a refusal's DETAIL that quotes a line beginning
LINE 2:keeps it; before, the DETAIL went into the message. A LINE is libpq's only with the caret it writes under the statement's line. - PHP:
php artisan rowstile:checksays when the server writes its messages in another language (lc_messages), in which PHP can't tell Postgres's own row-level security refusal from another error, and still exits 0;Rowstile::check()returns that warning. @rowstile/prismareads a nested write whose target isn't there, or is hidden from the user (aconnect), asNotFoundnaming that target's table. Before, an update named the row it updated, and a create stayed Prisma's error.@rowstile/postgres'sbegin(fn)runs the queries of an arrayfnreturns, as postgres.js's ownbegindoes. Before, it ran none of them and committed an empty transaction.- The Java SDK's
Rowstile.transactionrolls back whatever its work throws. AnError(a test's assertion) or a checked exception the work doesn't declare (Kotlin's, Lombok's@SneakyThrows) left its writes to be committed when the connection went back to auto-commit mode. It also takes a connection out of auto-commit mode with no transaction open on it (a pool'sautoCommit=false), and leaves it in its mode, instead of saying a transaction is open. - The Spring starter ends a transaction whose sign-in fails for any reason, the app's
PrincipalSourcethrowing too. Before, only the database's refusal did: otherwise the begun transaction stayed bound to the thread, its connection out of the pool, and later work on that thread joined it, signed in to no one. AREQUIRES_NEWtransaction the database won't sign in says why (CannotCreateTransactionException), instead of Spring'sIllegalStateExceptionabout a resource bound already. - The Spring starter signs in JPA's transactions on any JPA provider (EclipseLink), not on Hibernate alone: without it,
JpaTransactionManager's transactions were signed in to no one, and their queries failed (AZ701). Saying why an entity's update or delete changed nothing is still Hibernate's. - The Spring starter reads a refused entity delete as a delete with Hibernate's comments in its SQL (
hibernate.use_sql_comments). Before, it asked the update rule why, and could answer 409 where the delete rule refused (403). - The Spring starter makes the transaction manager it hands out with its class's constructor, where it has one without arguments (Spring's own managers), and writes no final field by reflection, which JDK 26 warns of and a later JDK is to refuse.
- The Kotlin module leaves alone the statements of Exposed's R2DBC transactions, which run its check that a transaction is one principal's too: with the module on the classpath, each failed with a
ClassCastException. - The Ktor plugin asks who a request is once, when its code first reads it, as its docs say: it asked again on every
actingFor(). - The Spring starter answers a refused update or delete of an entity whose id has several columns (an
@EmbeddedId, an@IdClass) with a 403 that names its table and command, and no reason, instead of a 500: it sent the id's own text, which the database couldn't read. Hibernate's order of the id's columns needn't be the policy's key's, so it asks nothing (Spring). - The .NET SDK: in a
TransactionScopethe connection takes part in, SaveChanges and the runtime's calls (CanAsync,PermsOfAsync,ExpectAsync) are refused before anything is sent, in the words a command is, which say to run them outside the scope or on a connection that takes no part in it (Enlist=false); EF Core refused them before, in words that didn't say why. A sign-in the database refuses rolls its transaction back (BeginSignedInAsync, and a context'sBeginTransaction), so the connection goes on; before, the next statement failed. A pooled context (AddDbContextPool) rolls back the SDK's transaction after a failed SaveChanges each time, not on its first lease alone.UseRowstile()takes a named connection string (Name=ConnectionStrings:Db), which it refused, and leaves it to EF Core.AddRowstilesays what to give when the start-up check finds no data source, and the middleware's problem body replaces what the endpoint had put on the response (its headers, its cookies). - The Ruby SDK's
Rowstile::Jobreads a job's arguments as the job's principal: a record given toperform_lateris found again as the service the job acts for. Before, Active Job read them before the job signed in, so in a worker the job failed (AZ701), and in a request it read them as the request's user. - The Ruby SDK refuses a dump of a rowstile database before
db:test:prepare(whichmaintain_test_schemaruns) empties the test database, and before Rails makes a worker's database again from it. Before, the migrated test database was emptied first, then the load refused. - The Ruby SDK keeps Rails from running a statement again on a new connection when the connection drops right after the sign-in: the connection's error is raised. Before, Rails began the transaction again without the sign-in, and the statement was refused (AZ701).
- The Ruby SDK's
Queries#permittedworks on a model with a composite key. Before, it raisedKeyError. - The Ruby SDK holds a statement named
SCHEMA(as Rails names its reads of the catalog) to the transaction's principal, as any other: in a transaction signed in as someone else, it raises before anything is sent. - The Ruby SDK's
Rowstile.problem_ofworks in an app without Rails. Before, it was defined only with the Railtie. - The Ruby SDK no longer keeps a connection leased after a refused update or destroy, outside Rails' executor (a thread of the app's own).
Rowstile.expecttakesconnection: Note(a model) as well as a connection. - The PHP SDK reads rowstile's code from the HINT the server wrote, never from text in the message or a DETAIL that looks like a HINT line (a value echoed back with a line break in it), and only where the HINT ends with it. Before, such a value could give an error another code, and another status.
- The PHP SDK's
SignInmiddleware writes a streamed response (response()->stream,streamDownload,StreamedJsonResponse) as the request's principal. Before, the body was written once the request acted for no one, and its queries failed (AZ701). - The PHP SDK's
SignInsays what is wrong when finding who the request acts for reads a table with rules (the users table, read by Laravel's guard before anyone is signed in): aLogicExceptionthat names it. Before, it was the not-signed-in error. - The PHP SDK answers a
ModelNotFoundExceptionthat names no model (made withoutsetModel) as Laravel does, a 404. Before, it was a 500. One for several ids (findOrFail([1, 2])) names none of them, instead of(1,2). - In a Laravel app, a model's
increment,decrement,incrementEach,decrementEachandforceDeletethat change no row say why, as its update and delete do:Rowstile\NotFoundorRowstile\Refused. Before, they changed nothing and said nothing. - The VS Code extension (0.1.5) leaves one language server running when
rowstile.commandchanges twice while a server starts: another was left running beside it, its mistakes shown twice. A server that didn't start leaves no log or problems behind: every server writes to one log,rowstile. - On Windows, the VS Code extension (0.1.5) quotes a word of
rowstile.commandthat holds&,|,<,>,^,(or), as it did one with a space:cmd.exeread them (a folderR&D, say). - Zed, Neovim and Helix read a test whose name holds a quote, as Studio writes some (
test "user 1 can view file "a""), to the last quote on the line, as the parser does. Before, they marked the name as an error, and the test went missing from the outline. - Zed, Neovim and Helix read a condition as Postgres and the parser do where it holds a comment inside a comment, a dollar quote with a tag of letters past ASCII, or a character past U+FFFF in a name. Before, they marked it as an error, and a brace inside could end the condition early.
- VS Code and the site colour the permission after
shared byas a permission, and Zed, Neovim and Helix colour the scopes of a test line'swith scope: each editor colours those lines as the others do. - VS Code and the site end a condition at its last brace when a dollar quote (
$$...$$,$tag$...$tag$) or anE'...'string inside it holds a brace or a quote. Before, the SQL colouring ended it early, and coloured the rest as policy words. - The Zed extension starts the language server with what Zed's
lsp.rowstile.binary.envsetting sets, and adds no closing quote to one typed inside a test's name, a quoted id or a comment. Before, it ignored that setting, and closed every quote. - The playground's app role may use the schema
public, as on a server: tables there (Prisma's, Django's, Rails') are read and written under the policy. Before, each run madepublicagain without its usual owner and grants, so asking as someone was refused there. Each run also starts from a new session: what the last run's tables and data set (SET search_path,SET session_replication_role, a temporary table) is gone. - A playground link that names no example (
#e=and a recipe renamed or removed since) opens the first one and says that no example has that name. Before, it opened the first one and said nothing. - The file manager example: a new version of a file whose own upload wasn't confirmed yet is refused (404). It became the file's current one while the file stayed hidden, and the maintenance job then stopped on the version's foreign key, leaving the file hidden for good with its name taken. The job removes a file never confirmed with every version it has.
- The file manager example's policy: only a group's owner hands it over or deletes it. Its admins still run its members and sub-groups, but they could make themselves its owner, which took the group from the person who made it, and delete it. The web app offers Delete only to the owner.
- The file manager example reads
FM_COOKIE_SECUREandFM_OPEN_SIGNUPas true or false (or 1 and 0) in any case, and stops at start on another word:TRUEleft the session cookie on plain HTTP.FM_WEB_ORIGINSmay have spaces after its commas. - The file manager's web app searches for a link's words as written when they hold a
%that is no escape (#/search/50%): the page went blank. - The file manager's maintenance jobs remove the objects in storage that no file's version names, after a day: a deleted file's objects, when deleting them failed after its rows were gone, stayed in the bucket for good.
- A type keyed by a date, a time, an interval or money is refused when the policy compiles, naming its line (AZ206). Before, applying failed with Postgres's own message about an index, which named no line.
rowstile review --db: Risk's example of a permission that allows more is someone Access shows gaining it on the review data, when it shows one. Before, it came from the review's small worlds alone, and could name a user who held the permission already.rowstile whyand Studio say "more" and "other" only of objects of the type asked about: a change that also gives edit on a note's one project says "edit on 1 project", not "on 1 more project".- In a condition, a
$right after a character beyond ASCII (an em dash, an emoji) goes on the name, as Postgres reads it, and opens no dollar quote. Before, the policy read the rest of the line as quoted. - The file manager's migrations run in a service of their own in
docker-compose.yml, which ends before the app starts, and its maintenance jobs in another (docker compose run --rm maintenance): the app no longer holds the database's admin password, onlyfm_app's. - The file manager's migrations, maintenance jobs and tests run as
fm_owner, the tables' owner, which isn't a superuser (db/owner.sql, run once by the Postgres image when it makes the database), as the messenger's do; they ran as the superuser. Its database is published on 127.0.0.1 only. A database compose made before has nofm_owner: start it afresh (docker compose down -v). - The messenger example's rules: a direct chat stays its two people, whoever left. Its creator who had left it, or the one who stayed, could put someone else in it, and its creator could start one between two others. A message deleted for everyone loses its text, whoever writes it (only the API cleared it). A member marks read no further than the chat's last message, and someone added has read what came before, which they never see: read receipts showed messages not sent yet as read, and old ones as unread once someone joined. A phone number shows only to the people who share a chat with its person (the app reads people through a masked view); anyone else finds an account by its exact number (
ms.find_by_phone). Every signed-in person and bot could read everyone's. Signing up reads the phone number before checking it:abcwas kept as an empty number, which any phone made of letters then found. A path under/api/the API doesn't have answers 404, not the web app's page. Opening a direct chat whose other person left blanked the web app, again on each reload; it opens, unnamed. Its schema is one migration, as the file manager's is. - The messenger example's rules and API: a direct chat stays its two people, whoever left. Its creator who had left it, or the one who stayed, could put someone else in it, and its creator could start one between two others. A message deleted for everyone loses its text, whoever writes it (only the API cleared it). A member marks read no further than the chat's last message, and someone added has read what came before, which they never see: read receipts showed messages not sent yet as read, and old ones as unread once someone joined. A phone number shows only to the people who share a chat with its person (the app reads people through a masked view); anyone else finds an account by its exact number (
ms.find_by_phone). Every signed-in person and bot could read everyone's. Signing up reads the phone number before checking it:abcwas kept as an empty number, which any phone made of letters then found. A path under/api/the API doesn't have answers 404, not the web app's page. Opening a direct chat whose other person left blanked the web app, again on each reload; it opens, unnamed. Its migrations run in a service of their own indocker-compose.yml, so the app no longer holds the tables' owner's password, and its schema is one migration, as the file manager's is. - The clients
rowstile client pyandrowstile client tswrite a key of several columns in a message as Postgres writes the row: a field is quoted for ASCII's six spaces, not for a no-break space or another Unicode space, and a NULL field is nothing (it wasNoneornull). A key of one value given as a tuple or an array is that value, in a message and in what they send:(7,)was sent as("7"). - The review for CI on GitHub: when GitHub can't be reached, or doesn't answer within 30 seconds, the comment step fails with an error that says so and that the review is in the run's summary. Before, it ended with a traceback, or waited for the job's timeout.
- A mistake on a line that goes on over several (a quote left open in braces, AZ106 and AZ114), or about a quote left open to the end of its line (in a condition or a test's statement), is underlined in the editor and the review up to the last character of its words. Before, the range ended one character past the end of that line.
- The npm package's launcher passes Ctrl-C and a hang-up on to the command only when none of its streams is a terminal:
npx rowstile ... < filein a terminal no longer gives the command each one twice. - The command's image and the Python package are built with the build's own packages (hatchling and what it needs) pinned by hash, as everything else they fetch is.
rowstile reviewandrowstile proveread a condition on a type's key column ({id = 2}) as the row's own id, as the database does. Before, their small worlds gave that column a value of its own, beside the id, so a refactor could be said to change what it doesn't, or a counterexample be one no database can hold.rowstile migratewrites a migration when a policy's lines only moved (a comment added above a rule): it writes where each line is now, and nothing else, androwstile migrate --checkasks for it. Before, there was none, and a migrated database's messages named a rule's old line until the next migration.- The language server, when a file a policy includes is closed while the policy is open, marks it with what the policy's check finds there. Before, with no policy named in rowstile.toml, it kept the mistakes the file had when read as a policy alone (no app role, say).
Upgrading
- An Axum app's
impl SignInwritesasync fn principal(&self, request: &mut Parts) -> Result<Principal, Error>where it wrotefn principal(&self, request: &Parts) -> Result<Principal, Error>; the body stays as it was. - A condition with a string, a quoted name or a dollar quote over several lines is refused (AZ114): write it on one line, a line break in a string as
E'\n'. - A type, a relation or a permission whose name starts or ends with
_is refused (AZ107), with the line it is on: rename it. - Code that signs one transaction in as two principals now gets AZ716: begin a transaction for each. A test that acts for several people in one transaction calls
authz.sign_out()between them, as the SDKs' test modes do. The next apply (or migration) makes the change. - Sign-ins are signed in a new way. A signature lasts one transaction, so a connection pool keeps none across the upgrade.
rowstile applyandpushwait for the transactions signed in before them; a migration doesn't, and a transaction signed in before it and still open when it commits gets AZ702 on its next statement: retry it. - A reader of the change feed reads everything again once after the upgrade, then follows from
authz.changes_position()(no longermax(pos), which may stand past an entry still to come). - A review started more than two weeks ago with the default deadline takes no more decisions: close it, or start it again.
- The next apply (or migration) makes
authz.shares_duefrom the times the shares have after the lastauthz.announce_timed_shares(), and drops the indexesauthz.shares_by_endandauthz.shares_by_start, which nothing reads any more. - A Go app whose
userfunction, given torowstile.Middleware, refuses a bad token with an error of its own returnsrowstile.Unauthorized("...")instead: any other error is now a 500.
0.1.0-beta.3 (2026-11-05)
The sync index, its engines (Electric, Zero, PowerSync) and the new SDKs and stacks are previews: they may change in any release, and the SDKs not on a registry yet install from the repository.
Added
rowstile dev's access lines name, under a permission someone gains, the rules that read it (read by the rules of app.folders: update id, owner_id, org_id, inherit; delete): whoever gainssharemay then also do what those rules letsharedo, such as give a folder away.- The sync index, a preview (its lines, tables and functions may change in any release):
sync role sync_enginenames the sync engine's Postgres role, andsync app.files : view(orsync app.folders, for the table's select rule) keeps, in the schemaauthz_sync, the keys that may read each row and the keys each user holds, current in the same transaction as each change, for engines such as Electric to replicate.authz.sync_tick()follows shares that start or end, andauthz.sync_verify()compares the index with a rebuild. AZ801 to AZ809 are its mistakes (The sync index). - The sync index, a preview, keyed by folder:
sync app.files : view by foldernames in each file's readers its folder's key (folder#view:7), and the index says whose own keys it inherits (authz_sync.inherits) and what each folder gives itself (authz_sync.given), which the engines' filter joins through: a move rewrites no file's readers and no key, only what the folders below inherit, and a share on a folder is one row, whatever is below it; each user holds their own and their groups' keys, as copied in (AZ810 where a line can't be keyed so).sync after commithas a worker,authz.sync_work(), keep the index after each change commits, so writers don't wait for it;authz.sync_behind()says how late it is. In the same transaction, writers whose work on the index meets nowhere don't wait for each other (The sync index). - Electric on the sync index, a preview:
rowstile client electric(or[clients] electric) writes each synced table's shape (its filter for the signed-in principal, its key columns, the columns the policy masks), andelectricShape()in@rowstile/clientis the route in front of Electric that sets it, whatever the client sends: 401 for nobody, 403 for a session limited by scopes,Varyon who asks. Its conformance suite runs Electric (integrations/electric, The sync index). - A stack page for Electric, a preview: the role an administrator makes, the publication the app's migration makes,
rowstile client electric, the route withelectricShapeandsyncPrincipal,Varyand a cache, and what can't be done (Electric). authz.session_limited()says whether the signed-in session is limited, by a key's or a token's scopes or by viewing as someone, believing the settings only when they are signed, as the rest of rowstile does. The app role may call it;syncPrincipal()in@rowstile/clientasks it. A migration brings it (Identity).- Zero on the sync index, a preview:
rowstile client zero(or[clients] zero) writes the index's tables as Zero tables, with their relationships, each synced table's relationship to its readers, the columns the policy masks, and each table's filter, which the app's query endpoint adds to the ZQL it gives zero-cache. Its conformance suite runs zero-cache 1.11.0 in each of the index's modes, with Zero's query and mutate endpoints signing each request in (integrations/zero, The sync index, Zero). - PowerSync on the sync index, a preview:
mirroredon a sync line (sync app.files : view mirrored) keeps a copy of the table inauthz_sync, every column but those the policy masks andreaders, the keys that may read each row, kept as the rows and their readers are written; androwstile client powersync(or[clients] powersync) writes the service's streams, which put each row in a bucket for each key that may read it, its columns read from the database. AZ811 refuses a mirrored line keyed by a type, and a table with a column of its own namedreaders. Its conformance suite runs the PowerSync service 1.27.0 in both modes a mirror takes (integrations/powersync, The sync index, PowerSync). authz.announce_timed_shares()tells the change feed of the shares that ended (expires_at) or began (starts_at) since it last ran, and of what reads their objects. Run it on a schedule, asauthz.trim_changes()is run (Operations): no write marks the moment a share ends, so until it runs a reader of the feed doesn't hear of it.- Background jobs in Celery's and RQ's workers, for the Python SDK (preview):
rowstile.job(who)is awithblock too, for a job that acts for the user its argument names (Principal.parse). In either form, the database's refusals inside it are raised asRefusedandNotFound(the decorator let the driver's error through before). The two keep what they say in their arguments, so pickle and Celery's results give them back whole. The FastAPI conformance suite runs them in both workers, on Redis. - Django, as a preview (it may change in any release):
rowstile[django]signs every transaction on Django's connections in as the request's user ("rowstile.django"inINSTALLED_APPS, and its middleware), answers refusals with 403 and hidden rows with 404, and gives pytest-django a copy of the test database per worker.rowstile migratewrites Django migrations (tool = "django"). Django. - Preview: the TypeScript SDK on Neon's serverless driver (
@neondatabase/serverless):@rowstile/pgtakes itsPool, over WebSockets, on Node.js and on Next.js's edge runtime, wherecheckAtStartnow throws, saying why, instead of reaching forprocess.exit. A BullMQ worker and Next'safter()sign in asjob()or the request say. The Next.js suite checks each, through Neon'swsproxyand a real Redis. @rowstile/jest, a preview:@rowstile/vitest's matchers,asUserand a test database per worker, for Jest 30. And a conformance suite for a plain Node server, also a preview: Express 5 on pg, Drizzle and postgres.js, with Drizzle Kit's migrations and its tests on Jest (integrations/node, the Node page).- A Go SDK, as a preview (
github.com/rowstile/rowstile/sdk/go, on pgx): transactions signed in, refusals asRefusedandNotFound,net/httpanswers, a test database per package;rowstile client gowrites the policy's names for it. Its conformance suite runs anet/httpapp with sqlc's queries and goose's migrations. - A .NET SDK, as a preview (it may change in any release):
Rowstile,Rowstile.EntityFrameworkCoreandRowstile.AspNetCoresign each transaction in as the request's user and answer refusals as the other SDKs do,rowstile migratewrites EF Core migrations (tool = "efcore"), androwstile client csharpthe policy's names. - The Ruby SDK for Rails apps, a preview: the
rowstilegem signs every Active Record transaction in, answers refusals 403 and hidden rows 404, refuses to start on a connection that skips row-level security, signs Active Job in as a service and copies the test database for each worker.rowstile migratewrites Rails migrations (tool = "rails"), androwstile client rubyandrbsthe policy's names and their signatures, for Steep. - A Java SDK, in preview:
dev.rowstile:rowstileover JDBC, and a Spring Boot starter that signs in every transaction Spring begins as the request's user and answers refusals with problem details (docs/stacks/spring.md).rowstile client javawrites the policy's names for it. It may change in any release. - A Kotlin module for the Java SDK, in preview:
dev.rowstile:rowstile-kotlinsigns in transactions from coroutines and Exposed's, and its Ktor plugin signs in each request's and answers refusals with problem details (docs/stacks/ktor.md). It may change in any release. - A Rust SDK, in preview: the
rowstilecrate signs sqlx and tokio-postgres transactions in, turns refusals into typed errors and problem details, and gives Axum an extractor for each request's transaction (docs/stacks/axum.md).rowstile migratewrites sqlx migrations (tool = "sqlx"), androwstile client rustthe policy's names. It may change in any release. - An Elixir SDK, a preview: the
rowstilepackage signs Ecto and Postgrex transactions in, answers refusals 403 and hidden rows 404 (a Plug, and a Phoenix fallback), refuses to start on a connection that skips row-level security, signs Oban jobs in for the user who asked, and copies the test database for each test partition (docs/stacks/phoenix.md).rowstile migratewrites Ecto migrations (tool = "ecto"), androwstile client elixirthe policy's names. It may change in any release. - A PHP SDK, a preview (it may change in any release):
rowstile/rowstilesigns PDO transactions in, and in Laravel every transaction as the request's or the job's principal, answers refusals 403 and hidden rows 404, and copies the test database for each worker.rowstile migratewrites Laravel migrations (tool = "laravel"), androwstile client phpthe policy's names as enums (Laravel).
Changed
rowstile inittakes the policy's app role from the database: the one role the tables are granted to, where it wroteapp_userwhatever the app's role was. It says so, and asks to make no role that is there (one that skips row-level security: what to change). With several roles granted the tables it names them, and with no tables it says the app's migrations come first.- A refused share or unshare (AZ705) says why, as a refused write does: its DETAIL is what
authz.explainanswers the one sharing, for the permission sharing takes (for an object they can't see, what one that isn't there gets). The SDKs give it aswhy, which was empty. - AZ607's title names its most common case: "The database holds the migration already, or isn't where it starts".
- The site's Markdown copy of each page (
/reference/language.md) andllms-full.txtleave out the notes that say which check holds each sentence (<!-- checked: ... -->), which the pages don't show either. - A transaction is one principal's, in every SDK. Inside a transaction an SDK signed in already, work for someone else, or for no one, is refused before anything is sent for it, with the same words everywhere ("this transaction is signed in as user 1 already, and a sign-in lasts the database transaction: service 1's work can't run inside it. Run it after, or in a transaction of its own (another connection)", each principal named by its type and id, or
nobody); the transaction goes on as its own principal's. Work for the same principal goes on as before. Until now the SDKs differed:- Python:
rowstile.psycopgandrowstile.asyncpgblocks took a savepoint and signed back after; SQLAlchemy'sinstall(engine)kept the outer principal;rowstile.djangoswitched statement by statement. Each now raises aRuntimeError. A psycopg or asyncpg block inside a transaction it didn't begin is refused too (who it is signed in as can't be known): psycopg without autocommit opens one at the first statement. - TypeScript (
@rowstile/pg,/postgres,/drizzle,/prisma): opened a second connection (on a pool of one, it waited until the pool's timeout). It now throws anError;@rowstile/clientexportssignedInAlready. - Go:
Tx/TxAsfor someone else took a savepoint signed in as them; now an error. So isTxon a transaction it didn't begin, or on a*pgx.Connor a*pgxpool.Connin a transaction. To begin one with pgx's options (an isolation level, read only),rowstile.Tx(ctx, rowstile.WithOptions(pool, opts), fn). - Ruby: switched statement by statement; now a
RuntimeError. In Rails' transactional tests, each transaction the app begins is one principal's, so a test may still act for one person, then another. - Django's tests the same: inside the test's transaction, each atomic block the app begins is one principal's.
- EF Core (
UseRowstile()) and the Spring Boot starter kept the transaction's principal without a word; now anInvalidOperationExceptionand anIllegalStateException. In Spring, both work that joins the transaction and each statement on its connection are checked (aJdbcClientcall, JPA's, anAuthzcall). The transaction managers are handed out as a subclass of their class, so the app may inject them by class (JpaTransactionManager) or as aPlatformTransactionManager; the app'sDataSourcebeans the same.Rowstile.signedInAlready(signed, who)in the Java SDK is the error. - Kotlin:
transactionandsuspendTransactionrefused another principal's inside one of theirs already; now each statement in one is checked too (Exposed's,calls, and those onDataSource.transaction's connection), and inside a blockingtransaction,actingFor()is the principal it signed in as. - Rust, Elixir and PHP refuse as they did (Rust's types already keep a transaction to one principal; the other two refused already). .NET, Java, Kotlin and Elixir named a principal
1orservice:1in the words, and nowuser 1andservice 1; .NET, Java, Python, Ruby and PHP said "the work of code that acts for no one" where the others say "nobody's work", which every SDK now says.
- Python:
- The .NET SDK turns on Npgsql's
Include Error Detailwhere it builds the app's connections:AddRowstile(o => o.ConnectionString = ...), which now builds theNpgsqlDataSource, and a context's connection string beforeUseRowstile(). A refused write says why without the app setting it. A data source the app builds itself keeps what it was built with.
Fixed
rowstile proveand the review's refactor check: a relation on the type's own key (self : user = id) holds on every row's own, in every world they try. They could report a counterexample where it didn't, which no database can hold.authz.break_glasschecks the relation'sshared iffor whoever breaks the glass, asauthz.sharedoes for any share, and refuses with the policy's line when it doesn't hold. (GHSA-x952-p96h-53wg)- The pages of the SDKs that aren't on a registry yet install them from the repository: the Rails, ASP.NET Core, Laravel and Phoenix pages, and the .NET, Rust and Elixir SDKs' own, named packages RubyGems, NuGet, Packagist, Hex and crates.io don't have. The README and
llms.txtlist every stack page, and the guide every migration tool. - The Next.js page:
initcomes after the migrations that make the tables and the app role, not in the install lines; the owner's URL isDATABASE_URL, the variableinitwrites inrowstile.tomland Prisma reads (the page used another, so following it gave two); andprisma migrate resolve --appliedis for the migrations after the first, which applies over whatrowstile devpushed. The sharing recipe says that the rules readingshareopen with it. Paths the docs name as proof are links, andllms.txtlinks the playground on the site. - The TypeScript SDKs (
@rowstile/pg,@rowstile/postgres,@rowstile/drizzle): work thattransaction(fn)(begin(fn)) started and that ran after it ended (a promisefndidn't await, a timer) still ran on the transaction's connection, which by then could be serving another request's transaction, signed in as someone else. That work now runs in a transaction of its own, as whoever it acts for. (GHSA-rjcp-7gwg-4mqw) rowstile initno longer tells a Prisma 7 app to sign in inside Prisma's generated client (src/generated/prisma/client.ts), which the nextprisma generatereplaces: it skips generated files.- The Next.js page: its
prisma.config.tsloads.env(import "dotenv/config"; Prisma 7 doesn't), and its page reads inside<Suspense>, whichnext buildneeds with Cache Components, on in a newcreate-next-app. The conformance app now runs with Cache Components. - The change feed announces what reads a changed object through a relation, and what reads those in turn, with the cause
dependent. It announced only the object itself, so a reader missed objects whose access had changed: the files in a moved folder (whose view reads the folder's); the folders and files a team is given, shared with or given a custom role on, when a member joins or leaves it (and the teams it sits in); the folders of an org whose admins change. Past a thousand objects of a type it says{*}for that type. A custom role whose permissions change announces the objects it is given on (the causerole), and every type's table tells the feed of its rows, where before only tables whose columns hold relations did: a change to a column a condition reads, or a row of a type only link tables name added or deleted, went unannounced. An update is announced only where it changes a row's key, a relation's column or a column the type's conditions name (any column, where the compiler can't tell which they read); before, every update of a row whose columns hold relations was, a file's renaming too. Writes that reach other objects take a little longer: on the docs app, a member leaving a team or a share on a folder about half a millisecond more; at most a thousand objects of a type are looked up (Limits). (GHSA-7f4r-8j8w-g94j)
Upgrading
- Work for another principal, or for no one, inside a transaction an SDK signed in already now raises (see Changed): run it after that transaction, or in a transaction of its own on another connection.
- An app that reads the change feed, with shares that end or begin at a time (
expires_at,starts_at): scheduleauthz.announce_timed_shares(), asauthz.trim_changes()is, or the feed doesn't hear of those shares (Operations).
0.1.0-beta.2 (2026-10-29)
Changed
- The Python the npm packages bring is CPython 3.13.18 (python-build-standalone 20261026), where it was 3.13.17.
authz.cancel_requestwrites a line in the audit trail (cancel_request, the request's object, relation and requester, and the request's id), as deciding a request does. Before, a withdrawn request left no trace there.- An empty condition is refused (AZ102, "empty {} condition") in a type's or a link table's
where, ashared ifand a caveat, as it already was in a permission or a rule. An emptywhereorifwas read as none, so the type or the relation took more rows than meant; an empty caveat compiled to SQL that Postgres refused on apply. A policy that has one: write the condition, or take thewhere {}(orif {}) away.
Fixed
- A condition that calls a function or an operator of the app's (
{not app.blocked(this.id)}) runs with the policy's rights where a view reads its permission too: another type's rule through an arrow (file.open = doc.open), a permission that inherits, a masked view. There it ran with the app role's rights, so a function reading a governed table saw only what the signed-in user may see: under anot, row-level security could show rows the policy refuses (authz.canand a type's own select rule were right); otherwise it hid rows the policy grants, and a function reading the permission's own table made every read fail ("stack depth limit exceeded"). Conditions written as subqueries were not affected. (GHSA-gfc6-697v-pv35) - The npm packages that hold the command's Python name its licence
Python-2.0in theirlicense, where they saidPSF-2.0: the licence file they carry is CPython's whole licence (the PSF, BeOpen, CNRI and CWI agreements), which SPDX namesPython-2.0;PSF-2.0is only the first of them. rowstile reviewflags ashared iftaken off or rewritten for one subject of a relation shared with several (viewer : user shared if {...}besideviewer : team#member shared). It compared the relation's conditions together, and a subject shared without one hid the change of another's. The flag names the subject there: "doc.viewerforuser: its share condition changed".- The review's GitHub action and GitLab template update only the comment their token wrote. They took the first one that starts with the review's marker, whoever wrote it: a person's comment starting so was overwritten with the review, or GitHub refused the edit and the job failed. Now theirs stays, and the review is posted beside it.
- The VS Code extension (0.1.4) stops the language server it was starting when
rowstile.commandchanges, once that server has started. It was left running beside the new one, and each mistake was shown twice until the window was reloaded. authz.view_asin a session limited by scopes (an API key's, a JWT's) keeps those scopes. It gave the session the scoperead, so a key whose scopes let it view as a user read everything that user may, beyond what the key itself was given. A session without scopes still views withread. The session's signature and a JWT's are now compared through their hashes, so the time a comparison takes says nothing of how much of one is right. (GHSA-xjmp-62rc-xfcq)authz.explainsays to whom a custom role was given when it was given toanyone, to every signed-in user (user:*) or to a link: "a custom role given to anyone (by 1) (role reader)". It said "a custom role given to (by 1)", naming nobody.
0.1.0-beta.1 (2026-10-22)
Added
cascade from schema.tableunder a table's rules says that its foreign key to that table deletes or changes its rows as meant (ON DELETE CASCADE,SET NULL, ...), and applying no longer warns of it. Where several keys to that table act, the line names the key's columns:cascade from app.users (owner_id). Applying refuses a line that names no such key, or several (AZ625); a column it names that the table doesn't have is said as such (AZ601). The review flags a line added,rowstile fmtlays it out, and the editors highlight it.- Versions have a beta stage,
X.Y.Z-beta.N(on PyPIX.Y.ZbN), after the version's alphas and before its release candidates. The command orders versions so when it refuses to apply, push or migrate over what a newer version wrote (AZ616), androwstile initasks a Python app for at least the beta it runs (rowstile>=0.1.0b1). - Codes for the mistakes
rowstile initandrowstile snapshotreport, each with its page (rowstile help AZ621): AZ620 (no tables to draft from), AZ621 (which table holds the users), AZ622 (a users table the draft can't use), AZ623 (too many people for a snapshot). rowstile review --out FILEwrites the pull request comment to FILE as well, beside what it prints:--annotations --out review.mdgives both from one review. The GitHub action runs the review once this way, where it ran it twice (the base's tests and the access comparison too).- The command's image (
ghcr.io/rowstile/rowstile) is built for arm64 as well as x64: on an Apple Silicon Mac or an arm64 machine, Docker runs it without emulation. Its labelorg.opencontainers.image.versionsays its version, and it comes with its provenance, signed through Sigstore by the release workflow that built it:gh attestation verify oci://ghcr.io/rowstile/rowstile:<version> --repo rowstile/rowstilechecks it. - The Next.js page has a part on Next.js with pg, without Prisma. The reference names the columns
authz.list_sharesreturns.
Changed
- The beta starts afresh: it doesn't upgrade a database an alpha made, and no longer reads the names from before the rename (
rowfence.toml,ROWFENCE_PYTHON, the marks rowfence wrote). Apply the policy to a new database, or to the same one afterrowstile remove --yes(shares and history stay). - The example apps (the file manager, the messenger) and the conformance apps (FastAPI, Next.js) each have one migration for their policy, written by this version's command: they kept every migration since the first alpha, about 45 each. The file manager's tables are one migration too, and the conformance apps no longer set
jit = offon their app role (the sign-in turns JIT off for its own transaction). A database one of them made before is made anew:docker compose down -v. - The Python package's extras ask for the versions its conformance suite runs on: FastAPI 0.110, asyncpg 0.29 and psycopg 3.1.4 or newer (they allowed FastAPI 0.100, asyncpg 0.28 and psycopg 3.1, which nothing ran). The suite also runs each night on the oldest versions the extras allow.
rowstile reviewsays "Meaning unchanged: no declaration changed" when no declaration of the policy changed. It said "unchanged (only comments, spacing or order)", also on a pull request that didn't touch the policy.- The VS Code extension (0.1.3) is no longer marked a preview on the Marketplace and Open VSX, and asks for VS Code 1.82 or newer, the oldest its language client runs on (it said 1.75).
- The npm packages ask for Node 22.12 or newer: the
rowstilecommand said Node 18, and the TypeScript SDK's packages said nothing. The SDK's peer ranges name the majors its checks run, no longer any later one:@rowstile/nextNext.js 16 (it said 15 or later),@rowstile/reactReact 19 (18 or later),@rowstile/prismaPrisma 7 (7 or later),@rowstile/postgrespostgres.js 3 (3.4 or later), each from the version the checks ran. - The npm packages with the command's Python are about 10 MB smaller each (
@rowstile/cli-linux-x64: 15 MB to download, from 26). They no longer carrylibpython(on Linux and macOS the Python is linked statically and never loaded it),python3.13-config, or thedbmmodule's C part (Berkeley DB on Linux), which the command never uses. Theirlicensenames the licence of each library in that Python, beside Apache-2.0 and PSF-2.0, and they carry those texts only. rowstile initdrafts a team inside a team as nested membership: the members of the teams inside count as members of the team above (member : team#member = app.teams(parent_id -> id)), where the draft passed the team above's view down. A comment says the other reading. For teams, groups, orgs, departments and the like; folders still pass their view down.rowstile initadds topackage.jsononly what the app needs to run, and says why each:@rowstile/reactand@rowstile/vitestare named, not added.rowstile init --db URLin an app whoseDATABASE_URL(in the environment,.envor.env.local) is another connection, often the app's, as its role, writesdatabase = "env:ROWSTILE_DATABASE_URL"inrowstile.toml, and says to set it to the owner's. It wroteenv:DATABASE_URL, and the next command connected with the app's URL. With--db, the linefound ..., Postgresno longer says the connection came fromDATABASE_URL.- The command refuses an option the command doesn't take, naming it, exit 2: another command's (
check --force,apply --check,migrate --development),--dboncheck,prove,fmtandmigrate, which read no database, and one written with a single dash (check -x p.authzblamed the policy file). Each was ignored without a word.rowstile graphandrowstile clientwith--dbread the policy in force on that database, not the filerowstile.tomlnames, and refuse--dbbeside a policy file. rowstile --help,-handhelpprint the usage on stdout, for a pager orgrep;--helpafter a command that doesn't exist says so, exit 2. A command short of an argument says how many it takes, and shows its usage.- TypeScript:
Problem, whatproblemOf(e)returns, types its fields (table,command,why,codebesidesstatus,type,title,detail), so a field it hasn't, such asp.body, is a type error. - The generated Python client's
sharetakescaveat_argsas a dict,{"ip": "10.0.0.7"}, as the TypeScript client'scaveatArgsandexplain_rule's row do (it took JSON text). Regenerate the client. rowstile.sqlalchemy.why_stale(exc)andwhy_stale_sync(exc)take theStaleDataError, which they no longer may leave out: the SDK asks the database why a flush failed before its transaction is rolled back, and puts the answer on the error.rowstile.sqlalchemy.install(engine, user=...)given auser()for an engine installed without one (asRowstile(app, engine)installs it) takes it, where it was ignored. Anotheruser()than the one the engine has is aValueError, where the first one stayed without a word.- In
rowstile.testing, a test that never awaits whatassert_refusedorassert_not_foundreturned for an async function fails at teardown and says to await it. It passed without checking anything. - The operations page (Behind a pooler) says what runs every night: both SDKs' conformance suites with the app's connection through PgBouncer in transaction mode, keeping prepared statements. It asks for the command and migrations on the direct URL or a pooler in session mode, as the change feed (it said they ran through a pooler too), and says when Supavisor, PgCat, Neon and Supabase were tried by hand.
- The speed figures on the limits page and the benchmark's page say what measured them: a build of 2026-10-03, on the laptop the project was developed on then. No build since has run those sizes.
- The Python the npm packages bring is CPython 3.13.17 (python-build-standalone 20261021, with OpenSSL 3.5.9), where it was 3.13.15.
Removed
rowstile review --jsonno longer hastests.invariants_removed, which nothing printed: Risk's flag "an invariant removed" names each one.- The Python SDK's helpers that its modules share are no longer public names:
rowstile.literal,call_problem,check_problems,key_text,key_shown,explain_rule_args,explain_rule_sqlandanswernow start with_, andkey_textandkey_shownare one.verdict()and the rest ofrowstile.__all__stay. - A test's name is written in double quotes only, as the docs show it:
test "owners see their folders".test owners see their foldersandtest 'owners'are refused, with the line to write instead (AZ101), and VS Code no longer colours them as a test's name. - The parser no longer knows
update cols check :, the old way to writeupdate cols after :. A column namedcheckis now a column like any other:update check : sealis a rule on it (it was refused, with advice to writeupdate after :). The review and the error pages no longer speak ofrole x,roles : ... grantorcheck. In VS Code,checkin a rule is no longer coloured as a word of the language, and anapp roleline typed under an indented one moves back to the margin, as atypeline does. - The SDKs read an error's code (
error_code(),errorCode()) fromrowstile help AZnnnin its hint alone: no longer from[AZnnn]at the end of a message, which only errors from applying a policy carry. - The command no longer takes names no doc gave:
-dfor--db,rowstile version(--version),rowstile help codes(help errors),--as nobodyand--as ""(--as anyone), andpython,typescriptandts-sdkin[clients]inrowstile.toml(pyandts).
Fixed
- The app role reads none of rowstile's views, and of the rules' functions it calls only those that explain them. It could read views and call functions that told what the rules hide: with
can view = folder.view and not {confidential}on files, the view offolder.viewon files listed the confidential files in the folders a user may view; with a deny inside inheritance ((viewer or parent.view) and not hidden), the view of what the permission gives before the deny listed the hidden folders shared with the user, and its function answered for any folder; a condition that reads another table answered for any row the caller made up. The views and functions the rules use are now inauthz_int: the rules use them, and the app role can't name them (Postgres keeps a rule as it was read when the policy was applied, and checks a schema's privilege only when a name is looked up). The rules' explanations (authz.explain_rule, the message of a refused write) answer for a new row or one the user may select, and say no to all of it for any other. A rule on a column is checked in its trigger'sWHEN. Code that read anauthz_genview now getspermission denied:authz.listanswers what it asked. (GHSA-2f72-cq6g-h9m4) - A rule condition with a quote that Postgres reads as part of a string or a name (
E'it\'s',$$it's$$,"o'neil") before a subquery now runs with the policy's rights, as any condition that reads another table does. The quote was read as the string's end, the subquery was missed, and the condition ran as the app role: through the other table's row-level security, anot existsthere could show rowsauthz.canrefused. The check that inheritance doesn't depend on the time missednow()after such a quote too. (GHSA-2868-c9qv-j9wp) - A rule's condition that calls a function of the app's named with a letter past ASCII (
{not app.muté(this.id)}) runs with the policy's rights, as one callingapp.muteddoes. It was read as no call, so the app role ran it, and the function read other tables through their row-level security: the app role could see rowsauthz.canrefused. (GHSA-ppqr-xfwr-697p) - Where the SDKs write the sign-in into the statement (Python: the asyncpg adapter, SQLAlchemy with a driver of another parameter style,
act_as_sql(); TypeScript:actAsSql()), an id holding a backslash stays one string whenstandard_conforming_stringsis off. An id such asx\'); SELECT ...ended the string early, and the rest ran as SQL. Such a value is now writtenE'...', its backslashes doubled. (GHSA-fh85-46x2-p9g2) - A statement on a partition, or on a table that inherits, runs the triggers of the table above. Moving a folder through a partition of the folders' table (a tree's table without rules), adding a link row to a partition of a link table, or changing a row a condition reads there left the inheritance tables and shares as they were, so users kept seeing what the move took away. Each partition and table that inherits now gets the triggers;
authz.lint()names one made since the policy was applied, and the app role's TRUNCATE on a partition of any table rowstile watches. (GHSA-4fm2-mjhf-rp88) authz.revoke_linkjudges a link given in several relations as things are before it goes, and turns it off in all of them or in none. It took the link out of one relation at a time and judged the next on what was left: a user whose access came by that link was refused in the second relation once the first was gone, and taking it from the first could let a user turn it off in a relation they could not unshare when they asked. (GHSA-v8x5-47x7-g86r)authz.explainwith the signed-in user's own id answers as without one. For a folder user 3 can't see,authz.explain('folder', 6, 'edit', '3')as user 3 showed its rule and the parts it reads (parent is a folder you can't see,yes {inherit}), where a missing folder showed none of that; it now saysno you have no access to folder 6, as for a missing one. Explaining another user's access with a scoped key now needs a scope that names the permission, asauthz.whodoes, and reads that user's access with their full rights, not the key's scopes. (GHSA-g6j3-fff4-c8hj)authz.explainsays "you" to a service signed in as itself, as it does to a user: a relation from a column readbot: bot_id isand stopped there, and a shareviewer: shared with. It now saysbot: bot_id is you.authz.whoasked about an id that isn't one of the type's (authz.who('doc', 'abc', 'view')for a numeric key) put back neither the caller's scopes nor its principal type, nor signed again, so the rest of the transaction ran as someone else or, for a role that isn't the policy's owner, was not believed (AZ702).authz.explainfor another user left that user signed in the same way. Only administrators get that far (the app role may not inspect such an id): both now put the caller back, as they do for any other id.- A user whose id holds
:or isnobodyis now writtenuser:<id>(user:service:1) wherever rowstile names who acted, and reads back as that user: in the SDKs (Principal.parse(str(p))in Python,parsePrincipal(describe(p))in TypeScript), the audit trail,created_by(shares, links, custom roles, reviews),decided_by(requests, reviews), whatauthz.login_keyandauthz.login_jwtreturn, the invariants'user_idandrowstile diff(its rows and--users). The user whose id isservice:1was writtenservice:1, as service 1 is, and read back as service 1; the user whose id isnobodycame back as nobody. Other users are still their id (42), and other principalstype:id. (GHSA-g6h7-6vfr-xm67) - The decision log (
authz_debug.log_decisions) named a service by its bare id, as if it were the user with that id. It now names who asked as the audit trail does:service:7,user:service:1. - Every
authz.*function that takes an object's id now takes it as the key's type too, asauthz.candid:authz.share('folder', 1::bigint, 'viewer', 'user', some_uuid)said "function does not exist" where users have uuid keys, and so didunshare,create_link,create_role,roles_of,request_access,break_glassandstart_reviewgiven a uuid. A policy whose keys are all text no longer gets their bigint versions. authz.roles_of('org', '007')listed none of org 7's roles: it compared the id as written, whereauthz.create_rolestores it as7. It now reads it asauthz.candoes.authz.decide_request()with nobody signed in (a backend that forgot to sign in, an operator in psql) said "you cannot decide your own request". It now says "sign in to decide a request" (AZ714, a 401 in the SDKs).authz.sync_members()given NULL for the list removed every member of the group (a sync job's failed fetch emptied the team), and a NULL in the list failed with Postgres's not-null error from the app's table. Both are now refused, saying to list the members with no NULL (AZ710, a 400 in the SDKs); an empty list still means none.- A mask that goes gives the app role back the SELECT it had on the column. Where the app role read the table column by column (
GRANT SELECT (id, body)) and a mask tookbody, removing the mask, by applying, by a migration or byrowstile remove, leftbodyunreadable: only a table-wide SELECT was given back. And a table-wide SELECT given back by applying no longer leaves beside it the column grants the mask gave instead. - An app role named with capitals works.
app role AppUsernames the role"AppUser", as written, as a table's name is. The rules and grants went toappuser(Postgres reads an unquoted name in lower case), while masks and the named tests looked forAppUser, and failed with "role ... does not exist".authz.connection_check()didn't find a connection's role named with capitals, and said nothing of it.rowstile init --role AppUserquotes the name in theCREATE ROLEit says to run. A policy that names a role made without quotes (CREATE ROLE App_Usermakesapp_user) writes it in lower case. - An app role that is the policy's owner, or a member of it, was not reported: its sessions are believed without a signature, and it may read rowstile's tables and turn row-level security off. Applying now refuses an app role that is the role applying the policy, or a member of it (AZ624), where applying as that role stopped on
permission denied for table masked_columns.authz.lint()andauthz.connection_check()report one that became a member since. authz.lint()andauthz.connection_check()said nothing of an app role that owns a governed table once the table hadFORCE ROW LEVEL SECURITY, which lint's own message advised. An owner may turn row-level security off again: both now report it either way, and lint says the app role must not own the tables.- Applying and
rowstile removeknow rowstile's own row-level security policies by the comment that marks them, not by their names. An app's own policy namedauthz_select(orauthz_insert,authz_update,authz_delete) was dropped as rowstile's, without a word, andauthz.lint()didn't report one on a governed table. Now it stays, and lint says it isn't rowstile's. - Applying warned only of foreign keys
ON DELETE CASCADEon a table with rules. It now also warns ofON DELETE SET NULLandSET DEFAULT, andON UPDATE SET NULLandSET DEFAULT: Postgres runs these without row-level security too, so deleting a row (or changing its key) can change rows the user may not change. The warning says which action and what it does, and asks forRESTRICT(where it saidON DELETE RESTRICT) or acascade fromline.ON UPDATE CASCADEstays quiet: the row still names the same row. rowstile removeleft the app role its USAGE on schemaauthzand its EXECUTE onauthz.ctxandauthz.link_hashes, which applying gives. It now takes them back: after removing, every privilege is as it was before the first apply.rowstile removeran over a policy a newer version of rowstile applied, though an older command doesn't know everything a newer one makes and would leave some of it behind. It is refused now (AZ616), asapply,pushandmigrateare, unless told--downgrade.- The command said "no policy is applied" (AZ609) whenever the database lacked an
authz.*function it called, though a policy was applied. Now that message is only for a database without one. A policy another version of rowstile applied, without the function as this command calls it, is said with that version's name androwstile reapply(AZ626, new), or "upgrade the rowstile command" when that version is newer (AZ616). A name rowstile doesn't make, or arguments no function takes (a typo inrowstile sql), is said in Postgres's words. - A new version of rowstile that changes only what the app role is granted, or only an inheritance tree's functions (a message, an error code), is the next migration. Before,
rowstile migrate --checksaid there was nothing to do, and a database set up by its migrations kept the old grants or messages. A tree's functions are replaced in place: the tree keeps its rows. - A schema migration can drop a column no rule reads from a table with write rules. After the policy was applied, Postgres refused to drop any column of such a table ("cannot drop column ... because other objects depend on it"), and its hint,
CASCADE, would have dropped the table's insert and update policies. The functions that explain a refused write, and the policies that call them, named every column of the row; now they pass the whole row and name only the columns the rules read. A column a rule reads still can't be dropped before the policy stops reading it. - Inheritance trees whose names are longer than Postgres keeps (63 bytes; the tree is named after its types and relations) work like the others. A migration that rebuilt one whose conditions read another table failed ("cannot drop desired object(s) because other objects depend on them"), and one that swapped in a tree built beside failed ("already exists"). Applying rebuilt such a tree each time, under its lock, where it keeps the others that didn't change. And
rowstile indexesadvises a name Postgres keeps for an index on long names, so it finds, and says to drop first, what a failedCREATE INDEX CONCURRENTLYof it left unfinished. - In a tree whose inheritance conditions read other tables (
{not exists (select 1 from app.frozen ...)}), every statement on the tree's own table checked those conditions again on every row of the type, under the type's lock: renaming a folder waited for a folder's move in another transaction. Such a statement now checks them again only when a condition reads that table itself (the folder above's columns, say), and only if it wrote a row. - In a tree of several types, moving a link in its table (an
UPDATEof a placement) refreshed what was below the new link, then what was below the old one: twice the work, and two entries in the change feed. It is done once. - A condition with a string or a comment that names
authz.uid()({note <> 'set by authz.uid()'}) compared with another string inauthz.can,authz.listand the rules: rowstile rewrote the call inside the string too. Only the condition's code is rewritten now. - A condition that names a column of its row in two cases (
this.IDandthis.id) inside a subquery failed withcolumn reference "id" is ambiguous. Both are one column now, as Postgres reads unquoted names. - A condition that limits inheritance and reads another table could call
age(x)with one argument, which counts from today: the stored inheritance went stale without a word. It is refused (AZ305), and so arecurrent_schema,current_catalog,current_database(),system_user,random_normal(),gen_random_uuid(),uuidv4(),uuidv7(),authz.principal(),pg_backend_pid(),txid_current()andpg_current_xact_id(). The language reference and AZ305's page list all it refuses. A column named like one of these functions (now,random) is no longer refused. - Conditions and tests that name a column with a letter past ASCII, unquoted, read it as Postgres does (
{not archivé},SELECT année FROM ...):rowstile apply,migrate,pushandteststopped with a Python traceback (AssertionError), and nothing was applied.this.étagenames the row's column (applying stopped:missing FROM-clause entry for table "this"), the hint ford.archivénames the whole column (it saidd.archiv), the warning on a barearchivéthat a subquery's table takes is given (it was missed), andARCHIVÉis the columnarchivÉ, as Postgres folds only ASCII letters to lower case. {size > ٣}compared size with the number 3; Postgres reads٣as a column's name. Only the digits 0 to 9 make a number now.- A condition may hold
/* ... */comments, as Postgres reads them (nested, over several lines): an apostrophe or a brace in one was read as a quote or the condition's end, and the policy refused with "a { condition is missing its closing }". A$inside a name (total$$) no longer opens a dollar quote either. - Parentheses that change nothing no longer get an inheritance refused.
can view = owner or (parent.view or owner), or((owner or parent.view) and {inherit}) and not hidden, was refused as depending on itself (AZ302) or as narrowed with more than conditions (AZ304). They are now read as if the parentheses weren't there. - A deny may inherit on the same conditions as the permission it takes away, written in another order, or on fewer of them:
can hidden = ... or (parent.hidden and {inherit})beside(parent.view and {not archived} and {inherit})is taken. Where its conditions differ otherwise ({INHERIT}for{inherit}), the message shows both: it said the deny must inherit throughparent, which it did. - A mistake after the first word of a line at the left margin says how that line is written:
type folder app.foldersgets "write types as: type name = schema.table [(key)] [principal] [where {sql}]", andinclude roles.authzis told to put the file's name in double quotes. Each such line was told it didn't start withapp role,type,rules, ... although it did. - A permission line takes a tab after
can, as every other line takes one between its words. It was read as a relation and refused ("write relations as ..."), androwstile fmtrefused the file. - A block ends at an include line and at the end of its file. An included file's first lines, indented, went on with the block before the
includeline, and indented lines after it with the included file's last type: they are now refused as outside a block. An indentedincludeline says it must start at the left margin (it was refused as a relation). - A missing included file is reported as
can't find teams.authz in the policy's folder, with the name it looked for from the policy's folder. The command said to "pass it in the files argument", which it has no such thing as. - A policy that includes a file named with an apostrophe (
include "o'brien.authz") failed to apply with a bare syntax error. It applies, and the messages that name the file's lines say its name as written, a%in it too. A file whose name holds a dollar quote's tag ($f$) can't be included: the include line is refused, saying to rename the file (AZ108). - A test line names a scope as the
scopeline declares it:with scope files:writeandwith scope read-onlywere refused ("a test's lines are ..."). The editors read such names too. - A test with an empty name (
test "") is refused, and words after a test's closing quote are said to be the mistake (it said the quote wasn't closed). as ... sees N {...}refuses a statement that writes after a comment or in itsWITH(WITH gone AS (DELETE ...) SELECT ...), as it refuses one that starts withDELETE.rowstile testfailed it with Postgres's error.rowstile check(the MCP server'schecktoo) and the editor report a mistake in the policy's own test lines, asrowstile testdoes: a test naming a type, a permission or a scope the policy doesn't have read asokthere.- Error pages and messages say what the compiler does. AZ302 no longer calls a permission inheriting across types (projects and folders inside each other) a mistake; AZ306 says conditions may join the inheritance beside the deny; the error codes' index says that an error the app meets at run time carries its code in its HINT, not at the end of the message. AZ502 names the types that sign in without "one of" a list of one, and messages no longer say "a org".
rowstile fmtlays out a condition whose string, quoted name or dollar quote goes on to a line that starts with--: that line is in the quote, not a comment. fmt refused such a policy, saying formatting would change what it says. And a run of spaces inside a quote counts: the lock file's lines, and fmt's check that it changes nothing, read'a b'and'a b'as two things.rowstile prove's counterexample, and the world the review shows when a change is no refactor, say what the world holds as you would make it. A share touser:*read as a share to one user (folder 1 -> user 1); it readsfolder 1 -> user:*. The rows each type'swherekeeps are said ({active} holds for user 1 (the type's where)), and making the world smaller no longer takes away the value a kept row needs (active = true): the user shown looked suspended. The custom roles given are listed (doc.roles with view: doc 1 -> user 1), andanyonereadsanyone, notanyone *. The review's world is made as small as it still grants otherwise in, as prove's is: no link that plays no part. "after 1 worlds" reads "after 1 world".rowstile proveand the review read two texts compared with one column as two values, so{status = 'Public'}and{status = 'public'}never held on one row there. A column under a case-insensitive collation holds both, and prove said an invariant held that the data broke. Texts a column may hold as one value (the same but for case, accents, spaces or punctuation; two that name numbers or dates; letters past ASCII) are now left to the database there, as a subquery is: prove draws the rows each holds for, and the review says it can't compare a change between them. Different words ('draft','published') are still read as two.rowstile reviewflags more of what widens access. A rule that reads a relation's permission itself (insert : folder.edit) changes through that relation, asselect : viewdoes: repointingfile.folderto another column now flags who may insert. Ashared ifremoved or changed, and a caveat changed, are flagged. A plainupdate afterremoved is no longer called a column rule: it is flagged where theupdaterule, which then checks in its place, lets more rows through; a new one is flagged where it lets more through thanupdatedid.rowstile review's Deploy names the tables a migration finds only as it runs, and the mode it locks them in: the tables an inheritance condition reads, and the partitions and child tables of the governed ones. It said "Locksapp.folders" while the migration also lockedapp.settings, which a condition read.- The comment
rowstile review --markdownwrites shows Meaning's example when a change thought a refactor isn't one: what differs, for whom, on what, and the world that shows it, as the text output says. A failed test without a line or a detail reads- fails: a test, not- fails: a test :and two backquotes. rowstile reviewchecks a change that looks like a refactor in seconds on a policy with many types. The small worlds it lists counted rows of every type, also those the change doesn't read: with 14 types, a permission rewritten asowner or ownertook almost four minutes, and each more type about four times as long. Only the types the change reads vary now, and the listing gets further in the same number of worlds.- The review's GitHub action passes on a pull request from a fork. GitHub gives such a pull request a read-only token, so the comment was refused and the job failed. Now the review is in the run's summary, and a notice says so.
- A review longer than a comment may be is cut, and the comment says where the whole review is: the run's summary on GitHub, the job's artifact on GitLab. GitHub refused a comment over 65,536 characters, and the GitLab job failed ("Argument list too long") on a review over 128 KiB.
- The GitLab template's header said a top-level
ROWSTILE_VERSIONpicks another release. GitLab gives the job's own variables first, so it was ignored. It now shows how to set it, and the stage, in the job, and says to setROWSTILE_REVIEW_TOKENin the CI/CD settings, not in the file. rowstile initread the columns a primary key or unique index INCLUDEs as part of the key. A table withPRIMARY KEY (id) INCLUDE (title)was drafted as keyed by(id, title): a users table so declared was refused (AZ622), and foreign keys to such a table gave no relation.authz.lint()likewise said the app role may choose a primary key the database makes when it may write a column the key's index INCLUDEs. Both read the key's own columns now.rowstile indexesandauthz.lint()counted an index's INCLUDE columns as if the index were sorted by them. An index on(parent_id) INCLUDE (parent_type)was said to serve a lookup by(parent_type, parent_id), so a lookup with no index could go unnamed. Only an index's key columns count now.rowstile initstopped with a Python traceback (KeyError) when the table the columns naming users point to wasn't among the drafted ones: in another schema (as Supabase'sauth.users, with--schema public), or left out for its name. It now says which table, which columns point to it, and what to do: draft its schema too, or name the table with--users.rowstile initnotes that a membership'spermissionorpermissionscolumn may say who does more, as it did forrole,kind,levelandaccess.rowstile init --helpsays it drafts from every schema of the app's when--schemanames none (it saidpubliconly).rowstile init --outrefuses an absolute path or one outside the folder, before writing anything (exit 2): every later command refused therowstile.tomlit wrote. A folder name holding"or\is written escaped, sorowstile.tomlstill reads.rowstile initfinds goose, dbmate and Flyway: their markers in a migrations folder's files, Flyway's names (V1__init.sql), or the folderflyway.tomlorflyway.confnames. It took them for plain SQL, and the filesrowstile migratethen wrote were refused or skipped. Files named for a tool rowstile writes none for (1_init.up.sql) leave[migrations]out ofrowstile.toml, and init says so. It reads Drizzle'sout: "../shared/drizzle"as written (it readshared/drizzle, and a key ending inout,layout:, asout), and marks a migrations folder that isrowstile.toml's own/*_authz_*in.gitattributes(./*_authz_*matched nothing).rowstile migratefor goose, dbmate and Flyway names its file with the number after the folder's last when that one is numbered (00003_,003_,V3__), as it did for plain SQL. It used the time, and the app's next migration, numbered after its own, then came below one applied already: goose, Flyway anddbmate --strictrefused it. Plain SQL files take the time after a folder whose last file starts with the time.rowstile sql --as WHO "COPY t FROM STDIN"waited for good, with a transaction open on the server. The copy now fails at once: "COPY from stdin failed: the rowstile command sends no rows to COPY FROM STDIN (psql's \copy does)".- An empty
--db(a script's--db "$DATABASE_URL"with the variable unset) stopped with a Python traceback. It now says--db is empty, exit 2, as an empty value of any option does. - The command connects as libpq does where it didn't.
sslmode=prefer(the default) tries again without TLS when TLS fails (a~/.postgresql/root.crtthat didn't sign the server's certificate) or the server refuses the session over TLS.sslmode=allowtries without TLS first.connect_timeout=0, or less, waits as long as it takes (it meant 10 seconds, and-1was refused). What still differs is named in the tools reference: no password file, 10 seconds whereconnect_timeoutisn't given, and no client certificate. - The command's connection messages: a port out of range (
postgresql://h:70000/app,port=0) is said as such (a URL's was blamed on a#in the password). A password stays out of them: a refused setting that holds a secret (scram_client_key,scram_server_key,oauth_client_secret) is named without its value, and the rest of a password with a space in it, unquoted (password=my secret), isn't repeated. When the server asks for a password and none was given, the error says where to give one, and that the command reads no password file such as~/.pgpass. - When the server closed the connection without a word (it crashed, a proxy dropped it) while a statement was on its way to it, the command said
lost the database: [Errno 104] Connection reset by peer. It now sayslost the database: the server closed the connection, as it does when the server closes between two statements. When the server said why first (the session was ended, it is shutting down), those words are still what the command says. - The MCP server (
rowstile mcp) answers a call whose arguments a tool refuses (one missing, null, or one that reads as an option, such as--development) with the tool's failed call (isError, exit code 2, the reason in its text), as MCP 2025-11-25 asks, so that the agent sees why and corrects the call. It answered with a protocol error, which a client may keep from the agent. A call whoseargumentsisn't an object is a protocol error now, where the tool ran as if it had none. - The language server checks an open test file again when the policy changes: renaming a permission in the policy marks the test lines that still name it, where they kept their old diagnostics until the test file itself changed. A mistake in the policy, seen from a test file, is said on the test file's first line with the policy's file and line (
policy.authz line 7: ...), where it sat on the test file at the policy's line. It clears a closed file's diagnostics, which an editor kept showing, and checks the open files again when the policy's file is closed with changes not saved. Find references searches the policy's included files and the open test files, not only the file it is asked in. - The language server counts columns as editors do (UTF-16 code units): after an emoji on a line, hover, completion, go to definition and the underlined words were one column off. A message it can't read (a body that isn't JSON, a
Content-Lengththat isn't a number) is answered with a parse error, and the server goes on. It ended, and the editor lost errors and completion. - The editors read more policies as the compiler does. Zed, Helix and Neovim showed a parse error on a condition holding
"a}b","it's",E'it\'s',$$}$$, a/* } */comment, or a--comment with a brace or an apostrophe in it; on a column namedbeforeorafter(update before before : edit, as the compiler's own message suggests); and on a test id with a$inside (user a$b can view file 1). In VS Code and on the site,beforeandafterat the end of an update rule's columns are coloured as words of the language, not as columns;testandinvariantsfollowed by a comment keep their colour; anduser:*(any type's),principal,include "roles.authz", a link table's name with itsobject:andsubject:, and test lines whose id is quoted with a space are coloured. VS Code movestype,rulesand the other first words back to the margin when typed on an indented line, and closes[and". - The VS Code extension builds from the repository as its page says (
npm run packageineditor/): it stopped on a missingLICENSE. The link on its Marketplace and Open VSX page, to installing the command, leads to that page again. When the language server doesn't start, the extension (0.1.3) says why, and how to install rowstile or setrowstile.command, where it only said it couldn't connect. A change torowstile.commandstarts the server again with it; it needed a window reload. - The editors' page says how to point VS Code and Zed at a
rowstileinstalled in the project (npm'snode_modules, a.venv): such an install isn't on the PATH the editor starts the server with. Its Neovim steps highlight: they now build the grammar, put it where Neovim looks and start highlighting, and say Neovim 0.11 or newer. Paths into the repository saycore/cli/, and Sublime Text is no longer said to read the TextMate grammar as it is. - Studio's grid showed a table's rows in the order of their ids as text: with numbered rows, 1, 10, 100, 101, ... 11, page after page. They now come in the key's own order, 1, 2, 3. Studio listed the tables, so two types over one table (a table with no rules may be read as several) showed as one, with one type's permissions under the other's name. It now lists the types, each with its table.
- In a Studio that can write (
--write,rowstile dev), why and the access diff ran in a transaction that was committed, though each change they try is undone. They are now rolled back whole: nothing they try stays. rowstile whyand Studio listed a change both as the best way to grant a permission and as "could not be tried", when the change grants it but counting what else it gives failed (a condition that fails on another row, say). It is now listed only as not tried, with the database's reason: what else it gives was never counted.- Studio's page: in the Tables tab each row's cells sit under their headings again (each row was laid out as a flex box, its cells bunched apart from the columns). "Why?" while viewing as anyone says to pick someone, where it showed "Asking…" for ever. Clicking a type or a permission in the graph shows how it is written (nothing happened). The page asks for the policy again when a tab or a table is opened, so under
rowstile deva permission added or renamed since the page opened is offered. The shares show a custom role's name (notrole:<id>), a caveat, and when a share starts; a request shows for how long approving gives it. A share link has no Unshare button: it removed nothing and said "Done". The page saysauthz.revoke_linkturns a link off, and Studio refuses to unshare a link. The graph uses the playground's Mermaid (12.0.0), checked against its hash. - The generated Python client named each type's permissions with its name in lower case after the first letter:
orgUnitgaveOrgunitPermission, and two types whose names differ only in case,docandDoc, both gaveDocPermission, the second replacing the first. A type's alias now keeps its name as written (OrgUnitPermission), and two types that would get the same one get none, with a comment that says why. - Both SDKs read Postgres's own refusals for what refused. An update after which the user could no longer see the row was a 403 that spoke of reading an insert back; it now says the user may not see the row as written (the select rule). In Python, an upsert (
INSERT ... ON CONFLICT DO UPDATE) of a row the user may not change named the select rule; it names the update rule, as in TypeScript. AMERGEthat matched a row the update or delete rule hides was no refusal at all (a 500); it is a 403 with no command, since Postgres doesn't say which rule. And in Python a refusal by a restrictive policy rowstile didn't make is no longer read as the select rule's: it stays the database's error, as in TypeScript. - TypeScript: inside
transaction(fn, who)(@rowstile/pg,@rowstile/drizzle) andbegin(fn, who)(@rowstile/postgres), the object's own calls (a.expect,a.can,a.share,a.query, ...) run in that transaction, aswho, andfnacts forwho. They ran in a transaction of their own on another connection, signed in as whoever the code around acted for (or theuserfunction, or nobody):a.expectgave the reason for someone else, nothing saw what the transaction had written, and on a pool of one they waited for ever. (GHSA-3vph-6725-7vhw) @rowstile/prismareads a compound key's fields in the key's order, which its name gives (project_id_user_id), not in the order thewherelists them:{ user_id: 2, project_id: 1 }was asked about row(2,1), so an update could be a 404 where it is a 403, or name the wrong row. A key given a name of its own (@@id(name: ...)) names no row unlessauthz({ keys })gives its fields.@rowstile/drizzleon node-postgres listens for a lost connection while a transaction holds one, as@rowstile/pgdoes: a database that restarts mid-transaction fails the transaction, where it stopped the process.@rowstile/reactworks in a Next.js server component, such asapp/layout.tsx: the package is a client module ("use client"). Rendering<AuthzProvider>or<Can>there failed the build, which asked for"use client"in a file of the app.rowstile.fastapiwith no engine,Rowstile(app, None, user=...)(an app on psycopg or asyncpg without SQLAlchemy), answers the drivers' errors as it answers SQLAlchemy's: a refused write 403, and each code as its page says. They were a 500.rowstile.fastapianswers an ORM update the rules allow that matched no row (the row changed since it was read: a version counter) with 409, where it answered 404 "the row not found". Where it can't tell (a model mapped to a join), it leaves theStaleDataErrorto the app.- A refused ORM update is explained from the flush's own transaction, before it is rolled back. A row that transaction had written answered 404, since another transaction can't see it; with a pool of one connection that the request's session still held, the answer waited for the pool and failed with a 500. A flush of more than 20 rows of a table was asked about its last 20 only (a 404 when the refused row came earlier), one query each: every row is asked about now, in one statement.
NotFound()without a table says "not found", andNotFound(id_=7)"row 7 not found" (it said "the row not found").rowstile.alembic.include_objectsaid it left out the masked views rowstile makes. It leaves out a model whose table says so,info={"rowstile": True}: the FastAPI page and the SDK's README now say to mark a model of a masked view that way.- The Python SDK's docs no longer offer
pytest_plugins = ["rowstile.testing"], which stops pytest once the package's entry point has loaded the fixtures.ids()says a uuid key takeskey_type=Uuid(withNonethe ids are text, which a uuid column can't be compared with), and that a key of several columns can't use it. - The npm launcher asks the Python
ROWSTILE_PYTHONnames for its version first, as it asks the one onPATH: one older than 3.11, or a path that isn't a Python, is refused with a sentence, where the command failed inside. A bundled Python that isn't executable and can't be made so (anode_modulesanother user installed) is said to be so, not to be missing.ROWSTILE_PYTHONhas its line in Installing and Troubleshooting. - The packages hold the command's files and nothing else: the npm package's build copied
core/authzliband Studio's folder whole, and the Python package's wheel and sdist took any file beside them, so a file left there (a note, an editor's backup) went in. Both now take the files one list names. A release publishes on PyPI and on the VS Code Marketplace the files its GitHub release attaches and attests (the wheel, the sdist and the.vsixwere built a second time for those), and a patch to an older line no longer becomes the repository's latest release on GitHub. - The tools reference lists every option each command takes (
migrate --tool --dir --one-phase --downgrade,diff --limit,bench --people --rounds,init --role --out,snapshot --out, and the others), everyrowstile.tomlsetting ([migrations] lockandwrite_after,[review] snapshot,[clients] ts), the exit codes, and which foldermigrate --dirand--outare read from.rowstile --helpnamesreview's policy argument and[review] snapshot, and says which policygraphdraws. - The reference's list of the generated Python client's calls left out
sign_in_as,principal,connection_checkand the API key calls, and it said the TypeScript client had the same calls, which it doesn't quite (noprincipal, signing in withasUser). It now lists each client's calls, and which calls the TypeScript SDK has. Its table of functions namesauthz.perms_ofandauthz.connection_check. - The policy language page's example applies as written: its
shared ifcondition had...in it, which no database runs. It says what an include may name (a file in the policy's folder, once). The identity page and the threat model nameview_asamong what signs a session in; the identity page no longer says the SDKs sign in with a key. The operations page says to make the roles first when restoring on a new server (pg_dumpkeeps none), and the OpenFGA and SpiceDB pages name the line their policy needs before its editors can be shared. - The docs didn't say that a write rule checks each row against the tables as the statement found them, so a count in a rule is no limit on how many rows there may be: with
insert : {(select count(*) ...) < 2}, oneINSERTof three rows writes all three. The limits page says so now, and what to use instead (a unique index, or a trigger). The messenger example relied on such counts: oneINSERTcould put three people in a direct chat, or two owners in a new group. Its schema now holds both. - The stack pages' code no longer takes the signed-in user from a request header. The Next.js and FastAPI pages showed the conformance apps' stand-in, a header any client can set; they now show the user coming from the app's session (
auth()in Next.js, the app's ownsession_userin FastAPI). The Next.js page's install line has@rowstile/pg, which its live updates import, and the FastAPI page's code importsosandrowstile, which it uses. - Three cookbook recipes gave more access than their pages said. In roles per organization, a document's owner could move it into another organisation, or make one there, and its members saw it: its organisation now can't change (
update org_id : nobody). In tenants, a ticket assigned to someone of another organisation was theirs to read and edit: the assignee now holds it only as a member ((assignee and org.member)), and an invariant says no one outside sees a ticket. The multi-tenant page says that someone in two organisations may move a project across, and how to forbid it. The language reference says which movesauthz.lint()warns about. A policy copied from these recipes wants the same change. - Each cookbook page said to take the recipe's files and run
rowstile dev, which stopped at "which policy file?". Each recipe's folder now has arowstile.tomlthat names its policy and its tests, and the cookbook says the steps: loadschema.sqlandrows.sql, then runrowstile dev. The recipes' tests now check what their pages say: someone with a link sees the document, a share starts and ends when it says, an approved request ends after the time asked for, nobody decides their own request, asking for a document that doesn't exist goes as asking for a hidden one, a private folder's owner keeps it, and teams count three deep and in a loop.rowstile dev --helpshows that it takes a policy file. - The page on files in S3-compatible storage (
docs/signed-urls.md) uploads as the file manager does: the browser sends the bytes to a place of their own (uploads/<key>), and confirming the upload moves them to the file's object and checks their size. The page signed the upload for the object's own key: that link goes on working after the confirm, so it could replace a confirmed file, whose stored size was then wrong. - The docs app's own tests (
core/example) pass on its own data, as their header says: 3 of their checks needed shares that only the end-to-end scenario made, and are now a named test that makes them. The playground's docs example shows the policy's tests too. - The playground goes on after an edit that follows an answer: the tests run again and the question is asked again. It stopped there for good, and Run did nothing until the page was reloaded. A step that fails no longer stops the ones after it, and an answer with a large
int8in an array (ARRAY[9007199254740993::int8]) shows. Asking after a failed run says the policy isn't applied, not that the last policy's role doesn't exist. An answer whose statement ranCOMMIT,ROLLBACKorRESET ROLEsays it wasn't rolled back, or which role it ended as (after aCOMMIT, the rest ran signed in as nobody). The Help pane shows an error page's examples as code. A link the page can't read says so until another example is chosen, and a page whosebundle.jsondoesn't load says why, where it said "loading…" for ever. - The site's links to the repository's files go to the release it shows, not to
main, where a file may have moved or changed since. Its headings' anchors are GitHub's (#what-a-0x-release-promises), so a link to a heading written for GitHub finds it on the site too. The card a shared link shows is drawn with fonts kept beside it (Inter, JetBrains Mono), so it looks the same whichever machine renders it. - The blog post's
experiment.sqlstopped at its first query when run by a role that isn't a superuser (permission denied to set role "demo_app"): it now grants that role to whoever runs it, so a role with CREATEROLE runs it on a stock server too. Its header says it drops an earlierdemoschema anddemo_approle first, and to read the middle of each query's three timings, as the post's figures are. - The file manager example: its development steps work as written, as the messenger's do (the README waits for the services, runs the frontend from its own folder and says
npm ci), and its README names each setting with its default, the maintenance jobs to schedule and each part of the backend.migrate.pyruns outside this repository: it needs the command only for--client, and there it runs the one installed. The app's image no longer copies the command, andtest.shtakes the database and storage down when a step stops the run early. - The file manager example's rules and API: moving a folder takes the right to share it, as deleting it does (an editor could move a folder into one of their own, which gave them
shareon it and took it from everyone who reached it from above). Two uploads committing at the same time could together pass the storage quota; the second now waits for the first.FM_MAX_UPLOAD_BYTESholds for the bytes an upload sends, not only for the size it claims. Its errors say what is wrong, from the constraint's name ("the folder isn't empty" was said of a group with sub-groups and of a member who has no account). Search pages by name then id, each list with its own cursor: a page that ended among equal names skipped the rest of them. The app waits for RustFS to answer before it starts. - The file manager's web app shows a file's Share, Rename, Move and Delete, a folder's Rename, and a file's "Upload a new version" and "Make current" only where the API says the user may (
can_edit,can_sharein each listing, fromauthz.can), and a folder's Share, Move and Delete only to those who may share it: they showed where they could only fail. Search shows "More" (it stopped at 50). A share link was listed twice in the share dialog. A share or link "until" a day lasts to the end of that day where the person is (it ended as that day began in UTC). A request's duration reads "7 days", not "P7D". Cancel on "Why not?" no longer denies the request, and a preview's Download or "Leave this group" that fails says why. - The messenger example: its development steps work as written (the README gives the two settings
db/migrate.pyneeds andnpm cibeforenpm run dev), andmigrate.pyruns outside this repository, as the file manager's does. An open chat loaded its messages again and again, each load marking the chat read and telling every member's browser to load it too: it now loads once per change. Its database is published on 127.0.0.1 only, and its migrations, policy and tests run as the tables' owner (ms_owner), not the superuser. - The messenger example's rules and API: a group's owner could leave it through the API, and the group, without an owner, could never be deleted; the owner now stays, and deletes the group instead. Marking a message "edited" without editing it is refused. An admin who opened their own group's invite link was told it didn't work. A negative
limit, or a number past bigint's range, answered 500 (now 422 or 400). The chat list counts unread messages from their numbers (it read each one: 5.5 s for 100,000). A direct chat whose other person left no longer disappears from the list, and a button whose request failed says why. - Some things only the alphas' release notes said are now in the docs: the SDKs'
not_signed_in(e)andnotSignedIn(e)(the not-signed-in error, AZ701, and not a refused login),db.$authz.tableName()and the Python SDK'sverdict(..., named=); theCREATE INDEX CONCURRENTLYthatrowstile indexesgives goose and dbmate in a migration of their own, a partitioned table's index without it, and the unfinished index a failed build leaves, named first; thatrowstile prove --worlds Ntries more worlds than N; whatrowstile sql --assays of a write that changed no row; and a key that two rows hold through a table that inherits (the limits page). - A relative link in a release's notes on GitHub (
[Installing](docs/installing.md)) led nowhere: the release's page reads it from its own address. The notes now link to the file at the release's tag.
Before the beta
The alphas, from 0.1.0-alpha.1 (2026-10-04) to 0.1.0-alpha.9 (2026-10-19), were for trying rowstile early. The first was published as rowfence; from 0.1.0-alpha.2 on the project is rowstile, as another product, a proxy for DuckDB, had the name first. The beta starts afresh: it doesn't upgrade a database an alpha made, and it reads none of the names from before the rename (see what a 0.x release promises). Each alpha's notes are on its GitHub release:
- 0.1.0-alpha.9 (2026-10-19)
- 0.1.0-alpha.8 (2026-10-19): tagged, and never published (its release run stopped before publishing)
- 0.1.0-alpha.7 (2026-10-13)
- 0.1.0-alpha.6 (2026-10-07)
- 0.1.0-alpha.5 (2026-10-06)
- 0.1.0-alpha.4 (2026-10-06)
- 0.1.0-alpha.3 (2026-10-05)
- 0.1.0-alpha.2 (2026-10-04)
- 0.1.0-alpha.1 (2026-10-04), published as rowfence