WIP - allow search in system fields

WIP - search with AI
WIP - Added pagination for list view
2026-01-13 10:55:11 +01:00 · 2026-01-13 10:44:38 +01:00 · 2026-01-13 09:03:11 +01:00
13 changed files with 1077 additions and 67 deletions
--- a/backend/src/ai-assistant/ai-assistant.controller.ts
+++ b/backend/src/ai-assistant/ai-assistant.controller.ts
@@ -4,6 +4,7 @@ import { CurrentUser } from '../auth/current-user.decorator';
 import { TenantId } from '../tenant/tenant.decorator';
 import { AiAssistantService } from './ai-assistant.service';
 import { AiChatRequestDto } from './dto/ai-chat.dto';
+import { AiSearchRequestDto } from './dto/ai-search.dto';

@Controller('ai')
@UseGuards(JwtAuthGuard)
@@ -24,4 +25,17 @@ export class AiAssistantController {
      payload.context,
    );
  }
+
+  @Post('search')
+  async search(
+    @TenantId() tenantId: string,
+    @CurrentUser() user: any,
+    @Body() payload: AiSearchRequestDto,
+  ) {
+    return this.aiAssistantService.searchRecords(
+      tenantId,
+      user.userId,
+      payload,
+    );
+  }
 }
--- a/backend/src/ai-assistant/ai-assistant.service.ts
+++ b/backend/src/ai-assistant/ai-assistant.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { JsonOutputParser } from '@langchain/core/output_parsers';
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import { ChatOpenAI } from '@langchain/openai';
@@ -11,6 +11,30 @@ import { OpenAIConfig } from '../voice/interfaces/integration-config.interface';
 import { AiAssistantReply, AiAssistantState } from './ai-assistant.types';
 import { MeilisearchService } from '../search/meilisearch.service';

+type AiSearchFilter = {
+  field: string;
+  operator: string;
+  value?: any;
+  values?: any[];
+  from?: string;
+  to?: string;
+};
+
+type AiSearchPlan = {
+  strategy: 'keyword' | 'query';
+  explanation: string;
+  keyword?: string | null;
+  filters?: AiSearchFilter[];
+  sort?: { field: string; direction: 'asc' | 'desc' } | null;
+};
+
+type AiSearchPayload = {
+  objectApiName: string;
+  query: string;
+  page?: number;
+  pageSize?: number;
+};
+
@Injectable()
 export class AiAssistantService {
  private readonly logger = new Logger(AiAssistantService.name);
@@ -70,6 +94,108 @@ export class AiAssistantService {
    };
  }

+  async searchRecords(
+    tenantId: string,
+    userId: string,
+    payload: AiSearchPayload,
+  ) {
+    const queryText = payload?.query?.trim();
+    if (!payload?.objectApiName || !queryText) {
+      throw new BadRequestException('objectApiName and query are required');
+    }
+
+    // Normalize tenant ID so Meilisearch index names align with indexed records
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+
+    const objectDefinition = await this.objectService.getObjectDefinition(
+      resolvedTenantId,
+      payload.objectApiName,
+    );
+    if (!objectDefinition) {
+      throw new BadRequestException(`Object ${payload.objectApiName} not found`);
+    }
+
+    const page = Number.isFinite(Number(payload.page)) ? Number(payload.page) : 1;
+    const pageSize = Number.isFinite(Number(payload.pageSize)) ? Number(payload.pageSize) : 20;
+
+    const plan = await this.buildSearchPlan(
+      resolvedTenantId,
+      queryText,
+      objectDefinition,
+    );
+
+    console.log('AI search plan:', plan);
+
+    if (plan.strategy === 'keyword') {
+
+      console.log('AI search plan (keyword):', plan);
+
+      const keyword = plan.keyword?.trim() || queryText;
+      if (this.meilisearchService.isEnabled()) {
+        const offset = (page - 1) * pageSize;
+        const meiliResults = await this.meilisearchService.searchRecords(
+          resolvedTenantId,
+          payload.objectApiName,
+          keyword,
+          { limit: pageSize, offset },
+        );
+
+        console.log('Meilisearch results:', meiliResults);
+
+        const ids = meiliResults.hits
+          .map((hit: any) => hit?.id)
+          .filter(Boolean);
+
+        const records = ids.length
+          ? await this.objectService.searchRecordsByIds(
+              resolvedTenantId,
+              payload.objectApiName,
+              userId,
+              ids,
+              { page, pageSize },
+            )
+          : { data: [], totalCount: 0, page, pageSize };
+
+        return {
+          ...records,
+          totalCount: meiliResults.total ?? records.totalCount ?? 0,
+          strategy: plan.strategy,
+          explanation: plan.explanation,
+        };
+      }
+
+      const fallback = await this.objectService.searchRecordsByKeyword(
+        resolvedTenantId,
+        payload.objectApiName,
+        userId,
+        keyword,
+        { page, pageSize },
+      );
+      return {
+        ...fallback,
+        strategy: plan.strategy,
+        explanation: plan.explanation,
+      };
+    }
+
+    console.log('AI search plan (query):', plan);
+
+    const filtered = await this.objectService.searchRecordsWithFilters(
+      resolvedTenantId,
+      payload.objectApiName,
+      userId,
+      plan.filters || [],
+      { page, pageSize },
+      plan.sort || undefined,
+    );
+
+    return {
+      ...filtered,
+      strategy: plan.strategy,
+      explanation: plan.explanation,
+    };
+  }
+
  private async runAssistantGraph(
    tenantId: string,
    userId: string,
@@ -523,6 +649,112 @@ export class AiAssistantService {
    return extracted;
  }

+  private async buildSearchPlan(
+    tenantId: string,
+    message: string,
+    objectDefinition: any,
+  ): Promise<AiSearchPlan> {
+    const openAiConfig = await this.getOpenAiConfig(tenantId);
+    if (!openAiConfig) {
+      return this.buildSearchPlanFallback(message);
+    }
+
+    try {
+      return await this.buildSearchPlanWithAi(openAiConfig, message, objectDefinition);
+    } catch (error) {
+      this.logger.warn(`AI search planning failed: ${error.message}`);
+      return this.buildSearchPlanFallback(message);
+    }
+  }
+
+  private buildSearchPlanFallback(message: string): AiSearchPlan {
+    const trimmed = message.trim();
+    return {
+      strategy: 'keyword',
+      keyword: trimmed,
+      explanation: `Searched records that matches the word: "${trimmed}"`,
+    };
+  }
+
+  private async buildSearchPlanWithAi(
+    openAiConfig: OpenAIConfig,
+    message: string,
+    objectDefinition: any,
+  ): Promise<AiSearchPlan> {
+    const model = new ChatOpenAI({
+      apiKey: openAiConfig.apiKey,
+      model: this.normalizeChatModel(openAiConfig.model),
+      temperature: 0.2,
+    });
+
+    const parser = new JsonOutputParser<AiSearchPlan>();
+    const fields = (objectDefinition.fields || []).map((field: any) => ({
+      apiName: field.apiName,
+      label: field.label,
+      type: field.type,
+    }));
+
+    console.log('fields:',fields);
+
+    const formatInstructions = parser.getFormatInstructions();
+    const today = new Date().toISOString();
+
+    const response = await model.invoke([
+      new SystemMessage(
+        `You are a CRM search assistant. Decide whether the user input is a keyword search or a structured query.` +
+          `\nReturn a JSON object with keys: strategy, explanation, keyword, filters, sort.` +
+          `\n- strategy must be "keyword" or "query".` +
+          `\n- explanation must be a short sentence explaining the approach.` +
+          `\n- keyword should be the search term when strategy is "keyword", otherwise null.` +
+          `\n- filters is an array of {field, operator, value, values, from, to}.` +
+          `\n- operators must be one of eq, neq, gt, gte, lt, lte, contains, startsWith, endsWith, in, notIn, isNull, notNull, between.` +
+          `\n- Use between with from/to when the user gives date ranges like "yesterday" or "last week".` +
+          `\n- sort should be {field, direction} when sorting is requested.` +
+          `\n- Only use field apiName values exactly as provided.` +
+          `\n${formatInstructions}`,
+      ),
+      new HumanMessage(
+        `Object: ${objectDefinition.label || objectDefinition.apiName}.\n` +
+          `Fields: ${JSON.stringify(fields)}.\n` +
+          `Today is ${today}.\n` +
+          `User query: ${message}`,
+      ),
+    ]);
+
+    const content = typeof response.content === 'string' ? response.content : '{}';
+    const parsed = await parser.parse(content);
+    return this.normalizeSearchPlan(parsed, message);
+  }
+
+  private normalizeSearchPlan(plan: AiSearchPlan, message: string): AiSearchPlan {
+    if (!plan || typeof plan !== 'object') {
+      return this.buildSearchPlanFallback(message);
+    }
+
+    const strategy = plan.strategy === 'query' ? 'query' : 'keyword';
+    const explanation = plan.explanation?.trim()
+      ? plan.explanation.trim()
+      : strategy === 'keyword'
+        ? `Searched records that matches the word: "${message.trim()}"`
+        : `Applied filters based on: "${message.trim()}"`;
+
+    if (strategy === 'keyword') {
+      return {
+        strategy,
+        keyword: plan.keyword?.trim() || message.trim(),
+        explanation,
+      };
+    }
+
+    return {
+      strategy,
+      explanation,
+      keyword: null,
+      filters: Array.isArray(plan.filters) ? plan.filters : [],
+      sort: plan.sort || null,
+    };
+  }
+
  private sanitizeUserOwnerFields(
    fields: Record<string, any>,
    fieldDefinitions: any[],
@@ -899,12 +1131,18 @@ export class AiAssistantService {

      const providedValue = typeof value === 'string' ? value.trim() : value;
      if (providedValue && typeof providedValue === 'string') {
+
+        console.log('providedValue:', providedValue);
+
        const meiliMatch = await this.meilisearchService.searchRecord(
          resolvedTenantId,
          targetDefinition?.apiName || targetApiName,
          providedValue,
          displayField,
        );
+
+        console.log('MeiliSearch lookup for', meiliMatch);
+
        if (meiliMatch?.id) {
          resolvedFields[field.apiName] = meiliMatch.id;
          continue;
--- a/backend/src/ai-assistant/dto/ai-search.dto.ts
+++ b/backend/src/ai-assistant/dto/ai-search.dto.ts
@@ -0,0 +1,22 @@
+import { Type } from 'class-transformer';
+import { IsNotEmpty, IsOptional, IsString, IsNumber } from 'class-validator';
+
+export class AiSearchRequestDto {
+  @IsString()
+  @IsNotEmpty()
+  objectApiName: string;
+
+  @IsString()
+  @IsNotEmpty()
+  query: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  page?: number;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  pageSize?: number;
+}
--- a/backend/src/object/object.service.ts
+++ b/backend/src/object/object.service.ts
@@ -10,6 +10,25 @@ import { User } from '../models/user.model';
 import { ObjectMetadata } from './models/dynamic-model.factory';
 import { MeilisearchService } from '../search/meilisearch.service';

+type SearchFilter = {
+  field: string;
+  operator: string;
+  value?: any;
+  values?: any[];
+  from?: string;
+  to?: string;
+};
+
+type SearchSort = {
+  field: string;
+  direction: 'asc' | 'desc';
+};
+
+type SearchPagination = {
+  page?: number;
+  pageSize?: number;
+};
+
@Injectable()
 export class ObjectService {
  private readonly logger = new Logger(ObjectService.name);
@@ -62,8 +81,10 @@ export class ObjectService {
      .where({ objectDefinitionId: obj.id })
      .orderBy('label', 'asc');

-    // Normalize all fields to ensure system fields are properly marked
-    const normalizedFields = fields.map((field: any) => this.normalizeField(field));
+    // Normalize all fields to ensure system fields are properly marked and add any missing system fields
+    const normalizedFields = this.addMissingSystemFields(
+      fields.map((field: any) => this.normalizeField(field)),
+    );

    // Get app information if object belongs to an app
    let app = null;
@@ -509,17 +530,14 @@ export class ObjectService {
    }
  }

-  // Runtime endpoints - CRUD operations
-  async getRecords(
+  private async buildAuthorizedQuery(
    tenantId: string,
    objectApiName: string,
    userId: string,
-    filters?: any,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);

-    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
@@ -528,7 +546,6 @@ export class ObjectService {
      throw new NotFoundException('User not found');
    }

-    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .withGraphFetched('fields');
@@ -537,20 +554,17 @@ export class ObjectService {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }

-    const tableName = this.getTableName(
-      objectDefModel.apiName,
-      objectDefModel.label,
-      objectDefModel.pluralLabel,
+    // Normalize and enrich fields to include system fields for downstream permissions/search
+    const normalizedFields = this.addMissingSystemFields(
+      (objectDefModel.fields || []).map((field: any) => this.normalizeField(field)),
    );
+    objectDefModel.fields = normalizedFields;

-    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);

-    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    let query = boundModel.query();

-    // Apply authorization scope (modifies query in place)
    await this.authService.applyScopeToQuery(
      query,
      objectDefModel,
@@ -559,15 +573,13 @@ export class ObjectService {
      knex,
    );

-    // Build graph expression for lookup fields
-    const lookupFields = objectDefModel.fields?.filter(f => 
-      f.type === 'LOOKUP' && f.referenceObject
+    const lookupFields = objectDefModel.fields?.filter((field) =>
+      field.type === 'LOOKUP' && field.referenceObject,
    ) || [];

    if (lookupFields.length > 0) {
-      // Build relation expression - use singular lowercase for relation name
      const relationExpression = lookupFields
-        .map(f => f.apiName.replace(/Id$/, '').toLowerCase())
+        .map((field) => field.apiName.replace(/Id$/, '').toLowerCase())
        .filter(Boolean)
        .join(', ');

@@ -576,21 +588,294 @@ export class ObjectService {
      }
    }

-    // Apply additional filters
-    if (filters) {
-      query = query.where(filters);
+    return {
+      query,
+      objectDefModel,
+      user,
+      knex,
+    };
+  }
+
+  private applySearchFilters(
+    query: any,
+    filters: SearchFilter[],
+    validFields: Set<string>,
+  ) {
+    if (!Array.isArray(filters) || filters.length === 0) {
+      return query;
+    }
+
+    for (const filter of filters) {
+      const field = filter?.field;
+      if (!field || !validFields.has(field)) {
+        continue;
+      }
+
+      const operator = String(filter.operator || 'eq').toLowerCase();
+      const value = filter.value;
+      const values = Array.isArray(filter.values) ? filter.values : undefined;
+
+      switch (operator) {
+        case 'eq':
+          query.where(field, value);
+          break;
+        case 'neq':
+          query.whereNot(field, value);
+          break;
+        case 'gt':
+          query.where(field, '>', value);
+          break;
+        case 'gte':
+          query.where(field, '>=', value);
+          break;
+        case 'lt':
+          query.where(field, '<', value);
+          break;
+        case 'lte':
+          query.where(field, '<=', value);
+          break;
+        case 'contains':
+          if (value !== undefined && value !== null) {
+            query.whereRaw('LOWER(??) like ?', [field, `%${String(value).toLowerCase()}%`]);
+          }
+          break;
+        case 'startswith':
+          if (value !== undefined && value !== null) {
+            query.whereRaw('LOWER(??) like ?', [field, `${String(value).toLowerCase()}%`]);
+          }
+          break;
+        case 'endswith':
+          if (value !== undefined && value !== null) {
+            query.whereRaw('LOWER(??) like ?', [field, `%${String(value).toLowerCase()}`]);
+          }
+          break;
+        case 'in':
+          if (values?.length) {
+            query.whereIn(field, values);
+          } else if (Array.isArray(value)) {
+            query.whereIn(field, value);
+          }
+          break;
+        case 'notin':
+          if (values?.length) {
+            query.whereNotIn(field, values);
+          } else if (Array.isArray(value)) {
+            query.whereNotIn(field, value);
+          }
+          break;
+        case 'isnull':
+          query.whereNull(field);
+          break;
+        case 'notnull':
+          query.whereNotNull(field);
+          break;
+        case 'between': {
+          const from = filter.from ?? (Array.isArray(value) ? value[0] : undefined);
+          const to = filter.to ?? (Array.isArray(value) ? value[1] : undefined);
+          if (from !== undefined && to !== undefined) {
+            query.whereBetween(field, [from, to]);
+          } else if (from !== undefined) {
+            query.where(field, '>=', from);
+          } else if (to !== undefined) {
+            query.where(field, '<=', to);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    return query;
+  }
+
+  private applyKeywordFilter(
+    query: any,
+    keyword: string,
+    fields: string[],
+  ) {
+    const trimmed = keyword?.trim();
+    if (!trimmed || fields.length === 0) {
+      return query;
+    }
+
+    query.where((builder: any) => {
+      const lowered = trimmed.toLowerCase();
+      for (const field of fields) {
+        builder.orWhereRaw('LOWER(??) like ?', [field, `%${lowered}%`]);
+      }
+    });
+
+    return query;
+  }
+
+  private async finalizeRecordQuery(
+    query: any,
+    objectDefModel: any,
+    user: any,
+    pagination?: SearchPagination,
+  ) {
+    const parsedPage = Number.isFinite(Number(pagination?.page)) ? Number(pagination?.page) : 1;
+    const parsedPageSize = Number.isFinite(Number(pagination?.pageSize))
+      ? Number(pagination?.pageSize)
+      : 0;
+    const safePage = parsedPage > 0 ? parsedPage : 1;
+    const safePageSize = parsedPageSize > 0 ? Math.min(parsedPageSize, 500) : 0;
+    const shouldPaginate = safePageSize > 0;
+
+    const totalCount = await query.clone().resultSize();
+
+    if (shouldPaginate) {
+      query = query.offset((safePage - 1) * safePageSize).limit(safePageSize);
    }

    const records = await query.select('*');
-    
-    // Filter fields based on field-level permissions
    const filteredRecords = await Promise.all(
-      records.map(record => 
-        this.authService.filterReadableFields(record, objectDefModel.fields, user)
-      )
+      records.map((record: any) =>
+        this.authService.filterReadableFields(record, objectDefModel.fields, user),
+      ),
    );

-    return filteredRecords;
+    return {
+      data: filteredRecords,
+      totalCount,
+      page: shouldPaginate ? safePage : 1,
+      pageSize: shouldPaginate ? safePageSize : filteredRecords.length,
+    };
+  }
+
+  // Runtime endpoints - CRUD operations
+  async getRecords(
+    tenantId: string,
+    objectApiName: string,
+    userId: string,
+    filters?: any,
+  ) {
+    let { query, objectDefModel, user } = await this.buildAuthorizedQuery(
+      tenantId,
+      objectApiName,
+      userId,
+    );
+    
+    // Extract pagination and sorting parameters from query string
+    const {
+      page,
+      pageSize,
+      sortField,
+      sortDirection,
+      ...rawFilters
+    } = filters || {};
+
+    const reservedFilterKeys = new Set(['page', 'pageSize', 'sortField', 'sortDirection']);
+    const filterEntries = Object.entries(rawFilters || {}).filter(
+      ([key, value]) =>
+        !reservedFilterKeys.has(key) &&
+        value !== undefined &&
+        value !== null &&
+        value !== '',
+    );
+
+    if (filterEntries.length > 0) {
+      query = query.where(builder => {
+        for (const [key, value] of filterEntries) {
+          builder.where(key, value as any);
+        }
+      });
+    }
+
+    if (sortField) {
+      const direction = sortDirection === 'desc' ? 'desc' : 'asc';
+      query = query.orderBy(sortField, direction);
+    }
+
+    return this.finalizeRecordQuery(query, objectDefModel, user, { page, pageSize });
+  }
+
+  async searchRecordsByIds(
+    tenantId: string,
+    objectApiName: string,
+    userId: string,
+    recordIds: string[],
+    pagination?: SearchPagination,
+  ) {
+    if (!Array.isArray(recordIds) || recordIds.length === 0) {
+      return {
+        data: [],
+        totalCount: 0,
+        page: pagination?.page ?? 1,
+        pageSize: pagination?.pageSize ?? 0,
+      };
+    }
+
+    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
+      tenantId,
+      objectApiName,
+      userId,
+    );
+
+    query.whereIn('id', recordIds);
+    const orderBindings: any[] = ['id'];
+    const cases = recordIds
+      .map((id, index) => {
+        orderBindings.push(id, index);
+        return 'when ? then ?';
+      })
+      .join(' ');
+
+    if (cases) {
+      query.orderByRaw(`case ?? ${cases} end`, orderBindings);
+    }
+
+    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
+  }
+
+  async searchRecordsWithFilters(
+    tenantId: string,
+    objectApiName: string,
+    userId: string,
+    filters: SearchFilter[],
+    pagination?: SearchPagination,
+    sort?: SearchSort,
+  ) {
+    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
+      tenantId,
+      objectApiName,
+      userId,
+    );
+
+    const validFields = new Set([
+      ...(objectDefModel.fields?.map((field: any) => field.apiName) || []),
+      ...this.getSystemFieldNames(),
+    ]);
+    this.applySearchFilters(query, filters, validFields);
+
+    if (sort?.field && validFields.has(sort.field)) {
+      query.orderBy(sort.field, sort.direction === 'desc' ? 'desc' : 'asc');
+    }
+
+    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
+  }
+
+  async searchRecordsByKeyword(
+    tenantId: string,
+    objectApiName: string,
+    userId: string,
+    keyword: string,
+    pagination?: SearchPagination,
+  ) {
+    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
+      tenantId,
+      objectApiName,
+      userId,
+    );
+
+    const keywordFields = (objectDefModel.fields || [])
+      .filter((field: any) => this.isKeywordField(field.type))
+      .map((field: any) => field.apiName);
+
+    this.applyKeywordFilter(query, keyword, keywordFields);
+
+    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
  }

  async getRecord(
@@ -952,6 +1237,73 @@ export class ObjectService {
    return { success: true };
  }

+  async deleteRecords(
+    tenantId: string,
+    objectApiName: string,
+    recordIds: string[],
+    userId: string,
+  ) {
+    if (!Array.isArray(recordIds) || recordIds.length === 0) {
+      throw new BadRequestException('No record IDs provided');
+    }
+
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
+    
+    // Get user with roles and permissions
+    const user = await User.query(knex)
+      .findById(userId)
+      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
+    
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+    
+    // Get object definition with authorization settings
+    const objectDefModel = await ObjectDefinition.query(knex)
+      .findOne({ apiName: objectApiName });
+    
+    if (!objectDefModel) {
+      throw new NotFoundException(`Object ${objectApiName} not found`);
+    }
+    
+    const tableName = this.getTableName(
+      objectDefModel.apiName,
+      objectDefModel.label,
+      objectDefModel.pluralLabel,
+    );
+
+    const records = await knex(tableName).whereIn('id', recordIds);
+    if (records.length === 0) {
+      throw new NotFoundException('No records found to delete');
+    }
+
+    const foundIds = new Set(records.map((record: any) => record.id));
+    const missingIds = recordIds.filter(id => !foundIds.has(id));
+    if (missingIds.length > 0) {
+      throw new NotFoundException(`Records not found: ${missingIds.join(', ')}`);
+    }
+    
+    // Check if user can delete each record
+    for (const record of records) {
+      await this.authService.assertCanPerformAction('delete', objectDefModel, record, user, knex);
+    }
+
+    // Ensure model is registered
+    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);
+
+    // Use Objection model
+    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+    await boundModel.query().whereIn('id', recordIds).delete();
+
+    // Remove from search index
+    await Promise.all(
+      recordIds.map((id) => this.removeIndexedRecord(resolvedTenantId, objectApiName, id)),
+    );
+    
+    return { success: true, deleted: recordIds.length };
+  }
+
  private async indexRecord(
    tenantId: string,
    objectApiName: string,
@@ -964,12 +1316,32 @@ export class ObjectService {
      .map((field: any) => field.apiName)
      .filter((apiName) => apiName && !this.isSystemField(apiName));

+    console.log('Indexing record', {
+      tenantId,
+      objectApiName,
+      recordId: record.id,
+      fieldsToIndex,
+    });
+
    await this.meilisearchService.upsertRecord(
      tenantId,
      objectApiName,
      record,
      fieldsToIndex,
    );
+
+    console.log('Indexed record successfully');
+
+
+    const meiliResults = await this.meilisearchService.searchRecords(
+          tenantId,
+          objectApiName,
+          record.name,
+          { limit: 10 },
+        );
+
+        console.log('Meilisearch results:', meiliResults);
+
  }

  private async removeIndexedRecord(
@@ -982,15 +1354,48 @@ export class ObjectService {
  }

  private isSystemField(apiName: string): boolean {
+    return this.getSystemFieldNames().includes(apiName);
+  }
+
+  private getSystemFieldNames(): string[] {
+    return ['id', 'ownerId', 'created_at', 'updated_at', 'createdAt', 'updatedAt', 'tenantId'];
+  }
+
+  private addMissingSystemFields(fields: any[]): any[] {
+    const existing = new Map((fields || []).map((field) => [field.apiName, field]));
+    const systemDefaults = [
+      { apiName: 'id', label: 'ID', type: 'STRING' },
+      { apiName: 'created_at', label: 'Created At', type: 'DATE_TIME' },
+      { apiName: 'updated_at', label: 'Updated At', type: 'DATE_TIME' },
+      { apiName: 'ownerId', label: 'Owner', type: 'LOOKUP', referenceObject: 'User' },
+    ];
+
+    const merged = [...fields];
+    for (const sysField of systemDefaults) {
+      if (!existing.has(sysField.apiName)) {
+        merged.push({
+          ...sysField,
+          isSystem: true,
+          isCustom: false,
+          isRequired: false,
+        });
+      }
+    }
+
+    return merged;
+  }
+
+  private isKeywordField(type: string | undefined): boolean {
+    const normalized = String(type || '').toUpperCase();
    return [
-      'id',
-      'ownerId',
-      'created_at',
-      'updated_at',
-      'createdAt',
-      'updatedAt',
-      'tenantId',
-    ].includes(apiName);
+      'STRING',
+      'TEXT',
+      'EMAIL',
+      'PHONE',
+      'URL',
+      'RICH_TEXT',
+      'TEXTAREA',
+    ].includes(normalized);
  }

  private async normalizePolymorphicRelatedObject(
--- a/backend/src/object/runtime-object.controller.ts
+++ b/backend/src/object/runtime-object.controller.ts
@@ -95,4 +95,20 @@ export class RuntimeObjectController {
      user.userId,
    );
  }
+
+  @Post(':objectApiName/records/bulk-delete')
+  async deleteRecords(
+    @TenantId() tenantId: string,
+    @Param('objectApiName') objectApiName: string,
+    @Body() body: { recordIds?: string[]; ids?: string[] },
+    @CurrentUser() user: any,
+  ) {
+    const recordIds: string[] = body?.recordIds || body?.ids || [];
+    return this.objectService.deleteRecords(
+      tenantId,
+      objectApiName,
+      recordIds,
+      user.userId,
+    );
+  }
 }
--- a/backend/src/search/meilisearch.service.ts
+++ b/backend/src/search/meilisearch.service.ts
@@ -28,6 +28,8 @@ export class MeilisearchService {
    const indexName = this.buildIndexName(config, tenantId, objectApiName);
    const url = `${config.host}/indexes/${encodeURIComponent(indexName)}/search`;

+    console.log('querying Meilisearch index:', { indexName, query, displayField });
+
    try {
      const response = await this.requestJson('POST', url, {
        q: query,
@@ -66,6 +68,48 @@ export class MeilisearchService {
    return null;
  }

+  async searchRecords(
+    tenantId: string,
+    objectApiName: string,
+    query: string,
+    options?: { limit?: number; offset?: number },
+  ): Promise<{ hits: any[]; total: number }> {
+    const config = this.getConfig();
+    if (!config) return { hits: [], total: 0 };
+
+    const indexName = this.buildIndexName(config, tenantId, objectApiName);
+    const url = `${config.host}/indexes/${encodeURIComponent(indexName)}/search`;
+    const limit = Number.isFinite(Number(options?.limit)) ? Number(options?.limit) : 20;
+    const offset = Number.isFinite(Number(options?.offset)) ? Number(options?.offset) : 0;
+
+    try {
+      const response = await this.requestJson('POST', url, {
+        q: query,
+        limit,
+        offset,
+      }, this.buildHeaders(config));
+
+      console.log('Meilisearch response body:', response.body);
+
+      if (!this.isSuccessStatus(response.status)) {
+        this.logger.warn(
+          `Meilisearch query failed for index ${indexName}: ${response.status}`,
+        );
+        return { hits: [], total: 0 };
+      }
+
+      const hits = Array.isArray(response.body?.hits) ? response.body.hits : [];
+      const total =
+        response.body?.estimatedTotalHits ??
+        response.body?.nbHits ??
+        hits.length;
+      return { hits, total };
+    } catch (error) {
+      this.logger.warn(`Meilisearch query failed: ${error.message}`);
+      return { hits: [], total: 0 };
+    }
+  }
+
  async upsertRecord(
    tenantId: string,
    objectApiName: string,
--- a/frontend/components/fields/LookupField.vue
+++ b/frontend/components/fields/LookupField.vue
@@ -78,7 +78,9 @@ const fetchRecords = async () => {
  try {
    const endpoint = `${props.baseUrl}/${relationObject.value}/records`
    const response = await api.get(endpoint)
-    records.value = response || []
+    records.value = Array.isArray(response)
+      ? response
+      : response?.data || response?.records || []
    
    // If we have a modelValue, find the selected record
    if (props.modelValue) {
--- a/frontend/components/views/ListView.vue
+++ b/frontend/components/views/ListView.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue'
+import { ref, computed, watch } from 'vue'
 import {
  Table,
  TableBody,
@@ -22,6 +22,8 @@ interface Props {
  loading?: boolean
  selectable?: boolean
  baseUrl?: string
+  totalCount?: number
+  searchSummary?: string
 }

 const props = withDefaults(defineProps<Props>(), {
@@ -29,6 +31,7 @@ const props = withDefaults(defineProps<Props>(), {
  loading: false,
  selectable: false,
  baseUrl: '/runtime/objects',
+  searchSummary: '',
 })

 const emit = defineEmits<{
@@ -41,6 +44,8 @@ const emit = defineEmits<{
  'sort': [field: string, direction: 'asc' | 'desc']
  'search': [query: string]
  'refresh': []
+  'page-change': [page: number, pageSize: number]
+  'load-more': [page: number, pageSize: number]
 }>()

 // State
@@ -48,12 +53,46 @@ const selectedRows = ref<Set<string>>(new Set())
 const searchQuery = ref('')
 const sortField = ref<string>('')
 const sortDirection = ref<'asc' | 'desc'>('asc')
+const currentPage = ref(1)

 // Computed
 const visibleFields = computed(() => 
  props.config.fields.filter(f => f.showOnList !== false)
 )

+const pageSize = computed(() => props.config.pageSize ?? 10)
+const maxFrontendRecords = computed(() => props.config.maxFrontendRecords ?? 500)
+const totalRecords = computed(() => 
+  (props.totalCount && props.totalCount > 0)
+    ? props.totalCount
+    : props.data.length
+)
+const useHybridPagination = computed(() => totalRecords.value > maxFrontendRecords.value)
+const totalPages = computed(() => Math.max(1, Math.ceil(totalRecords.value / pageSize.value)))
+const loadedPages = computed(() => Math.max(1, Math.ceil(props.data.length / pageSize.value)))
+const availablePages = computed(() => {
+  if (useHybridPagination.value && props.totalCount && props.data.length < props.totalCount) {
+    return loadedPages.value
+  }
+  return totalPages.value
+})
+const startIndex = computed(() => (currentPage.value - 1) * pageSize.value)
+const paginatedData = computed(() => {
+  const start = startIndex.value
+  const end = start + pageSize.value
+  return props.data.slice(start, end)
+})
+const pageStart = computed(() => (props.data.length === 0 ? 0 : startIndex.value + 1))
+const pageEnd = computed(() => Math.min(startIndex.value + paginatedData.value.length, totalRecords.value))
+const showPagination = computed(() => totalRecords.value > pageSize.value)
+const canGoPrev = computed(() => currentPage.value > 1)
+const canGoNext = computed(() => currentPage.value < availablePages.value)
+const showLoadMore = computed(() => (
+  useHybridPagination.value &&
+  Boolean(props.totalCount) &&
+  props.data.length < totalRecords.value
+))
+
 const allSelected = computed({
  get: () => props.data.length > 0 && selectedRows.value.size === props.data.length,
  set: (val: boolean) => {
@@ -96,6 +135,28 @@ const handleSearch = () => {
 const handleAction = (actionId: string) => {
  emit('action', actionId, getSelectedRows())
 }
+
+const goToPage = (page: number) => {
+  const nextPage = Math.min(Math.max(page, 1), availablePages.value)
+  if (nextPage !== currentPage.value) {
+    currentPage.value = nextPage
+    emit('page-change', nextPage, pageSize.value)
+  }
+}
+
+const loadMore = () => {
+  const nextPage = Math.ceil(props.data.length / pageSize.value) + 1
+  emit('load-more', nextPage, pageSize.value)
+}
+
+watch(
+  () => [props.data.length, totalRecords.value, pageSize.value],
+  () => {
+    if (currentPage.value > availablePages.value) {
+      currentPage.value = availablePages.value
+    }
+  }
+)
 </script>

 <template>
@@ -113,6 +174,9 @@ const handleAction = (actionId: string) => {
            @keyup.enter="handleSearch"
          />
        </div>
+        <p v-if="searchSummary" class="mt-2 text-xs text-muted-foreground">
+          {{ searchSummary }}
+        </p>
      </div>

      <div class="flex items-center gap-2">
@@ -192,7 +256,7 @@ const handleAction = (actionId: string) => {
          </TableRow>
          <TableRow
            v-else
-            v-for="row in data"
+            v-for="row in paginatedData"
            :key="row.id"
            class="cursor-pointer hover:bg-muted/50"
            @click="emit('row-click', row)"
@@ -227,7 +291,26 @@ const handleAction = (actionId: string) => {
      </Table>
    </div>

-    <!-- Pagination would go here -->
+    <div v-if="showPagination" class="flex flex-wrap items-center justify-between gap-3 text-sm text-muted-foreground">
+      <div class="flex items-center gap-2">
+        <span>Showing {{ pageStart }}-{{ pageEnd }} of {{ totalRecords }} records</span>
+        <span v-if="showLoadMore">
+          (loaded {{ data.length }})
+        </span>
+      </div>
+      <div class="flex flex-wrap items-center gap-2">
+        <Button variant="outline" size="sm" :disabled="!canGoPrev" @click="goToPage(currentPage - 1)">
+          Previous
+        </Button>
+        <span class="px-2">Page {{ currentPage }} of {{ totalPages }}</span>
+        <Button variant="outline" size="sm" :disabled="!canGoNext" @click="goToPage(currentPage + 1)">
+          Next
+        </Button>
+        <Button v-if="showLoadMore" variant="secondary" size="sm" @click="loadMore">
+          Load more
+        </Button>
+      </div>
+    </div>
  </div>
 </template>

--- a/frontend/composables/useFieldViews.ts
+++ b/frontend/composables/useFieldViews.ts
@@ -78,7 +78,8 @@ export const useFields = () => {
      objectApiName: objectDef.apiName,
      mode: 'list' as ViewMode,
      fields,
-      pageSize: 25,
+      pageSize: 10,
+      maxFrontendRecords: 500,
      searchable: true,
      filterable: true,
      exportable: true,
@@ -183,6 +184,7 @@ export const useViewState = <T extends { id?: string }>(
  apiEndpoint: string
 ) => {
  const records = ref<T[]>([])
+  const totalCount = ref(0)
  const currentRecord = ref<T | null>(null)
  const currentView = ref<'list' | 'detail' | 'edit'>('list')
  const loading = ref(false)
@@ -191,13 +193,51 @@ export const useViewState = <T extends { id?: string }>(

  const { api } = useApi()

-  const fetchRecords = async (params?: Record<string, any>) => {
+  const normalizeListResponse = (response: any) => {
+    const payload: { data: T[]; totalCount: number; page?: number; pageSize?: number } = {
+      data: [],
+      totalCount: 0,
+    }
+
+    if (Array.isArray(response)) {
+      payload.data = response
+      payload.totalCount = response.length
+      return payload
+    }
+
+    if (response && typeof response === 'object') {
+      if (Array.isArray(response.data)) {
+        payload.data = response.data
+      } else if (Array.isArray((response as any).records)) {
+        payload.data = (response as any).records
+      } else if (Array.isArray((response as any).results)) {
+        payload.data = (response as any).results
+      }
+
+      payload.totalCount =
+        response.totalCount ??
+        response.total ??
+        response.count ??
+        payload.data.length ??
+        0
+      payload.page = response.page
+      payload.pageSize = response.pageSize
+    }
+
+    return payload
+  }
+
+  const fetchRecords = async (params?: Record<string, any>, options?: { append?: boolean }) => {
    loading.value = true
    error.value = null
    try {
      const response = await api.get(apiEndpoint, { params })
-      // Handle response - data might be directly in response or in response.data
-      records.value = response.data || response || []
+      const normalized = normalizeListResponse(response)
+      totalCount.value = normalized.totalCount ?? normalized.data.length ?? 0
+      records.value = options?.append
+        ? [...records.value, ...normalized.data]
+        : normalized.data
+      return normalized
    } catch (e: any) {
      error.value = e.message
      console.error('Failed to fetch records:', e)
@@ -230,6 +270,7 @@ export const useViewState = <T extends { id?: string }>(
      // Handle response - it might be the data directly or wrapped in { data: ... }
      const recordData = response.data || response
      records.value.push(recordData)
+      totalCount.value += 1
      currentRecord.value = recordData
      return recordData
    } catch (e: any) {
@@ -272,6 +313,7 @@ export const useViewState = <T extends { id?: string }>(
    try {
      await api.delete(`${apiEndpoint}/${id}`)
      records.value = records.value.filter(r => r.id !== id)
+      totalCount.value = Math.max(0, totalCount.value - 1)
      if (currentRecord.value?.id === id) {
        currentRecord.value = null
      }
@@ -290,6 +332,7 @@ export const useViewState = <T extends { id?: string }>(
    try {
      await Promise.all(ids.map(id => api.delete(`${apiEndpoint}/${id}`)))
      records.value = records.value.filter(r => !ids.includes(r.id!))
+      totalCount.value = Math.max(0, totalCount.value - ids.length)
    } catch (e: any) {
      error.value = e.message
      console.error('Failed to delete records:', e)
@@ -327,6 +370,7 @@ export const useViewState = <T extends { id?: string }>(
  return {
    // State
    records,
+    totalCount,
    currentRecord,
    currentView,
    loading,
--- a/frontend/pages/[objectName]/[[recordId]]/[[view]].vue
+++ b/frontend/pages/[objectName]/[[recordId]]/[[view]].vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, onBeforeUnmount, watch, nextTick } from 'vue'
+import { ref, computed, onMounted, onBeforeUnmount, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import { useApi } from '@/composables/useApi'
 import { useFields, useViewState } from '@/composables/useFieldViews'
@@ -38,6 +38,7 @@ const error = ref<string | null>(null)
 // Use view state composable
 const {
  records,
+  totalCount,
  currentRecord,
  loading: dataLoading,
  saving,
@@ -57,7 +58,7 @@ const handleAiRecordCreated = (event: Event) => {
    return
  }
  if (view.value === 'list') {
-    fetchRecords()
+    initializeListRecords()
  }
 }

@@ -142,6 +143,14 @@ const editConfig = computed(() => {
  return buildEditViewConfig(objectDefinition.value)
 })

+const listPageSize = computed(() => listConfig.value?.pageSize ?? 25)
+const maxFrontendRecords = computed(() => listConfig.value?.maxFrontendRecords ?? 500)
+const searchQuery = ref('')
+const searchSummary = ref('')
+const searchLoading = ref(false)
+
+const isSearchActive = computed(() => searchQuery.value.trim().length > 0)
+
 // Fetch object definition
 const fetchObjectDefinition = async () => {
  try {
@@ -220,6 +229,88 @@ const handleCancel = () => {
  }
 }

+const loadListRecords = async (
+  page = 1,
+  options?: { append?: boolean; pageSize?: number }
+) => {
+  const pageSize = options?.pageSize ?? listPageSize.value
+  const result = await fetchRecords({ page, pageSize }, { append: options?.append })
+  const resolvedTotal = result?.totalCount ?? totalCount.value ?? records.value.length
+  totalCount.value = resolvedTotal
+  return result
+}
+
+const searchListRecords = async (
+  page = 1,
+  options?: { append?: boolean; pageSize?: number }
+) => {
+  if (!isSearchActive.value) {
+    return initializeListRecords()
+  }
+  searchLoading.value = true
+  try {
+    const pageSize = options?.pageSize ?? listPageSize.value
+    const response = await api.post('/ai/search', {
+      objectApiName: objectApiName.value,
+      query: searchQuery.value.trim(),
+      page,
+      pageSize,
+    })
+    const data = response?.data ?? []
+    const total = response?.totalCount ?? data.length
+    records.value = options?.append ? [...records.value, ...data] : data
+    totalCount.value = total
+    searchSummary.value = response?.explanation || ''
+    return response
+  } catch (e: any) {
+    error.value = e.message || 'Failed to search records'
+    return null
+  } finally {
+    searchLoading.value = false
+  }
+}
+
+const initializeListRecords = async () => {
+  const firstResult = await loadListRecords(1)
+  const resolvedTotal = firstResult?.totalCount ?? totalCount.value ?? records.value.length
+  const shouldPrefetchAll =
+    resolvedTotal <= maxFrontendRecords.value && records.value.length < resolvedTotal
+
+  if (shouldPrefetchAll) {
+    await loadListRecords(1, { append: false, pageSize: maxFrontendRecords.value })
+  }
+}
+
+const handlePageChange = async (page: number, pageSize: number) => {
+  if (isSearchActive.value) {
+    await searchListRecords(page, { append: page > 1, pageSize })
+    return
+  }
+  const loadedPages = Math.ceil(records.value.length / pageSize)
+  if (page > loadedPages && totalCount.value > records.value.length) {
+    await loadListRecords(page, { append: true, pageSize })
+  }
+}
+
+const handleLoadMore = async (page: number, pageSize: number) => {
+  if (isSearchActive.value) {
+    await searchListRecords(page, { append: true, pageSize })
+    return
+  }
+  await loadListRecords(page, { append: true, pageSize })
+}
+
+const handleSearch = async (query: string) => {
+  const trimmed = query.trim()
+  searchQuery.value = trimmed
+  if (!trimmed) {
+    searchSummary.value = ''
+    await initializeListRecords()
+    return
+  }
+  await searchListRecords(1, { append: false, pageSize: listPageSize.value })
+}
+
 // Watch for route changes
 watch(() => route.params, async (newParams, oldParams) => {
  // Reset current record when navigating to 'new'
@@ -234,7 +325,7 @@ watch(() => route.params, async (newParams, oldParams) => {
  
  // Fetch records if navigating back to list
  if (!newParams.recordId && !newParams.view) {
-    await fetchRecords()
+    await initializeListRecords()
  }
 }, { deep: true })

@@ -243,7 +334,7 @@ onMounted(async () => {
  await fetchObjectDefinition()
  
  if (view.value === 'list') {
-    await fetchRecords()
+    await initializeListRecords()
  } else if (recordId.value && recordId.value !== 'new') {
    await fetchRecord(recordId.value)
  }
@@ -288,13 +379,18 @@ onMounted(async () => {
        v-else-if="view === 'list' && listConfig"
        :config="listConfig"
        :data="records"
-        :loading="dataLoading"
+        :loading="dataLoading || searchLoading"
+        :total-count="totalCount"
+        :search-summary="searchSummary"
        :base-url="`/runtime/objects`"
        selectable
        @row-click="handleRowClick"
        @create="handleCreate"
        @edit="handleEdit"
        @delete="handleDelete"
+        @search="handleSearch"
+        @page-change="handlePageChange"
+        @load-more="handleLoadMore"
      />

      <!-- Detail View -->
--- a/frontend/pages/app/[appSlug]/[pageSlug].vue
+++ b/frontend/pages/app/[appSlug]/[pageSlug].vue
@@ -71,7 +71,12 @@ const fetchPage = async () => {

    if (page.value.objectApiName) {
      loadingRecords.value = true
-      records.value = await api.get(`/runtime/objects/${page.value.objectApiName}/records`)
+      const response = await api.get(
+        `/runtime/objects/${page.value.objectApiName}/records`
+      )
+      records.value = Array.isArray(response)
+        ? response
+        : response?.data || response?.records || []
    }
  } catch (e: any) {
    error.value = e.message
--- a/frontend/pages/app/objects/[objectName]/[[recordId]]/[[view]].vue
+++ b/frontend/pages/app/objects/[objectName]/[[recordId]]/[[view]].vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, onBeforeUnmount, watch, nextTick } from 'vue'
+import { ref, computed, onMounted, onBeforeUnmount, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import { useApi } from '@/composables/useApi'
 import { useFields, useViewState } from '@/composables/useFieldViews'
@@ -31,6 +31,7 @@ const error = ref<string | null>(null)
 // Use view state composable
 const {
  records,
+  totalCount,
  currentRecord,
  loading: dataLoading,
  saving,
@@ -50,7 +51,7 @@ const handleAiRecordCreated = (event: Event) => {
    return
  }
  if (view.value === 'list') {
-    fetchRecords()
+    initializeListRecords()
  }
 }

@@ -82,6 +83,9 @@ const editConfig = computed(() => {
  return buildEditViewConfig(objectDefinition.value)
 })

+const listPageSize = computed(() => listConfig.value?.pageSize ?? 25)
+const maxFrontendRecords = computed(() => listConfig.value?.maxFrontendRecords ?? 500)
+
 // Fetch object definition
 const fetchObjectDefinition = async () => {
  try {
@@ -160,6 +164,39 @@ const handleCancel = () => {
  }
 }

+const loadListRecords = async (
+  page = 1,
+  options?: { append?: boolean; pageSize?: number }
+) => {
+  const pageSize = options?.pageSize ?? listPageSize.value
+  const result = await fetchRecords({ page, pageSize }, { append: options?.append })
+  const resolvedTotal = result?.totalCount ?? totalCount.value ?? records.value.length
+  totalCount.value = resolvedTotal
+  return result
+}
+
+const initializeListRecords = async () => {
+  const firstResult = await loadListRecords(1)
+  const resolvedTotal = firstResult?.totalCount ?? totalCount.value ?? records.value.length
+  const shouldPrefetchAll =
+    resolvedTotal <= maxFrontendRecords.value && records.value.length < resolvedTotal
+
+  if (shouldPrefetchAll) {
+    await loadListRecords(1, { append: false, pageSize: maxFrontendRecords.value })
+  }
+}
+
+const handlePageChange = async (page: number, pageSize: number) => {
+  const loadedPages = Math.ceil(records.value.length / pageSize)
+  if (page > loadedPages && totalCount.value > records.value.length) {
+    await loadListRecords(page, { append: true, pageSize })
+  }
+}
+
+const handleLoadMore = async (page: number, pageSize: number) => {
+  await loadListRecords(page, { append: true, pageSize })
+}
+
 // Watch for route changes
 watch(() => route.params, async (newParams, oldParams) => {
  // Reset current record when navigating to 'new'
@@ -174,7 +211,7 @@ watch(() => route.params, async (newParams, oldParams) => {
  
  // Fetch records if navigating back to list
  if (!newParams.recordId && !newParams.view) {
-    await fetchRecords()
+    await initializeListRecords()
  }
 }, { deep: true })

@@ -183,7 +220,7 @@ onMounted(async () => {
  await fetchObjectDefinition()
  
  if (view.value === 'list') {
-    await fetchRecords()
+    await initializeListRecords()
  } else if (recordId.value && recordId.value !== 'new') {
    await fetchRecord(recordId.value)
  }
@@ -225,11 +262,14 @@ onMounted(async () => {
        :config="listConfig"
        :data="records"
        :loading="dataLoading"
+        :total-count="totalCount"
        selectable
        @row-click="handleRowClick"
        @create="handleCreate"
        @edit="handleEdit"
        @delete="handleDelete"
+        @page-change="handlePageChange"
+        @load-more="handleLoadMore"
      />

      <!-- Detail View -->
--- a/frontend/types/field-types.ts
+++ b/frontend/types/field-types.ts
@@ -114,6 +114,7 @@ export interface ViewConfig {
 export interface ListViewConfig extends ViewConfig {
  mode: ViewMode.LIST;
  pageSize?: number;
+  maxFrontendRecords?: number;
  searchable?: boolean;
  filterable?: boolean;
  exportable?: boolean;
Author	SHA1	Message	Date
Francisco Gaona	d00e26ad27	WIP - allow search in system fields	2026-01-13 10:55:11 +01:00
Francisco Gaona	9dcedcdf69	WIP - search with AI	2026-01-13 10:44:38 +01:00
Francisco Gaona	47fa72451d	WIP - Added pagination for list view	2026-01-13 09:03:11 +01:00