@venizia/ignis-docs 0.2.1-0 → 0.2.1-1

package/content/references/base/filter-system/array-operators.md

@@ -23,44 +23,34 @@ Find rows where the array column contains **all** specified elements.
 // Schema: tags varchar(100)[]
 // Data: Product A has ['electronics', 'featured', 'sale']
 
-// Find products with BOTH 'electronics' AND 'featured'
 { where: { tags: { contains: ['electronics', 'featured'] } } }
 // SQL: "tags"::text[] @> ARRAY['electronics', 'featured']::text[]
-
-// Single element (can pass single value or array)
-{ where: { tags: { contains: ['featured'] } } }
-{ where: { tags: { contains: 'featured' } } }  // Also works
-// Matches: ['featured'], ['featured', 'sale'], ['a', 'featured', 'b']
 ```
 
+> [!NOTE]
+> A single value is wrapped in an array automatically: `{ contains: 'featured' }` is treated as `{ contains: ['featured'] }`.
+
 
 ## containedBy (<@)
 
 Find rows where **all** array elements are within the specified set.
 
 ```typescript
-// Find products where ALL tags are in the allowed list
 { where: { tags: { containedBy: ['sale', 'featured', 'new', 'popular'] } } }
 // SQL: "tags"::text[] <@ ARRAY['sale', 'featured', 'new', 'popular']::text[]
-
-// Product A ['featured', 'sale'] -> matches (all in list)
-// Product B ['featured', 'clearance'] -> no match ('clearance' not in list)
-// Product C [] -> matches (empty is subset of everything)
 ```
 
+> [!NOTE]
+> An empty array is a subset of every set, so `tags: []` always matches `containedBy`.
+
 
 ## overlaps (&&)
 
 Find rows where the arrays share at least one common element.
 
 ```typescript
-// Find products with 'premium' OR 'sale' tag
 { where: { tags: { overlaps: ['premium', 'sale'] } } }
 // SQL: "tags"::text[] && ARRAY['premium', 'sale']::text[]
-
-// Product A ['featured', 'sale'] -> matches (has 'sale')
-// Product B ['premium', 'luxury'] -> matches (has 'premium')
-// Product C ['new', 'featured'] -> no match (no overlap)
 ```
 
 
@@ -84,52 +74,41 @@ Find rows where the arrays share at least one common element.
 | "Must have AT LEAST ONE of these tags" | `overlaps` |
 
 
-## Empty Array Behavior
-
-| Operator | SQL Generated | Behavior |
-|----------|---------------|----------|
-| `contains: []` | `WHERE true` | Returns **ALL** rows |
-| `containedBy: []` | `WHERE "col" = '{}'` | Returns only rows with **empty arrays** |
-| `overlaps: []` | `WHERE false` | Returns **NO** rows |
-
-> [!NOTE]
-> Single values are automatically wrapped in an array: `{ contains: 'value' }` is treated as `{ contains: ['value'] }`.
-
-
 ## Type Handling
 
-**String Arrays** (`varchar[]`, `text[]`, `char[]`):
+The element type of the array column decides the cast in the generated SQL.
+
 ```typescript
+// String arrays (varchar[], text[], char[]) - both sides cast to text[]
 { where: { tags: { contains: ['a', 'b'] } } }
 // SQL: "tags"::text[] @> ARRAY['a', 'b']::text[]
-```
 
-Both the column and the array literal are cast to `text[]` for compatibility.
-
-**Numeric Arrays** (`integer[]`, `numeric[]`):
-```typescript
+// Numeric arrays (integer[], numeric[]) - no cast needed
 { where: { scores: { contains: [100, 200] } } }
 // SQL: "scores" @> ARRAY[100, 200]
-```
-
-No casting needed for numeric arrays.
 
-**Boolean Arrays**:
-```typescript
+// Boolean arrays - no cast needed
 { where: { flags: { contains: [true, false] } } }
 // SQL: "flags" @> ARRAY[true, false]
 ```
 
 
+## Empty Array Behavior
+
+| Operator | SQL generated | Behavior |
+|----------|---------------|----------|
+| `contains: []` | `WHERE true` | Returns **ALL** rows |
+| `containedBy: []` | `WHERE "col" = '{}'` | Returns only rows with **empty arrays** |
+| `overlaps: []` | `WHERE false` | Returns **NO** rows |
+
+
 ## Security: Parameterized Values
 
-Every element of `contains`/`containedBy`/`overlaps` is bound as a query parameter -- only the operator token (`@>`/`<@`/`&&`) is raw SQL. See [The Hardening Round](../../../changelogs/2026-07-13-hardening-round) for the prior injection this closed.
+Every element of `contains`/`containedBy`/`overlaps` is bound as a query parameter - only the operator token (`@>`/`<@`/`&&`) is raw SQL. See [The Hardening Round](../../../changelogs/2026-07-13-hardening-round) for the prior injection this closed.
 
 
 ## Defining Array Columns
 
-In your Drizzle schema:
-
 ```typescript
 import { pgTable, text, varchar, integer } from 'drizzle-orm/pg-core';
 
@@ -137,7 +116,6 @@ export const productTable = pgTable('Product', {
   id: text('id').primaryKey(),
   name: text('name').notNull(),
 
-  // Array columns
   tags: varchar('tags', { length: 100 }).array(),      // varchar(100)[]
   categories: text('categories').array(),              // text[]
   scores: integer('scores').array(),                   // integer[]
@@ -152,6 +130,6 @@ export const productTable = pgTable('Product', {
 
 **Files:**
 
-- [`packages/core/src/connectors/postgres/repositories/dialect/query.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/dialect/query.ts) - `PostgresQueryOperators.FNS`, `buildPgArrayComparison`
-- [`packages/core/src/connectors/postgres/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/dialect/filter.ts) - `FilterBuilder`, translates `TFilter` to Drizzle/SQL
-- [`packages/core/src/base/repositories/common/operators.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/base/repositories/common/operators.ts) - `QueryOperators` constants
+- [`packages/core-server/src/connectors/postgres/repositories/dialect/query.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/postgres/repositories/dialect/query.ts) - `PostgresQueryOperators.FNS`, `buildPgArrayComparison`
+- [`packages/core-server/src/connectors/relational/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/relational/repositories/dialect/filter.ts) - `FilterBuilder`, translates `TFilter` to Drizzle/SQL
+- [`packages/filter/src/common/operators.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/filter/src/common/operators.ts) - `QueryOperators` constants

package/content/references/base/filter-system/comparison-operators.md

@@ -6,116 +6,96 @@ difficulty: intermediate
 
 # Comparison Operators
 
-Equality and comparison operators for filtering records.
+Compares a field against a value: equality, inequality, and ordering.
 
+| Operator | SQL | Meaning |
+|----------|-----|---------|
+| `eq` | `=` / `IS NULL` | Equal to |
+| `ne` | `!=` / `IS NOT NULL` | Not equal to |
+| `neq` | `!=` / `IS NOT NULL` | Alias for `ne` |
+| `gt` | `>` | Greater than |
+| `gte` | `>=` | Greater than or equal |
+| `lt` | `<` | Less than |
+| `lte` | `<=` | Less than or equal |
 
-## eq - Equal To
-
-Matches records where field equals the value.
+## eq
 
 ```typescript
-// Implicit equality
-{ where: { status: 'active' } }
-
-// Explicit form
 { where: { status: { eq: 'active' } } }
-
 // SQL: WHERE "status" = 'active'
 ```
 
-**Special Cases:**
-```typescript
-// Null equality
-{ where: { deletedAt: null } }
-{ where: { deletedAt: { eq: null } } }
-// SQL: WHERE "deleted_at" IS NULL
-
-// Array shorthand (becomes IN)
-{ where: { id: [1, 2, 3] } }
-// SQL: WHERE "id" IN (1, 2, 3)
-
-// Empty array shorthand
-{ where: { id: [] } }
-// SQL: WHERE false (no results)
-```
-
+**Notice:** the bare shorthand `{ status: 'active' }` (no operator key) means the same thing.
 
-## ne / neq - Not Equal To
+**Edge cases:**
+- `{ eq: null }` compiles to `IS NULL`, never `= NULL`.
+- Bare array `{ field: [1, 2, 3] }` (no operator key) compiles to `IN (1, 2, 3)`.
+- An explicit `{ eq: [1, 2, 3] }` does not become `IN` - it compares the column to an array value.
+- Bare empty array `{ field: [] }` matches no rows (`WHERE false`).
 
-Matches records where field does NOT equal the value. Both `ne` and `neq` are aliases and behave identically.
+## ne / neq
 
 ```typescript
 { where: { status: { ne: 'deleted' } } }
-{ where: { status: { neq: 'deleted' } } }  // Alias
-
 // SQL: WHERE "status" != 'deleted'
-
-// Null handling
-{ where: { deletedAt: { ne: null } } }
-{ where: { deletedAt: { neq: null } } }
-// SQL: WHERE "deleted_at" IS NOT NULL
 ```
 
-> [!NOTE]
-> When compared against a **real value** (not `null`), `ne`/`neq` follow SQL three-valued logic: a row whose field is `NULL` never matches `{ field: { neq: value } }`, because `NULL <> value` evaluates to UNKNOWN rather than TRUE. To include NULL rows, add an explicit branch: `{ or: [{ field: { neq: value } }, { field: null }] }`.
+**Notice:** `ne` and `neq` are the same operator under two names.
 
+**Edge cases:**
+- `{ ne: null }` compiles to `IS NOT NULL`.
+- SQL three-valued logic applies: a `NULL` field never matches `{ ne: value }`, because `NULL <> value` is UNKNOWN.
+- Add an `or` branch to include NULL rows: `{ or: [{ field: { ne: value } }, { field: null }] }`.
 
-## gt - Greater Than
+## gt
 
 ```typescript
-// Numbers
 { where: { price: { gt: 100 } } }
 // SQL: WHERE "price" > 100
-
-// Dates
-{ where: { createdAt: { gt: new Date('2024-01-01') } } }
-// SQL: WHERE "created_at" > '2024-01-01'
-
-// Strings (lexicographic)
-{ where: { name: { gt: 'M' } } }
-// SQL: WHERE "name" > 'M'
 ```
 
+**Notice:** works on numbers, dates, and strings (lexicographic comparison).
+
+**Edge cases:**
+- `{ gt: null }` compiles to `"price" > NULL`, which is never true - no rows match.
+- Use `is`/`exists` instead to check for null.
+- Combine with other operators in the same object: `{ gte: 18, lt: 65 }`.
 
-## gte - Greater Than or Equal
+## gte
 
 ```typescript
 { where: { quantity: { gte: 10 } } }
 // SQL: WHERE "quantity" >= 10
-
-// Combined with other operators
-{ where: { age: { gte: 18, lt: 65 } } }
-// SQL: WHERE "age" >= 18 AND "age" < 65
 ```
 
+**Notice:** inclusive of the boundary value.
+
+**Edge cases:**
+- Same null behavior as `gt`: `{ gte: null }` matches no rows.
 
-## lt - Less Than
+## lt
 
 ```typescript
 { where: { stock: { lt: 5 } } }
 // SQL: WHERE "stock" < 5
 ```
 
+**Notice:** exclusive of the boundary value.
+
+**Edge cases:**
+- Same null behavior as `gt`: `{ lt: null }` matches no rows.
 
-## lte - Less Than or Equal
+## lte
 
 ```typescript
 { where: { rating: { lte: 3 } } }
 // SQL: WHERE "rating" <= 3
 ```
 
+**Notice:** inclusive of the boundary value.
 
-## Summary
-
-| Operator | SQL | Description |
-|----------|-----|-------------|
-| `eq` | `=` / `IS NULL` | Equal to (handles null) |
-| `ne` | `!=` / `IS NOT NULL` | Not equal to (handles null) |
-| `neq` | `!=` / `IS NOT NULL` | Alias for `ne` |
-| `gt` | `>` | Greater than |
-| `gte` | `>=` | Greater than or equal |
-| `lt` | `<` | Less than |
-| `lte` | `<=` | Less than or equal |
+**Edge cases:**
+- Same null behavior as `gt`: `{ lte: null }` matches no rows.
 
 ## See also
 
@@ -125,6 +105,6 @@ Matches records where field does NOT equal the value. Both `ne` and `neq` are al
 
 **Files:**
 
-- [`packages/core/src/connectors/postgres/repositories/dialect/query.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/dialect/query.ts) - `PostgresQueryOperators.FNS`, per-operator SQL builders
-- [`packages/core/src/connectors/postgres/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/dialect/filter.ts) - `FilterBuilder`, translates `TFilter` to Drizzle/SQL
-- [`packages/core/src/base/repositories/common/operators.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/base/repositories/common/operators.ts) - `QueryOperators` constants
+- [`packages/core-server/src/connectors/postgres/repositories/dialect/query.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/postgres/repositories/dialect/query.ts) - `PostgresQueryOperators.FNS`, per-operator SQL builders
+- [`packages/core-server/src/connectors/relational/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/relational/repositories/dialect/filter.ts) - `FilterBuilder`, translates `TFilter` to Drizzle/SQL
+- [`packages/filter/src/common/operators.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/filter/src/common/operators.ts) - `QueryOperators` constants

package/content/references/base/filter-system/default-filter.md

@@ -2,14 +2,12 @@
 title: Default Filter
 description: Automatically apply filter conditions to all repository queries
 difficulty: intermediate
-lastUpdated: 2026-03-15
+lastUpdated: 2026-07-23
 ---
 
 # Default Filter <Badge type="tip" text="v0.0.5+" />
 
-A model's `settings.defaultFilter` merges into every `find`/`findOne`/`findById`/`count`/`updateAll`/`deleteAll` call for that model - the standard way to implement soft delete, multi-tenancy, active-record scoping, and query-limit protection without repeating a `where` clause at every call site.
-
-## Quick start
+A model's `settings.defaultFilter` merges into every `find`/`findOne`/`findById`/`count`/`updateById`/`updateAll`/`deleteById`/`deleteAll` call for that model. It's the standard way to implement soft delete, multi-tenancy, active-record scoping, and query-limit protection without repeating a `where` clause at every call site.
 
 ```typescript
 import { model, BaseEntity } from '@venizia/ignis';
@@ -17,15 +15,21 @@ import { userTable } from '@/schemas';
 
 @model({
   type: 'entity',
-  settings: {
-    defaultFilter: { where: { isDeleted: false }, limit: 100 },
-  },
+  settings: { defaultFilter: { where: { isDeleted: false }, limit: 100 } },
 })
 export class User extends BaseEntity<typeof User.schema> {
   static override schema = userTable;
 }
 ```
 
+## Options
+
+| Option | Type | Default | Meaning |
+|---|---|---|---|
+| `settings.defaultFilter` | `TFilter` | none | Filter merged into every query for the model - `where`, `limit`, `offset`, `order`, `fields`, `include` are all valid inside it. |
+| `settings.defaultLimit` | `number` (positive integer) | `DEFAULT_LIMIT` (`10`) | Per-model row cap. Independent of `defaultFilter` - see [Fields, Order & Pagination -> Default limit resolution](./fields-order-pagination#default-limit-resolution). |
+| `options.shouldSkipDefaultFilter` | `boolean` | `false` | Skips the `defaultFilter` merge for one call. Does not drop `defaultLimit`. |
+
 ```typescript
 import { userRepository } from '@/repositories';
 
@@ -38,7 +42,7 @@ await userRepository.find({ filter: { where: { status: 'active' } } });
 `applyDefaultFilter()` merges the model's `defaultFilter` with the caller's filter via `FilterBuilder.mergeFilter()`.
 
 - **`where` narrows per-key.** See the narrowing law below.
-- **Everything else is user-wins-if-provided.** A caller value replaces the default, but a caller value of `undefined` never does - a filter built by spreading an optional object can't silently blow away a tenant scope or a limit.
+- **Everything else is user-wins-if-provided.** A caller value replaces the default, but a caller value of `undefined` never does. A filter built by spreading an optional object can't silently blow away a tenant scope or a limit.
 
 | Property | Merge strategy |
 |---|---|
@@ -47,7 +51,7 @@ await userRepository.find({ filter: { where: { status: 'active' } } });
 
 ### The `where` narrowing law
 
-Keys present on only one side pass through untouched. When the **same key** appears on both sides, the outcome depends on shape:
+Keys present on only one side pass through untouched. When the same key appears on both sides, the outcome depends on shape:
 
 | Default | Caller | Result |
 |---|---|---|
@@ -58,7 +62,7 @@ Keys present on only one side pass through untouched. When the **same key** appe
 
 - **`and` collisions concatenate.** Both conjunct lists merge into one.
 - **`or` collisions cannot concatenate** - that would union, not narrow - so each side's `or` group becomes its own conjunct instead.
-- **Non-scalar collisions always AND-compose.** A default scope - a `createdAt` floor, a tenant `inq` - can be narrowed by a caller filter but never widened or dropped.
+- **Non-scalar collisions always AND-compose.** Take a default scope - a `createdAt` floor, a tenant `inq`. A caller filter can narrow it, but never widen or drop it.
 - **Only scalar-over-scalar is a true override.** Every other collision shape composes rather than replaces.
 
 ```typescript
@@ -80,7 +84,7 @@ Non-colliding keys still combine with an implicit AND, exactly like two `where`
 
 ## Bypassing the default filter
 
-Pass `shouldSkipDefaultFilter: true` in `options` to skip the merge entirely. It is honored by every repository verb - `find`, `findOne`, `findById`, `count`, `updateById`, `updateAll`, `deleteById`, `deleteAll`:
+Pass `shouldSkipDefaultFilter: true` in `options` to skip the merge entirely. Every repository verb honors it - `find`, `findOne`, `findById`, `count`, `updateById`, `updateAll`, `deleteById`, `deleteAll`:
 
 ```typescript
 // Normal - default filter applies
@@ -95,6 +99,17 @@ await repository.find({
 // WHERE "role" = 'admin' (includes soft-deleted rows)
 ```
 
+`updateById` and `deleteById` merge the default filter into their `{ id }` condition the same way `updateAll`/`deleteAll` merge it into their `where`. The bypass applies to all four identically:
+
+```typescript
+// Also merges the default filter into { id: postId } - skip to update a soft-deleted row
+await postRepository.updateById({
+  id: postId,
+  data: { title: 'Restored' },
+  options: { shouldSkipDefaultFilter: true },
+});
+```
+
 It composes with a transaction the same way any other option does:
 
 ```typescript
@@ -121,9 +136,25 @@ try {
 | Cross-tenant analytics | Count/aggregate across every tenant |
 | Data migration | Update rows regardless of status |
 
+`shouldSkipDefaultFilter` lives on the same options interface every repository verb accepts:
+
+```typescript
+interface IExtraOptions extends IWithTransaction {
+  shouldSkipDefaultFilter?: boolean;
+  log?: TRepositoryLogOptions;
+  lock?: TLockOptions;
+}
+
+interface IWithTransaction {
+  transaction?: ITransaction;
+}
+```
+
+`log` and `lock` are documented in [Advanced Repository Features](../repositories/advanced.md) - `log` only takes effect on write verbs (`create`/`updateById`/`updateAll`/`deleteById`/`deleteAll`), not on reads.
+
 ## Configuring a default filter
 
-Any `TFilter` property is valid inside `defaultFilter` - `where`, `limit`, `offset`, `order`, `fields`, `include` (see [Filter System Overview](./)). The two recurring shapes:
+Any `TFilter` property is valid inside `defaultFilter` - `where`, `limit`, `offset`, `order`, `fields`, `include` (see [Filter System Overview](./)). Two shapes cover most cases.
 
 **Soft delete or multi-tenant scoping** - a `where` clause that every query must carry:
 
@@ -144,7 +175,7 @@ await postRepository.updateById({
 });
 ```
 
-**Query-limit protection** - prefer the dedicated `settings.defaultLimit` over a `limit` inside `defaultFilter`. It resolves independently (`query.limit ?? defaultLimit ?? 10`, see [Fields, Order & Pagination -> Default Limit](./fields-order-pagination#default-limit)) and, unlike `defaultFilter`, is **not** dropped by `shouldSkipDefaultFilter`:
+**Query-limit protection** - prefer the dedicated `settings.defaultLimit` over a `limit` inside `defaultFilter`. It resolves independently (`query.limit ?? defaultLimit ?? 10`, see [Fields, Order & Pagination -> Default limit resolution](./fields-order-pagination#default-limit-resolution)). Unlike `defaultFilter`, it is not dropped by `shouldSkipDefaultFilter`:
 
 ```typescript
 @model({
@@ -153,7 +184,7 @@ await postRepository.updateById({
 })
 export class LogEntry extends BaseEntity<typeof LogEntry.schema> {}
 
-await logEntryRepository.find({ filter: {} });           // LIMIT 1000
+await logEntryRepository.find({ filter: {} }); // LIMIT 1000
 await logEntryRepository.find({ filter: { limit: 50 } }); // LIMIT 50
 ```
 
@@ -190,7 +221,7 @@ await repository.find({
                               +------------------+
 ```
 
-`RelationalBaseRepository` (compatibility alias `PostgresBaseRepository`, `packages/core/src/connectors/postgres/repositories/core/base.ts`) implements the default-filter behavior directly - no mixin is composed onto it:
+`RelationalBaseRepository` (compatibility alias `PostgresBaseRepository`, `packages/core-server/src/connectors/postgres/repositories/core/base.ts`) implements the default-filter behavior directly - no mixin is composed onto it:
 
 ```typescript
 hasDefaultFilter(): boolean
@@ -199,53 +230,26 @@ getDefaultLimit(): number | undefined
 applyDefaultFilter(opts: { userFilter?: TFilter; shouldSkipDefaultFilter?: boolean }): TFilter
 ```
 
-`getDefaultFilter()` reads `this.modelSettings?.defaultFilter`, where `modelSettings` is a protected getter on `AbstractRepository` (`src/base/repositories/core/abstract.ts`) resolved from `MetadataRegistry` by the entity's constructor (not by name string) on first access, then memoized.
+`getDefaultFilter()` reads `this.modelSettings?.defaultFilter`. `modelSettings` is a protected getter on `AbstractRepository` (`src/base/repositories/core/abstract.ts`), resolved from `MetadataRegistry` by the entity's constructor - not by name string - on first access, then memoized.
+
+Read verbs (`find`/`findOne`/`findById`/`count`) call `applyDefaultFilter()` directly. Write verbs (`updateById`/`updateAll`/`deleteById`/`deleteAll`) route through the shared `_update`/`_delete` helpers instead. Those helpers call it against `{ where: opts.where }` (or `{ id }` for the `ById` forms) before building the SQL condition.
 
 > [!NOTE]
 > An older `DefaultFilterMixin` implemented this same behavior via mixin composition. It is no longer composed onto any repository class - see [Repository Mixins (Removed)](../repositories/mixins.md) for history.
 
-The merge itself is `FilterBuilder.mergeFilter()`:
+The merge itself is `FilterBuilder.mergeFilter()`. Reach it through the datasource's query dialect -
+`FilterBuilder` is abstract, so you never construct it directly:
 
 ```typescript
-const filterBuilder = new FilterBuilder();
+const queryDialect = dataSource.getQueryDialect();
 
-filterBuilder.mergeFilter({
+queryDialect.mergeFilter({
   defaultFilter: { where: { isDeleted: false }, limit: 100 },
   userFilter: { where: { status: 'active' }, limit: 10 },
 });
 // { where: { isDeleted: false, status: 'active' }, limit: 10 }
 ```
 
-### `IExtraOptions`
-
-`shouldSkipDefaultFilter` lives on the same options interface every repository verb accepts:
-
-```typescript
-interface IExtraOptions extends IWithTransaction {
-  shouldSkipDefaultFilter?: boolean;
-  log?: TRepositoryLogOptions;
-  lock?: TLockOptions;
-}
-
-interface IWithTransaction {
-  transaction?: ITransaction;
-}
-```
-
-`log` and `lock` are documented in [Advanced Repository Features](../repositories/advanced.md) - `log` only takes effect on write verbs (`create`/`updateById`/`updateAll`/`deleteById`/`deleteAll`), not on reads.
-
-## Quick reference
-
-| Want to... | Code |
-|---|---|
-| Configure a default filter | `@model({ settings: { defaultFilter: { ... } } })` |
-| Bypass the default filter | `options: { shouldSkipDefaultFilter: true }` |
-| Bypass for one relation | `include: [{ relation: 'x', shouldSkipDefaultFilter: true }]` |
-| Combine with a transaction | `options: { transaction: tx, shouldSkipDefaultFilter: true }` |
-| Check if a model has a default | `repository.hasDefaultFilter()` |
-| Read the raw default filter | `repository.getDefaultFilter()` |
-| Read the raw default limit | `repository.getDefaultLimit()` |
-
 ## See also
 
 - [Filter System Overview](./) - the `filter` shape and every operator family
@@ -255,7 +259,9 @@ interface IWithTransaction {
 
 **Files:**
 
-- [`packages/core/src/connectors/postgres/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/dialect/filter.ts) - `FilterBuilder.mergeFilter()`/`mergeWhere()`, the narrowing merge
-- [`packages/core/src/connectors/postgres/repositories/core/base.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/connectors/postgres/repositories/core/base.ts) - `RelationalBaseRepository`, `applyDefaultFilter`/`getDefaultFilter`/`getDefaultLimit`
-- [`packages/core/src/base/metadata/persistents.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/base/metadata/persistents.ts) - `@model` decorator, `defaultLimit` validation
-- [`packages/core/src/base/repositories/common/types.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core/src/base/repositories/common/types.ts) - `IExtraOptions`, `IWithTransaction`
+- [`packages/core-server/src/connectors/relational/repositories/dialect/filter.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/relational/repositories/dialect/filter.ts) - `FilterBuilder.mergeFilter()`/`mergeWhere()`, the narrowing merge
+- [`packages/core-server/src/connectors/postgres/repositories/core/base.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/postgres/repositories/core/base.ts) - `RelationalBaseRepository`, `applyDefaultFilter`/`getDefaultFilter`/`getDefaultLimit`
+- [`packages/core-server/src/connectors/postgres/repositories/core/readable.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/postgres/repositories/core/readable.ts) - `find`/`findOne`/`count` calling `applyDefaultFilter`
+- [`packages/core-server/src/connectors/postgres/repositories/core/persistable.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/connectors/postgres/repositories/core/persistable.ts) - `_update`/`_delete` calling `applyDefaultFilter` for `updateById`/`updateAll`/`deleteById`/`deleteAll`
+- [`packages/core-server/src/base/metadata/persistents.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/base/metadata/persistents.ts) - `@model` decorator, `defaultLimit` validation
+- [`packages/core-server/src/base/repositories/common/types.ts`](https://github.com/VENIZIA-AI/ignis/blob/main/packages/core-server/src/base/repositories/common/types.ts) - `IExtraOptions`, `IWithTransaction`