@supabase/lite 0.5.0 → 0.5.1-next.1

package/LIMITATIONS.md

@@ -36,6 +36,10 @@ Anchors below point to the corresponding STATUS.md section. If a limitation here
 
 Most SQLite-only limitations above do not apply. `rpc()`, ranges, regex, quantified comparisons, full-text search, and native `DEFAULT auth.uid()` all work on the Postgres path. See per-section status tables in [STATUS.md](https://github.com/supabase-community/lite/blob/HEAD/STATUS.md).
 
+- Custom domain types (data representations): read/`RETURNING` output formats via the domain's `CAST(… AS json)`, and mutating JSON values **into** a domain column (epoch→`timestamptz`, base64→`bytea`, decimal-string→`numeric`) is converted on the Postgres path. Remaining gap: domain formatting through cross-relation embeds. See [Translated Field Types](https://github.com/supabase-community/lite/blob/HEAD/STATUS.md#translated-field-types).
+- Postgres sessions run in **UTC** by default (so `timestamptz` rendering is deterministic regardless of the server's host timezone). Override via the `postgresOptions.connection.TimeZone` connection option. See [Translated Field Types](https://github.com/supabase-community/lite/blob/HEAD/STATUS.md#translated-field-types).
+- Embedding **through views** resolves for views whose FK column is a plain projection of a base-table column — including **materialized views** and **multi-level recursive view-of-view** chains (the column mapping is composed across each hop to the underlying base table). Views whose FK column is not a plain projection (CTE, GROUP BY, subselect-in-FROM, or any JOIN view) are still not traced. View-FK resolution matches relations by **bare name**: if two exposed schemas expose a relation with the same name, an embed through a view may resolve against the wrong one — keep colliding names out of co-exposed schemas, or embed via an explicit FK/constraint-name hint.
+
 ## Anti-patterns
 
 Common ways code goes wrong against supalite. The fix for each is the corresponding bullet above.

package/STATUS.md

@@ -156,6 +156,8 @@ CREATE TABLE orders
 
 Unsupported PostgreSQL data types currently include `oid`, `xid`, `xid8`, `cid`, `money`, `citext`, `cidr`, `macaddr`, `macaddr8`, `bit`, `bit varying`, `varbit`, geometric types (`point`, `line`, `lseg`, `box`, `path`, `polygon`, `circle`), `xml`, text-search types (`tsvector`, `tsquery`), range and multirange types, `reg*` catalog reference types, internal types (`tid`, `pg_lsn`, `internal`), pseudo-types, and handler types.
 
+**Custom domains & data representations.** On the Postgres path (PGlite/PostgreSQL), a column typed as a domain that defines `CAST(<domain> AS json)` (the PostgREST "data representations" feature) renders through that cast on reads and `RETURNING` — e.g. a `unixtz` domain over `timestamptz` returns epoch seconds, a `monetary` domain over `numeric` returns a fixed-precision string. On the SQLite path the known representation types (`color`, `unixtz`, `isodate`, `monetary`, `bytea_b64`) are handled by built-in field shims. Mutating JSON values **into** a domain column (epoch→`timestamptz`, base64→`bytea`, decimal-string→`numeric`) is converted on the Postgres path via `buildDomainInputValue`. Not yet handled: domain formatting through cross-relation embeds. Postgres connections run with `TimeZone=UTC` by default so `timestamptz` rendering is deterministic regardless of the server's host timezone; override via the `postgresOptions.connection.TimeZone` connection option.
+
 ### Column Defaults
 
 Column `DEFAULT` expressions in Postgres DDL are evaluated by the SQLite translator at CREATE TABLE time. Only constant expressions and a small allow-list of functions are honored.
@@ -428,6 +430,8 @@ Supported natively on the Postgres / PGlite path.
 | `throwOnError()` | ✅      | ✅        | JS error mode                         |
 | `maxAffected()`  | ✅      | ✅        | Check `changes()` after execution     |
 
+**CORS / `OPTIONS` preflight:** Handled across `/rest/v1`, `/auth/v1`, and `/storage/v1` (not a supabase-js method, so excluded from the counts below). Each surface matches its upstream service: on `/rest`, `OPTIONS` follows PostgREST semantics — `200` with CORS headers for a known table, `404` (PGRST205) for an unknown one — and never requires auth (preflight succeeds even when anonymous access is disabled); `/auth` mirrors GoTrue's `204` preflight (reflected method, credentials, wildcard origin); `/storage` answers preflight with `204`. Origin is `*` (matches the Supabase CLI), and `Content-Range`, `Content-Location`, and `Preference-Applied` are exposed via `Access-Control-Expose-Headers`.
+
 ### Control & Specialized
 
 | Method            | SQLite | Postgres | Notes                                                 |
@@ -840,8 +844,8 @@ PostgREST spec status (`cd app && bun run test:spec:status`):
 
 | Backend | Total | Passing | Pass % | Skipped | Skip % | Failed |
 |---------|------:|--------:|-------:|--------:|-------:|-------:|
-| Postgres | 2,460 | **1,923** | 78.2% | 537 | 21.8% | 0 |
-| PGlite | 2,460 | **1,933** | 78.6% | 527 | 21.4% | 0 |
+| Postgres | 2,460 | **2,339** | 95.1% | 121 | 4.9% | 0 |
+| PGlite | 2,460 | **2,347** | 95.4% | 113 | 4.6% | 0 |
 | SQLite | 1,702 | **1,677** | 98.5% | 25 | 1.5% | 0 |
 | SQLite-Postgres | 1,702 | **1,677** | 98.5% | 25 | 1.5% | 0 |
 

package/dist/{Connection-DF_xKWko.d.ts → Connection-DJbw6dM8.d.ts}

@@ -129,6 +129,8 @@ interface RpcAST extends BaseAST {
     type: "rpc";
     function: string;
     args?: object | unknown[];
+    /** Embed joins, when `select=` embeds related tables on a `SETOF <table>` result. */
+    join?: JoinMap;
     where?: Where;
     order?: OrderEntry[];
     limit?: number;
@@ -282,6 +284,13 @@ interface ColumnInfo {
     } | null;
     is_identity: boolean;
     pg_type?: string;
+    /**
+     * Schema of the column's data type (information_schema `udt_schema`). For a
+     * composite/enum/domain typed column this is the schema the *type* lives in,
+     * which can differ from the table's `schema` — used to resolve the type
+     * against `custom_types` without cross-schema false matches. Postgres only.
+     */
+    udt_schema?: string;
     is_generated?: boolean;
 }
 interface IndexInfo {
@@ -352,6 +361,46 @@ interface CustomTypesInfo {
         type: string;
     }[];
 }
+interface FunctionInfo {
+    schema: string;
+    name: string;
+    /** Input parameter names, in declaration order. Empty for unnamed-param functions. */
+    arg_names: string[];
+    /** Input parameter type names (format_type), aligned with proargtypes order. */
+    arg_types: string[];
+    /** Count of trailing input params that have a DEFAULT (pronargdefaults). */
+    arg_defaults: number;
+    /** True when the function has a VARIADIC parameter. */
+    has_variadic: boolean;
+    /** provolatile: 'i' immutable, 's' stable, 'v' volatile. */
+    volatility: string;
+    /** Formatted return type (e.g. "integer", "SETOF" is conveyed via return_is_setof). */
+    return_type: string;
+    /** proretset — function returns a set (SETOF / TABLE). */
+    return_is_setof: boolean;
+    /**
+     * prorows — planner row-count estimate. A SETOF function declared `ROWS 1`
+     * has prorows === 1, which PostgREST reads as a to-one computed relationship.
+     * SETOF without ROWS defaults to 1000; non-set functions to 0.
+     */
+    return_rows?: number;
+    /**
+     * pg_type.typtype of the return type: 'b' base, 'c' composite, 'd' domain,
+     * 'e' enum, 'p' pseudo (record/void), 'r' range, 'm' multirange. 'c'/'p'
+     * indicate a row/record (object) result rather than a scalar.
+     */
+    return_typtype: string;
+    /**
+     * When the return type is a domain ('d'), the formatted name of its underlying
+     * base type (pg_type.typbasetype via format_type) — e.g. a `"text/plain"`
+     * domain over `text` carries `return_base_type: "text"`. Empty/undefined for
+     * non-domain returns. Used to decode a media-type-domain RPC result as raw
+     * text vs raw bytea. See server/data/response/media-domain.ts.
+     */
+    return_base_type?: string;
+    /** True when the function has OUT/INOUT/TABLE output columns (object-shaped result). */
+    has_out_args: boolean;
+}
 type IntrospectOptions = {
     exclude_tables?: string[];
     name?: string;
@@ -369,10 +418,39 @@ interface IntrospectResult {
     comments: CommentInfo[];
     custom_types: CustomTypesInfo[];
     triggers: TriggerInfo[];
+    /** Stored functions/procedures. Populated on the Postgres dialects only. */
+    functions?: FunctionInfo[];
+    /**
+     * Individual table partitions and their partitioned parent. Populated on the
+     * Postgres dialects only. Partitions are hidden from `tables`/`foreign_keys`
+     * (like PostgREST), so this carries the partition→parent mapping used to emit
+     * the "Perhaps you meant '<parent>'" hint when a partition is requested.
+     */
+    partitions?: {
+        name: string;
+        schema: string;
+        parent: string;
+    }[];
     database_name: string;
     version: string;
     ddl_dialect?: "postgres" | "sqlite";
     schema_separator?: string;
+    /**
+     * The API's configured default schema (PostgREST `db-schemas` head). Used to
+     * resolve schema-sensitive catalog lookups (e.g. computed relationships/
+     * columns) for requests that omit `Accept-/Content-Profile`, where the
+     * deparser's `currentSchema` is undefined but the DB still reads this schema.
+     */
+    default_schema?: string;
+    /**
+     * Valid time-zone names from `pg_timezone_names`. Populated on the Postgres
+     * dialects only and cached with the rest of the introspection. Mirrors
+     * PostgREST's cached `TimezoneNames`: a `Prefer: timezone=` value with
+     * `handling=strict` is rejected (PGRST122) unless it is a member. Absent on
+     * sqlite (no such catalog), where the preference stays lenient. Stored as an
+     * array (not a Set) so it survives the JSON schema-cache round-trip.
+     */
+    timezones?: readonly string[];
 }
 interface TableDiff {
     type: "added" | "removed" | "modified";
@@ -504,6 +582,21 @@ type TransactionOptions = {
 };
 type ConnectionContextOptions = {
     forceRollback?: boolean;
+    /**
+     * Present for RPC (`/rpc/*`) requests on the postgres backend only. Forces the
+     * call into one explicit transaction so request.* GUC injection, GET read-only
+     * mode, and the function's transaction-local response.* GUCs (read back by the
+     * handler) are atomic. Without it, the common anon path runs with no
+     * transaction and `set_config(...,true)` would be lost before the read-back.
+     * Ignored by the base/sqlite pass-through `withContext` (RPC is rejected on
+     * sqlite at server/data.ts, so sqlite never constructs this).
+     */
+    rpc?: {
+        method: string;
+        path: string;
+        readOnly: boolean;
+        requestHeaders?: Record<string, string>;
+    };
 };
 declare class RelationNotFoundError extends Error {
     readonly schema: string | undefined;
@@ -558,6 +651,29 @@ declare abstract class Connection<Driver = unknown, DB = any, Config extends ICo
      * Default: pass-through.
      */
     withContext<T>(_vars: VarsContext | undefined, fn: (db: Kysely<any>) => Promise<T>, _opts?: ConnectionContextOptions): Promise<T>;
+    /**
+     * Whether this connection serves RPC (stored functions). SQLite-backed
+     * connections have none; the data route uses this to gate `/rpc/*`.
+     */
+    get supportsRpc(): boolean;
+    /**
+     * OPTIONS write-capability for a view, resolved from the catalog. Returns
+     * `null` when the dialect cannot introspect view updatability via SQL (e.g.
+     * SQLite, where the caller derives it from `INSTEAD OF` triggers instead).
+     * Overridden on the Postgres path.
+     */
+    viewOptionsMetadata(_viewName: string, _viewSchema: string): Promise<ViewOptionsMetadata | null>;
+}
+/** Catalog metadata for a view used to build an OPTIONS `Allow` header. */
+interface ViewOptionsMetadata {
+    canInsert: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+    /** Base relations the view reads from, for scoping the PK check. */
+    baseTables: Array<{
+        schema: string;
+        name: string;
+    }>;
 }
 
-export { type QbUpdate as $, type AnyAST as A, type BaseAST as B, Connection as C, DataLossError as D, type EmbedDef as E, type FiltersResult as F, type InsertAST as G, type HeadersResult as H, type IConnectionConfig as I, type IntrospectOptions as J, type JoinDef as K, type JoinMap as L, type Meta as M, MigrationError as N, type OrderEntry as O, type PlanResult as P, type PlanStep as Q, PlanStepType as R, type PreferToken as S, type TransactionOptions as T, type PrimaryKeyInfo as U, type VarsContext as V, type Where as W, type Qb as X, type QbDelete as Y, type QbInsert as Z, type QbSelect as _, type IntrospectResult as a, type QueryAST as a0, type QueryParamsResult as a1, RelationNotFoundError as a2, type RouteResult as a3, type RpcAST as a4, type RpcResult as a5, type SchemaDiffResult as a6, type SelectEntry as a7, type SelectResult as a8, type TableDiff as a9, type TableInfo as aa, type TextSearchValue as ab, type TransformsResult as ac, type TranslatorConfig as ad, type TriggerInfo as ae, type UniqueConstraintInfo as af, type UpdateAST as ag, type UpsertAST as ah, type UpsertResult as ai, type ViewInfo as aj, type WhereValue as ak, isRef as al, type CacheDriver as b, type CacheSetOptions as c, type AST as d, type ASTType as e, type AggregateFunction as f, type BodyResult as g, type CheckConstraintInfo as h, type ColumnDef as i, type ColumnDiff as j, type ColumnInfo as k, type ColumnRef as l, type CommentInfo as m, type ConnectionContextOptions as n, type ConnectionMigrator as o, type CustomTypesInfo as p, type DataLossWarning as q, type DeleteAST as r, type Dialect as s, type DiffResult as t, type EmbedTransform as u, type ExplainOptions as v, type ForeignKeyDiff as w, type ForeignKeyInfo as x, type IndexDiff as y, type IndexInfo as z };
+export { type QbSelect as $, type AnyAST as A, type BaseAST as B, Connection as C, DataLossError as D, type EmbedDef as E, type FiltersResult as F, type IndexInfo as G, type HeadersResult as H, type IConnectionConfig as I, type InsertAST as J, type IntrospectOptions as K, type JoinDef as L, type JoinMap as M, type Meta as N, MigrationError as O, type OrderEntry as P, type PlanResult as Q, type PlanStep as R, PlanStepType as S, type TransactionOptions as T, type PreferToken as U, type VarsContext as V, type Where as W, type PrimaryKeyInfo as X, type Qb as Y, type QbDelete as Z, type QbInsert as _, type IntrospectResult as a, type QbUpdate as a0, type QueryAST as a1, type QueryParamsResult as a2, RelationNotFoundError as a3, type RouteResult as a4, type RpcAST as a5, type RpcResult as a6, type SchemaDiffResult as a7, type SelectEntry as a8, type SelectResult as a9, type TableDiff as aa, type TableInfo as ab, type TextSearchValue as ac, type TransformsResult as ad, type TranslatorConfig as ae, type TriggerInfo as af, type UniqueConstraintInfo as ag, type UpdateAST as ah, type UpsertAST as ai, type UpsertResult as aj, type ViewInfo as ak, type ViewOptionsMetadata as al, type WhereValue as am, isRef as an, type CacheDriver as b, type CacheSetOptions as c, type AST as d, type ASTType as e, type AggregateFunction as f, type BodyResult as g, type CheckConstraintInfo as h, type ColumnDef as i, type ColumnDiff as j, type ColumnInfo as k, type ColumnRef as l, type CommentInfo as m, type ConnectionContextOptions as n, type ConnectionMigrator as o, type CustomTypesInfo as p, type DataLossWarning as q, type DeleteAST as r, type Dialect as s, type DiffResult as t, type EmbedTransform as u, type ExplainOptions as v, type ForeignKeyDiff as w, type ForeignKeyInfo as x, type FunctionInfo as y, type IndexDiff as z };

package/dist/db/fallback.d.ts

@@ -1,4 +1,4 @@
-import { I as IConnectionConfig, C as Connection } from '../Connection-DF_xKWko.js';
+import { I as IConnectionConfig, C as Connection } from '../Connection-DJbw6dM8.js';
 import 'kysely';
 
 declare function createConnection<E extends IConnectionConfig = IConnectionConfig>(_config?: E): Promise<Connection>;

package/dist/db/postgres/{BasePostgresConnection-NlNmZWv1.d.ts → BasePostgresConnection-xaPv2E6u.d.ts}

@@ -1,4 +1,4 @@
-import { IConnectionConfig, Connection, IntrospectResult, VarsContext, ConnectionContextOptions, AnyAST, TransactionOptions } from '@supabase/lite';
+import { IConnectionConfig, Connection, IntrospectResult, VarsContext, ConnectionContextOptions, AnyAST, TransactionOptions, ViewOptionsMetadata } from '@supabase/lite';
 import { Kysely } from 'kysely';
 
 interface IBasePostgresConnectionConfig extends IConnectionConfig {
@@ -20,9 +20,22 @@ declare abstract class BasePostgresConnection<Driver = unknown, DB = any> extend
     private ensureRlsContext;
     private postgresTransactionActive;
     private applyJwtSessionContext;
+    /**
+     * Inject PostgREST's `request.*` context GUCs and reset `response.*` for an RPC
+     * request. A function may read the HTTP context via `current_setting('request.headers')`
+     * etc.; that call (used without the `missing_ok` arg in the fixtures) errors 42704
+     * if the GUC is unset, so request.method/path/headers are always set. response.status
+     * and response.headers are reset to empty first so a value set by an earlier step in
+     * the harness's shared outer transaction can't leak into this request (in production
+     * each RPC gets its own tx, so the leak is harness-only — but the reset is correct
+     * either way). All transaction-local (`is_local = true`).
+     */
+    private applyRpcRequestGucs;
     withContext<T>(vars: VarsContext | undefined, fn: (db: Kysely<any>) => Promise<T>, opts?: ConnectionContextOptions): Promise<T>;
     onPostgrestAST(ast: AnyAST): Promise<AnyAST>;
     transaction(statements: string[], opts?: TransactionOptions): Promise<void>;
+    get supportsRpc(): boolean;
+    viewOptionsMetadata(viewName: string, viewSchema: string): Promise<ViewOptionsMetadata>;
 }
 
 export { BasePostgresConnection as B, type IBasePostgresConnectionConfig as I };

package/dist/db/postgres/PostgresConnection.d.ts

@@ -1,9 +1,18 @@
 import postgres from 'postgres';
-import { I as IBasePostgresConnectionConfig, B as BasePostgresConnection } from './BasePostgresConnection-NlNmZWv1.js';
+import { I as IBasePostgresConnectionConfig, B as BasePostgresConnection } from './BasePostgresConnection-xaPv2E6u.js';
 import '@supabase/lite';
 import 'kysely';
 
 interface IPostgresConnectionConfig extends IBasePostgresConnectionConfig {
+    /**
+     * Extra options forwarded to the underlying `postgres` (postgres.js) driver,
+     * merged over lite's defaults. `connection` and `types` are deep-merged (your
+     * keys win, lite's other defaults are kept); every other key is shallow-spread.
+     *
+     * Example — run the session in a non-UTC timezone instead of the UTC default:
+     * `{ connection: { TimeZone: "America/New_York" } }`.
+     */
+    postgresOptions?: postgres.Options<Record<string, postgres.PostgresType>>;
 }
 declare class PostgresConnection extends BasePostgresConnection<postgres.Sql, any> {
     driver: postgres.Sql<any>;

package/dist/db/postgres/PostgresConnection.js

@@ -1,4 +1,4 @@
-import F from'postgres';import {PostgresJSDialect}from'kysely-postgres-js';import {Kysely,sql}from'kysely';import {Connection,invariant,RelationNotFoundError}from'@supabase/lite';try {
+import me from'postgres';import {PostgresJSDialect}from'kysely-postgres-js';import {Kysely,sql}from'kysely';import {Connection,invariant,RelationNotFoundError}from'@supabase/lite';try {
    /**
     * Adding this to avoid warnings from node:sqlite being experimental
     */
@@ -8,13 +8,13 @@ import F from'postgres';import {PostgresJSDialect}from'kysely-postgres-js';impor
       return emitWarning(warning, ...args);
    };
 } catch {}
-var $=["anon","authenticated","service_role"];function v(c){return c==="service_role"?"NOLOGIN BYPASSRLS":"NOLOGIN"}function D(c){return c.size===0?"":`DO $$ BEGIN${[...c].map(s=>`
+var Y=["anon","authenticated","service_role"];function V(a){return a==="service_role"?"NOLOGIN BYPASSRLS":"NOLOGIN"}function Q(a){return a.size===0?"":`DO $$ BEGIN${[...a].map(s=>`
    IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${s}') THEN
-      CREATE ROLE ${s} ${v(s)};
+      CREATE ROLE ${s} ${V(s)};
    END IF;`).join("")}
 END $$;
-`}var g=D(new Set($));var m="anon, authenticated, service_role",U=new Set(["anon","authenticated","service_role"]);function A(c){return `"${c.replace(/"/g,'""')}"`}var p=class extends Error{constructor(s){super("Force rollback");this.result=s;}},E=class extends Connection{dialect="postgres";harnessHoldingOuterTx=false;constructor(n){super({...n,baseSchema:`
-            ${n.baseSchema??""}
+`}var k=Q(new Set(Y));function T(a){let e=a.trim();return e.startsWith('"')&&e.endsWith('"')||e.startsWith("`")&&e.endsWith("`")||e.startsWith("[")&&e.endsWith("]")?e.slice(1,-1):e}function Z(a){let e=[],s="",i=0,n=null;for(let o=0;o<a.length;o++){let c=a[o];if(n){s+=c,c===n&&(n=null);continue}if(c==='"'||c==="`"||c==="'"){n=c,s+=c;continue}if(c==="("?i++:c===")"&&i>0&&i--,c===","&&i===0){e.push(s.trim()),s="";continue}s+=c;}return s.trim()&&e.push(s.trim()),e}function X(a){let e=a.match(/^(.*?)\s+as\s+(.+)$/i),s=e?e[1].trim():a.trim(),i=e?e[2].trim():void 0;if(!i){let c=a.match(/^(.+?)\s+((?:"[^"]+"|`[^`]+`|\[[^\]]+\]|\w+))$/);c&&!/[()]/.test(c[1])&&(s=c[1].trim(),i=c[2].trim());}let n=s.split(".").map(T);if(n.length>2)return null;let o=n.at(-1);return !o||!/^[A-Za-z_][\w$]*$/.test(o)?null:{baseColumn:o,viewColumn:i?T(i):o}}function x(a){return !!(a&&/[A-Za-z0-9_$]/.test(a))}function ee(a){let e=/\bselect\b/i.exec(a);if(!e)return null;let s=0,i=null;for(let n=e.index+e[0].length;n<a.length;n++){let o=a[n];if(i){o===i&&(i=null);continue}if(o==='"'||o==="`"||o==="'"){i=o;continue}if(o==="("){s++;continue}if(o===")"&&s>0){s--;continue}if(s===0&&a.slice(n,n+4).toLowerCase()==="from"&&!x(a[n-1])&&!x(a[n+4]))return {selectList:a.slice(e.index+e[0].length,n).trim(),fromRest:a.slice(n+4).trim()}}return null}function te(a){let e=0,s=[];for(;e<a.length;){for(;/\s/.test(a[e]??"");)e++;let i=a[e],n="";if(i==='"'||i==="`"){let r=a.indexOf(i,e+1);if(r===-1)return null;n=a.slice(e,r+1),e=r+1;}else if(i==="["){let r=a.indexOf("]",e+1);if(r===-1)return null;n=a.slice(e,r+1),e=r+1;}else {let r=/^[A-Za-z_][\w$]*/.exec(a.slice(e));if(!r)return null;n=r[0],e+=n.length;}s.push(n);let o=a.slice(e),c=/^\s*\./.exec(o);if(!c)break;e+=c[0].length;}return s.length===0?null:{raw:s.join("."),rest:a.slice(e).trim()}}function v(a,e,s){let i=a.get(e)??[];i.includes(s)||i.push(s),a.set(e,i);}function ne(a,e){if(!a)return null;let s=ee(a);if(!s)return null;let i=te(s.fromRest);if(!i)return null;let{raw:n,rest:o}=i;if(/\b(join|union|intersect|except)\b/i.test(o))return null;let c=n.split(".").map(T).at(-1);if(!c)return null;let r=new Map,l=e.get(c)??new Set;for(let p of Z(s.selectList)){let m=p.trim();if(m==="*"||m.endsWith(".*")){for(let d of l)v(r,d,d);continue}let g=X(p);g&&v(r,g.baseColumn,g.viewColumn);}return r.size===0?null:{baseTable:c,columns:r}}function se(a,e){let s=new Map;for(let[i,n]of e){let o=[];for(let c of n){let r=a.get(c);if(r)for(let l of r)o.includes(l)||o.push(l);}o.length>0&&s.set(i,o);}return s}function ae(a){let e=new Map,s=new Map;for(let r of a.columns??[]){let l=s.get(r.table)??new Set;l.add(r.name),s.set(r.table,l);}let i=(r,l)=>{let p=e.get(r)??[];p.some(m=>m.name===l.name&&m.schema===l.schema)||p.push(l),e.set(r,p);};for(let r of a.tables??[]){if(r.type!=="table")continue;let l=s.get(r.name);l&&i(r.name,{name:r.name,schema:r.schema,columnByBaseColumn:new Map([...l].map(p=>[p,[p]]))});}let n=new Map;for(let r of a.views??[]){let l=ne(r.sql,s);if(!l)continue;let p=s.get(r.name);if(!p)continue;let m=new Map;for(let[d,_]of l.columns){let f=_.filter(h=>p.has(h));f.length>0&&m.set(d,f);}if(m.size===0)continue;let g={name:r.name,schema:r.schema,columnByBaseColumn:m,fromRelation:l.baseTable};n.set(r.name,g);}let o=16;function c(r,l,p){if(l>o)return null;let m=r.fromRelation;if(e.has(m))return {physicalBase:m,columnByBaseColumn:r.columnByBaseColumn};let g=n.get(m);if(!g||p.has(m))return null;p.add(m);let d=c(g,l+1,p);if(p.delete(m),!d)return null;let _=se(r.columnByBaseColumn,d.columnByBaseColumn);return _.size===0?null:{physicalBase:d.physicalBase,columnByBaseColumn:_}}for(let r of n.values()){let l=c(r,0,new Set([r.name]));l&&i(l.physicalBase,{name:r.name,schema:r.schema,columnByBaseColumn:l.columnByBaseColumn});}return e}function B(a){return `${a.foreign_key_group??""}:${a.table}.${a.column}->${a.ref_table}.${a.ref_column}`}function oe(a){let e=new Map;for(let s of a){let i=`${s.schema}.${s.table}.${s.foreign_key_name}.${s.ref_schema??""}.${s.ref_table}`,n=e.get(i);n?n.push(s):e.set(i,[s]);}return [...e.values()]}function ie(a){let e=[[]];for(let s of a){let i=[];for(let n of e)for(let o of s)i.push([...n,o]);e=i;}return e}function re(a,e,s,i){let n=i.map(c=>c.childColumn).join(","),o=i.map(c=>c.parentColumn).join(",");return `${s}:${a.name}(${n})->${e.name}(${o})`}function $(a){if(!a.foreign_keys?.length||!a.views?.length)return a;let e=ae(a),s=new Set(a.foreign_keys.map(B)),i=[];for(let n of oe(a.foreign_keys)){let o=n[0],c=e.get(o.table)??[],r=e.get(o.ref_table)??[];for(let l of c)for(let p of r){if(l.schema!==p.schema)continue;let m=[];for(let g of n){let d=l.columnByBaseColumn.get(g.column)??[],_=p.columnByBaseColumn.get(g.ref_column)??[],f=d.flatMap(h=>_.map(y=>({fk:g,childColumn:h,parentColumn:y})));if(f.length===0){m.length=0;break}m.push(f);}for(let g of ie(m)){let _=l.name===o.table&&p.name===o.ref_table&&g.every(f=>f.childColumn===f.fk.column&&f.parentColumn===f.fk.ref_column)?void 0:re(l,p,o.foreign_key_name,g);for(let f of g){let h={...f.fk,table:l.name,column:f.childColumn,schema:l.schema,ref_table:p.name,ref_column:f.parentColumn,ref_schema:p.schema,foreign_key_group:_},y=B(h);s.has(y)||(s.add(y),i.push(h));}}}}return i.length?{...a,foreign_keys:[...a.foreign_keys,...i]}:a}var A="anon, authenticated, service_role",ue=new Set(["anon","authenticated","service_role"]);function F(a){return `"${a.replace(/"/g,'""')}"`}var S=class extends Error{constructor(s){super("Force rollback");this.result=s;}},O=class extends Connection{dialect="postgres";harnessHoldingOuterTx=false;constructor(e){super({...e,baseSchema:`
+            ${e.baseSchema??""}
          
             CREATE SCHEMA IF NOT EXISTS auth;
 
@@ -40,7 +40,7 @@ END $$;
                 '{}'
               )::jsonb;
             $$ LANGUAGE SQL STABLE;
-         `});}async introspect(n){invariant(typeof n=="object"||n===void 0,"options must be an object");let s=n?.useCache??false,t=await this.readCachedIntrospection({useCache:s});if(t)return t;try{let i=(await sql`
+         `});}async introspect(e){invariant(typeof e=="object"||e===void 0,"options must be an object");let s=e?.useCache??false,i=await this.readCachedIntrospection({useCache:s});if(i)return i;try{let n=await sql`
             SELECT
                tbls.table_name AS "name",
                tbls.table_schema AS "schema",
@@ -52,8 +52,47 @@ END $$;
             WHERE
                tbls.table_schema NOT IN ('information_schema', 'pg_catalog')
                AND tbls.table_type IN ('BASE TABLE', 'FOREIGN TABLE')
+               -- Individual partitions are hidden from the relation cache (like PostgREST):
+               -- direct access -> PGRST205, embedding -> PGRST200. The partitioned parent
+               -- (relkind 'p', relispartition = false) stays exposed.
+               AND NOT EXISTS (
+                  SELECT 1
+                  FROM pg_catalog.pg_class pc
+                     JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace
+                  WHERE pc.relname = tbls.table_name
+                     AND pn.nspname = tbls.table_schema
+                     AND pc.relispartition
+               )
             ORDER BY tbls.table_schema, tbls.table_name
-         `.execute(this.kysely)).rows.map(e=>({name:e.name,schema:e.schema,type:"table",rows:Number(e.rows),sql:"",engine:"",collation:""})),l=(await sql`
+         `.execute(this.kysely),o=await sql`
+            SELECT
+               mv.schemaname AS "schema",
+               mv.matviewname AS "name",
+               mv.definition  AS "sql"
+            FROM pg_catalog.pg_matviews mv
+            WHERE mv.schemaname NOT IN ('information_schema', 'pg_catalog')
+            ORDER BY mv.schemaname, mv.matviewname
+         `.execute(this.kysely),c=await sql`
+            SELECT
+               n.nspname          AS "schema",
+               c.relname          AS "table",
+               a.attname          AS "name",
+               a.attnum           AS "ordinal_position",
+               format_type(a.atttypid, a.atttypmod) AS "type",
+               NOT a.attnotnull   AS "nullable",
+               pg_get_expr(d.adbin, d.adrelid) AS "default_value"
+            FROM pg_catalog.pg_class c
+               JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+               JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+               LEFT JOIN pg_catalog.pg_attrdef d
+                         ON d.adrelid = c.oid AND d.adnum = a.attnum
+            WHERE
+               c.relkind = 'm'
+               AND n.nspname NOT IN ('information_schema', 'pg_catalog')
+               AND a.attnum > 0
+               AND NOT a.attisdropped
+            ORDER BY n.nspname, c.relname, a.attnum
+         `.execute(this.kysely),r=n.rows.map(t=>({name:t.name,schema:t.schema,type:"table",rows:Number(t.rows),sql:"",engine:"",collation:""}));for(let t of o.rows)r.push({name:t.name,schema:t.schema,type:"table",rows:0,sql:"",engine:"",collation:""});let p=(await sql`
             SELECT
                cols.table_name AS "table",
                cols.table_schema AS "schema",
@@ -95,6 +134,7 @@ END $$;
                   END AS "is_identity",
                COALESCE(cols.collation_name, '') AS "collation",
                cols.udt_name AS "udt_name",
+               cols.udt_schema AS "udt_schema",
                CASE WHEN pt.typtype = 'd' THEN pt.typname ELSE cols.udt_name END AS "domain_type",
                CASE WHEN cols.is_generated = 'NEVER' THEN false ELSE true END AS "is_generated"
             FROM information_schema.columns cols
@@ -106,7 +146,7 @@ END $$;
                LEFT JOIN pg_catalog.pg_type pt ON pt.oid = attr.atttypid
             WHERE cols.table_schema NOT IN ('information_schema', 'pg_catalog')
             ORDER BY cols.table_schema, cols.table_name, cols.ordinal_position
-         `.execute(this.kysely)).rows.map(e=>({table:e.table,schema:e.schema,name:e.name,type:e.type,nullable:e.nullable,default_value:e.default_value,is_primary_key:!1,ordinal_position:Number(e.ordinal_position),character_maximum_length:e.character_maximum_length??null,precision:e.precision??null,is_identity:e.is_identity,collation:e.collation,pg_type:e.domain_type??e.udt_name??void 0,is_generated:e.is_generated??!1})),r=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,schema:t.schema,name:t.name,type:t.type,nullable:t.nullable,default_value:t.default_value,is_primary_key:!1,ordinal_position:Number(t.ordinal_position),character_maximum_length:t.character_maximum_length??null,precision:t.precision??null,is_identity:t.is_identity,collation:t.collation,pg_type:t.domain_type??t.udt_name??void 0,udt_schema:t.udt_schema??void 0,is_generated:t.is_generated??!1}));for(let t of c.rows)p.push({table:t.table,schema:t.schema,name:t.name,type:t.type??"",nullable:t.nullable??!0,default_value:t.default_value??null,is_primary_key:!1,ordinal_position:Number(t.ordinal_position),character_maximum_length:null,precision:null,is_identity:!1,collation:"",pg_type:void 0,udt_schema:void 0,is_generated:!1});let g=(await sql`
             SELECT
                ns.nspname AS "schema",
                cl.relname AS "table",
@@ -130,8 +170,13 @@ END $$;
                AND ns.nspname NOT IN (
                'information_schema'
                , 'pg_catalog')
+               -- Skip FK rows on/to individual partitions (partition-level copies of an
+               -- inherited FK). Keeps the partitioned parent's FK; prevents a partition
+               -- surfacing as a spurious embed candidate.
+               AND NOT cl.relispartition
+               AND NOT ref_cl.relispartition
             ORDER BY ns.nspname, cl.relname, con.conname, cols.ord
-         `.execute(this.kysely)).rows.map(e=>({table:e.table,column:e.column,schema:e.schema,ref_table:e.ref_table,ref_column:e.ref_column,foreign_key_name:e.foreign_key_name,fk_def:e.fk_def,on_update:"",on_delete:""})),_=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,column:t.column,schema:t.schema,ref_table:t.ref_table,ref_column:t.ref_column,foreign_key_name:t.foreign_key_name,fk_def:t.fk_def,on_update:"",on_delete:""})),_=(await sql`
             SELECT
                ns.nspname AS "schema",
                cl.relname AS "table",
@@ -148,7 +193,7 @@ END $$;
                'information_schema'
                , 'pg_catalog')
             GROUP BY ns.nspname, cl.relname, con.oid
-         `.execute(this.kysely)).rows.map(e=>({table:e.table,columns:e.columns,schema:e.schema,field_count:e.columns.length})),h=new Set(_.flatMap(e=>e.columns.map(x=>`${e.schema}.${e.table}.${x}`)));for(let e of l)e.is_primary_key=h.has(`${e.schema}.${e.table}.${e.name}`);let R=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,columns:t.columns,schema:t.schema,field_count:t.columns.length})),f=new Set(_.flatMap(t=>t.columns.map(N=>`${t.schema}.${t.table}.${N}`)));for(let t of p)t.is_primary_key=f.has(`${t.schema}.${t.table}.${t.name}`);let y=(await sql`
             SELECT
                tnsp.nspname AS "schema",
                cl.relname AS "table",
@@ -169,7 +214,7 @@ END $$;
                'information_schema'
                , 'pg_catalog')
             GROUP BY tnsp.nspname, cl.relname, ic.relname, idx.indisunique
-         `.execute(this.kysely)).rows.map(e=>({table:e.table,name:e.name,unique:e.unique,columns:e.columns,schema:e.schema})),O=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,name:t.name,unique:t.unique,columns:t.columns,schema:t.schema})),C=(await sql`
             SELECT
                views.schemaname AS "schema",
                views.viewname AS "name",
@@ -177,7 +222,7 @@ END $$;
             FROM pg_views views
             WHERE views.schemaname NOT IN ('information_schema', 'pg_catalog')
             ORDER BY views.schemaname, views.viewname
-         `.execute(this.kysely)).rows.map(e=>({name:e.name,schema:e.schema,sql:e.sql??""})),T=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({name:t.name,schema:t.schema,sql:t.sql??""}));for(let t of o.rows)C.push({name:t.name,schema:t.schema,sql:t.sql??""});let D=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -189,7 +234,7 @@ END $$;
                c.contype = 'c'
                AND n.nspname NOT IN ('information_schema', 'pg_catalog')
             ORDER BY n.nspname, cl.relname
-         `.execute(this.kysely)).rows.map(e=>({schema:e.schema,table:e.table,expression:e.expression??""})),L=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,expression:t.expression??""})),H=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -204,7 +249,7 @@ END $$;
                c.contype = 'u'
                AND n.nspname NOT IN ('information_schema', 'pg_catalog')
             GROUP BY n.nspname, cl.relname, c.conname, c.oid
-         `.execute(this.kysely)).rows.map(e=>({schema:e.schema,table:e.table,name:e.name,columns:e.columns})),w=(await sql`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,name:t.name,columns:t.columns})),J=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -219,7 +264,7 @@ END $$;
                n.nspname NOT IN ('information_schema', 'pg_catalog')
                AND cl.relkind IN ('r', 'v', 'm', 'f', 'p')
                AND d.description IS NOT NULL
-         `.execute(this.kysely)).rows.map(e=>({schema:e.schema,table:e.table,column:e.column??void 0,text:e.text})),b=await sql`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,column:t.column??void 0,text:t.text})),M=await sql`
             SELECT
                n.nspname AS "schema",
                t.typname AS "type",
@@ -230,7 +275,7 @@ END $$;
                JOIN pg_namespace n ON n.oid = t.typnamespace
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
             GROUP BY n.nspname, t.typname
-         `.execute(this.kysely),I=await sql`
+         `.execute(this.kysely),U=await sql`
             SELECT
                n.nspname AS "schema",
                t.typname AS "type",
@@ -252,10 +297,51 @@ END $$;
                AND NOT a.attisdropped
                AND n.nspname NOT IN ('pg_catalog', 'information_schema')
             GROUP BY n.nspname, t.typname
-         `.execute(this.kysely),C=[...b.rows.map(e=>({schema:e.schema,type:e.type,kind:"enum",values:e.values})),...I.rows.map(e=>({schema:e.schema,type:e.type,kind:"composite",fields:e.fields}))],k=(await sql`SELECT current_database() AS "name"`.execute(this.kysely)).rows[0]?.name??"postgres",f={tables:i,columns:l,indexes:R,foreign_keys:r,primary_keys:_,views:O,triggers:[],check_constraints:T,unique_constraints:L,comments:w,custom_types:C,database_name:k,version:""};return await this.writeCachedIntrospection(f,{useDriver:s}),f}catch(o){return console.error("Introspection failed:",o),{tables:[],columns:[],indexes:[],foreign_keys:[],primary_keys:[],views:[],triggers:[],check_constraints:[],unique_constraints:[],comments:[],custom_types:[],database_name:"postgres",version:""}}}rlsState="unknown";async ensureRlsContext(){if(this.rlsState!=="unknown")return this.rlsState==="active";let n=await sql`
+         `.execute(this.kysely),P=[...M.rows.map(t=>({schema:t.schema,type:t.type,kind:"enum",values:t.values})),...U.rows.map(t=>({schema:t.schema,type:t.type,kind:"composite",fields:t.fields}))],W=(await sql`
+            SELECT
+               n.nspname AS "schema",
+               p.proname AS "name",
+               p.proargnames AS "arg_names_raw",
+               p.proargmodes::text[] AS "arg_modes_raw",
+               p.pronargdefaults AS "arg_defaults",
+               p.provariadic <> 0 AS "has_variadic",
+               p.provolatile AS "volatility",
+               p.proretset AS "return_is_setof",
+               p.prorows AS "return_rows",
+               format_type(p.prorettype, NULL) AS "return_type",
+               rt.typtype AS "return_typtype",
+               CASE WHEN rt.typtype = 'd' AND rt.typbasetype <> 0
+                  THEN format_type(rt.typbasetype, NULL) END AS "return_base_type",
+               (SELECT array_agg(format_type(t, NULL) ORDER BY ord)
+                  FROM unnest(p.proargtypes) WITH ORDINALITY AS at(t, ord)) AS "arg_types_raw"
+            FROM pg_proc p
+               JOIN pg_namespace n ON n.oid = p.pronamespace
+               LEFT JOIN pg_type rt ON rt.oid = p.prorettype
+            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+               AND p.prokind = 'f'
+            ORDER BY n.nspname, p.proname
+         `.execute(this.kysely)).rows.map(t=>{let N=t.arg_names_raw??[],E=t.arg_modes_raw??null,q=E&&E.length===N.length?N.filter((R,w)=>E[w]==="i"||E[w]==="b"||E[w]==="v"):N,z=!!E?.some(R=>R==="o"||R==="b"||R==="t");return {schema:t.schema,name:t.name,arg_names:q,arg_types:t.arg_types_raw??[],arg_defaults:Number(t.arg_defaults??0),has_variadic:t.has_variadic===!0,volatility:t.volatility??"v",return_type:t.return_type??"",return_is_setof:t.return_is_setof===!0,return_rows:Number(t.return_rows??0),return_typtype:t.return_typtype??"",return_base_type:t.return_base_type??void 0,has_out_args:z}}),G=(await sql`
+            SELECT
+               c.relname AS "name",
+               n.nspname AS "schema",
+               p.relname AS "parent"
+            FROM pg_catalog.pg_inherits i
+               JOIN pg_catalog.pg_class c ON c.oid = i.inhrelid AND c.relispartition
+               JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+               JOIN pg_catalog.pg_class p ON p.oid = i.inhparent
+            WHERE n.nspname NOT IN ('information_schema', 'pg_catalog')
+         `.execute(this.kysely)).rows.map(t=>({name:t.name,schema:t.schema,parent:t.parent})),j=(await sql`SELECT name FROM pg_catalog.pg_timezone_names`.execute(this.kysely)).rows.map(t=>t.name),K=(await sql`SELECT current_database() AS "name"`.execute(this.kysely)).rows[0]?.name??"postgres",I=$({tables:r,columns:p,indexes:y,foreign_keys:g,primary_keys:_,views:C,triggers:[],functions:W,check_constraints:D,unique_constraints:H,comments:J,custom_types:P,partitions:G,database_name:K,version:"",default_schema:this.config?.translation?.schemas?.defaultSchema??"public",timezones:j});return await this.writeCachedIntrospection(I,{useDriver:s}),I}catch(n){return console.error("Introspection failed:",n),{tables:[],columns:[],indexes:[],foreign_keys:[],primary_keys:[],views:[],triggers:[],check_constraints:[],unique_constraints:[],comments:[],custom_types:[],database_name:"postgres",version:""}}}rlsState="unknown";async ensureRlsContext(){if(this.rlsState!=="unknown")return this.rlsState==="active";let e=await sql`
          SELECT count(*) ::text as count FROM pg_class WHERE relrowsecurity = true
-      `.execute(this.kysely);if(!(Number(n.rows[0]?.count??0)>0))return this.rlsState="inactive",false;this.rlsState="active",await sql.raw(g).execute(this.kysely);let t=await sql`
+      `.execute(this.kysely);if(!(Number(e.rows[0]?.count??0)>0))return this.rlsState="inactive",false;this.rlsState="active",await sql.raw(k).execute(this.kysely);let i=await sql`
          SELECT DISTINCT n.nspname FROM pg_class c
          JOIN pg_namespace n ON n.oid = c.relnamespace
          WHERE c.relrowsecurity = true
-      `.execute(this.kysely);for(let{nspname:o}of t.rows){let i=A(o);await sql.raw(`GRANT USAGE ON SCHEMA ${i} TO ${m}`).execute(this.kysely),await sql.raw(`GRANT ALL ON ALL TABLES IN SCHEMA ${i} TO ${m}`).execute(this.kysely),await sql.raw(`GRANT ALL ON ALL SEQUENCES IN SCHEMA ${i} TO ${m}`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA ${i} GRANT ALL ON TABLES TO ${m}`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA ${i} GRANT ALL ON SEQUENCES TO ${m}`).execute(this.kysely);}return  true}async postgresTransactionActive(n){try{return await sql`SAVEPOINT __supalite_outer_tx_check`.execute(n),await sql`RELEASE SAVEPOINT __supalite_outer_tx_check`.execute(n),!0}catch{return  false}}async applyJwtSessionContext(n,s,t){let o=s.auth,i=o?.role||"anon",d=String(o?.uid??""),l=o?.jwt;await sql`SELECT set_config('role', ${i}, true)`.execute(n),await sql`SELECT set_config('request.jwt.claim.sub', ${d}, true)`.execute(n),await sql`SELECT set_config('request.jwt.claim.role', ${i}, true)`.execute(n),t&&await sql.raw(`SET LOCAL ROLE ${A(i)}`).execute(n),l&&typeof l=="object"&&await sql`SELECT set_config('request.jwt.claims', ${JSON.stringify(l)}, true)`.execute(n);}async withContext(n,s,t){let o=t?.forceRollback===true;if(!o&&!n)return s(this.kysely);let i=n?await this.ensureRlsContext():false,l=n?.auth?.role||"anon",u=typeof l=="string"&&/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(l)&&!U.has(l);if(!o&&!i&&!u)return s(this.kysely);if(!o&&u)return this.harnessHoldingOuterTx?(invariant(await this.postgresTransactionActive(this.kysely),"harnessHoldingOuterTx is set but the connection has no open PostgreSQL transaction; wrap REST requests in BEGIN/ROLLBACK in the spec harness"),await this.applyJwtSessionContext(this.kysely,n,true),s(this.kysely)):this.kysely.transaction().execute(async r=>(await this.applyJwtSessionContext(r,n,true),s(r)));if(!o&&i&&!u)return this.kysely.transaction().execute(async r=>(await this.applyJwtSessionContext(r,n,true),s(r)));try{return await this.kysely.transaction().execute(async r=>{n&&(i||u)&&await this.applyJwtSessionContext(r,n,u);let S=await s(r);if(o)throw new p(S);return S})}catch(r){if(r instanceof p)return r.result;throw r}}async onPostgrestAST(n){if(!n.from)return n;let s=n.schema??"public",t=n.from,o=await this.introspect({useCache:true});if(!o.tables.some(i=>i.name===t&&i.schema===s)&&!o.views.some(i=>i.name===t&&i.schema===s))throw new RelationNotFoundError(s,t);return n}async transaction(n,s){await this.exec("BEGIN");try{for(let t of n)await this.exec(t);await this.exec("COMMIT");}catch(t){throw await this.exec("ROLLBACK"),t}finally{s?.intent==="migration"&&await this.clearSchemaCache();}}};var N=class extends E{driver;dialect="postgres";constructor(n){super(n),this.driver=F(n.url??"",{types:{bigint:{to:20,from:[20],serialize:t=>t.toString(),parse:t=>{let o=Number(t);return Number.isSafeInteger(o)?o:BigInt(t)}},json:{to:114,from:[114],serialize:t=>JSON.stringify(t),parse:t=>JSON.parse(t)},jsonb:{to:3802,from:[3802],serialize:t=>JSON.stringify(t),parse:t=>JSON.parse(t)},numeric:{to:1700,from:[1700],serialize:t=>String(t),parse:t=>{let o=Number(t);return Number.isFinite(o)&&String(o)===t?o:t}},date:{to:1082,from:[1082],serialize:t=>t,parse:t=>t},time:{to:1083,from:[1083],serialize:t=>t,parse:t=>t},timestamp:{to:1114,from:[1114],serialize:t=>t,parse:t=>t},timestamptz:{to:1184,from:[1184],serialize:t=>t,parse:t=>t},timetz:{to:1266,from:[1266],serialize:t=>t,parse:t=>t}}});let s=new PostgresJSDialect({postgres:this.driver});this.kysely=new Kysely({dialect:s});}async close(){await this.driver.end();}};function ae(c){return new N(c)}export{N as PostgresConnection,ae as createPostgresConnection};
+      `.execute(this.kysely);for(let{nspname:n}of i.rows){let o=F(n);await sql.raw(`GRANT USAGE ON SCHEMA ${o} TO ${A}`).execute(this.kysely),await sql.raw(`GRANT ALL ON ALL TABLES IN SCHEMA ${o} TO ${A}`).execute(this.kysely),await sql.raw(`GRANT ALL ON ALL SEQUENCES IN SCHEMA ${o} TO ${A}`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA ${o} GRANT ALL ON TABLES TO ${A}`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA ${o} GRANT ALL ON SEQUENCES TO ${A}`).execute(this.kysely);}return  true}async postgresTransactionActive(e){try{return await sql`SAVEPOINT __supalite_outer_tx_check`.execute(e),await sql`RELEASE SAVEPOINT __supalite_outer_tx_check`.execute(e),!0}catch{return  false}}async applyJwtSessionContext(e,s,i){let n=s.auth,o=n?.role||"anon",c=String(n?.uid??""),r=n?.jwt;await sql`SELECT set_config('role', ${o}, true)`.execute(e),await sql`SELECT set_config('request.jwt.claim.sub', ${c}, true)`.execute(e),await sql`SELECT set_config('request.jwt.claim.role', ${o}, true)`.execute(e),i&&await sql.raw(`SET LOCAL ROLE ${F(o)}`).execute(e),r&&typeof r=="object"&&await sql`SELECT set_config('request.jwt.claims', ${JSON.stringify(r)}, true)`.execute(e);}async applyRpcRequestGucs(e,s){await sql`SELECT set_config('response.status', '', true)`.execute(e),await sql`SELECT set_config('response.headers', '', true)`.execute(e),await sql`SELECT set_config('request.method', ${s.method}, true)`.execute(e),await sql`SELECT set_config('request.path', ${s.path}, true)`.execute(e),await sql`SELECT set_config('request.headers', ${JSON.stringify(s.requestHeaders??{})}, true)`.execute(e);}async withContext(e,s,i){let n=i?.forceRollback===true;if(!n&&!e)return s(this.kysely);let o=e?await this.ensureRlsContext():false,r=e?.auth?.role||"anon",l=typeof r=="string"&&/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(r)&&!ue.has(r),p=i?.rpc;if(p){let m=async g=>{e&&(o||l)&&await this.applyJwtSessionContext(g,e,l),await this.applyRpcRequestGucs(g,p),p.readOnly&&await sql`SET LOCAL transaction_read_only = on`.execute(g);};if(this.harnessHoldingOuterTx)return invariant(await this.postgresTransactionActive(this.kysely),"harnessHoldingOuterTx is set but the connection has no open PostgreSQL transaction; wrap REST requests in BEGIN/ROLLBACK in the spec harness"),await m(this.kysely),s(this.kysely);try{return await this.kysely.transaction().execute(async g=>{await m(g);let d=await s(g);if(n)throw new S(d);return d})}catch(g){if(g instanceof S)return g.result;throw g}}if(!n&&!o&&!l)return s(this.kysely);if(!n&&l)return this.harnessHoldingOuterTx?(invariant(await this.postgresTransactionActive(this.kysely),"harnessHoldingOuterTx is set but the connection has no open PostgreSQL transaction; wrap REST requests in BEGIN/ROLLBACK in the spec harness"),await this.applyJwtSessionContext(this.kysely,e,true),s(this.kysely)):this.kysely.transaction().execute(async m=>(await this.applyJwtSessionContext(m,e,true),s(m)));if(!n&&o&&!l)return this.kysely.transaction().execute(async m=>(await this.applyJwtSessionContext(m,e,true),s(m)));try{return await this.kysely.transaction().execute(async m=>{e&&(o||l)&&await this.applyJwtSessionContext(m,e,l);let g=await s(m);if(n)throw new S(g);return g})}catch(m){if(m instanceof S)return m.result;throw m}}async onPostgrestAST(e){if(!e.from)return e;let s=e.schema??"public",i=e.from,n=await this.introspect({useCache:true});if(!n.tables.some(o=>o.name===i&&o.schema===s)&&!n.views.some(o=>o.name===i&&o.schema===s))throw new RelationNotFoundError(s,i);return e}async transaction(e,s){await this.exec("BEGIN");try{for(let i of e)await this.exec(i);await this.exec("COMMIT");}catch(i){throw await this.exec("ROLLBACK"),i}finally{s?.intent==="migration"&&await this.clearSchemaCache();}}get supportsRpc(){return  true}async viewOptionsMetadata(e,s){let{rows:i}=await sql`
+         select is_insertable_into, is_updatable,
+                is_trigger_insertable_into, is_trigger_updatable, is_trigger_deletable
+         from information_schema.views
+         where table_schema = ${s} and table_name = ${e}
+      `.execute(this.kysely),n=i[0],o=r=>r==="YES",{rows:c}=await sql`
+         select table_schema, table_name from information_schema.view_table_usage
+         where view_schema = ${s} and view_name = ${e}
+      `.execute(this.kysely);return {canInsert:o(n?.is_insertable_into)||o(n?.is_trigger_insertable_into),canUpdate:o(n?.is_updatable)||o(n?.is_trigger_updatable),canDelete:o(n?.is_updatable)||o(n?.is_trigger_deletable),baseTables:c.map(r=>({schema:r.table_schema,name:r.table_name}))}}};var L=class extends O{driver;dialect="postgres";constructor(e){super(e);let{postgresOptions:s}=e;this.driver=me(e.url??"",{...s,connection:{TimeZone:"UTC",...s?.connection},types:{bigint:{to:20,from:[20],serialize:n=>n.toString(),parse:n=>{let o=Number(n);return Number.isSafeInteger(o)?o:BigInt(n)}},json:{to:114,from:[114],serialize:n=>JSON.stringify(n),parse:n=>JSON.parse(n)},jsonb:{to:3802,from:[3802],serialize:n=>JSON.stringify(n),parse:n=>JSON.parse(n)},numeric:{to:1700,from:[1700],serialize:n=>String(n),parse:n=>{let o=Number(n);return Number.isFinite(o)&&String(o)===n?o:n}},date:{to:1082,from:[1082],serialize:n=>n,parse:n=>n},time:{to:1083,from:[1083],serialize:n=>n,parse:n=>n},timestamp:{to:1114,from:[1114],serialize:n=>n,parse:n=>n},timestamptz:{to:1184,from:[1184],serialize:n=>n,parse:n=>n},timetz:{to:1266,from:[1266],serialize:n=>n,parse:n=>n},...s?.types}});let i=new PostgresJSDialect({postgres:this.driver});this.kysely=new Kysely({dialect:i});}async close(){await this.driver.end();}};function ve(a){return new L(a)}export{L as PostgresConnection,ve as createPostgresConnection};

package/dist/db/postgres/pglite/PgliteConnection.d.ts

@@ -1,6 +1,6 @@
 import { PGliteOptions, PGlite } from '@electric-sql/pglite';
 export { PGlite } from '@electric-sql/pglite';
-import { I as IBasePostgresConnectionConfig, B as BasePostgresConnection } from '../BasePostgresConnection-NlNmZWv1.js';
+import { I as IBasePostgresConnectionConfig, B as BasePostgresConnection } from '../BasePostgresConnection-xaPv2E6u.js';
 import { ConnectionMigrator, SchemaDiffResult, PlanResult, PlanStep } from '@supabase/lite';
 import 'kysely';