@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/services/entity-helpers.ts

@@ -11,10 +11,31 @@ import { getTableName } from "@rebasepro/common";
  * `PostgresCollectionRegistry` instance — there is no global singleton.
  */
 
+/**
+ * Interface for Drizzle column metadata introspection.
+ * Replaces unsafe `as unknown as Record<string, unknown>` double-cast chains.
+ */
+export interface DrizzleColumnMeta {
+    columnType?: string;
+    dataType?: string;
+    primary?: boolean;
+}
+
+/** Safely extract Drizzle column metadata from a column object. */
+export function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta {
+    const raw = col as unknown as Record<string | symbol, unknown>;
+    return {
+        columnType: typeof raw.columnType === "string" ? raw.columnType : undefined,
+        dataType: typeof raw.dataType === "string" ? raw.dataType : undefined,
+        primary: typeof raw.primary === "boolean" ? raw.primary : undefined
+    };
+}
+
 export function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): EntityCollection {
     const collection = registry.getCollectionByPath(collectionPath);
     if (!collection) {
-        throw new Error(`Collection not found: ${collectionPath}`);
+        const registered = registry.getCollections().map(c => c.slug).join(", ");
+        throw new Error(`Collection not found: ${collectionPath}. Registered collections: [${registered}]`);
     }
     return collection;
 }
@@ -28,16 +49,17 @@ export function getTableForCollection(collection: EntityCollection, registry: Po
     return table;
 }
 
-export function getPrimaryKeys(collection: EntityCollection, registry: PostgresCollectionRegistry): { fieldName: string; type: "string" | "number" }[] {
+export function getPrimaryKeys(collection: EntityCollection, registry: PostgresCollectionRegistry): { fieldName: string; type: "string" | "number"; isUUID?: boolean }[] {
     const table = getTableForCollection(collection, registry);
 
     // Fallback to explicitly defined isId properties
     if (collection.properties) {
         const idProps = Object.entries(collection.properties)
-            .filter(([_, prop]) => "isId" in (prop as object) && Boolean((prop as unknown as Record<string, unknown>).isId))
+            .filter(([_, prop]) => "isId" in (prop as object) && Boolean((prop as { isId?: unknown }).isId))
             .map(([key, prop]) => ({
                 fieldName: key,
-                type: prop.type === "number" ? "number" as const : "string" as const
+                type: prop.type === "number" ? "number" as const : "string" as const,
+                isUUID: (prop as { isId?: unknown }).isId === "uuid"
             }));
 
         if (idProps.length > 0) {
@@ -46,12 +68,14 @@ export function getPrimaryKeys(collection: EntityCollection, registry: PostgresC
     }
 
     // Otherwise infer from Drizzle schema
-    const keys: { fieldName: string; type: "string" | "number" }[] = [];
+    const keys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[] = [];
     for (const [key, colRaw] of Object.entries(table)) {
         const col = colRaw as AnyPgColumn;
         if (col && typeof col === "object" && "primary" in col && col.primary) {
-            const type = col.dataType === "number" || (col as unknown as Record<string, unknown>).columnType === "PgSerial" || (col as unknown as Record<string, unknown>).columnType === "PgInteger" ? "number" : "string";
-            keys.push({ fieldName: key, type });
+            const meta = getColumnMeta(col);
+            const type = col.dataType === "number" || meta.columnType === "PgSerial" || meta.columnType === "PgInteger" ? "number" : "string";
+            const isUUID = meta.columnType === "PgUUID";
+            keys.push({ fieldName: key, type, isUUID });
         }
     }
 
@@ -59,14 +83,16 @@ export function getPrimaryKeys(collection: EntityCollection, registry: PostgresC
     // This maintains backwards compatibility
     if (keys.length === 0 && "id" in table) {
         const idCol = table["id" as keyof typeof table] as AnyPgColumn;
-        const type = idCol.dataType === "number" || (idCol as unknown as Record<string, unknown>).columnType === "PgSerial" || (idCol as unknown as Record<string, unknown>).columnType === "PgInteger" ? "number" : "string";
-        keys.push({ fieldName: "id", type });
+        const idMeta = getColumnMeta(idCol);
+        const type = idCol.dataType === "number" || idMeta.columnType === "PgSerial" || idMeta.columnType === "PgInteger" ? "number" : "string";
+        const isUUID = idMeta.columnType === "PgUUID";
+        keys.push({ fieldName: "id", type, isUUID });
     }
 
     return keys;
 }
 
-export function parseIdValues(idValue: string | number, primaryKeys: { fieldName: string; type: "string" | "number" }[]): Record<string, string | number> {
+export function parseIdValues(idValue: string | number, primaryKeys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[]): Record<string, string | number> {
     const result: Record<string, string | number> = {};
 
     if (primaryKeys.length === 0) {
@@ -75,7 +101,7 @@ export function parseIdValues(idValue: string | number, primaryKeys: { fieldName
 
     if (primaryKeys.length === 1) {
         const pk = primaryKeys[0];
-        if (pk.type === "number") {
+        if (pk.type === "number" && !pk.isUUID) {
             const parsed = typeof idValue === "number" ? idValue : parseInt(String(idValue), 10);
             if (isNaN(parsed)) {
                 throw new Error(`Invalid numeric ID: ${idValue}`);
@@ -96,7 +122,7 @@ export function parseIdValues(idValue: string | number, primaryKeys: { fieldName
     for (let i = 0; i < primaryKeys.length; i++) {
         const pk = primaryKeys[i];
         const val = parts[i];
-        if (pk.type === "number") {
+        if (pk.type === "number" && !pk.isUUID) {
             const parsed = parseInt(val, 10);
             if (isNaN(parsed)) {
                 throw new Error(`Invalid numeric ID component: ${val}`);
@@ -110,7 +136,7 @@ export function parseIdValues(idValue: string | number, primaryKeys: { fieldName
     return result;
 }
 
-export function buildCompositeId(values: Record<string, any>, primaryKeys: { fieldName: string; type: "string" | "number" }[]): string {
+export function buildCompositeId(values: Record<string, unknown>, primaryKeys: { fieldName: string; type: "string" | "number"; isUUID?: boolean }[]): string {
     if (primaryKeys.length === 0) {
         return "";
     }

package/src/services/entityService.ts

@@ -19,13 +19,13 @@ export * from "../interfaces";
 
 /**
  * EntityService - Facade for entity operations.
- * 
+ *
  * This class provides a unified API for entity CRUD operations by delegating
  * to specialized services:
  * - EntityFetchService: Read operations (fetch, search, count)
  * - EntityPersistService: Write operations (save, delete)
  * - RelationService: Relation operations (fetch related, update relations)
- * 
+ *
  * Implements the EntityRepository interface for database abstraction.
  */
 export class EntityService implements EntityRepository {
@@ -44,7 +44,7 @@ export class EntityService implements EntityRepository {
     /**
      * Fetch a single entity by ID
      */
-    async fetchEntity<M extends Record<string, any>>(
+    async fetchEntity<M extends Record<string, unknown>>(
         collectionPath: string,
         entityId: string | number,
         databaseId?: string
@@ -55,13 +55,14 @@ export class EntityService implements EntityRepository {
     /**
      * Fetch a collection of entities with optional filtering, ordering, and pagination
      */
-    async fetchCollection<M extends Record<string, any>>(
+    async fetchCollection<M extends Record<string, unknown>>(
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;
+            offset?: number;
             startAfter?: Record<string, unknown>;
             searchString?: string;
             databaseId?: string;
@@ -73,7 +74,7 @@ export class EntityService implements EntityRepository {
     /**
      * Search entities by text
      */
-    async searchEntities<M extends Record<string, any>>(
+    async searchEntities<M extends Record<string, unknown>>(
         collectionPath: string,
         searchString: string,
         options: {
@@ -90,10 +91,11 @@ export class EntityService implements EntityRepository {
     /**
      * Count entities in a collection
      */
-    async countEntities<M extends Record<string, any>>(
+    async countEntities<M extends Record<string, unknown>>(
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
+            searchString?: string;
             databaseId?: string;
         } = {}
     ): Promise<number> {
@@ -116,7 +118,7 @@ export class EntityService implements EntityRepository {
     /**
      * Fetch entities related to a parent entity
      */
-    async fetchRelatedEntities<M extends Record<string, any>>(
+    async fetchRelatedEntities<M extends Record<string, unknown>>(
         parentCollectionPath: string,
         parentEntityId: string | number,
         relationKey: string,
@@ -145,7 +147,7 @@ export class EntityService implements EntityRepository {
     /**
      * Save an entity (create or update)
      */
-    async saveEntity<M extends Record<string, any>>(
+    async saveEntity<M extends Record<string, unknown>>(
         collectionPath: string,
         values: Partial<M>,
         entityId?: string | number,
@@ -177,7 +179,7 @@ export class EntityService implements EntityRepository {
         const result = await this.db.execute(sql.raw(sqlText));
         const rows = result.rows;
         if (process.env.NODE_ENV !== "production") {
-            console.debug(`SQL executed successfully. Returned ${Array.isArray(rows) ? rows.length : 'non-array'} rows.`);
+            console.debug(`SQL executed successfully. Returned ${Array.isArray(rows) ? rows.length : "non-array"} rows.`);
         }
         return rows as Record<string, unknown>[];
     }

package/src/services/realtimeService.ts

@@ -4,7 +4,7 @@ import { Client as PgClient } from "pg";
 import { randomUUID } from "crypto";
 import { EntityService } from "./entityService";
 
-import { Entity, FetchCollectionProps, ListenCollectionProps, ListenEntityProps, DataDriver, CollectionUpdateMessage, EntityUpdateMessage, CollectionEntityPatchMessage, WebSocketMessage } from "@rebasepro/types";
+import { Entity, FetchCollectionProps, ListenCollectionProps, ListenEntityProps, DataDriver, CollectionUpdateMessage, EntityUpdateMessage, CollectionEntityPatchMessage, WebSocketMessage, FilterValues, EntityCollection, RebaseCallContext } from "@rebasepro/types";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { sql as drizzleSql } from "drizzle-orm";
 import { RealtimeProvider, CollectionSubscriptionConfig, EntitySubscriptionConfig } from "../interfaces";
@@ -32,7 +32,7 @@ type RealTimeListenEntityProps = ListenEntityProps & { subscriptionId: string };
 /**
  * PostgreSQL-specific realtime service.
  * Handles WebSocket connections and subscriptions for real-time entity updates.
- * 
+ *
  * Implements the RealtimeProvider interface for database abstraction.
  */
 export class RealtimeService extends EventEmitter implements RealtimeProvider {
@@ -50,6 +50,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;
+            offset?: number;
             startAfter?: Record<string, unknown>;
             databaseId?: string;
             searchString?: string;
@@ -111,6 +112,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;
+            offset?: number;
             startAfter?: Record<string, unknown>;
             databaseId?: string;
             searchString?: string;
@@ -253,6 +255,16 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         const subscriptionId = request.subscriptionId;
 
         try {
+            // Early validation: ensure the requested collection exists in the registry
+            const collection = this.registry.getCollectionByPath(request.path);
+            if (!collection) {
+                const registered = this.registry.getCollections().map(c => c.slug).join(", ");
+                const msg = `Collection not found: '${request.path}'. Registered: [${registered}]`;
+                console.error(`[RealtimeService] ${msg}`);
+                this.sendError(clientId, msg, subscriptionId);
+                return;
+            }
+
             // Store subscription with full request parameters and auth context for RLS
             this._subscriptions.set(subscriptionId, {
                 clientId,
@@ -273,7 +285,6 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             // Send initial data
             let entities;
             if (this.driver) {
-                const collection = this.registry.getCollectionByPath(request.path);
                 entities = await this.driver.fetchCollection({
                     path: request.path,
                     collection: collection,
@@ -307,6 +318,16 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         const subscriptionId = request.subscriptionId;
 
         try {
+            // Early validation: ensure the requested collection exists in the registry
+            const collection = this.registry.getCollectionByPath(request.path);
+            if (!collection) {
+                const registered = this.registry.getCollections().map(c => c.slug).join(", ");
+                const msg = `Collection not found: '${request.path}'. Registered: [${registered}]`;
+                console.error(`[RealtimeService] ${msg}`);
+                this.sendError(clientId, msg, subscriptionId);
+                return;
+            }
+
             // Store subscription in memory with auth context for RLS
             this._subscriptions.set(subscriptionId, {
                 clientId,
@@ -319,7 +340,6 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             // Send initial data
             let entity;
             if (this.driver) {
-                const collection = this.registry.getCollectionByPath(request.path);
                 entity = await this.driver.fetchEntity({
                     path: request.path,
                     entityId: request.entityId,
@@ -424,7 +444,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             try {
                 if (subscription.type === "entity" && notifyPath === originalPath) {
                     // Send entity update directly (only for exact path matches)
-                    if (entity && (entity as any).values?._rebase_invalidated) {
+                    if (entity && (entity as unknown as Record<string, unknown>).values && ((entity as unknown as Record<string, unknown>).values as Record<string, unknown>)?._rebase_invalidated) {
                         this.debouncedEntityRefetch(subscriptionId, notifyPath, entityId, subscription);
                     } else {
                         this.sendEntityUpdate(subscription.clientId, subscriptionId, entity);
@@ -432,7 +452,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 } else if (subscription.type === "collection" && subscription.collectionRequest) {
                     // Phase 1: Send instant entity-level patch (no DB query)
                     // This gives immediate cross-tab feedback
-                    if (!entity || !(entity as any).values?._rebase_invalidated) {
+                    if (!entity || !((entity as unknown as Record<string, unknown>).values && ((entity as unknown as Record<string, unknown>).values as Record<string, unknown>)?._rebase_invalidated)) {
                         this.sendCollectionEntityPatch(subscription.clientId, subscriptionId, entityId, entity);
                     }
 
@@ -453,7 +473,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 if (!callback) continue;
 
                 if (subscription.type === "entity" && notifyPath === originalPath) {
-                    if (entity && (entity as any).values?._rebase_invalidated) {
+                    if (entity && (entity as unknown as Record<string, unknown>).values && ((entity as unknown as Record<string, unknown>).values as Record<string, unknown>)?._rebase_invalidated) {
                         this.debouncedEntityDriverRefetch(subscriptionId, notifyPath, entityId, subscription, callback);
                     } else {
                         // Call the callback directly with the entity (only for exact path matches)
@@ -476,7 +496,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private debouncedCollectionRefetch(
         subscriptionId: string,
         notifyPath: string,
-        subscription: { clientId: string; collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext }
+        subscription: { clientId: string; collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext }
     ) {
         const timerKey = `ws_${subscriptionId}`;
         const existing = this.refetchTimers.get(timerKey);
@@ -502,7 +522,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private debouncedDriverRefetch(
         subscriptionId: string,
         notifyPath: string,
-        subscription: { collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext },
+        subscription: { collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext },
         callback: (data: Entity[] | Entity | null) => void
     ) {
         const timerKey = `drv_${subscriptionId}`;
@@ -528,7 +548,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
      */
     private async fetchCollectionWithAuth(
         notifyPath: string,
-        collectionRequest: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string },
+        collectionRequest: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string },
         authContext?: SubscriptionAuthContext
     ): Promise<Entity[]> {
         if (this.driver) {
@@ -540,6 +560,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 orderBy: collectionRequest.orderBy,
                 order: collectionRequest.order,
                 limit: collectionRequest.limit,
+                offset: collectionRequest.offset,
                 startAfter: collectionRequest.startAfter,
                 searchString: collectionRequest.searchString
             });
@@ -549,7 +570,8 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 return await this.db.transaction(async (tx) => {
                     await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${authContext.userId}, true)`);
                     await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${authContext.roles.join(",")}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId, roles: authContext.roles })}, true)`);
+                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId,
+roles: authContext.roles })}, true)`);
                     const txEntityService = new EntityService(tx, this.registry);
                     let fetchedEntities;
                     if (collectionRequest.searchString) {
@@ -557,7 +579,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                             notifyPath,
                             collectionRequest.searchString,
                             {
-                            filter: collectionRequest.filter as import("@rebasepro/types").FilterValues<string>,
+                            filter: collectionRequest.filter as FilterValues<string>,
                             orderBy: collectionRequest.orderBy,
                             order: collectionRequest.order,
                             limit: collectionRequest.limit,
@@ -566,10 +588,11 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                         );
                     } else {
                         fetchedEntities = await txEntityService.fetchCollection(notifyPath, {
-                        filter: collectionRequest.filter as import("@rebasepro/types").FilterValues<string>,
+                        filter: collectionRequest.filter as FilterValues<string>,
                         orderBy: collectionRequest.orderBy,
                         order: collectionRequest.order,
                         limit: collectionRequest.limit,
+                        offset: collectionRequest.offset,
                         startAfter: collectionRequest.startAfter,
                         databaseId: collectionRequest.databaseId
                     });
@@ -578,18 +601,20 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                     // Re-apply `afterRead` lifecycle hooks to ensure consistent data structures
                     // between the initial driver fetch and this RLS-bound refetch.
                     const registryCollection = this.registry.getCollectionByPath(notifyPath);
-                    const resolvedCollection = collection ? { ...collection, ...registryCollection } as import("@rebasepro/types").EntityCollection : registryCollection as import("@rebasepro/types").EntityCollection;
-                    
+                    const resolvedCollection = collection ? { ...collection,
+...registryCollection } as EntityCollection : registryCollection as EntityCollection;
+
                     const callbacks = resolvedCollection?.callbacks;
                     const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
 
                     if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
                         const contextForCallback = {
-                            user: { uid: authContext.userId, roles: authContext.roles },
+                            user: { uid: authContext.userId,
+roles: authContext.roles },
                             driver: this.driver,
-                            data: this.driver ? (this.driver as any).data : undefined
-                        } as any;
-                        
+                            data: this.driver ? (this.driver as unknown as Record<string, unknown>).data : undefined
+                        } as unknown as RebaseCallContext;
+
                         return await Promise.all(fetchedEntities.map(async (entity) => {
                             let processedEntity = entity;
                             if (callbacks?.afterRead) {
@@ -625,7 +650,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 notifyPath,
                 collectionRequest.searchString,
                 {
-                    filter: collectionRequest.filter as import("@rebasepro/types").FilterValues<string>,
+                    filter: collectionRequest.filter as FilterValues<string>,
                     orderBy: collectionRequest.orderBy,
                     order: collectionRequest.order,
                     limit: collectionRequest.limit,
@@ -634,10 +659,11 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             );
         }
         return await this.entityService.fetchCollection(notifyPath, {
-            filter: collectionRequest.filter as import("@rebasepro/types").FilterValues<string>,
+            filter: collectionRequest.filter as FilterValues<string>,
             orderBy: collectionRequest.orderBy,
             order: collectionRequest.order,
             limit: collectionRequest.limit,
+            offset: collectionRequest.offset,
             startAfter: collectionRequest.startAfter,
             databaseId: collectionRequest.databaseId
         });
@@ -677,7 +703,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         notifyPath: string,
         entityId: string,
         subscription: { clientId: string; authContext?: SubscriptionAuthContext },
-        callback: (data: any) => void
+        callback: (data: Entity[] | Entity | null) => void
     ) {
         const timerKey = `drve_${subscriptionId}`;
         const existing = this.refetchTimers.get(timerKey);
@@ -716,24 +742,27 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 return await this.db.transaction(async (tx) => {
                     await tx.execute(drizzleSql`SELECT set_config('app.user_id', ${authContext.userId}, true)`);
                     await tx.execute(drizzleSql`SELECT set_config('app.user_roles', ${authContext.roles.join(",")}, true)`);
-                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId, roles: authContext.roles })}, true)`);
+                    await tx.execute(drizzleSql`SELECT set_config('app.jwt', ${JSON.stringify({ sub: authContext.userId,
+roles: authContext.roles })}, true)`);
                     const txEntityService = new EntityService(tx, this.registry);
                     let processedEntity = await txEntityService.fetchEntity(notifyPath, entityId, collection?.databaseId);
 
                     if (processedEntity) {
                         const registryCollection = this.registry.getCollectionByPath(notifyPath);
-                        const resolvedCollection = collection ? { ...collection, ...registryCollection } as import("@rebasepro/types").EntityCollection : registryCollection as import("@rebasepro/types").EntityCollection;
-                        
+                        const resolvedCollection = collection ? { ...collection,
+...registryCollection } as EntityCollection : registryCollection as EntityCollection;
+
                         const callbacks = resolvedCollection?.callbacks;
                         const propertyCallbacks = resolvedCollection?.properties ? buildPropertyCallbacks(resolvedCollection.properties) : undefined;
 
                         if (callbacks?.afterRead || propertyCallbacks?.afterRead) {
                             const contextForCallback = {
-                                user: { uid: authContext.userId, roles: authContext.roles },
+                                user: { uid: authContext.userId,
+roles: authContext.roles },
                                 driver: this.driver,
-                                data: this.driver ? (this.driver as any).data : undefined
-                            } as any;
-                            
+                                data: this.driver ? (this.driver as unknown as Record<string, unknown>).data : undefined
+                            } as unknown as RebaseCallContext;
+
                             if (callbacks?.afterRead) {
                                 processedEntity = await callbacks.afterRead({
                                     collection: resolvedCollection,