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

package/src/utils/drizzle-conditions.ts

@@ -6,7 +6,7 @@ import { PostgresCollectionRegistry } from "../collections/PostgresCollectionReg
 import { ConditionBuilderStatic } from "../interfaces";
 
 /** Drizzle dynamic query builder — accepts innerJoin + where chaining */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 export interface DrizzleDynamicQuery {
     innerJoin(table: PgTable<any>, condition: SQL): this;
     where(condition: SQL | undefined): this;
@@ -15,10 +15,10 @@ export interface DrizzleDynamicQuery {
 
 /**
  * Unified condition builder for Drizzle/PostgreSQL queries.
- * 
+ *
  * This class uses static methods and satisfies the ConditionBuilderStatic<SQL> type.
  * It translates Rebase filter conditions to Drizzle SQL conditions.
- * 
+ *
  * @example
  * const builder: ConditionBuilderStatic<SQL> = DrizzleConditionBuilder;
  */
@@ -27,7 +27,7 @@ export class DrizzleConditionBuilder {
     /**
      * Build filter conditions from FilterValues
      */
-    static buildFilterConditions<M extends Record<string, any>>(
+    static buildFilterConditions<M extends Record<string, unknown>>(
         filter: FilterValues<Extract<keyof M, string>>,
         table: PgTable<any>,
         collectionPath: string
@@ -104,7 +104,7 @@ export class DrizzleConditionBuilder {
         joinConditions: { table: PgTable<any>; condition: SQL }[];
         whereConditions: SQL[];
     } {
-        console.debug(`🔍 [buildRelationConditions] Building conditions for relation:`, {
+        console.debug("🔍 [buildRelationConditions] Building conditions for relation:", {
             relationName: relation.relationName,
             cardinality: relation.cardinality,
             direction: relation.direction,
@@ -118,7 +118,7 @@ export class DrizzleConditionBuilder {
         const whereConditions: SQL[] = [];
 
         if (relation.joinPath && relation.joinPath.length > 0) {
-            console.debug(`🔍 [buildRelationConditions] Using joinPath logic`);
+            console.debug("🔍 [buildRelationConditions] Using joinPath logic");
             // Handle join path relations
             const {
                 joins,
@@ -135,7 +135,7 @@ export class DrizzleConditionBuilder {
             whereConditions.push(finalCondition);
 
         } else if (relation.through && relation.cardinality === "many" && relation.direction === "owning") {
-            console.debug(`🔍 [buildRelationConditions] Using owning many-to-many with explicit through`);
+            console.debug("🔍 [buildRelationConditions] Using owning many-to-many with explicit through");
             // Handle many-to-many relations with junction table
             const junctionResult = this.buildJunctionTableConditions(
                 relation.through,
@@ -147,7 +147,7 @@ export class DrizzleConditionBuilder {
             whereConditions.push(junctionResult.condition);
 
         } else if (relation.through && relation.cardinality === "many" && relation.direction === "inverse") {
-            console.debug(`🔍 [buildRelationConditions] Using inverse many-to-many with explicit through`);
+            console.debug("🔍 [buildRelationConditions] Using inverse many-to-many with explicit through");
             // Handle inverse many-to-many relations with junction table
             const junctionResult = this.buildInverseJunctionTableConditions(
                 relation.through,
@@ -159,12 +159,12 @@ export class DrizzleConditionBuilder {
             whereConditions.push(junctionResult.condition);
 
         } else if (relation.cardinality === "many" && relation.direction === "inverse" && !relation.through) {
-            console.debug(`🔍 [buildRelationConditions] Handling inverse many relationship without explicit through`);
+            console.debug("🔍 [buildRelationConditions] Handling inverse many relationship without explicit through");
 
             // First, try to find a junction table (for many-to-many relationships)
             const junctionInfo = this.findCorrespondingJunctionTable(relation, registry);
             if (junctionInfo) {
-                console.debug(`🔍 [buildRelationConditions] Found junction info for inverse many-to-many, building junction conditions`);
+                console.debug("🔍 [buildRelationConditions] Found junction info for inverse many-to-many, building junction conditions");
                 const junctionResult = this.buildInverseJunctionTableConditions(
                     junctionInfo,
                     targetIdColumn,
@@ -174,7 +174,7 @@ export class DrizzleConditionBuilder {
                 joinConditions.push(junctionResult.join);
                 whereConditions.push(junctionResult.condition);
             } else if (relation.foreignKeyOnTarget) {
-                console.debug(`🔍 [buildRelationConditions] No junction table found, treating as inverse one-to-many with foreign key on target`);
+                console.debug("🔍 [buildRelationConditions] No junction table found, treating as inverse one-to-many with foreign key on target");
                 // This is a true inverse one-to-many relationship
                 const simpleCondition = this.buildSimpleRelationCondition(
                     relation,
@@ -184,11 +184,11 @@ export class DrizzleConditionBuilder {
                 );
                 whereConditions.push(simpleCondition);
             } else {
-                console.error(`🔍 [buildRelationConditions] Failed to find junction table info and no foreign key specified`);
+                console.error("🔍 [buildRelationConditions] Failed to find junction table info and no foreign key specified");
                 throw new Error(`Cannot resolve inverse many relation '${relation.relationName}'. Either specify 'through' property, ensure corresponding owning relation exists with junction table configuration, or specify 'foreignKeyOnTarget' for one-to-many relationships.`);
             }
         } else {
-            console.debug(`🔍 [buildRelationConditions] Using simple relation logic - THIS IS WHERE THE ERROR MIGHT OCCUR`);
+            console.debug("🔍 [buildRelationConditions] Using simple relation logic - THIS IS WHERE THE ERROR MIGHT OCCUR");
             // Handle simple relations
             const simpleCondition = this.buildSimpleRelationCondition(
                 relation,
@@ -199,7 +199,7 @@ export class DrizzleConditionBuilder {
             whereConditions.push(simpleCondition);
         }
 
-        console.debug(`🔍 [buildRelationConditions] Final result:`, {
+        console.debug("🔍 [buildRelationConditions] Final result:", {
             joinConditionsCount: joinConditions.length,
             whereConditionsCount: whereConditions.length
         });
@@ -635,15 +635,16 @@ export class DrizzleConditionBuilder {
      */
     static buildSearchConditions(
         searchString: string,
-        properties: Record<string, any>,
+        properties: Record<string, unknown>,
         table: PgTable<any>
     ): SQL[] {
         const searchConditions: SQL[] = [];
 
         for (const [key, prop] of Object.entries(properties)) {
+            const p = prop as Record<string, unknown>;
             // Only include string properties that don't have enum defined
             // PostgreSQL enum and uuid columns don't support ILIKE, so we skip them
-            if (prop.type === "string" && !prop.enum && prop.isId !== "uuid") {
+            if (p.type === "string" && !p.enum && p.isId !== "uuid") {
                 const fieldColumn = table[key as keyof typeof table] as AnyPgColumn;
                 if (fieldColumn) {
                     searchConditions.push(ilike(fieldColumn, `%${searchString}%`));
@@ -938,7 +939,7 @@ export class DrizzleConditionBuilder {
             console.debug(`🔍 [findCorrespondingJunctionTable] Looking for junction table for inverse relation '${relation.relationName}' with inverseRelationName '${relation.inverseRelationName}'`);
 
             if (!relation.inverseRelationName) {
-                console.debug(`🔍 [findCorrespondingJunctionTable] No inverseRelationName specified`);
+                console.debug("🔍 [findCorrespondingJunctionTable] No inverseRelationName specified");
                 return null;
             }
 
@@ -947,8 +948,8 @@ export class DrizzleConditionBuilder {
             console.debug(`🔍 [findCorrespondingJunctionTable] Target collection: ${targetCollection.slug}`);
 
             // Find the corresponding owning relation on the target collection
-            const targetCollectionRelations = resolveCollectionRelations(targetCollection as import("@rebasepro/types").PostgresCollection<any, any>);
-            console.debug(`🔍 [findCorrespondingJunctionTable] Target collection relations:`, Object.keys(targetCollectionRelations));
+            const targetCollectionRelations = resolveCollectionRelations(targetCollection);
+            console.debug("🔍 [findCorrespondingJunctionTable] Target collection relations:", Object.keys(targetCollectionRelations));
 
             // Look for the owning many-to-many relation that matches our inverseRelationName
             const correspondingRelation = targetCollectionRelations[relation.inverseRelationName];
@@ -958,7 +959,7 @@ export class DrizzleConditionBuilder {
                 return null;
             }
 
-            console.debug(`🔍 [findCorrespondingJunctionTable] Found relation:`, {
+            console.debug("🔍 [findCorrespondingJunctionTable] Found relation:", {
                 relationName: correspondingRelation.relationName,
                 cardinality: correspondingRelation.cardinality,
                 direction: correspondingRelation.direction,
@@ -969,21 +970,21 @@ export class DrizzleConditionBuilder {
             if (correspondingRelation.cardinality !== "many" ||
                 correspondingRelation.direction !== "owning" ||
                 !correspondingRelation.through) {
-                console.debug(`🔍 [findCorrespondingJunctionTable] Relation is not an owning many-to-many with junction table`);
+                console.debug("🔍 [findCorrespondingJunctionTable] Relation is not an owning many-to-many with junction table");
                 return null;
             }
 
-            console.debug(`🔍 [findCorrespondingJunctionTable] Found matching owning relation with junction table!`);
+            console.debug("🔍 [findCorrespondingJunctionTable] Found matching owning relation with junction table!");
 
             // For inverse relation, we need to swap source and target columns
             const through = correspondingRelation.through;
             const result = {
                 table: through.table,
                 sourceColumn: through.targetColumn, // Swapped for inverse relation
-                targetColumn: through.sourceColumn  // Swapped for inverse relation
+                targetColumn: through.sourceColumn // Swapped for inverse relation
             };
 
-            console.debug(`🔍 [findCorrespondingJunctionTable] Returning junction info:`, result);
+            console.debug("🔍 [findCorrespondingJunctionTable] Returning junction info:", result);
             return result;
         } catch (error) {
             console.error(`🔍 [findCorrespondingJunctionTable] Error finding corresponding junction table for relation '${relation.relationName}':`, error);

package/src/websocket.ts

@@ -1,6 +1,6 @@
 import { RealtimeService } from "./services/realtimeService";
 import { PostgresBackendDriver } from "./PostgresBackendDriver";
-import { DataDriver, DeleteEntityProps, FetchCollectionProps, FetchEntityProps, SaveEntityProps, TableMetadata, BranchInfo } from "@rebasepro/types";
+import { DataDriver, DeleteEntityProps, FetchCollectionProps, FetchEntityProps, SaveEntityProps, TableMetadata, BranchInfo, isSQLAdmin, isSchemaAdmin } from "@rebasepro/types";
 import { WebSocketServer, WebSocket } from "ws";
 import { Server } from "http";
 import { inspect } from "util";
@@ -21,7 +21,7 @@ interface ClientSession {
 const clientSessions = new Map<string, ClientSession>();
 
 /** Maximum messages per client per window */
-const WS_RATE_LIMIT = 200;
+const WS_RATE_LIMIT = 2000;
 /** Rate limit window in milliseconds (60 seconds) */
 const WS_RATE_WINDOW_MS = 60_000;
 
@@ -61,6 +61,19 @@ export function createPostgresWebSocket(
     /** Debug logger that is suppressed in production to prevent PII/data leaks */
     const wsDebug = (...args: unknown[]) => { if (!isProduction) console.debug(...args); };
     const wss = new WebSocketServer({ server });
+
+    // Handle errors on the WSS so that EADDRINUSE from the underlying HTTP
+    // server doesn't surface as an unhandled 'error' event and crash the
+    // process.  The dev-mode `listenWithPortRetry` utility handles retry
+    // logic on the HTTP server side — we just need the WSS not to throw.
+    wss.on("error", (err: NodeJS.ErrnoException) => {
+        if (err.code === "EADDRINUSE") {
+            // Silently absorbed — listenWithPortRetry will retry the next port
+            return;
+        }
+        console.error("❌ [WebSocket Server] Error:", err);
+    });
+
     const requireAuth = authConfig?.requireAuth !== false && authConfig?.jwtSecret;
 
     wss.on("connection", (ws) => {
@@ -68,7 +81,10 @@ export function createPostgresWebSocket(
         wsDebug(`WebSocket client connected: ${clientId}`);
 
         // Initialize client session
-        clientSessions.set(clientId, { ws, authenticated: !requireAuth, messageCount: 0, messageWindowStart: Date.now() });
+        clientSessions.set(clientId, { ws,
+authenticated: !requireAuth,
+messageCount: 0,
+messageWindowStart: Date.now() });
         realtimeService.addClient(clientId, ws);
 
         ws.on("close", () => {
@@ -95,7 +111,8 @@ export function createPostgresWebSocket(
                     ws.send(JSON.stringify({
                         type: errType,
                         requestId,
-                        payload: { error: { message: msg, code } }
+                        payload: { error: { message: msg,
+code } }
                     }));
                 };
 
@@ -117,7 +134,8 @@ export function createPostgresWebSocket(
                         ws.send(JSON.stringify({
                             type: "AUTH_SUCCESS",
                             requestId,
-                            payload: { userId: user.userId, roles: user.roles }
+                            payload: { userId: user.userId,
+roles: user.roles }
                         }));
                         wsDebug(`🔐 [WebSocket Server] Client ${clientId} authenticated as ${user.userId}`);
                     } else {
@@ -163,7 +181,7 @@ export function createPostgresWebSocket(
                 }
 
                 // Helper to get correctly scoped delegate for the current request
-                const getScopedDelegate = async () => {
+                const getScopedDelegate = async (): Promise<DataDriver> => {
                     const session = clientSessions.get(clientId);
                     if (session?.user && "withAuth" in driver && typeof (driver as unknown as Record<string, unknown>).withAuth === "function") {
                         try {
@@ -217,10 +235,12 @@ export function createPostgresWebSocket(
                     case "SAVE_ENTITY": {
                         wsDebug("💾 [WebSocket Server] Processing SAVE_ENTITY request");
                         const request: SaveEntityProps = payload;
-                        wsDebug("💾 [WebSocket Server] Saving entity with request:", inspect(request, { depth: null, colors: true }));
+                        wsDebug("💾 [WebSocket Server] Saving entity with request:", inspect(request, { depth: null,
+colors: true }));
                         const delegate = await getScopedDelegate();
                         const entity = await delegate.saveEntity(request);
-                        wsDebug("💾 [WebSocket Server] SAVE_ENTITY result:", inspect(entity, { depth: null, colors: true }));
+                        wsDebug("💾 [WebSocket Server] SAVE_ENTITY result:", inspect(entity, { depth: null,
+colors: true }));
                         const response = {
                             type: "SAVE_ENTITY_SUCCESS",
                             payload: { entity },
@@ -287,9 +307,14 @@ export function createPostgresWebSocket(
                     case "EXECUTE_SQL": {
                         const { sql, options } = payload;
                         const delegate = await getScopedDelegate();
-                        const result = await (delegate as unknown as { executeSql: (sql: string, options?: { database?: string, role?: string }) => Promise<Record<string, unknown>[]> }).executeSql(sql, options);
+                        const admin = delegate.admin;
+                        if (!isSQLAdmin(admin)) {
+                            sendError("ERROR", "NOT_SUPPORTED", "SQL execution is not available for this driver.");
+                            break;
+                        }
+                        const result = await admin.executeSql(sql, options);
                         if (process.env.NODE_ENV !== "production") {
-                            wsDebug(`⚡ [WebSocket Server] SQL executed. Returned ${Array.isArray(result) ? result.length : 'non-array'} rows.`);
+                            wsDebug(`⚡ [WebSocket Server] SQL executed. Returned ${Array.isArray(result) ? result.length : "non-array"} rows.`);
                         }
                         const response = {
                             type: "EXECUTE_SQL_SUCCESS",
@@ -303,9 +328,10 @@ export function createPostgresWebSocket(
                     case "FETCH_DATABASES": {
                         wsDebug("📚 [WebSocket Server] Processing FETCH_DATABASES request");
                         const delegate = await getScopedDelegate();
+                        const admin = delegate.admin;
                         let databases: string[] = [];
-                        if (delegate.fetchAvailableDatabases) {
-                            databases = await delegate.fetchAvailableDatabases();
+                        if (isSQLAdmin(admin) && admin.fetchAvailableDatabases) {
+                            databases = await admin.fetchAvailableDatabases();
                         }
                         wsDebug(`📚 [WebSocket Server] Fetched ${databases.length} databases.`);
                         const response = {
@@ -320,9 +346,10 @@ export function createPostgresWebSocket(
                     case "FETCH_ROLES": {
                         wsDebug("👤 [WebSocket Server] Processing FETCH_ROLES request");
                         const delegate = await getScopedDelegate();
+                        const admin = delegate.admin;
                         let roles: string[] = [];
-                        if (delegate.fetchAvailableRoles) {
-                            roles = await delegate.fetchAvailableRoles();
+                        if (isSQLAdmin(admin) && admin.fetchAvailableRoles) {
+                            roles = await admin.fetchAvailableRoles();
                         }
                         wsDebug(`👤 [WebSocket Server] Fetched ${roles.length} roles.`);
                         const response = {
@@ -337,9 +364,10 @@ export function createPostgresWebSocket(
                     case "FETCH_CURRENT_DATABASE": {
                         wsDebug("📚 [WebSocket Server] Processing FETCH_CURRENT_DATABASE request");
                         const delegate = await getScopedDelegate();
+                        const admin = delegate.admin;
                         let database: string | undefined = undefined;
-                        if (delegate.fetchCurrentDatabase) {
-                            database = await delegate.fetchCurrentDatabase();
+                        if (isSQLAdmin(admin) && admin.fetchCurrentDatabase) {
+                            database = await admin.fetchCurrentDatabase();
                         }
                         const response = {
                             type: "FETCH_CURRENT_DATABASE_SUCCESS",
@@ -353,9 +381,10 @@ export function createPostgresWebSocket(
                     case "FETCH_UNMAPPED_TABLES": {
                         wsDebug("📋 [WebSocket Server] Processing FETCH_UNMAPPED_TABLES request");
                         const delegate = await getScopedDelegate();
+                        const admin = delegate.admin;
                         let tables: string[] = [];
-                        if (delegate.fetchUnmappedTables) {
-                            tables = await delegate.fetchUnmappedTables(payload?.mappedPaths);
+                        if (isSchemaAdmin(admin) && admin.fetchUnmappedTables) {
+                            tables = await admin.fetchUnmappedTables(payload?.mappedPaths);
                         }
                         wsDebug(`📋 [WebSocket Server] Fetched ${tables.length} unmapped tables.`);
                         const response = {
@@ -371,9 +400,10 @@ export function createPostgresWebSocket(
                         wsDebug("📋 [WebSocket Server] Processing FETCH_TABLE_METADATA request");
                         const { tableName } = payload;
                         const delegate = await getScopedDelegate();
+                        const admin = delegate.admin;
                         let metadata: TableMetadata | undefined;
-                        if (delegate.fetchTableMetadata) {
-                            metadata = await delegate.fetchTableMetadata(tableName);
+                        if (isSchemaAdmin(admin) && admin.fetchTableMetadata) {
+                            metadata = await admin.fetchTableMetadata(tableName) as TableMetadata;
                         }
                         wsDebug(`📋 [WebSocket Server] Fetched metadata for table '${tableName}'. (${metadata?.columns?.length ?? 0} columns)`);
                         const response = {
@@ -448,7 +478,8 @@ export function createPostgresWebSocket(
                         // Attach auth context from the WS session so RLS-aware refetches work
                         const session = clientSessions.get(clientId);
                         const authContext = session?.user
-                            ? { userId: session.user.userId, roles: session.user.roles ?? [] }
+                            ? { userId: session.user.userId,
+roles: session.user.roles ?? [] }
                             : undefined;
                         // Let RealtimeService handle these messages
                         await realtimeService.handleClientMessage(clientId, {