@palbase/backend 27.1.0 → 29.0.0

package/dist/engine/index.d.cts

@@ -1,8 +1,8 @@
-import '../index-CgE4sVhg.cjs';
-export { A as App, e as AuthVerifier, B as BootRefused, f as CreateAppOptions, E as EgressPolicy, g as EngineConfig, M as ModuleClients, R as RateLimiter, h as RequestDatabase, i as RouteEntry, j as RuntimeHooks, S as ScrubResult, k as SqlDriver, l as SqlTx, m as buildRouteTable, n as createApp, o as createLazyTransaction, p as createOps, q as createRequestDatabase, r as effectiveAuth, s as hostAllowed, t as installEgressFence, u as loadConfig, v as makeMemoryCache, w as matchRoute, x as quoteIdent, y as scrubSecrets, z as withTables } from '../index-H-0qv5d4.cjs';
+import '../index-ChvoVczS.cjs';
+export { A as App, g as AuthVerifier, B as BootRefused, h as CreateAppOptions, D as DECLARATION_REFUSAL, a as DeclarationRefused, E as EgressPolicy, j as EngineConfig, M as ModuleClients, R as RateLimiter, k as RequestDatabase, l as RouteEntry, m as RuntimeHooks, S as ScrubResult, n as SqlDriver, o as SqlTx, p as buildRouteTable, q as createApp, r as createLazyTransaction, s as createOps, t as createRequestDatabase, u as effectiveAuth, v as hostAllowed, w as installEgressFence, i as isDeclarationRefused, x as loadConfig, y as makeMemoryCache, z as matchRoute, F as quoteIdent, G as scrubSecrets, H as withTables } from '../index-BZfmdRmh.cjs';
 import '../db/env.cjs';
 import '../stack.cjs';
 import 'zod';
 import 'node:async_hooks';
 import '../module-Dl1KFVtc.cjs';
-import '../registry-DHsPDY0_.cjs';
+import '../registry-B2KfKWv1.cjs';

package/dist/engine/index.d.ts

@@ -1,8 +1,8 @@
-import '../index-V7QRh1wg.js';
-export { A as App, e as AuthVerifier, B as BootRefused, f as CreateAppOptions, E as EgressPolicy, g as EngineConfig, M as ModuleClients, R as RateLimiter, h as RequestDatabase, i as RouteEntry, j as RuntimeHooks, S as ScrubResult, k as SqlDriver, l as SqlTx, m as buildRouteTable, n as createApp, o as createLazyTransaction, p as createOps, q as createRequestDatabase, r as effectiveAuth, s as hostAllowed, t as installEgressFence, u as loadConfig, v as makeMemoryCache, w as matchRoute, x as quoteIdent, y as scrubSecrets, z as withTables } from '../index-CAKOgAlP.js';
+import '../index-BOe82fsK.js';
+export { A as App, g as AuthVerifier, B as BootRefused, h as CreateAppOptions, D as DECLARATION_REFUSAL, a as DeclarationRefused, E as EgressPolicy, j as EngineConfig, M as ModuleClients, R as RateLimiter, k as RequestDatabase, l as RouteEntry, m as RuntimeHooks, S as ScrubResult, n as SqlDriver, o as SqlTx, p as buildRouteTable, q as createApp, r as createLazyTransaction, s as createOps, t as createRequestDatabase, u as effectiveAuth, v as hostAllowed, w as installEgressFence, i as isDeclarationRefused, x as loadConfig, y as makeMemoryCache, z as matchRoute, F as quoteIdent, G as scrubSecrets, H as withTables } from '../index-BYDUKexK.js';
 import '../db/env.js';
 import '../stack.js';
 import 'zod';
 import 'node:async_hooks';
 import '../module-Dl1KFVtc.js';
-import '../registry-4EI8aaFs.js';
+import '../registry-DaqHsOq8.js';

package/dist/engine/index.js

@@ -16,16 +16,22 @@ import {
   quoteIdent,
   scrubSecrets,
   withTables
-} from "../chunk-EB3TUX5J.js";
-import "../chunk-BQN723PL.js";
-import "../chunk-OZKSM3JW.js";
-import "../chunk-JVZQCC77.js";
+} from "../chunk-DHJ3SYAE.js";
+import {
+  DECLARATION_REFUSAL,
+  DeclarationRefused,
+  isDeclarationRefused
+} from "../chunk-ESSQ3YML.js";
+import "../chunk-SG4UTNOP.js";
+import "../chunk-3TUJWHC2.js";
 import "../chunk-VVMJEVQP.js";
 import "../chunk-CGNN2PUH.js";
 import "../chunk-VXPNPVAG.js";
 export {
   AuthVerifier,
   BootRefused,
+  DECLARATION_REFUSAL,
+  DeclarationRefused,
   RateLimiter,
   buildRouteTable,
   createApp,
@@ -35,6 +41,7 @@ export {
   effectiveAuth,
   hostAllowed,
   installEgressFence,
+  isDeclarationRefused,
   loadConfig,
   makeMemoryCache,
   matchRoute,

package/dist/{index-V7QRh1wg.d.ts → index-BOe82fsK.d.ts}

@@ -51,12 +51,24 @@ interface User {
 interface AuthConfig {
     /** Whether authentication is required. Defaults to true. */
     required: boolean;
-    /** Required role for access. If undefined, any authenticated user is allowed.
+    /** Required application role for access. If undefined, any authenticated user is allowed.
      *
-     * Matched against the caller's `metadata.role` — NOT `user.role`, which is the
-     * database role RLS reads and is always "authenticated" for a signed-in user.
-     * Not signed in → 401; signed in with a different or missing role → 403. */
+     * Matched against the caller's rows in `auth.user_roles` — NOT against the
+     * `role` claim, which is the DATABASE role RLS reads and is the literal
+     * string "authenticated" for every signed-in user. Reading it from the table
+     * is what makes a revoked role take effect on the very NEXT request instead
+     * of whenever the token happens to expire.
+     *
+     * Not signed in → 401; signed in without the role → 403. */
     role?: string;
+    /** Required permission for access, as `resource.action` (e.g. "posts.delete_any").
+     *
+     * Resolved through `auth.has_permission(...)`, which answers from the roles
+     * the caller holds and the permissions those roles carry. The query runs in
+     * the request's own transaction, so it costs no extra connection.
+     *
+     * Signed in without the permission → 403. */
+    permission?: string;
     /** Require a confirmed email address. An unverified caller gets 403
      * `email_not_verified`. Fences a whole controller; for a partial rule read
      * `user.emailVerified` in the handler instead. */
@@ -2825,7 +2837,12 @@ type RowShape<T extends TableDef> = {
 };
 /** A typed table accessor that mirrors the runtime DBClient surface. */
 interface TypedTable<T extends TableDef> {
-    insert(data: InsertShape<T>): Promise<RowShape<T>>;
+    insert(data: InsertValues<InsertShape<T>>): Promise<RowShape<T>>;
+    /** Çok satır, TEK statement. Satırların anahtar kümesi aynı olmalı. */
+    insertMany(rows: readonly InsertValues<InsertShape<T>>[], opts?: {
+        onConflict: readonly string[];
+        action?: "ignore" | "update";
+    }): Promise<RowShape<T>[]>;
     put(q: {
         data: InsertShape<T>;
         onConflict: readonly string[];
@@ -2837,7 +2854,7 @@ interface TypedTable<T extends TableDef> {
         where: {
             id: string;
         };
-        set: Partial<InsertShape<T>>;
+        set: SetShape<InsertShape<T>>;
     }): Promise<RowShape<T> | null>;
     delete(id: string): Promise<void>;
     findById(id: string): Promise<RowShape<T> | null>;
@@ -2859,11 +2876,33 @@ interface TypedTable<T extends TableDef> {
      * if (row === undefined) throw new Conflict("yetersiz bakiye");
      * ```
      */
-    updateMany(q: MutateInput<RowShape<T>, InsertShape<T>>): Promise<RowShape<T>[]>;
+    updateMany<const Q extends MutateInput<RowShape<T>, InsertShape<T>>>(q: Q): Promise<Q extends {
+        returning: false;
+    } ? number : RowShape<T>[]>;
     /** Delete every matching row; resolves to how many. Empty filter refused. */
     deleteMany(q: {
         where: WhereFilter<RowShape<T>> | SqlFragment;
     }): Promise<number>;
+    /**
+     * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.
+     *
+     * ```ts
+     * const r = await Database.public.entries.aggregate({
+     *   where: { account_id },
+     *   sum: ["amount_kurus"],
+     *   count: true,
+     * });
+     * r.sum.amount_kurus;   // string | null — KAYIPSIZ
+     * r.count;              // number
+     * ```
+     *
+     * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS
+     * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres
+     * boş kümede NULL döndürür — "hiç satır yoktu" ile "toplam sıfırdı" farklı.
+     *
+     * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.
+     */
+    aggregate<const Q extends AggregateInput<RowShape<T>>>(q: Q): Promise<AggregateResult<Q, RowShape<T>>>;
     /** How many rows match. An empty filter is legitimate: counting is a read. */
     count(q?: {
         where?: WhereFilter<RowShape<T>> | SqlFragment;
@@ -2974,9 +3013,39 @@ declare function col<const N extends string>(name: N): ColRef<N>;
  * kabul, `numeric ↔ text` ret olur ve ikisi de DOĞRU olur. Defterde teklif.
  */
 type PgFamily<V> = [NonNullable<V>] extends [boolean] ? "bool" : [NonNullable<V>] extends [readonly (number | string)[]] ? "array" : [NonNullable<V>] extends [Date] ? "date" : [NonNullable<V>] extends [string | number] ? "scalar" : "opaque";
-/** `Row`'un `V` ile karşılaştırılabilir kolonları — aynı aileden olanlar. */
+/**
+ * Kolonun BİLDİRİLMİŞ Postgres tipi — `env-gen`'in bastığı markadan.
+ *
+ * Marka yoksa `"?"`: elle yazılmış bir `Tables` (testler) ya da yeniden
+ * üretilmemiş bir `palbase-env.d.ts`. O durumda eski TS-tipi sezgiseline
+ * düşülüyor, çünkü marka olmadan söylenebilecek daha doğru bir şey yok.
+ */
+type PgTag<V> = [NonNullable<V>] extends [{
+    readonly __pg?: infer N;
+}] ? [N] extends [string] ? N : "?" : "?";
+/**
+ * Postgres'te birbirleriyle karşılaştırılabilen tipler tek "cins".
+ *
+ * `integer`, `bigint` ve `numeric` örtük sayısal dönüşümle karşılaştırılır;
+ * geri kalan her tip yalnız kendisiyle. `uuid ↔ text` ve `enum ↔ text`
+ * Postgres'te `operator does not exist` verir — D-021'de CANLI ölçülmüştü ve
+ * tip bunu göremediği için kabul ediyordu.
+ */
+type PgKind<P> = P extends "integer" | "bigint" | "numeric" ? "num" : P;
+/** İki tarafın da markası var mı — yoksa sezgisele düşülür. */
+type BothBranded<A, B> = "?" extends PgTag<A> ? false : "?" extends PgTag<B> ? false : true;
+type PgSameKind<A, B> = [PgKind<PgTag<A>>] extends [PgKind<PgTag<B>>] ? [PgKind<PgTag<B>>] extends [PgKind<PgTag<A>>] ? true : false : false;
+/**
+ * `A` kolonu `B` ile karşılaştırılabilir mi.
+ *
+ * Marka varsa CEVAP KESİN: ne yanlış ret ne yanlış kabul. D-021 bu kuralı
+ * "doğru olamaz" diye kaydetmişti çünkü tipte ayırt edecek bilgi yoktu; bilgi
+ * artık tipte.
+ */
+type ColComparable<A, B> = BothBranded<A, B> extends true ? PgSameKind<A, B> : [PgFamily<A>] extends [PgFamily<B>] ? true : false;
+/** `Row`'un `V` ile karşılaştırılabilir kolonları. */
 type ColumnsComparableTo<Row, V> = {
-    [K in keyof Row]-?: PgFamily<Row[K]> extends PgFamily<V> ? K : never;
+    [K in keyof Row]-?: ColComparable<Row[K], V> extends true ? K : never;
 }[keyof Row];
 /**
  * Bu satırın kolonlarından birine referans. `Row` bilinmiyorsa hiçbiri.
@@ -2985,7 +3054,26 @@ type ColumnsComparableTo<Row, V> = {
  * `findMany`'nin `Row`'u bilmediği yolların ve jsonb kolonlarının hâli, ve
  * ikisinde de tipin söyleyebileceği bir şey yok.
  */
-type ColRefOf<Row, V = unknown> = [keyof Row] extends [never] ? never : [unknown] extends [V] ? ColRef<Extract<keyof Row, string>> : ColRef<Extract<ColumnsComparableTo<Row, V>, string>>;
+/**
+ * "Kısıt verilmedi" için AYRI bir işaret — `unknown` DEĞİL.
+ *
+ * Eskiden varsayılan `unknown`'dı ve dal `[unknown] extends [V]` ile
+ * seçiliyordu. Ama `jsonb` kolonlarının DEĞER TİPİ de `unknown`: yani gerçek
+ * bir jsonb kolonu "kısıt verilmedi" sanılıp TÜM kolonlarla karşılaştırılabilir
+ * hâle geliyordu. D-021 bunu "jsonb ↔ text derleniyor" diye kaydetmişti ve PG
+ * markası tek başına kapatmadı — `unknown & X` kesişimi `X`'e çöktüğü için
+ * jsonb markalanamıyor (markalamak kolonu daraltıp meşru yazmaları kırdı,
+ * gerçek projede ölçüldü).
+ *
+ * Ayrı bir işaretle iki durum artık ayrışıyor: kısıtsız yol kısıtsız kalıyor,
+ * jsonb ise KENDİ ailesine düşüyor — yani yalnız başka bir jsonb ile
+ * karşılaştırılabiliyor.
+ */
+declare const NO_CONSTRAINT: unique symbol;
+type NoColConstraint = {
+    readonly [NO_CONSTRAINT]: true;
+};
+type ColRefOf<Row, V = NoColConstraint> = [keyof Row] extends [never] ? never : [V] extends [NoColConstraint] ? ColRef<Extract<keyof Row, string>> : ColRef<Extract<ColumnsComparableTo<Row, V>, string>>;
 /**
  * Doğrulanmış, GÖMÜLEBİLİR bir SQL parçası (FR-018, FR-019).
  *
@@ -3063,7 +3151,7 @@ type TextOps<V> = V extends string ? {
  * kolonunda YASAKLAMAK yazarı bu yüzden `sqlFragment`e düşürürdü — ve bu
  * özelliğin var olma nedeni tam olarak o düşüşü kaldırmak.
  */
-type NowComparable<V> = [NonNullable<V>] extends [string | Date] ? TxNow : never;
+type NowComparable<V> = "?" extends PgTag<V> ? [NonNullable<V>] extends [string | Date] ? TxNow : never : PgTag<V> extends "timestamp" ? TxNow : never;
 type WhereOpBody<V, C> = {
     gt?: V | C | NowComparable<V>;
     gte?: V | C | NowComparable<V>;
@@ -3246,6 +3334,15 @@ type QueryInput<Row, K extends keyof Row = keyof Row, Rels = unknown> = {
 type MutateInput<Row, Insert, Rels = unknown> = {
     where: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;
     set: SetShape<Insert>;
+    /**
+     * `false` verilirse SATIRLAR değil SAYI döner — `deleteMany` ile aynı şekil.
+     *
+     * ÖLÇÜLDÜ (200 bin satır, canlı pg16): `RETURNING *` sunucuda %55 daha
+     * pahalı (7,2 sn → 11,1 sn) ve JS'te 45 MB yığın tutuyor — satır başına 236
+     * bayt, yani bir milyon satırda 225 MB. Çoğu çağrı için dönen diziyi okumak
+     * DOĞRU ve varsayılan odur; toplu bir iş için çıkış yolu olması gerekiyordu.
+     */
+    returning?: boolean;
 };
 /**
  * `set`'e yazılabilen değer (FR-012): kolonun kendi tipi ya da — sayısal
@@ -3257,7 +3354,25 @@ type MutateInput<Row, Insert, Rels = unknown> = {
  * string de sayısal sayılır; ayrımı burada yapamayız, ama D-007 zaten miktarın
  * JS `number`'a hiç uğramamasını istiyor.
  */
-type SetValue<V> = V | (NonNullable<V> extends number | string ? TxColumnExpr : never) | (NonNullable<V> extends Date ? TxNow : never);
+/** `increment()`/`decrement()` HANGİ kolonlarda anlamlı — bildirilmiş PG tipine
+ *  göre. Marka yoksa eski sezgisel (`number | string`), ki o `text` kolonda da
+ *  izin veriyordu: Postgres `text + 1` demez. */
+type NumericCol<V> = "?" extends PgTag<V> ? NonNullable<V> extends number | string ? TxColumnExpr : never : PgKind<PgTag<V>> extends "num" ? TxColumnExpr : never;
+/**
+ * Bir EKLEME yolunda yazılabilecek değer.
+ *
+ * Kolonun kendi tipi ya da — zaman kolonlarında — sunucu saati. `increment()`
+ * burada YOK ve olamaz: satır henüz yokken "kolonun şu anki değeri" diye bir
+ * şey yok, motor da bunu adıyla reddediyor.
+ *
+ * Var olma nedeni ölçülmüş: introspect edilmiş şemalarda zaman kolonlarının
+ * çoğu varsayılansız (`timestamp()`), yani "eklerken sunucu saatini yaz"ın tek
+ * karşılığı istemci saatiydi — 33 tablolu bir projede 12 yerde.
+ */
+type InsertValues<Insert> = {
+    [K in keyof Insert]: Insert[K] | NowComparable<Insert[K]>;
+};
+type SetValue<V> = V | NumericCol<V> | NowComparable<V>;
 /** Bir update'in `set`'i: insert şeklinin herhangi bir alt kümesi, ifadelerle. */
 type SetShape<Insert> = {
     [K in keyof Insert]?: SetValue<Insert[K]>;
@@ -3338,9 +3453,90 @@ type RecommendParamsTyped<T extends TableTypes> = SimilarParamsTyped<T> & {
 type RelsOf<T> = T extends {
     relations: infer R;
 } ? R : unknown;
+/**
+ * TOPLAMA — dönüş tipi PG markasından TÜRETİLİR, tahmin edilmez.
+ *
+ * Para bu SDK'dan geçecek, ve toplamada kaybedilecek tek şey kesinliktir:
+ * `sum(numeric)` Postgres'te `numeric`, `sum(integer)` `bigint` — İKİSİ DE JS
+ * `number`'ında kayıplı. Bu yüzden `sum`/`avg` HER ZAMAN `string` döner ve
+ * motor `::text` ile döker. D-007'nin kapattığı hata buydu:
+ * 41.00821234567890123 canlıda 41.0082123456789 oluyordu.
+ *
+ * `| null` bir süs değil: Postgres BOŞ kümede NULL döndürür, 0 değil. "Hiç
+ * satır yoktu" ile "toplam sıfırdı" farklı şeyler, ve tip bunu sormaya
+ * ZORLUYOR.
+ */
+type SummableCols<Row> = {
+    [K in keyof Row]-?: "?" extends PgTag<Row[K]> ? NonNullable<Row[K]> extends number | string ? K : never : PgKind<PgTag<Row[K]>> extends "num" ? K : never;
+}[keyof Row];
+/** `min`/`max` sıralanabilir her kolonda — jsonb ve vektör hariç. */
+type OrderableCols<Row> = {
+    [K in keyof Row]-?: "?" extends PgTag<Row[K]> ? NonNullable<Row[K]> extends number | string | Date ? K : never : PgTag<Row[K]> extends "jsonb" | "vector" ? never : K;
+}[keyof Row];
+type AggCols<Row> = Extract<SummableCols<Row>, string>;
+type AggOrderCols<Row> = Extract<OrderableCols<Row>, string>;
+type AggregateInput<Row, Rels = unknown> = {
+    where?: WhereFilter<Row> | SqlFragment | HasBranch<Row, Rels>;
+    /** Toplam — yalnız sayısal kolonlarda; sonuç `string | null` (kayıpsız). */
+    sum?: readonly AggCols<Row>[];
+    /** Ortalama — sonuç `numeric`, yani `string | null`. */
+    avg?: readonly AggCols<Row>[];
+    min?: readonly AggOrderCols<Row>[];
+    max?: readonly AggOrderCols<Row>[];
+    /** Kaç satır — `count()` ile aynı sayı, ama AYNI turda. */
+    count?: boolean;
+    /** Verilirse SATIRLAR döner ve her satır grup kolonlarını taşır. */
+    groupBy?: readonly Extract<keyof Row, string>[];
+};
+type AggPart<Q, Row, F extends "sum" | "avg" | "min" | "max"> = Q extends {
+    [K in F]: readonly (infer C extends keyof Row)[];
+} ? {
+    [P in C]: F extends "sum" | "avg" ? string | null : Row[P] | null;
+} : never;
+type AggBody<Q, Row> = ([AggPart<Q, Row, "sum">] extends [never] ? unknown : {
+    sum: AggPart<Q, Row, "sum">;
+}) & ([AggPart<Q, Row, "avg">] extends [never] ? unknown : {
+    avg: AggPart<Q, Row, "avg">;
+}) & ([AggPart<Q, Row, "min">] extends [never] ? unknown : {
+    min: AggPart<Q, Row, "min">;
+}) & ([AggPart<Q, Row, "max">] extends [never] ? unknown : {
+    max: AggPart<Q, Row, "max">;
+}) & (Q extends {
+    count: true;
+} ? {
+    count: number;
+} : unknown);
+type AggregateResult<Q, Row> = Q extends {
+    groupBy: readonly (infer G extends keyof Row)[];
+} ? ({
+    [P in G]: Row[P];
+} & AggBody<Q, Row>)[] : AggBody<Q, Row>;
 /** Temel tablo erişimcisi — search'süz beş op. */
 interface EnvTypedTableBase<T extends TableTypes> {
-    insert(data: T["insert"]): Promise<T["row"]>;
+    insert(data: InsertValues<T["insert"]>): Promise<T["row"]>;
+    /**
+     * Çok satırı TEK statement'la ekle (tek gidiş-dönüş).
+     *
+     * ```ts
+     * await Database.public.journey_stops.insertMany(
+     *   stops.map((s, i) => ({ journey_id, name: s.name, sort_order: i })),
+     * );
+     * ```
+     *
+     * Satırların anahtar kümesi AYNI olmalı: tek statement kolon listesini
+     * paylaşır, yani farklı şekilli bir satırın fazla kolonu sessizce yazılmaz
+     * ve eksiği yanlış sütuna kayardı. Eksik alan için `null` yazın.
+     *
+     * Boş dizi boş sonuç döner — hata değil: "eklenecek bir şey yoktu".
+     */
+    insertMany(rows: readonly InsertValues<T["insert"]>[], opts?: {
+        /** Çakışmanın ARANDIĞI kolonlar — benzersiz bir kısıt ya da index taşımalı. */
+        onConflict: readonly Extract<keyof T["row"], string>[];
+        /** `"ignore"` (VARSAYILAN, plan yoluyla aynı) çakışanı atlar ve o satır
+         *  SONUÇTA DÖNMEZ — Postgres yalnız yazdıklarını döndürür; `"update"`
+         *  üzerine yazar. */
+        action?: "ignore" | "update";
+    }): Promise<T["row"][]>;
     /**
      * Bir idempotency anahtarını sahiplen (FR-033).
      *
@@ -3356,7 +3552,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * İlk argüman satırı BULAN alanlar, ikincisi yalnız yazılanlar — ikinci çağrı
      * farklı bir yük gönderse bile satır anahtarla bulunur.
      */
-    claim(unique: Partial<T["insert"]>, extra?: Partial<T["insert"]>): Promise<{
+    claim(unique: Partial<T["insert"]>, extra?: Partial<InsertValues<T["insert"]>>): Promise<{
         inserted: boolean;
         row: T["row"];
     }>;
@@ -3381,7 +3577,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * seçmeyi kolay yapıyordu.
      */
     put(q: {
-        data: T["insert"];
+        data: InsertValues<T["insert"]>;
         onConflict: readonly Extract<keyof T["row"], string>[];
     }): Promise<T["row"]>;
     /** Update the row by id; resolves to the updated row, or `null` if no row
@@ -3391,7 +3587,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
         where: {
             id: string;
         };
-        set: Partial<T["insert"]>;
+        set: SetShape<T["insert"]>;
     }): Promise<T["row"] | null>;
     delete(id: string): Promise<void>;
     findById(id: string): Promise<T["row"] | null>;
@@ -3413,11 +3609,34 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * if (row === undefined) throw new Conflict("yetersiz bakiye");
      * ```
      */
-    updateMany(q: MutateInput<T["row"], T["insert"], RelsOf<T>>): Promise<T["row"][]>;
+    updateMany<const Q extends MutateInput<T["row"], T["insert"], RelsOf<T>>>(q: Q): Promise<Q extends {
+        returning: false;
+    } ? number : T["row"][]>;
     /** Delete every matching row; resolves to how many. Empty filter refused. */
     deleteMany(q: {
         where: WhereFilter<T["row"]> | SqlFragment | HasBranch<T["row"], RelsOf<T>>;
     }): Promise<number>;
+    /**
+     * Toplama — `sum` / `avg` / `min` / `max` / `count`, isteğe bağlı `groupBy`.
+     *
+     * ```ts
+     * const r = await Database.public.entries.aggregate({
+     *   where: { account_id },
+     *   sum: ["amount_kurus"],
+     *   count: true,
+     * });
+     * r.sum.amount_kurus;   // string | null — KAYIPSIZ
+     * r.count;              // number
+     * ```
+     *
+     * `sum`/`avg` yalnız sayısal kolonlarda ve HER ZAMAN `string` döner: para JS
+     * `number`'ına uğradığı anda kesinliğini kaybeder. `| null` çünkü Postgres
+     * boş kümede NULL döndürür — "hiç satır yoktu" ile "toplam sıfırdı" farklı
+     * şeyler ve tip bunu sormaya zorluyor.
+     *
+     * `groupBy` verilirse dönüş bir DİZİ ve her satır grup kolonlarını taşır.
+     */
+    aggregate<const Q extends AggregateInput<T["row"], RelsOf<T>>>(q: Q): Promise<AggregateResult<Q, T["row"]>>;
     /** How many rows match. An empty filter is legitimate: counting is a read. */
     count(q?: {
         where?: WhereFilter<T["row"]> | SqlFragment | HasBranch<T["row"], RelsOf<T>>;
@@ -3426,7 +3645,7 @@ interface EnvTypedTableBase<T extends TableTypes> {
      * kapanır (valid_to/superseded_by), yenisi TEK savepoint'te eklenir; dönüş
      * yeni satır. Validity beyanı olmayan tabloda adlandırılmış çalışma-zamanı
      * hatası — tip düzeyinde ayrım env `Tables` bayrağı taşımadığından yapılamaz. */
-    supersede(id: string, row: T["insert"]): Promise<T["row"]>;
+    supersede(id: string, row: InsertValues<T["insert"]>): Promise<T["row"]>;
 }
 /** Tablo erişimcisi: env girdisi `searchable: true` taşıyorsa (vector kolonu ya da
  * search beyanı — env-gen üretir) `search()` üyesi VARDIR; yoksa üye hiç yoktur ve
@@ -4362,6 +4581,22 @@ interface DBOps {
      */
     query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
     insert(table: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Çok satır, TEK statement. Satırların anahtar kümesi aynı olmalı — kolon
+     *  listesi paylaşıldığı için farklı şekilli bir satırın kolonu sessizce
+     *  yazılmazdı. */
+    aggregate(table: string, q: {
+        where?: Record<string, unknown>;
+        sum?: readonly string[];
+        avg?: readonly string[];
+        min?: readonly string[];
+        max?: readonly string[];
+        count?: boolean;
+        groupBy?: readonly string[];
+    }): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    insertMany(table: string, rows: readonly Record<string, unknown>[], opts?: {
+        onConflict: readonly string[];
+        action?: "ignore" | "update";
+    }): Promise<Record<string, unknown>[]>;
     /**
      * Insert the row, or update it when it collides on `onConflict` — one
      * statement, so two concurrent callers cannot both lose.
@@ -4435,7 +4670,9 @@ interface DBOps {
      * yetmedi) — ikisini ayıran tek şey dönen dizidir. Çağrı hata fırlatmadı diye
      * işlem oldu SAYILAMAZ; kontrol çağıranın işi.
      */
-    updateMany(table: string, where: Record<string, unknown>, set: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    updateMany(table: string, where: Record<string, unknown>, set: Record<string, unknown>, opts?: {
+        returning?: boolean;
+    }): Promise<Record<string, unknown>[] | number>;
     /**
      * Bir idempotency anahtarını sahiplen (FR-033).
      *