diff --git a/pkg/codegen/assets/store_rdbms.gen.go.tpl b/pkg/codegen/assets/store_rdbms.gen.go.tpl
index 20d10624e..131308c34 100644
--- a/pkg/codegen/assets/store_rdbms.gen.go.tpl
+++ b/pkg/codegen/assets/store_rdbms.gen.go.tpl
@@ -122,7 +122,7 @@ func (s Store) {{ toggleExport .Search.Export "Search" $.Types.Plural }}(ctx con
 		f.PageCursor = nil
 		return nil
 	{{- else }}
-		set, _, _, err = s.{{ export "query" $.Types.Plural }}(ctx{{ template "extraArgsCall" . }}, q, {{ if $.Search.EnableFilterCheckFn }}f.Check{{else}}nil{{ end }})
+		set, err = s.{{ export "query" $.Types.Plural }}(ctx{{ template "extraArgsCall" . }}, q, {{ if $.Search.EnableFilterCheckFn }}f.Check{{else}}nil{{ end }})
 		return err
 	{{- end }}
 	}()
@@ -176,23 +176,20 @@ func (s Store) {{ unexport "fetchFullPageOf" $.Types.Plural  }} (
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.{{ export "query" $.Types.Plural }}(ctx{{ template "extraArgsCall" . }}, tryQuery, check); err != nil {
+		if aux, err = s.{{ export "query" $.Types.Plural }}(ctx{{ template "extraArgsCall" . }}, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collect{{ export $.Types.Singular }}CursorValues(aux[0], sortColumns...)
 		}
 
-
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
-			next = s.collect{{ export $.Types.Singular }}CursorValues(aux[limit-1], sortColumns...);
-		}
+		if fetched > limit && limit > 0 {
+			next = s.collect{{ export $.Types.Singular }}CursorValues(aux[limit-1], sortColumns...)
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -243,30 +240,27 @@ func (s Store) {{ export "query" $.Types.Plural }} (
 	ctx context.Context{{ template "extraArgsDef" . }},
 	q squirrel.Sqlizer,
 	check func(*{{ $.Types.GoType }}) (bool, error),
-) ([]*{{ $.Types.GoType }}, uint, *{{ $.Types.GoType }}, error) {
+) ([]*{{ $.Types.GoType }}, error) {
 	var (
 		set = make([]*{{ $.Types.GoType }}, 0, DefaultSliceCapacity)
 		res  *{{ $.Types.GoType }}
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internal{{ export $.Types.Singular }}RowScanner({{ template "extraArgsCallFirst" . }}rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 	{{ if $.Search.EnableFilterCheckFn }}
@@ -274,7 +268,7 @@ func (s Store) {{ export "query" $.Types.Plural }} (
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -285,11 +279,11 @@ func (s Store) {{ export "query" $.Types.Plural }} (
 
 {{ if .RDBMS.CustomPostLoadProcessor }}
 	if err = s.{{ unexport $.Types.Singular }}PostLoadProcessor(ctx{{ template "extraArgsCall" . }}, set...); err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 {{end }}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 
diff --git a/store/rdbms/actionlog.gen.go b/store/rdbms/actionlog.gen.go
index 2b2efaa41..106463a07 100644
--- a/store/rdbms/actionlog.gen.go
+++ b/store/rdbms/actionlog.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfActionlogs(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryActionlogs(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryActionlogs(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectActionlogCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectActionlogCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,36 +187,33 @@ func (s Store) QueryActionlogs(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*actionlog.Action) (bool, error),
-) ([]*actionlog.Action, uint, *actionlog.Action, error) {
+) ([]*actionlog.Action, error) {
 	var (
 		set = make([]*actionlog.Action, 0, DefaultSliceCapacity)
 		res *actionlog.Action
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalActionlogRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // CreateActionlog creates one or more rows in actionlog table
diff --git a/store/rdbms/applications.gen.go b/store/rdbms/applications.gen.go
index 609f467fb..470f95794 100644
--- a/store/rdbms/applications.gen.go
+++ b/store/rdbms/applications.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfApplications(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryApplications(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryApplications(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectApplicationCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectApplicationCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryApplications(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Application) (bool, error),
-) ([]*types.Application, uint, *types.Application, error) {
+) ([]*types.Application, error) {
 	var (
 		set = make([]*types.Application, 0, DefaultSliceCapacity)
 		res *types.Application
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalApplicationRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryApplications(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupApplicationByID searches for application by ID
diff --git a/store/rdbms/attachments.gen.go b/store/rdbms/attachments.gen.go
index e52999bdd..dc8497a7e 100644
--- a/store/rdbms/attachments.gen.go
+++ b/store/rdbms/attachments.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchAttachments(ctx context.Context, f types.AttachmentFilter)
 			return err
 		}
 
-		set, _, _, err = s.QueryAttachments(ctx, q, f.Check)
+		set, err = s.QueryAttachments(ctx, q, f.Check)
 		return err
 	}()
 }
@@ -50,37 +50,34 @@ func (s Store) QueryAttachments(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Attachment) (bool, error),
-) ([]*types.Attachment, uint, *types.Attachment, error) {
+) ([]*types.Attachment, error) {
 	var (
 		set = make([]*types.Attachment, 0, DefaultSliceCapacity)
 		res *types.Attachment
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalAttachmentRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -89,7 +86,7 @@ func (s Store) QueryAttachments(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupAttachmentByID searches for attachment by its ID
diff --git a/store/rdbms/compose_attachments.gen.go b/store/rdbms/compose_attachments.gen.go
index 8ea76f8cd..ea833852f 100644
--- a/store/rdbms/compose_attachments.gen.go
+++ b/store/rdbms/compose_attachments.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchComposeAttachments(ctx context.Context, f types.AttachmentF
 			return err
 		}
 
-		set, _, _, err = s.QueryComposeAttachments(ctx, q, f.Check)
+		set, err = s.QueryComposeAttachments(ctx, q, f.Check)
 		return err
 	}()
 }
@@ -50,37 +50,34 @@ func (s Store) QueryComposeAttachments(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Attachment) (bool, error),
-) ([]*types.Attachment, uint, *types.Attachment, error) {
+) ([]*types.Attachment, error) {
 	var (
 		set = make([]*types.Attachment, 0, DefaultSliceCapacity)
 		res *types.Attachment
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeAttachmentRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -89,7 +86,7 @@ func (s Store) QueryComposeAttachments(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposeAttachmentByID searches for attachment by its ID
diff --git a/store/rdbms/compose_charts.gen.go b/store/rdbms/compose_charts.gen.go
index e9b8c9f88..783f8bd74 100644
--- a/store/rdbms/compose_charts.gen.go
+++ b/store/rdbms/compose_charts.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfComposeCharts(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryComposeCharts(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryComposeCharts(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectComposeChartCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectComposeChartCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryComposeCharts(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Chart) (bool, error),
-) ([]*types.Chart, uint, *types.Chart, error) {
+) ([]*types.Chart, error) {
 	var (
 		set = make([]*types.Chart, 0, DefaultSliceCapacity)
 		res *types.Chart
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeChartRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryComposeCharts(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposeChartByID searches for compose chart by ID
diff --git a/store/rdbms/compose_module_fields.gen.go b/store/rdbms/compose_module_fields.gen.go
index 275939104..54025fb19 100644
--- a/store/rdbms/compose_module_fields.gen.go
+++ b/store/rdbms/compose_module_fields.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchComposeModuleFields(ctx context.Context, f types.ModuleFiel
 			return err
 		}
 
-		set, _, _, err = s.QueryComposeModuleFields(ctx, q, nil)
+		set, err = s.QueryComposeModuleFields(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryComposeModuleFields(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.ModuleField) (bool, error),
-) ([]*types.ModuleField, uint, *types.ModuleField, error) {
+) ([]*types.ModuleField, error) {
 	var (
 		set = make([]*types.ModuleField, 0, DefaultSliceCapacity)
 		res *types.ModuleField
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeModuleFieldRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposeModuleFieldByModuleIDName searches for compose module field by name (case-insensitive)
diff --git a/store/rdbms/compose_modules.gen.go b/store/rdbms/compose_modules.gen.go
index d22730386..391ab0e21 100644
--- a/store/rdbms/compose_modules.gen.go
+++ b/store/rdbms/compose_modules.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfComposeModules(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryComposeModules(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryComposeModules(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectComposeModuleCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectComposeModuleCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryComposeModules(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Module) (bool, error),
-) ([]*types.Module, uint, *types.Module, error) {
+) ([]*types.Module, error) {
 	var (
 		set = make([]*types.Module, 0, DefaultSliceCapacity)
 		res *types.Module
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeModuleRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryComposeModules(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposeModuleByNamespaceIDHandle searches for compose module by handle (case-insensitive)
diff --git a/store/rdbms/compose_namespaces.gen.go b/store/rdbms/compose_namespaces.gen.go
index 1ed0a03cb..a88f413f2 100644
--- a/store/rdbms/compose_namespaces.gen.go
+++ b/store/rdbms/compose_namespaces.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfComposeNamespaces(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryComposeNamespaces(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryComposeNamespaces(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectComposeNamespaceCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectComposeNamespaceCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryComposeNamespaces(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Namespace) (bool, error),
-) ([]*types.Namespace, uint, *types.Namespace, error) {
+) ([]*types.Namespace, error) {
 	var (
 		set = make([]*types.Namespace, 0, DefaultSliceCapacity)
 		res *types.Namespace
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeNamespaceRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryComposeNamespaces(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposeNamespaceBySlug searches for namespace by slug (case-insensitive)
diff --git a/store/rdbms/compose_pages.gen.go b/store/rdbms/compose_pages.gen.go
index 7b01d80ae..c7d54e940 100644
--- a/store/rdbms/compose_pages.gen.go
+++ b/store/rdbms/compose_pages.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfComposePages(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryComposePages(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryComposePages(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectComposePageCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectComposePageCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryComposePages(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Page) (bool, error),
-) ([]*types.Page, uint, *types.Page, error) {
+) ([]*types.Page, error) {
 	var (
 		set = make([]*types.Page, 0, DefaultSliceCapacity)
 		res *types.Page
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposePageRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryComposePages(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupComposePageByNamespaceIDHandle searches for page by handle (case-insensitive)
diff --git a/store/rdbms/compose_record_values.gen.go b/store/rdbms/compose_record_values.gen.go
index 7e2c528d3..e780d20c4 100644
--- a/store/rdbms/compose_record_values.gen.go
+++ b/store/rdbms/compose_record_values.gen.go
@@ -36,7 +36,7 @@ func (s Store) searchComposeRecordValues(ctx context.Context, _mod *types.Module
 			return err
 		}
 
-		set, _, _, err = s.QueryComposeRecordValues(ctx, _mod, q, nil)
+		set, err = s.QueryComposeRecordValues(ctx, _mod, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryComposeRecordValues(
 	ctx context.Context, _mod *types.Module,
 	q squirrel.Sqlizer,
 	check func(*types.RecordValue) (bool, error),
-) ([]*types.RecordValue, uint, *types.RecordValue, error) {
+) ([]*types.RecordValue, error) {
 	var (
 		set = make([]*types.RecordValue, 0, DefaultSliceCapacity)
 		res *types.RecordValue
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeRecordValueRowScanner(_mod, rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // createComposeRecordValue creates one or more rows in compose_record_value table
diff --git a/store/rdbms/compose_records.gen.go b/store/rdbms/compose_records.gen.go
index 860894413..24c8e07d9 100644
--- a/store/rdbms/compose_records.gen.go
+++ b/store/rdbms/compose_records.gen.go
@@ -67,22 +67,20 @@ func (s Store) fetchFullPageOfComposeRecords(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryComposeRecords(ctx, _mod, tryQuery, check); err != nil {
+		if aux, err = s.QueryComposeRecords(ctx, _mod, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectComposeRecordCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectComposeRecordCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -131,37 +129,34 @@ func (s Store) QueryComposeRecords(
 	ctx context.Context, _mod *types.Module,
 	q squirrel.Sqlizer,
 	check func(*types.Record) (bool, error),
-) ([]*types.Record, uint, *types.Record, error) {
+) ([]*types.Record, error) {
 	var (
 		set = make([]*types.Record, 0, DefaultSliceCapacity)
 		res *types.Record
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalComposeRecordRowScanner(_mod, rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -171,10 +166,10 @@ func (s Store) QueryComposeRecords(
 	}
 
 	if err = s.composeRecordPostLoadProcessor(ctx, _mod, set...); err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // lookupComposeRecordByID searches for compose record by ID
diff --git a/store/rdbms/credentials.gen.go b/store/rdbms/credentials.gen.go
index ab0896cb9..182170c99 100644
--- a/store/rdbms/credentials.gen.go
+++ b/store/rdbms/credentials.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchCredentials(ctx context.Context, f types.CredentialsFilter)
 			return err
 		}
 
-		set, _, _, err = s.QueryCredentials(ctx, q, nil)
+		set, err = s.QueryCredentials(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryCredentials(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Credentials) (bool, error),
-) ([]*types.Credentials, uint, *types.Credentials, error) {
+) ([]*types.Credentials, error) {
 	var (
 		set = make([]*types.Credentials, 0, DefaultSliceCapacity)
 		res *types.Credentials
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalCredentialsRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupCredentialsByID searches for credentials by ID
diff --git a/store/rdbms/labels.gen.go b/store/rdbms/labels.gen.go
index 04814751f..543e6a950 100644
--- a/store/rdbms/labels.gen.go
+++ b/store/rdbms/labels.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchLabels(ctx context.Context, f types.LabelFilter) (types.Lab
 			return err
 		}
 
-		set, _, _, err = s.QueryLabels(ctx, q, nil)
+		set, err = s.QueryLabels(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryLabels(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Label) (bool, error),
-) ([]*types.Label, uint, *types.Label, error) {
+) ([]*types.Label, error) {
 	var (
 		set = make([]*types.Label, 0, DefaultSliceCapacity)
 		res *types.Label
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalLabelRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupLabelByKindResourceIDName Label lookup by kind, resource, name
diff --git a/store/rdbms/messaging_attachments.gen.go b/store/rdbms/messaging_attachments.gen.go
index 5e5e38f02..9c476460e 100644
--- a/store/rdbms/messaging_attachments.gen.go
+++ b/store/rdbms/messaging_attachments.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchMessagingAttachments(ctx context.Context, f types.Attachmen
 			return err
 		}
 
-		set, _, _, err = s.QueryMessagingAttachments(ctx, q, f.Check)
+		set, err = s.QueryMessagingAttachments(ctx, q, f.Check)
 		return err
 	}()
 }
@@ -50,37 +50,34 @@ func (s Store) QueryMessagingAttachments(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Attachment) (bool, error),
-) ([]*types.Attachment, uint, *types.Attachment, error) {
+) ([]*types.Attachment, error) {
 	var (
 		set = make([]*types.Attachment, 0, DefaultSliceCapacity)
 		res *types.Attachment
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingAttachmentRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -89,7 +86,7 @@ func (s Store) QueryMessagingAttachments(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingAttachmentByID searches for attachment by its ID
diff --git a/store/rdbms/messaging_channel_members.gen.go b/store/rdbms/messaging_channel_members.gen.go
index 377db127c..c516ecafa 100644
--- a/store/rdbms/messaging_channel_members.gen.go
+++ b/store/rdbms/messaging_channel_members.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchMessagingChannelMembers(ctx context.Context, f types.Channe
 			return err
 		}
 
-		set, _, _, err = s.QueryMessagingChannelMembers(ctx, q, nil)
+		set, err = s.QueryMessagingChannelMembers(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryMessagingChannelMembers(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.ChannelMember) (bool, error),
-) ([]*types.ChannelMember, uint, *types.ChannelMember, error) {
+) ([]*types.ChannelMember, error) {
 	var (
 		set = make([]*types.ChannelMember, 0, DefaultSliceCapacity)
 		res *types.ChannelMember
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingChannelMemberRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // CreateMessagingChannelMember creates one or more rows in messaging_channel_member table
diff --git a/store/rdbms/messaging_channels.gen.go b/store/rdbms/messaging_channels.gen.go
index f4993463c..68db2cf95 100644
--- a/store/rdbms/messaging_channels.gen.go
+++ b/store/rdbms/messaging_channels.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfMessagingChannels(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryMessagingChannels(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryMessagingChannels(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectMessagingChannelCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectMessagingChannelCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryMessagingChannels(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Channel) (bool, error),
-) ([]*types.Channel, uint, *types.Channel, error) {
+) ([]*types.Channel, error) {
 	var (
 		set = make([]*types.Channel, 0, DefaultSliceCapacity)
 		res *types.Channel
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingChannelRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryMessagingChannels(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingChannelByID searches for attachment by its ID
diff --git a/store/rdbms/messaging_flags.gen.go b/store/rdbms/messaging_flags.gen.go
index 5d051c319..679c8e6e4 100644
--- a/store/rdbms/messaging_flags.gen.go
+++ b/store/rdbms/messaging_flags.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchMessagingFlags(ctx context.Context, f types.MessageFlagFilt
 			return err
 		}
 
-		set, _, _, err = s.QueryMessagingFlags(ctx, q, nil)
+		set, err = s.QueryMessagingFlags(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryMessagingFlags(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.MessageFlag) (bool, error),
-) ([]*types.MessageFlag, uint, *types.MessageFlag, error) {
+) ([]*types.MessageFlag, error) {
 	var (
 		set = make([]*types.MessageFlag, 0, DefaultSliceCapacity)
 		res *types.MessageFlag
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingFlagRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingFlagByID searches for flags by ID
diff --git a/store/rdbms/messaging_mentions.gen.go b/store/rdbms/messaging_mentions.gen.go
index 2ae6b8ebe..192313f63 100644
--- a/store/rdbms/messaging_mentions.gen.go
+++ b/store/rdbms/messaging_mentions.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchMessagingMentions(ctx context.Context, f types.MentionFilte
 			return err
 		}
 
-		set, _, _, err = s.QueryMessagingMentions(ctx, q, nil)
+		set, err = s.QueryMessagingMentions(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryMessagingMentions(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Mention) (bool, error),
-) ([]*types.Mention, uint, *types.Mention, error) {
+) ([]*types.Mention, error) {
 	var (
 		set = make([]*types.Mention, 0, DefaultSliceCapacity)
 		res *types.Mention
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingMentionRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingMentionByID searches for attachment by its ID
diff --git a/store/rdbms/messaging_message_attachments.gen.go b/store/rdbms/messaging_message_attachments.gen.go
index 537235425..005c0b6cd 100644
--- a/store/rdbms/messaging_message_attachments.gen.go
+++ b/store/rdbms/messaging_message_attachments.gen.go
@@ -28,36 +28,33 @@ func (s Store) QueryMessagingMessageAttachments(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.MessageAttachment) (bool, error),
-) ([]*types.MessageAttachment, uint, *types.MessageAttachment, error) {
+) ([]*types.MessageAttachment, error) {
 	var (
 		set = make([]*types.MessageAttachment, 0, DefaultSliceCapacity)
 		res *types.MessageAttachment
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingMessageAttachmentRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingMessageAttachmentByMessageID searches for message attachment by message ID
diff --git a/store/rdbms/messaging_messages.gen.go b/store/rdbms/messaging_messages.gen.go
index 6455c5b1f..d343f298d 100644
--- a/store/rdbms/messaging_messages.gen.go
+++ b/store/rdbms/messaging_messages.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchMessagingMessages(ctx context.Context, f types.MessageFilte
 			return err
 		}
 
-		set, _, _, err = s.QueryMessagingMessages(ctx, q, nil)
+		set, err = s.QueryMessagingMessages(ctx, q, nil)
 		return err
 	}()
 }
@@ -50,36 +50,33 @@ func (s Store) QueryMessagingMessages(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Message) (bool, error),
-) ([]*types.Message, uint, *types.Message, error) {
+) ([]*types.Message, error) {
 	var (
 		set = make([]*types.Message, 0, DefaultSliceCapacity)
 		res *types.Message
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingMessageRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupMessagingMessageByID searches for message by its ID
diff --git a/store/rdbms/messaging_messages.go b/store/rdbms/messaging_messages.go
index 906918820..077558e1c 100644
--- a/store/rdbms/messaging_messages.go
+++ b/store/rdbms/messaging_messages.go
@@ -140,7 +140,7 @@ func (s Store) SearchMessagingThreads(ctx context.Context, filter types.MessageF
 	// Create CTE with originals & base
 	cte := squirrel.ConcatExpr("WITH originals AS (", originals, ") ", base)
 
-	if set, _, _, err = s.QueryMessagingMessages(ctx, cte, nil); err != nil {
+	if set, err = s.QueryMessagingMessages(ctx, cte, nil); err != nil {
 		return nil, filter, err
 	}
 
diff --git a/store/rdbms/messaging_unread.gen.go b/store/rdbms/messaging_unread.gen.go
index dc313a298..e15a053a4 100644
--- a/store/rdbms/messaging_unread.gen.go
+++ b/store/rdbms/messaging_unread.gen.go
@@ -28,36 +28,33 @@ func (s Store) QueryMessagingUnreads(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Unread) (bool, error),
-) ([]*types.Unread, uint, *types.Unread, error) {
+) ([]*types.Unread, error) {
 	var (
 		set = make([]*types.Unread, 0, DefaultSliceCapacity)
 		res *types.Unread
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalMessagingUnreadRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // CreateMessagingUnread creates one or more rows in messaging_unread table
diff --git a/store/rdbms/messaging_unread.go b/store/rdbms/messaging_unread.go
index e6790f9ea..cd8a50992 100644
--- a/store/rdbms/messaging_unread.go
+++ b/store/rdbms/messaging_unread.go
@@ -82,7 +82,7 @@ func (s Store) CountMessagingUnread(ctx context.Context, userID, channelID uint6
 		q = q.Where(squirrel.Eq{"rel_reply_to": threadIDs})
 	}
 
-	uu, _, _, err = s.QueryMessagingUnreads(ctx, q, nil)
+	uu, err = s.QueryMessagingUnreads(ctx, q, nil)
 	return
 }
 
@@ -126,7 +126,7 @@ func (s Store) PresetMessagingUnread(ctx context.Context, channelID, threadID ui
 			})
 		)
 
-		if set, _, _, err = s.QueryMessagingUnreads(ctx, q, nil); err != nil {
+		if set, err = s.QueryMessagingUnreads(ctx, q, nil); err != nil {
 			return
 		}
 
diff --git a/store/rdbms/rbac_rules.gen.go b/store/rdbms/rbac_rules.gen.go
index dd770dbbd..8c578ebd0 100644
--- a/store/rdbms/rbac_rules.gen.go
+++ b/store/rdbms/rbac_rules.gen.go
@@ -33,7 +33,7 @@ func (s Store) SearchRbacRules(ctx context.Context, f rbac.RuleFilter) (rbac.Rul
 	return set, f, func() error {
 		q = s.rbacRulesSelectBuilder()
 
-		set, _, _, err = s.QueryRbacRules(ctx, q, nil)
+		set, err = s.QueryRbacRules(ctx, q, nil)
 		return err
 	}()
 }
@@ -47,36 +47,33 @@ func (s Store) QueryRbacRules(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*rbac.Rule) (bool, error),
-) ([]*rbac.Rule, uint, *rbac.Rule, error) {
+) ([]*rbac.Rule, error) {
 	var (
 		set = make([]*rbac.Rule, 0, DefaultSliceCapacity)
 		res *rbac.Rule
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalRbacRuleRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // CreateRbacRule creates one or more rows in rbac_rules table
diff --git a/store/rdbms/reminders.gen.go b/store/rdbms/reminders.gen.go
index 9dc001068..d7e44c413 100644
--- a/store/rdbms/reminders.gen.go
+++ b/store/rdbms/reminders.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfReminders(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryReminders(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryReminders(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectReminderCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectReminderCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryReminders(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Reminder) (bool, error),
-) ([]*types.Reminder, uint, *types.Reminder, error) {
+) ([]*types.Reminder, error) {
 	var (
 		set = make([]*types.Reminder, 0, DefaultSliceCapacity)
 		res *types.Reminder
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalReminderRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryReminders(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupReminderByID searches for reminder by its ID
diff --git a/store/rdbms/role_members.gen.go b/store/rdbms/role_members.gen.go
index fc4bf9689..c2989db35 100644
--- a/store/rdbms/role_members.gen.go
+++ b/store/rdbms/role_members.gen.go
@@ -33,7 +33,7 @@ func (s Store) SearchRoleMembers(ctx context.Context, f types.RoleMemberFilter)
 	return set, f, func() error {
 		q = s.roleMembersSelectBuilder()
 
-		set, _, _, err = s.QueryRoleMembers(ctx, q, nil)
+		set, err = s.QueryRoleMembers(ctx, q, nil)
 		return err
 	}()
 }
@@ -47,36 +47,33 @@ func (s Store) QueryRoleMembers(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.RoleMember) (bool, error),
-) ([]*types.RoleMember, uint, *types.RoleMember, error) {
+) ([]*types.RoleMember, error) {
 	var (
 		set = make([]*types.RoleMember, 0, DefaultSliceCapacity)
 		res *types.RoleMember
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalRoleMemberRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // CreateRoleMember creates one or more rows in role_members table
diff --git a/store/rdbms/roles.gen.go b/store/rdbms/roles.gen.go
index 35567ab08..e1562e013 100644
--- a/store/rdbms/roles.gen.go
+++ b/store/rdbms/roles.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfRoles(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryRoles(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryRoles(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectRoleCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectRoleCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryRoles(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.Role) (bool, error),
-) ([]*types.Role, uint, *types.Role, error) {
+) ([]*types.Role, error) {
 	var (
 		set = make([]*types.Role, 0, DefaultSliceCapacity)
 		res *types.Role
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalRoleRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryRoles(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupRoleByID searches for role by ID
diff --git a/store/rdbms/settings.gen.go b/store/rdbms/settings.gen.go
index 13205818b..94c20430d 100644
--- a/store/rdbms/settings.gen.go
+++ b/store/rdbms/settings.gen.go
@@ -36,7 +36,7 @@ func (s Store) SearchSettings(ctx context.Context, f types.SettingsFilter) (type
 			return err
 		}
 
-		set, _, _, err = s.QuerySettings(ctx, q, f.Check)
+		set, err = s.QuerySettings(ctx, q, f.Check)
 		return err
 	}()
 }
@@ -50,37 +50,34 @@ func (s Store) QuerySettings(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.SettingValue) (bool, error),
-) ([]*types.SettingValue, uint, *types.SettingValue, error) {
+) ([]*types.SettingValue, error) {
 	var (
 		set = make([]*types.SettingValue, 0, DefaultSliceCapacity)
 		res *types.SettingValue
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalSettingRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -89,7 +86,7 @@ func (s Store) QuerySettings(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupSettingByNameOwnedBy searches for settings by name and owner
diff --git a/store/rdbms/users.gen.go b/store/rdbms/users.gen.go
index 14425f82c..3a85abc52 100644
--- a/store/rdbms/users.gen.go
+++ b/store/rdbms/users.gen.go
@@ -125,22 +125,20 @@ func (s Store) fetchFullPageOfUsers(
 			tryQuery = tryQuery.Limit(uint64(limit + 1))
 		}
 
-		if aux, fetched, _, err = s.QueryUsers(ctx, tryQuery, check); err != nil {
+		if aux, err = s.QueryUsers(ctx, tryQuery, check); err != nil {
 			return nil, nil, nil, err
 		}
 
-		if cursor != nil && prev == nil && len(aux) > 0 {
+		fetched = uint(len(aux))
+		if cursor != nil && prev == nil && fetched > 0 {
 			// Cursor for previous page is calculated only when cursor is used (so, not on first page)
 			prev = s.collectUserCursorValues(aux[0], sortColumns...)
 		}
 
 		// Point cursor to the last fetched element
-		// if last != nil {
-		if fetched >= limit && limit > 0 {
+		if fetched > limit && limit > 0 {
 			next = s.collectUserCursorValues(aux[limit-1], sortColumns...)
-		}
 
-		if limit > 0 && uint(len(aux)) >= limit {
 			// we should use only as much as requested
 			set = append(set, aux[:limit]...)
 			break
@@ -189,37 +187,34 @@ func (s Store) QueryUsers(
 	ctx context.Context,
 	q squirrel.Sqlizer,
 	check func(*types.User) (bool, error),
-) ([]*types.User, uint, *types.User, error) {
+) ([]*types.User, error) {
 	var (
 		set = make([]*types.User, 0, DefaultSliceCapacity)
 		res *types.User
 
 		// Query rows with
 		rows, err = s.Query(ctx, q)
-
-		fetched uint
 	)
 
 	if err != nil {
-		return nil, 0, nil, err
+		return nil, err
 	}
 
 	defer rows.Close()
 	for rows.Next() {
-		fetched++
 		if err = rows.Err(); err == nil {
 			res, err = s.internalUserRowScanner(rows)
 		}
 
 		if err != nil {
-			return nil, 0, nil, err
+			return nil, err
 		}
 
 		// check fn set, call it and see if it passed the test
 		// if not, skip the item
 		if check != nil {
 			if chk, err := check(res); err != nil {
-				return nil, 0, nil, err
+				return nil, err
 			} else if !chk {
 				continue
 			}
@@ -228,7 +223,7 @@ func (s Store) QueryUsers(
 		set = append(set, res)
 	}
 
-	return set, fetched, res, rows.Err()
+	return set, rows.Err()
 }
 
 // LookupUserByID searches for user by ID
diff --git a/store/tests/users_test.go b/store/tests/users_test.go
index a330cdbf0..2793df62d 100644
--- a/store/tests/users_test.go
+++ b/store/tests/users_test.go
@@ -329,7 +329,65 @@ func testUsers(t *testing.T, s store.Users) {
 			f.Sort = filter.SortExprSet{&filter.SortExpr{Column: "email", Descending: true}}
 			set, f, err = store.SearchUsers(ctx, s, f)
 			req.EqualError(err, "incompatible sort")
+		})
 
+		t.Run("with empty cursors", func(t *testing.T) {
+			req := require.New(t)
+			req.NoError(s.TruncateUsers(ctx))
+
+			set := []*types.User{makeNew("01"), makeNew("02")}
+
+			req.NoError(s.CreateUser(ctx, set...))
+
+			f := types.UserFilter{}
+			f.Limit = 2
+			_, f, err := store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.Nil(f.NextPage)
+			req.Nil(f.PrevPage)
+
+			f.Limit = 1
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.NotNil(f.NextPage)
+			req.Nil(f.PrevPage)
+
+			f.PageCursor = f.NextPage
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.Nil(f.NextPage)
+			req.NotNil(f.PrevPage)
+
+			f = types.UserFilter{}
+			f.Sort = filter.SortExprSet{&filter.SortExpr{Column: "id", Descending: true}}
+			f.Limit = 2
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.Nil(f.NextPage)
+			req.Nil(f.PrevPage)
+
+			f.Limit = 1
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.NotNil(f.NextPage)
+			req.Nil(f.PrevPage)
+
+			f.PageCursor = f.NextPage
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.Nil(f.NextPage)
+			req.NotNil(f.PrevPage)
+
+			// expecting empty next if check fn filters out resources
+			f = types.UserFilter{Check: func(user *types.User) (bool, error) {
+				return user.Handle != "handle_02", nil
+			}}
+			f.Sort = filter.SortExprSet{&filter.SortExpr{Column: "id", Descending: true}}
+			f.Limit = 1
+			_, f, err = store.SearchUsers(ctx, s, f)
+			req.NoError(err)
+			req.Nil(f.NextPage)
+			req.Nil(f.PrevPage)
 		})
 
 		t.Run("by role", func(t *testing.T) {