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

package/dist/server-postgresql/src/PostgresBackendDriver.d.ts

@@ -33,17 +33,19 @@ export declare class PostgresBackendDriver implements DataDriver {
     constructor(db: DrizzleClient, realtimeService: RealtimeService, registry: PostgresCollectionRegistry, user?: User, poolManager?: DatabasePoolManager | undefined, historyService?: HistoryService);
     /**
      * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
+     * Implemented as a getter so method references are resolved at call-time,
+     * allowing test spies applied after construction to take effect.
      */
-    admin: DatabaseAdmin;
+    get admin(): DatabaseAdmin;
     private resolveCollectionCallbacks;
-    fetchCollection<M extends Record<string, any>>({ path, collection, filter, limit, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
-    listenCollection<M extends Record<string, any>>({ path, collection, filter, limit, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, any>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, any>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, any>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, any>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
+    fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
+    fetchEntity<M extends Record<string, unknown>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, any>>({ path, collection, filter }: FetchCollectionProps<M>): Promise<number>;
+    countEntities<M extends Record<string, unknown>>({ path, collection, filter, searchString }: FetchCollectionProps<M>): Promise<number>;
     private getTargetDb;
     executeSql(sqlText: string, options?: {
         database?: string;
@@ -82,31 +84,17 @@ export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
      */
     admin: DatabaseAdmin;
     private withTransaction;
-    fetchCollection<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
     /**
      * Injects the authenticated user's context into the most recently
      * registered realtime subscription so RLS-aware polling can apply.
      */
     private injectAuthContext;
-    listenCollection<M extends Record<string, any>>(props: ListenCollectionProps<M>): () => void;
-    fetchEntity<M extends Record<string, any>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
-    listenEntity<M extends Record<string, any>>(props: ListenEntityProps<M>): () => void;
-    saveEntity<M extends Record<string, any>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
-    deleteEntity<M extends Record<string, any>>(props: DeleteEntityProps<M>): Promise<void>;
+    listenCollection<M extends Record<string, unknown>>(props: ListenCollectionProps<M>): () => void;
+    fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
-    countEntities<M extends Record<string, any>>(props: FetchCollectionProps<M>): Promise<number>;
-    /**
-     * Intentionally delegates to the base delegate WITHOUT RLS wrapping.
-     * executeSql is an admin-only feature; access control should be enforced
-     * at the API route level, not via database-level RLS.
-     */
-    executeSql(sqlText: string, options?: {
-        database?: string;
-        role?: string;
-    }): Promise<Record<string, unknown>[]>;
-    fetchAvailableDatabases(): Promise<string[]>;
-    fetchAvailableRoles(): Promise<string[]>;
-    fetchCurrentDatabase(): Promise<string | undefined>;
-    fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]>;
-    fetchTableMetadata(tableName: string): Promise<TableMetadata>;
+    countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
 }

package/dist/server-postgresql/src/auth/services.d.ts

@@ -1,6 +1,6 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { User, NewUser } from "../schema/auth-schema";
-import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
+import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, UserIdentityData, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
 export type { Role };
 /**
  * PostgreSQL implementation of UserRepository.
@@ -12,7 +12,9 @@ export declare class UserService implements UserRepository {
     createUser(data: NewUser): Promise<User>;
     getUserById(id: string): Promise<User | null>;
     getUserByEmail(email: string): Promise<User | null>;
-    getUserByGoogleId(googleId: string): Promise<User | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<User | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
     updateUser(id: string, data: Partial<Omit<NewUser, "id">>): Promise<User | null>;
     deleteUser(id: string): Promise<void>;
     listUsers(): Promise<User[]>;
@@ -148,7 +150,9 @@ export declare class PostgresAuthRepository implements AuthRepository {
     createUser(data: CreateUserData): Promise<UserData>;
     getUserById(id: string): Promise<UserData | null>;
     getUserByEmail(email: string): Promise<UserData | null>;
-    getUserByGoogleId(googleId: string): Promise<UserData | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
     updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null>;
     deleteUser(id: string): Promise<void>;
     listUsers(): Promise<UserData[]>;

package/dist/server-postgresql/src/collections/PostgresCollectionRegistry.d.ts

@@ -1,5 +1,5 @@
 import { CollectionRegistry } from "@rebasepro/common";
-import type { EntityCollection } from "@rebasepro/types";
+import { type EntityCollection } from "@rebasepro/types";
 import { PgEnum, PgTable } from "drizzle-orm/pg-core";
 import { Relations } from "drizzle-orm";
 import { CollectionRegistryInterface } from "../interfaces";

package/dist/server-postgresql/src/connection.d.ts

@@ -1,7 +1,40 @@
 import { Pool } from "pg";
-export declare function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>): {
+/**
+ * Configuration for the Postgres connection pool.
+ *
+ * Sensible defaults are provided for production Cloud Run / single-instance
+ * deployments. Override via environment variables or explicit config.
+ */
+export interface PostgresPoolConfig {
+    /** Maximum number of connections in the pool (default: 20) */
+    max?: number;
+    /** Close idle connections after this many ms (default: 30 000) */
+    idleTimeoutMillis?: number;
+    /** Abort connection attempts after this many ms (default: 10 000) */
+    connectionTimeoutMillis?: number;
+    /** Per-query timeout in ms (default: 30 000) */
+    queryTimeout?: number;
+    /** Per-statement timeout in ms (default: 30 000) */
+    statementTimeout?: number;
+    /** Enable TCP keep-alive (default: true) */
+    keepAlive?: boolean;
+}
+/**
+ * Create a Drizzle-backed Postgres connection with a production-grade
+ * connection pool.
+ *
+ * @param connectionString  Postgres connection URL
+ * @param schema            Optional Drizzle schema for the relational API
+ * @param poolConfig        Optional pool tuning (merged over defaults)
+ *
+ * @returns `{ db, pool, connectionString }` — the `pool` is exposed so
+ *          callers can register shutdown hooks (`pool.end()`) or monitor
+ *          pool metrics.
+ */
+export declare function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
     db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
         $client: Pool;
     };
+    pool: Pool;
     connectionString: string;
 };

package/dist/server-postgresql/src/data-transformer.d.ts

@@ -1,9 +1,31 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { EntityCollection, Properties, Property } from "@rebasepro/types";
+import { EntityCollection, Properties, Property, Relation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 /**
  * Data transformation utilities for converting between frontend and database formats.
  */
+/**
+ * Typed result from `serializeDataToServer`.
+ * Replaces the hidden `__inverseRelationUpdates` / `__joinPathRelationUpdates`
+ * dunder-property mutation pattern with explicit, typed state management.
+ */
+export interface SerializedEntityData {
+    /** Scalar column values ready for INSERT/UPDATE. */
+    scalarData: Record<string, unknown>;
+    /** Inverse relation updates that must be applied to target tables. */
+    inverseRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newValue: unknown;
+        currentEntityId?: string | number;
+    }>;
+    /** JoinPath relation updates that require multi-hop writes. */
+    joinPathRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newTargetId: string | number | null;
+    }>;
+}
 /**
  * Helper function to sanitize and convert dates to ISO strings
  */
@@ -11,7 +33,7 @@ export declare function sanitizeAndConvertDates(obj: unknown): unknown;
 /**
  * Transform relations for database storage (relation objects to IDs)
  */
-export declare function serializeDataToServer<M extends Record<string, any>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): Record<string, unknown>;
+export declare function serializeDataToServer<M extends Record<string, unknown>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): SerializedEntityData;
 /**
  * Serialize a single property value for database storage
  */
@@ -19,7 +41,7 @@ export declare function serializePropertyToServer(value: unknown, property: Prop
 /**
  * Transform IDs back to relation objects for frontend
  */
-export declare function parseDataFromServer<M extends Record<string, any>>(data: M, collection: EntityCollection, db?: NodePgDatabase<any>, registry?: PostgresCollectionRegistry): Promise<M>;
+export declare function parseDataFromServer<M extends Record<string, unknown>>(data: M, collection: EntityCollection, db?: NodePgDatabase<Record<string, unknown>>, registry?: PostgresCollectionRegistry): Promise<M>;
 /**
  * Parse a single property value from database format to frontend format
  */
@@ -33,4 +55,4 @@ export declare function parsePropertyFromServer(value: unknown, property: Proper
  * Use this instead of `parseDataFromServer` when processing results from
  * `db.query.findFirst/findMany` which return pre-hydrated relation data.
  */
-export declare function normalizeDbValues<M extends Record<string, any>>(data: M, collection: EntityCollection): M;
+export declare function normalizeDbValues<M extends Record<string, unknown>>(data: M, collection: EntityCollection): M;

package/dist/server-postgresql/src/databasePoolManager.d.ts

@@ -1,5 +1,5 @@
-import { Pool } from 'pg';
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { Pool } from "pg";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
 export declare class DatabasePoolManager {
     private pools;
     private drizzleInstances;

package/dist/server-postgresql/src/schema/auth-schema.d.ts

@@ -103,44 +103,6 @@ export declare const users: import("drizzle-orm/pg-core").PgTableWithColumns<{
         }, {}, {
             length: 500;
         }>;
-        provider: import("drizzle-orm/pg-core").PgColumn<{
-            name: "provider";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 50;
-        }>;
-        googleId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "google_id";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 255;
-        }>;
         emailVerified: import("drizzle-orm/pg-core").PgColumn<{
             name: "email_verified";
             tableName: "users";
@@ -739,10 +701,144 @@ export declare const appConfig: import("drizzle-orm/pg-core").PgTableWithColumns
     };
     dialect: "pg";
 }>;
+/**
+ * User identities - maps external OAuth profiles back to local users
+ */
+export declare const userIdentities: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "user_identities";
+    schema: "rebase";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 50;
+        }>;
+        providerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_id";
+            tableName: "user_identities";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        profileData: import("drizzle-orm/pg-core").PgColumn<{
+            name: "profile_data";
+            tableName: "user_identities";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "user_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "user_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export declare const usersRelations: import("drizzle-orm").Relations<"users", {
     userRoles: import("drizzle-orm").Many<"user_roles">;
     refreshTokens: import("drizzle-orm").Many<"refresh_tokens">;
     passwordResetTokens: import("drizzle-orm").Many<"password_reset_tokens">;
+    userIdentities: import("drizzle-orm").Many<"user_identities">;
 }>;
 export declare const rolesRelations: import("drizzle-orm").Relations<"roles", {
     userRoles: import("drizzle-orm").Many<"user_roles">;
@@ -757,6 +853,9 @@ export declare const refreshTokensRelations: import("drizzle-orm").Relations<"re
 export declare const passwordResetTokensRelations: import("drizzle-orm").Relations<"password_reset_tokens", {
     user: import("drizzle-orm").One<"users", true>;
 }>;
+export declare const userIdentitiesRelations: import("drizzle-orm").Relations<"user_identities", {
+    user: import("drizzle-orm").One<"users", true>;
+}>;
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
 export type Role = typeof roles.$inferSelect;
@@ -765,3 +864,5 @@ export type UserRole = typeof userRoles.$inferSelect;
 export type RefreshToken = typeof refreshTokens.$inferSelect;
 export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;
+export type UserIdentity = typeof userIdentities.$inferSelect;
+export type NewUserIdentity = typeof userIdentities.$inferInsert;

package/dist/server-postgresql/src/schema/doctor-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server-postgresql/src/schema/doctor.d.ts

@@ -0,0 +1,43 @@
+import { EntityCollection, Property } from "@rebasepro/types";
+export type IssueSeverity = "error" | "warning" | "info";
+export interface DoctorIssue {
+    severity: IssueSeverity;
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key";
+    table?: string;
+    column?: string;
+    expected?: string;
+    actual?: string;
+    message: string;
+    fix: string;
+}
+export interface DoctorReport {
+    collectionsToSchema: {
+        passed: boolean;
+        issues: DoctorIssue[];
+    };
+    schemaToDatabase: {
+        passed: boolean;
+        issues: DoctorIssue[];
+    };
+    summary: {
+        passed: number;
+        warnings: number;
+        errors: number;
+    };
+}
+export declare function getExpectedColumnType(prop: Property): string | null;
+export declare function loadCollections(collectionsPath: string): Promise<EntityCollection[]>;
+export declare function checkCollectionsVsSchema(collections: EntityCollection[], schemaFilePath: string): Promise<{
+    passed: boolean;
+    issues: DoctorIssue[];
+}>;
+export declare function checkCollectionsVsDatabase(collections: EntityCollection[], databaseUrl: string): Promise<{
+    passed: boolean;
+    issues: DoctorIssue[];
+}>;
+export declare function renderReport(report: DoctorReport): void;
+export declare function runDoctor(options: {
+    collectionsPath: string;
+    schemaPath: string;
+    databaseUrl?: string;
+}): Promise<DoctorReport>;

package/dist/server-postgresql/src/schema/generate-drizzle-schema-logic.d.ts

@@ -1,2 +1,2 @@
 import { EntityCollection } from "@rebasepro/types";
-export declare const generateSchema: (collections: EntityCollection[]) => Promise<string>;
+export declare const generateSchema: (collections: EntityCollection[], stripPolicies?: boolean) => Promise<string>;

package/dist/server-postgresql/src/schema/test-schema.d.ts

@@ -0,0 +1,24 @@
+export declare const testTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "test";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "test";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/server-postgresql/src/services/EntityFetchService.d.ts

@@ -22,7 +22,12 @@ export declare class EntityFetchService {
      * Build filter conditions from FilterValues
      * Delegates to DrizzleConditionBuilder.buildFilterConditions
      */
-    buildFilterConditions<M extends Record<string, any>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    buildFilterConditions<M extends Record<string, unknown>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    /**
+     * Resolves the correct Drizzle column for sorting.
+     * Automatically maps owning relation property keys to their underlying foreign key column.
+     */
+    private resolveOrderByField;
     /**
      * Build the `with` config for Drizzle's relational query API.
      * Converts collection relations to a Drizzle-compatible `with` object.
@@ -63,6 +68,11 @@ export declare class EntityFetchService {
      * Uses batch fetching to avoid N+1 queries for list views.
      */
     private resolveJoinPathRelationsBatch;
+    /**
+     * Resolves joinPath relations for raw REST rows and directly injects them.
+     * Uses RelationService to query the database and maps results back to the flattened objects.
+     */
+    private resolveJoinPathRelationsBatchRest;
     /**
      * Convert a db.query result row to a flat REST-style object with populated relations.
      */
@@ -79,15 +89,16 @@ export declare class EntityFetchService {
     /**
      * Fetch a single entity by ID
      */
-    fetchEntity<M extends Record<string, any>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
+    fetchEntity<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
     /**
      * Unified method to fetch entities with optional search functionality
      */
-    fetchEntitiesWithConditions<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchEntitiesWithConditions<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;
@@ -103,11 +114,12 @@ export declare class EntityFetchService {
     /**
      * Fetch a collection of entities
      */
-    fetchCollection<M extends Record<string, any>>(collectionPath: string, options?: {
+    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;
@@ -115,7 +127,7 @@ export declare class EntityFetchService {
     /**
      * Search entities by text
      */
-    searchEntities<M extends Record<string, any>>(collectionPath: string, searchString: string, options?: {
+    searchEntities<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -129,8 +141,9 @@ export declare class EntityFetchService {
     /**
      * Count entities in a collection
      */
-    countEntities<M extends Record<string, any>>(collectionPath: string, options?: {
+    countEntities<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
         databaseId?: string;
     }): Promise<number>;
     /**
@@ -153,11 +166,12 @@ export declare class EntityFetchService {
      *
      * @param include - Array of relation keys to populate, or ["*"] for all
      */
-    fetchCollectionForRest<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchCollectionForRest<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;
@@ -165,7 +179,7 @@ export declare class EntityFetchService {
     /**
      * Fetch a single entity with optional relation includes for REST API.
      */
-    fetchEntityForRest<M extends Record<string, any>>(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
+    fetchEntityForRest<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
     /**
      * Fetch raw rows without any relation processing (for REST fast path)
      */

package/dist/server-postgresql/src/services/EntityPersistService.d.ts

@@ -20,7 +20,7 @@ export declare class EntityPersistService {
     /**
      * Save an entity (create or update)
      */
-    saveEntity<M extends Record<string, any>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
+    saveEntity<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
     /**
      * Get the RelationService instance for external use
      */

package/dist/server-postgresql/src/services/RelationService.d.ts

@@ -12,7 +12,7 @@ export declare class RelationService {
     /**
      * Fetch entities related to a parent entity through a specific relation
      */
-    fetchRelatedEntities<M extends Record<string, any>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
+    fetchRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -24,7 +24,7 @@ export declare class RelationService {
     /**
      * Fetch entities using join paths for complex relations
      */
-    fetchEntitiesUsingJoins<M extends Record<string, any>>(parentCollection: EntityCollection, parentEntityId: string | number, relation: Relation, options?: {
+    fetchEntitiesUsingJoins<M extends Record<string, unknown>>(parentCollection: EntityCollection, parentEntityId: string | number, relation: Relation, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -36,18 +36,24 @@ export declare class RelationService {
     /**
      * Count related entities for a parent entity
      */
-    countRelatedEntities<M extends Record<string, any>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
+    countRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         databaseId?: string;
     }): Promise<number>;
     /**
      * Batch fetch related entities for multiple parent entities to avoid N+1 queries
      */
-    batchFetchRelatedEntities(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string | number, Entity<Record<string, unknown>>>>;
+    batchFetchRelatedEntities(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, Entity<Record<string, unknown>>>>;
+    /**
+     * Batch fetch many-cardinality related entities for multiple parent entities.
+     * Returns a Map<parentId, Entity[]> instead of Map<parentId, Entity>.
+     * Uses a single SQL query with IN clause to avoid N+1.
+     */
+    batchFetchRelatedEntitiesMany(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, Entity<Record<string, unknown>>[]>>;
     /**
      * Update many-to-many and junction relations
      */
-    updateRelationsUsingJoins<M extends Record<string, any>>(tx: DrizzleClient, collection: EntityCollection, entityId: string | number, relationValues: Partial<M>): Promise<void>;
+    updateRelationsUsingJoins<M extends Record<string, unknown>>(tx: DrizzleClient, collection: EntityCollection, entityId: string | number, relationValues: Partial<M>): Promise<void>;
     /**
      * Update inverse relations (where FK is on the target table)
      */