@venizia/ignis-docs 0.0.8 → 0.2.0

package/content/references/base/repositories/mixins.md

@@ -1,335 +1,99 @@
 ---
-title: Repository Mixins
-description: Composable mixins for repository functionality
+title: Repository Mixins (Removed)
+description: FieldsVisibilityMixin and DefaultFilterMixin were removed - the behavior now lives on AbstractRepository and PostgresBaseRepository
 difficulty: intermediate
-lastUpdated: 2026-01-02
+lastUpdated: 2026-07-06
 ---
 
-# Repository Mixins <Badge type="tip" text="v0.0.5+" />
+# Repository Mixins <Badge type="danger" text="removed" />
 
-Composable mixins that provide reusable functionality for repository classes.
+> [!WARNING] Removed
+> `FieldsVisibilityMixin` and `DefaultFilterMixin` have been **removed** from IGNIS. They are no longer exported and must not be imported or composed in new code. This page remains as a tombstone documenting where the equivalent behavior now lives.
 
-> [!NOTE] Refactored in v0.0.5
-> Repository mixins were extracted and refactored in v0.0.5 to provide better composition and reusability.
+## What They Were
 
-**Files:** `packages/core/src/base/repositories/mixins/`
-
-
-## Overview
-
-Ignis uses the mixin pattern to compose repository features. This enables:
-
-- **Separation of concerns** - Each mixin handles one responsibility
-- **Reusability** - Mixins can be applied to different base classes
-- **Testability** - Individual features can be tested in isolation
-- **Flexibility** - Create custom repositories with only needed features
-
-
-## Available Mixins
+Before the connectors restructure, `AbstractRepository` composed two mixins onto `BaseHelper`:
 
 | Mixin | Responsibility |
 |-------|----------------|
-| `FieldsVisibilityMixin` | Hidden properties exclusion at SQL level |
-| `DefaultFilterMixin` | Automatic filter application from model settings |
+| `FieldsVisibilityMixin` | Hidden-properties exclusion at SQL level (reads `hiddenProperties` from `@model` settings) |
+| `DefaultFilterMixin` | Automatic default-filter merging (reads `defaultFilter` from `@model` settings) |
 
+## Where the Behavior Lives Now
 
-## FieldsVisibilityMixin
+The functionality was not dropped - it was folded directly into the repository hierarchy.
 
-Provides hidden properties management for SQL-level field exclusion. Reads `hiddenProperties` from `@model` metadata settings and builds a visible columns map for Drizzle's `select()` and `returning()` calls.
+### Engine-neutral: `AbstractRepository`
 
-**File:** `packages/core/src/base/repositories/mixins/fields-visibility.ts`
+**File:** `packages/core/src/base/repositories/core/abstract.ts`
 
-### Abstract Requirements
-
-Classes using this mixin must implement:
+`AbstractRepository` resolves `@model` settings by class (Reflect target) via `MetadataRegistry` and exposes them as protected getters, memoized after first access:
 
 ```typescript
-abstract getEntity(): BaseEntity<TTableSchemaWithId>;
+protected get modelSettings(): IModelMetadata['settings'];  // full @model settings
+protected get hiddenFields(): string[];                     // settings.hiddenProperties ?? []
+protected get defaultWhere(): TWhere | undefined;           // settings.defaultFilter?.where
+protected get defaultLimit(): number | undefined;           // settings.defaultLimit
 ```
 
-### Properties
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `_hiddenProperties` | `Set<string> \| null` | Cached hidden property names (`null` = not yet computed) |
-| `_visibleProperties` | `Record<string, any> \| null \| undefined` | Cached visible columns (`null` = not yet computed, `undefined` = computed with no hidden props) |
-
-### Methods
+### PostgreSQL: `PostgresBaseRepository`
 
-| Method | Returns | Description |
-|--------|---------|-------------|
-| `get hiddenProperties` | `Set<string>` | Getter that delegates to `getHiddenProperties()` |
-| `set hiddenProperties` | `void` | Override hidden properties set |
-| `getHiddenProperties()` | `Set<string>` | Get hidden properties from model metadata (cached) |
-| `hasHiddenProperties()` | `boolean` | Check if model has any hidden properties |
-| `get visibleProperties` | `Record<string, any> \| undefined` | Getter that delegates to `getVisibleProperties()` |
-| `set visibleProperties` | `void` | Override visible properties |
-| `getVisibleProperties()` | `Record<string, any> \| undefined` | Build visible columns object for Drizzle (cached). Returns `undefined` if no hidden props. |
+**File:** `packages/core/src/connectors/postgres/repositories/core/base.ts`
 
-### Usage
+Builds on those getters to implement SQL-level column exclusion and full-filter merging for Drizzle:
 
 ```typescript
-import { FieldsVisibilityMixin } from '@venizia/ignis';
-import { BaseHelper } from '@venizia/ignis-helpers';
-
-class MyRepository extends FieldsVisibilityMixin(BaseHelper) {
-  // Required abstract implementation
-  abstract getEntity(): BaseEntity;
-
-  // Now has access to:
-  // - hiddenProperties (getter/setter)
-  // - visibleProperties (getter/setter)
-  // - getHiddenProperties()
-  // - hasHiddenProperties()
-  // - getVisibleProperties()
-}
+getHiddenProperties(): Set<string>;                       // memoized Set of hiddenFields
+hasHiddenProperties(): boolean;
+getVisibleProperties(): Record<string, any> | undefined;  // memoized Drizzle column-selection map
+
+getDefaultFilter(): TFilter | undefined;                  // full settings.defaultFilter (where/order/limit/...)
+getDefaultLimit(): number | undefined;
+hasDefaultFilter(): boolean;
+applyDefaultFilter(opts: {
+  userFilter?: TFilter;
+  shouldSkipDefaultFilter?: boolean;
+}): TFilter;                                              // merges via FilterBuilder.mergeFilter
 ```
 
-### Visible Properties for Drizzle
+Hidden columns are excluded from `select()` and `returning()` calls at query time - the same SQL-level guarantee the mixins provided. The typesense connector implements its own equivalent natively since it is not Drizzle-aware.
 
-The `getVisibleProperties()` method returns a columns object for Drizzle's `select()` or `returning()`:
+## Migration
 
-```typescript
-// Model with hiddenProperties: ['password', 'apiKey']
-// Schema columns: { id, email, password, apiKey, createdAt }
+| Old (mixin) | New |
+|-------------|-----|
+| `FieldsVisibilityMixin` -> `getHiddenProperties()` | `PostgresBaseRepository.getHiddenProperties()` |
+| `FieldsVisibilityMixin` -> `getVisibleProperties()` | `PostgresBaseRepository.getVisibleProperties()` |
+| `FieldsVisibilityMixin` -> `hasHiddenProperties()` | `PostgresBaseRepository.hasHiddenProperties()` |
+| `DefaultFilterMixin` -> `getDefaultFilter()` | `PostgresBaseRepository.getDefaultFilter()` |
+| `DefaultFilterMixin` -> `hasDefaultFilter()` | `PostgresBaseRepository.hasDefaultFilter()` |
+| `DefaultFilterMixin` -> `applyDefaultFilter()` | `PostgresBaseRepository.applyDefaultFilter()` |
 
-const visibleProps = this.getVisibleProperties();
-// Result: { id: column, email: column, createdAt: column }
-// (password and apiKey excluded)
+If you extended `DefaultCRUDRepository` (or any class in the PostgreSQL hierarchy), no change is needed - these methods have always been available on your repository instances; only the internal composition changed.
 
-// Used in Drizzle queries
-await connector.select(visibleProps).from(schema);
-// SELECT id, email, created_at FROM users
-```
-
-### How It Resolves Hidden Properties
-
-1. Checks the cache (`_hiddenProperties`). If not `null`, returns cached value.
-2. Looks up the entity name in `MetadataRegistry.getModelEntry()`.
-3. Reads `metadata.settings.hiddenProperties` (array of field names).
-4. Converts to a `Set<string>` and caches.
-
-
-## DefaultFilterMixin
-
-Provides automatic default filter application for all repository queries. Reads `defaultFilter` from `@model` metadata settings and merges it with user-provided filters.
+## Custom Mixins Still Work
 
-**File:** `packages/core/src/base/repositories/mixins/default-filter.ts`
-
-### Abstract Requirements
-
-Classes using this mixin must implement:
-
-```typescript
-abstract getEntity(): BaseEntity<TTableSchemaWithId>;
-abstract get filterBuilder(): FilterBuilder;
-```
-
-### Properties
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `_defaultFilter` | `TFilter \| null \| undefined` | Cached default filter (`null` = not yet computed, `undefined` = computed with no default filter) |
-
-### Methods
-
-| Method | Returns | Description |
-|--------|---------|-------------|
-| `getDefaultFilter()` | `TFilter \| undefined` | Get default filter from model metadata (cached) |
-| `hasDefaultFilter()` | `boolean` | Check if model has a default filter configured |
-| `applyDefaultFilter(opts)` | `TFilter` | Merge default filter with user filter |
-
-### Usage
-
-```typescript
-import { DefaultFilterMixin } from '@venizia/ignis';
-import { BaseHelper } from '@venizia/ignis-helpers';
-
-class MyRepository extends DefaultFilterMixin(BaseHelper) {
-  // Required abstract implementations
-  abstract getEntity(): BaseEntity;
-  abstract get filterBuilder(): FilterBuilder;
-
-  // Now has access to:
-  // - getDefaultFilter()
-  // - hasDefaultFilter()
-  // - applyDefaultFilter()
-}
-```
-
-### applyDefaultFilter Options
-
-```typescript
-applyDefaultFilter<DataObject = any>(opts: {
-  userFilter?: TFilter<DataObject>;        // User-provided filter
-  shouldSkipDefaultFilter?: boolean;       // If true, bypass default filter
-}): TFilter<DataObject>
-```
-
-**Behavior:**
-
-1. If `shouldSkipDefaultFilter` is `true`, returns the user filter as-is (or `{}` if none).
-2. If no default filter is configured, returns the user filter as-is (or `{}` if none).
-3. Otherwise, delegates to `filterBuilder.mergeFilter({ defaultFilter, userFilter })` which deep-merges `where` conditions and uses user values for other filter properties (`order`, `limit`, `offset`, `skip`, `fields`, `include`).
-
-
-## Mixin Composition
-
-The `AbstractRepository` composes both mixins:
-
-```typescript
-export abstract class AbstractRepository<...>
-  extends DefaultFilterMixin(FieldsVisibilityMixin(BaseHelper))
-  implements IPersistableRepository<...>
-{
-  // Inherits from both mixins:
-  // From FieldsVisibilityMixin:
-  //   - hiddenProperties (getter/setter)
-  //   - visibleProperties (getter/setter)
-  //   - getHiddenProperties()
-  //   - hasHiddenProperties()
-  //   - getVisibleProperties()
-  //
-  // From DefaultFilterMixin:
-  //   - getDefaultFilter()
-  //   - hasDefaultFilter()
-  //   - applyDefaultFilter()
-}
-```
-
-### Composition Order
-
-Mixins are applied right-to-left:
-
-```typescript
-// FieldsVisibilityMixin applied first (to BaseHelper)
-// DefaultFilterMixin applied second (to the result)
-DefaultFilterMixin(FieldsVisibilityMixin(BaseHelper))
-```
-
-
-## Creating Custom Mixins
-
-Follow the TypeScript mixin pattern using `TMixinTarget`:
+The mixin *pattern* remains a valid technique for your own repository code, via `TMixinTarget` from `@venizia/ignis-helpers`:
 
 ```typescript
 import { TMixinTarget } from '@venizia/ignis-helpers';
 
 export const AuditLogMixin = <T extends TMixinTarget<object>>(baseClass: T) => {
-  abstract class Mixed extends baseClass {
-    // Properties
-    private _auditEnabled: boolean = true;
-
-    // Abstract dependencies (if needed)
-    abstract getEntity(): BaseEntity;
-
-    // Public methods
-    enableAudit(): void {
-      this._auditEnabled = true;
-    }
-
-    disableAudit(): void {
-      this._auditEnabled = false;
-    }
-
-    isAuditEnabled(): boolean {
-      return this._auditEnabled;
-    }
-
-    logOperation(operation: string, data: any): void {
-      if (this._auditEnabled) {
-        console.log(`[${this.getEntity().name}] ${operation}:`, data);
-      }
+  class Mixed extends baseClass {
+    logOperation(opts: { operation: string; data: unknown }): void {
+      // custom behavior
     }
   }
-
   return Mixed;
 };
-```
-
-### Using Custom Mixins
-
-```typescript
-// Compose with existing mixins
-class MyRepository extends AuditLogMixin(DefaultFilterMixin(BaseHelper)) {
-  getEntity() {
-    return this._entity;
-  }
 
-  get filterBuilder() {
-    return this._filterBuilder;
-  }
-}
-
-// Or create a composed base
-const AuditableRepository = AuditLogMixin(DefaultFilterMixin(FieldsVisibilityMixin(BaseHelper)));
-
-class ProductRepository extends AuditableRepository {
-  // Has all mixin functionality
-}
-```
-
-
-## Caching Behavior
-
-Both mixins use a three-state caching pattern for performance:
-
-```typescript
-// DefaultFilterMixin caching
-// null = not computed yet
-// undefined = computed, no default filter exists
-// TFilter = computed, has default filter
-_defaultFilter: TFilter | null | undefined = null;
-
-getDefaultFilter() {
-  if (this._defaultFilter !== null) {
-    return this._defaultFilter;  // Return cached value (either TFilter or undefined)
-  }
-  // Compute from MetadataRegistry and cache...
-}
-
-// FieldsVisibilityMixin caching
-// null = not computed yet
-// Set<string> = computed (may be empty)
-_hiddenProperties: Set<string> | null = null;
-
-// null = not computed yet
-// undefined = computed, no hidden properties exist
-// Record<string, any> = computed, has visible column map
-_visibleProperties: Record<string, any> | null | undefined = null;
+export class ProductRepository extends AuditLogMixin(
+  DefaultCRUDRepository<typeof Product.schema>,
+) {}
 ```
 
-This ensures metadata lookups happen only once per repository instance, with subsequent calls returning the cached value.
-
-
-## Quick Reference
-
-| Mixin | Method | Purpose |
-|-------|--------|---------|
-| `FieldsVisibilityMixin` | `hasHiddenProperties()` | Check if hidden props exist |
-| `FieldsVisibilityMixin` | `getHiddenProperties()` | Get hidden property names as `Set<string>` |
-| `FieldsVisibilityMixin` | `getVisibleProperties()` | Get Drizzle columns object (excludes hidden) |
-| `DefaultFilterMixin` | `hasDefaultFilter()` | Check if default filter exists |
-| `DefaultFilterMixin` | `getDefaultFilter()` | Get raw default filter from model metadata |
-| `DefaultFilterMixin` | `applyDefaultFilter()` | Merge default filter with user filter |
-
-
-## Next Steps
-
-- [Default Filter](../filter-system/default-filter.md) - Full default filter documentation
-- [Advanced Features](./advanced.md) - Hidden properties usage
-- [Repository Overview](./index.md) - Repository basics
-
 ## See Also
 
-- **Related Concepts:**
-  - [Repositories Overview](./index) - Core repository operations
-  - [Models](/guides/core-concepts/persistent/models) - Entity definitions
-
-- **Related Topics:**
-  - [Default Filter](../filter-system/default-filter) - Automatic filtering
-  - [Advanced Features](./advanced) - Hidden properties and transactions
-  - [Relations & Includes](./relations) - Loading related data
-
-- **Best Practices:**
-  - [Data Modeling](/best-practices/data-modeling) - Soft delete patterns
+- [Repository Overview](./index.md) - Current class hierarchy
+- [Advanced Features](./advanced.md) - Hidden properties and default-filter bypass in practice
+- [Default Filter](../filter-system/default-filter.md) - Configuring `@model` default filters

package/content/references/base/repositories/relations.md

@@ -9,7 +9,7 @@ Fetch related data using `include` for eager loading. This guide covers one-to-o
 
 ```typescript
 // Fetch user with their posts
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{ relation: 'posts' }]
@@ -31,7 +31,7 @@ const user = await userRepo.findOne({
 
 ```typescript
 // Fetch post with its author
-const post = await postRepo.findOne({
+const post = await postRepository.findOne({
   filter: {
     where: { id: 'p1' },
     include: [{ relation: 'author' }]
@@ -51,7 +51,7 @@ const post = await postRepo.findOne({
 
 ```typescript
 // Fetch post with author AND comments
-const post = await postRepo.findOne({
+const post = await postRepository.findOne({
   filter: {
     where: { id: 'p1' },
     include: [
@@ -74,7 +74,7 @@ Apply filters, ordering, and limits to included relations using `scope`:
 
 ```typescript
 // User with only published posts
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -91,7 +91,7 @@ const user = await userRepo.findOne({
 
 ```typescript
 // User with posts ordered by date
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -108,7 +108,7 @@ const user = await userRepo.findOne({
 
 ```typescript
 // User with their 5 most recent posts
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -125,7 +125,7 @@ const user = await userRepo.findOne({
 ### Combined Scope Options
 
 ```typescript
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -147,7 +147,7 @@ Each inclusion can independently bypass the related model's default filter:
 
 ```typescript
 // Include soft-deleted posts that would normally be filtered out
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -167,7 +167,7 @@ Include relations of relations (up to 2 levels recommended):
 
 ```typescript
 // User -> Posts -> Comments
-const user = await userRepo.findOne({
+const user = await userRepository.findOne({
   filter: {
     where: { id: '123' },
     include: [{
@@ -200,7 +200,7 @@ const user = await userRepo.findOne({
 
 ```typescript
 // Product -> SaleChannelProduct (junction) -> SaleChannel
-const product = await productRepo.findOne({
+const product = await productRepository.findOne({
   filter: {
     where: { id: 'prod1' },
     include: [{
@@ -236,7 +236,7 @@ const product = await productRepo.findOne({
 
 ## Defining Relations
 
-Relations are defined using the `createRelations` helper and the `TRelationConfig` type. These use Drizzle ORM's relation system under the hood.
+Relations are declared on the model as a static `relations` resolver returning an array of `TRelationConfig`. The framework translates them to Drizzle ORM relations internally during schema discovery.
 
 ### Relation Config Type
 
@@ -261,34 +261,32 @@ type TRelationConfig = {
 
 ```typescript
 // src/models/user.model.ts
-import { createRelations } from '@venizia/ignis';
+import { model, RelationTypes } from '@venizia/ignis';
+import { BasePostgresEntity, TRelationConfig } from '@venizia/ignis/postgres';
+import { pgTable, text } from 'drizzle-orm/pg-core';
+import { Post } from './post.model';
 
-export const userTable = pgTable('User', {
-  id: text('id').primaryKey(),
-  name: text('name').notNull(),
-  email: text('email').notNull(),
-});
+@model({ type: 'entity' })
+export class User extends BasePostgresEntity<typeof User.schema> {
+  static override schema = pgTable('User', {
+    id: text('id').primaryKey(),
+    name: text('name').notNull(),
+    email: text('email').notNull(),
+  });
 
-const userRelationsConfig = createRelations({
-  source: userTable,
-  relations: [
+  static override relations = (): TRelationConfig[] => [
     {
-      type: 'many',
-      schema: postTable,
       name: 'posts',
+      type: RelationTypes.MANY,
+      schema: Post.schema,
       metadata: { relationName: 'posts' },
     },
-  ],
-});
-
-@model({ type: 'entity' })
-export class User extends BaseEntity<typeof User.schema> {
-  static override schema = userTable;
-  static override relations = () => userRelationsConfig.definitions;
-  static override TABLE_NAME = 'User';
+  ];
 }
 ```
 
+The resolver form (`() => [...]`) defers evaluation until all `@model` classes are registered, avoiding circular-import ordering issues between related models.
+
 ### Relation Types
 
 | Type | Drizzle Function | Description | Example |
@@ -297,46 +295,38 @@ export class User extends BaseEntity<typeof User.schema> {
 | `'many'` | `many()` | One-to-many | User has many Posts |
 
 > [!NOTE]
-> Unlike LoopBack 4's `hasMany`/`hasOne`/`belongsTo` terminology, Ignis uses Drizzle ORM's relation model which has only `one` and `many` types. A "belongsTo" relationship is expressed as `type: 'one'` with `fields` (local FK) and `references` (remote PK) in the metadata.
+> Unlike LoopBack 4's `hasMany`/`hasOne`/`belongsTo` terminology, IGNIS uses Drizzle ORM's relation model which has only `one` and `many` types. A "belongsTo" relationship is expressed as `type: 'one'` with `fields` (local FK) and `references` (remote PK) in the metadata.
 
 ### Example: Post Model with Both Types
 
 ```typescript
-const postRelationsConfig = createRelations({
-  source: postTable,
-  relations: [
+@model({ type: 'entity' })
+export class Post extends BasePostgresEntity<typeof Post.schema> {
+  static override schema = postTable;
+
+  static override relations = (): TRelationConfig[] => [
     {
-      type: 'one',
-      schema: userTable,
       name: 'author',
+      type: RelationTypes.ONE,
+      schema: User.schema,
       metadata: {
-        fields: [postTable.authorId],
-        references: [userTable.id],
+        fields: [Post.schema.authorId],
+        references: [User.schema.id],
       },
     },
     {
-      type: 'many',
-      schema: commentTable,
       name: 'comments',
+      type: RelationTypes.MANY,
+      schema: Comment.schema,
       metadata: { relationName: 'comments' },
     },
-  ],
-});
+  ];
+}
 ```
 
-### createRelations Return Value
-
-`createRelations` returns an object with two properties:
-
-```typescript
-const result = createRelations({ source, relations });
-
-result.definitions;  // Record<string, TRelationConfig> - keyed by relation name
-result.relations;    // Drizzle relations() call result - pass to DataSource schema
-```
+### How Configs Become Drizzle Relations
 
-- **`definitions`**: Used by `BaseEntity.relations` for include resolution at runtime.
-- **`relations`**: The actual Drizzle ORM relations definition, needed for DataSource schema registration.
+During schema discovery, `MetadataRegistry` resolves each model's `relations` array and passes it to the `createRelations` helper (`packages/core/src/connectors/postgres/repositories/operators/relation.ts`), which builds the actual Drizzle `relations()` definition registered on the DataSource schema. You do not call `createRelations` yourself in application code.
 
 
 ## Auto-Resolution
@@ -362,7 +352,7 @@ When building include queries, the `FilterBuilder.toInclude()` method automatica
 
 ```typescript
 // User model has hiddenProperties: ['password']
-const post = await postRepo.findOne({
+const post = await postRepository.findOne({
   filter: {
     include: [{ relation: 'author' }]
   }
@@ -383,7 +373,7 @@ type UserWithPosts = User & {
 };
 
 // Use generic override
-const user = await userRepo.findOne<UserWithPosts>({
+const user = await userRepository.findOne<UserWithPosts>({
   filter: {
     where: { id: '123' },
     include: [{ relation: 'posts' }]
@@ -405,7 +395,7 @@ type ProductWithChannels = Product & {
   })[];
 };
 
-const product = await productRepo.findOne<ProductWithChannels>({
+const product = await productRepository.findOne<ProductWithChannels>({
   filter: {
     where: { id: 'prod1' },
     include: [{
@@ -441,7 +431,7 @@ type TInclusion = {
 
 ```typescript
 // Get users with post count
-const users = await userRepo.find({
+const users = await userRepository.find({
   filter: {
     include: [{
       relation: 'posts',
@@ -465,7 +455,7 @@ async function getUser(id: string, includePosts: boolean) {
     ? [{ relation: 'posts' }]
     : [];
 
-  return userRepo.findOne({
+  return userRepository.findOne({
     filter: {
       where: { id },
       include
@@ -483,7 +473,7 @@ If you try to include a relation that doesn't exist:
 
 ```typescript
 // Error: [FilterBuilder][toInclude] Relation NOT FOUND | relation: 'nonExistent'
-await userRepo.find({
+await userRepository.find({
   filter: {
     include: [{ relation: 'nonExistent' }]
   }
@@ -520,14 +510,14 @@ in connector.query | Available keys: [Post, Comment]
 
 ```typescript
 // Instead of deep nesting, use separate queries
-const user = await userRepo.findById({ id: '123' });
-const posts = await postRepo.find({
+const user = await userRepository.findById({ id: '123' });
+const posts = await postRepository.find({
   filter: {
     where: { authorId: '123' },
     limit: 10
   }
 });
-const comments = await commentRepo.find({
+const comments = await commentRepository.find({
   filter: {
     where: { postId: { inq: posts.map(p => p.id) } }
   }
@@ -563,7 +553,7 @@ const comments = await commentRepo.find({
 
 - **Related Topics:**
   - [Advanced Features](./advanced) - Hidden properties, transactions
-  - [Repository Mixins](./mixins) - Default filter and fields visibility
+  - [Repository Mixins (Removed)](./mixins) - Where default-filter and fields-visibility behavior lives now
   - [Filter System](/references/base/filter-system/) - Query operators
 
 - **External Resources:**