@rebasepro/server-postgresql 0.3.0 → 0.5.0

package/src/data-transformer.ts

@@ -272,41 +272,19 @@ export function serializePropertyToServer(value: unknown, property: Property): u
             return value;
         }
 
-        case "binary":
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
-            if (Buffer.isBuffer(value)) {
-                return value;
-            }
+        case "binary": {
+            const decoded = tryDecodeBase64DataUrl(value);
+            if (decoded) return decoded;
+            if (Buffer.isBuffer(value)) return value;
             return value;
+        }
 
         case "string":
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
-            return value;
-
-        default:
-            if (typeof value === "string") {
-                if (value.startsWith("data:application/octet-stream;base64,")) {
-                    const base64Data = value.split(",")[1];
-                    if (base64Data) {
-                        return Buffer.from(base64Data, "base64");
-                    }
-                }
-            }
+        default: {
+            const decoded = tryDecodeBase64DataUrl(value);
+            if (decoded) return decoded;
             return value;
+        }
     }
 }
 
@@ -486,24 +464,53 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
 }
 
 /**
- * Parse a single property value from database format to frontend format
+ * Try to decode a `data:application/octet-stream;base64,...` data URL string
+ * into a Buffer. Returns null if the value is not a matching data URL.
  */
-export function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown {
-    if (value === null || value === undefined) {
-        return value;
+function tryDecodeBase64DataUrl(value: unknown): Buffer | null {
+    if (typeof value !== "string") return null;
+    if (!value.startsWith("data:application/octet-stream;base64,")) return null;
+    const base64Data = value.split(",")[1];
+    return base64Data ? Buffer.from(base64Data, "base64") : null;
+}
+
+/**
+ * Try to resolve an unknown value into a Buffer.
+ * Handles native Buffers and `{ type: "Buffer", data: number[] }` objects (from JSON deserialization).
+ * Returns null if the value is not a buffer.
+ */
+function tryResolveBuffer(value: unknown): Buffer | null {
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "object" && value !== null) {
+        const rawVal = value as Record<string, unknown>;
+        if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
+            return Buffer.from(rawVal.data as number[]);
+        }
     }
+    return null;
+}
+
+/**
+ * Convert a Buffer to a UTF-8 string if all bytes are printable ASCII,
+ * otherwise return a base64 data URL.
+ */
+function bufferToStringOrBase64(buf: Buffer): string {
+    for (let i = 0; i < buf.length; i++) {
+        const b = buf[i];
+        // Allow standard printable ASCII + common whitespace (\r, \n, \t)
+        if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+            return `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
+    }
+    return buf.toString("utf8");
+}
+
+export function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown {
+    if (value === null || value === undefined) return value;
 
     switch (property.type) {
         case "binary": {
-            let buf: Buffer | null = null;
-            if (Buffer.isBuffer(value)) {
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
+            const buf = tryResolveBuffer(value);
             if (buf) {
                 return `data:application/octet-stream;base64,${buf.toString("base64")}`;
             }
@@ -514,32 +521,9 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             if (typeof value === "string") return value;
             
             // Handle Buffer objects (e.g. from PostgreSQL bytea columns)
-            let isBuffer = false;
-            let buf: Buffer | null = null;
-            
-            if (Buffer.isBuffer(value)) {
-                isBuffer = true;
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    isBuffer = true;
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
-            
-            if (isBuffer && buf) {
-                // Heuristic: if all bytes are printable ASCII, return utf8, else base64
-                let isPrintable = true;
-                for (let i = 0; i < buf.length; i++) {
-                    const b = buf[i];
-                    // Allow standard printable ASCII + common whitespace (\r, \n, \t)
-                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
-                        isPrintable = false;
-                        break;
-                    }
-                }
-                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            const buf = tryResolveBuffer(value);
+            if (buf) {
+                return bufferToStringOrBase64(buf);
             }
             
             if (typeof value === "object" && value !== null) {
@@ -665,32 +649,10 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
 
         default: {
             // Fallback for buffers in case they are mapped to something other than string
-            let isBuffer = false;
-            let buf: Buffer | null = null;
-            
-            if (Buffer.isBuffer(value)) {
-                isBuffer = true;
-                buf = value;
-            } else if (typeof value === "object" && value !== null) {
-                const rawVal = value as Record<string, unknown>;
-                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
-                    isBuffer = true;
-                    buf = Buffer.from(rawVal.data as number[]);
-                }
-            }
-            
-            if (isBuffer && buf) {
-                let isPrintable = true;
-                for (let i = 0; i < buf.length; i++) {
-                    const b = buf[i];
-                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
-                        isPrintable = false;
-                        break;
-                    }
-                }
-                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            const buf = tryResolveBuffer(value);
+            if (buf) {
+                return bufferToStringOrBase64(buf);
             }
-            
             return value;
         }
     }

package/src/databasePoolManager.ts

@@ -18,7 +18,7 @@ export class DatabasePoolManager {
         }
     }
 
-    public getDrizzle(databaseName: string): NodePgDatabase<any> {
+    public getDrizzle(databaseName: string): NodePgDatabase<Record<string, never>> {
         const existing = this.drizzleInstances.get(databaseName);
         if (existing) {
             return existing;
@@ -81,5 +81,6 @@ export class DatabasePoolManager {
         }
         await Promise.all(promises);
         this.pools.clear();
+        this.drizzleInstances.clear();
     }
 }

package/src/schema/auth-schema.ts

@@ -1,15 +1,14 @@
-import { pgSchema, pgTable, varchar, uuid, timestamp, boolean, jsonb, primaryKey, unique } from "drizzle-orm/pg-core";
+import { pgSchema, pgTable, varchar, uuid, timestamp, boolean, jsonb, text, unique } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
 
 /**
  * Factory function to dynamically create the auth tables bound to the specified schema names.
  */
-export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchemaName: string = "rebase") {
-    const rolesSchema = rolesSchemaName === "public" ? null : pgSchema(rolesSchemaName);
+export function createAuthSchema(usersSchemaName: string = "rebase") {
     const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
-    const rolesTableCreator = (rolesSchema ? rolesSchema.table.bind(rolesSchema) : pgTable) as typeof pgTable;
-    const usersTableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
+    const tableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
+    const usersTableCreator = tableCreator;
 
     /**
      * Users table - stores both email/password and OAuth users
@@ -24,48 +23,18 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         emailVerificationToken: varchar("email_verification_token", { length: 255 }),
         emailVerificationSentAt: timestamp("email_verification_sent_at"),
         isAnonymous: boolean("is_anonymous").default(false).notNull(),
+        roles: text("roles").array().default([]).notNull(),
         metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}).notNull(),
         createdAt: timestamp("created_at").defaultNow().notNull(),
         updatedAt: timestamp("updated_at").defaultNow().notNull()
     });
 
-    /**
-     * Roles table - defines permission sets
-     */
-    const roles = rolesTableCreator("roles", {
-        id: varchar("id", { length: 50 }).primaryKey(), // 'admin', 'editor', 'viewer'
-        name: varchar("name", { length: 100 }).notNull(),
-        isAdmin: boolean("is_admin").default(false).notNull(),
-        defaultPermissions: jsonb("default_permissions").$type<{
-            read?: boolean;
-            create?: boolean;
-            edit?: boolean;
-            delete?: boolean;
-        }>(),
-        collectionPermissions: jsonb("collection_permissions").$type<
-            Record<string, {
-                read?: boolean;
-                create?: boolean;
-                edit?: boolean;
-                delete?: boolean;
-            }>
-        >()
-    });
 
-    /**
-     * User-Role junction table
-     */
-    const userRoles = rolesTableCreator("user_roles", {
-        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-        roleId: varchar("role_id", { length: 50 }).notNull().references(() => roles.id, { onDelete: "cascade" })
-    }, (table) => ({
-        pk: primaryKey({ columns: [table.userId, table.roleId] })
-    }));
 
     /**
      * Refresh tokens for long-lived sessions
      */
-    const refreshTokens = rolesTableCreator("refresh_tokens", {
+    const refreshTokens = tableCreator("refresh_tokens", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
@@ -80,7 +49,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * Password reset tokens for forgot password flow
      */
-    const passwordResetTokens = rolesTableCreator("password_reset_tokens", {
+    const passwordResetTokens = tableCreator("password_reset_tokens", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
@@ -92,7 +61,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * App config - key/value store for custom settings
      */
-    const appConfig = rolesTableCreator("app_config", {
+    const appConfig = tableCreator("app_config", {
         key: varchar("key", { length: 100 }).primaryKey(),
         value: jsonb("value").notNull(),
         updatedAt: timestamp("updated_at").defaultNow().notNull()
@@ -101,7 +70,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * User identities - maps external OAuth profiles back to local users
      */
-    const userIdentities = rolesTableCreator("user_identities", {
+    const userIdentities = tableCreator("user_identities", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         provider: varchar("provider", { length: 50 }).notNull(), // e.g. 'google', 'linkedin'
@@ -116,7 +85,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * MFA factors table - stores enrolled MFA methods
      */
-    const mfaFactors = rolesTableCreator("mfa_factors", {
+    const mfaFactors = tableCreator("mfa_factors", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         factorType: varchar("factor_type", { length: 20 }).notNull(), // 'totp'
@@ -130,7 +99,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * MFA challenges table - tracks active MFA verification attempts
      */
-    const mfaChallenges = rolesTableCreator("mfa_challenges", {
+    const mfaChallenges = tableCreator("mfa_challenges", {
         id: uuid("id").defaultRandom().primaryKey(),
         factorId: uuid("factor_id").notNull().references(() => mfaFactors.id, { onDelete: "cascade" }),
         createdAt: timestamp("created_at").defaultNow().notNull(),
@@ -142,7 +111,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * Recovery codes table - backup codes for MFA
      */
-    const recoveryCodes = rolesTableCreator("recovery_codes", {
+    const recoveryCodes = tableCreator("recovery_codes", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         codeHash: varchar("code_hash", { length: 255 }).notNull(),
@@ -151,11 +120,8 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     });
 
     return {
-        rolesSchema,
         usersSchema,
         users,
-        roles,
-        userRoles,
         refreshTokens,
         passwordResetTokens,
         appConfig,
@@ -167,14 +133,11 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
 }
 
 // Instantiate default schema and tables using the default "rebase" schema
-const defaultAuthSchema = createAuthSchema("rebase", "rebase");
+const defaultAuthSchema = createAuthSchema("rebase");
 
-export const rebaseSchema = defaultAuthSchema.rolesSchema;
 export const usersSchema = defaultAuthSchema.usersSchema;
 
 export const users = defaultAuthSchema.users;
-export const roles = defaultAuthSchema.roles;
-export const userRoles = defaultAuthSchema.userRoles;
 export const refreshTokens = defaultAuthSchema.refreshTokens;
 export const passwordResetTokens = defaultAuthSchema.passwordResetTokens;
 export const appConfig = defaultAuthSchema.appConfig;
@@ -185,7 +148,6 @@ export const recoveryCodes = defaultAuthSchema.recoveryCodes;
 
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
-    userRoles: many(userRoles),
     refreshTokens: many(refreshTokens),
     passwordResetTokens: many(passwordResetTokens),
     userIdentities: many(userIdentities),
@@ -193,21 +155,6 @@ export const usersRelations = relations(users, ({ many }) => ({
     recoveryCodes: many(recoveryCodes)
 }));
 
-export const rolesRelations = relations(roles, ({ many }) => ({
-    userRoles: many(userRoles)
-}));
-
-export const userRolesRelations = relations(userRoles, ({ one }) => ({
-    user: one(users, {
-        fields: [userRoles.userId],
-        references: [users.id]
-    }),
-    role: one(roles, {
-        fields: [userRoles.roleId],
-        references: [roles.id]
-    })
-}));
-
 export const refreshTokensRelations = relations(refreshTokens, ({ one }) => ({
     user: one(users, {
         fields: [refreshTokens.userId],
@@ -254,9 +201,6 @@ export const recoveryCodesRelations = relations(recoveryCodes, ({ one }) => ({
 // Type exports
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
-export type Role = typeof roles.$inferSelect;
-export type NewRole = typeof roles.$inferInsert;
-export type UserRole = typeof userRoles.$inferSelect;
 export type RefreshToken = typeof refreshTokens.$inferSelect;
 export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;

package/src/schema/doctor.ts

@@ -84,10 +84,28 @@ export function getExpectedColumnType(prop: Property): string | null {
             if (dp.columnType === "time") return "time without time zone";
             return "timestamp with time zone";
         }
-        case "map":
         case "array": {
-            const ap = prop as ArrayProperty | MapProperty;
-            if (ap.columnType === "json") return "json";
+            const ap = prop as ArrayProperty;
+            let colType = ap.columnType;
+            if (!colType && ap.of && !Array.isArray(ap.of)) {
+                const ofProp = ap.of as Property;
+                if (ofProp.type === "string") {
+                    colType = "text[]";
+                } else if (ofProp.type === "number") {
+                    colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                } else if (ofProp.type === "boolean") {
+                    colType = "boolean[]";
+                }
+            }
+
+            if (colType === "json") return "json";
+            if (colType === "jsonb") return "jsonb";
+            if (colType && colType.endsWith("[]")) return "ARRAY";
+            return "jsonb";
+        }
+        case "map": {
+            const mp = prop as MapProperty;
+            if (mp.columnType === "json") return "json";
             return "jsonb";
         }
         case "relation":
@@ -485,6 +503,29 @@ export async function checkCollectionsVsDatabase(
                     if (prop.type === "vector" && dbCol.udt_name !== "vector") {
                         isMismatch = true;
                     }
+                    if (prop.type === "array") {
+                        const ap = prop as ArrayProperty;
+                        let expectedColType = ap.columnType;
+                        if (!expectedColType && ap.of && !Array.isArray(ap.of)) {
+                            const ofProp = ap.of as Property;
+                            if (ofProp.type === "string") expectedColType = "text[]";
+                            else if (ofProp.type === "number") expectedColType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                            else if (ofProp.type === "boolean") expectedColType = "boolean[]";
+                        }
+                        if (expectedColType && expectedColType.endsWith("[]")) {
+                            if (actualType !== "ARRAY") {
+                                isMismatch = true;
+                            } else {
+                                const expectedUdt = expectedColType === "text[]" ? "_text" :
+                                                    expectedColType === "integer[]" ? "_int4" :
+                                                    expectedColType === "boolean[]" ? "_bool" :
+                                                    expectedColType === "numeric[]" ? "_numeric" : "";
+                                if (expectedUdt && dbCol.udt_name !== expectedUdt) {
+                                    isMismatch = true;
+                                }
+                            }
+                        }
+                    }
                     if (isMismatch) {
                         issues.push({
                             severity: "warning",

package/src/schema/generate-drizzle-schema-logic.ts

@@ -70,6 +70,8 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 columnDefinition = `${enumName}("${colName}")`;
             } else if ("isId" in stringProp && stringProp.isId === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
+            } else if (stringProp.columnType === "uuid") {
+                columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "text") {
                 columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
@@ -145,11 +147,39 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             break;
         }
-        case "map":
+        case "map": {
+            const mapProp = prop as MapProperty;
+            if (mapProp.columnType === "json") {
+                columnDefinition = `json("${colName}")`;
+            } else {
+                columnDefinition = `jsonb("${colName}")`;
+            }
+            break;
+        }
         case "array": {
-            const arrayOrMapProp = prop as ArrayProperty | MapProperty;
-            if (arrayOrMapProp.columnType === "json") {
+            const arrayProp = prop as ArrayProperty;
+            let colType = arrayProp.columnType;
+            if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
+                const ofProp = arrayProp.of as Property;
+                if (ofProp.type === "string") {
+                    colType = "text[]";
+                } else if (ofProp.type === "number") {
+                    colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                } else if (ofProp.type === "boolean") {
+                    colType = "boolean[]";
+                }
+            }
+
+            if (colType === "json") {
                 columnDefinition = `json("${colName}")`;
+            } else if (colType === "text[]") {
+                columnDefinition = `text("${colName}").array()`;
+            } else if (colType === "integer[]") {
+                columnDefinition = `integer("${colName}").array()`;
+            } else if (colType === "boolean[]") {
+                columnDefinition = `boolean("${colName}").array()`;
+            } else if (colType === "numeric[]") {
+                columnDefinition = `numeric("${colName}").array()`;
             } else {
                 columnDefinition = `jsonb("${colName}")`;
             }

package/src/schema/generate-drizzle-schema.ts

@@ -5,7 +5,7 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { EntityCollection } from "@rebasepro/types";
-import { defaultUsersCollection } from "@rebasepro/common";
+
 
 // --- Helper Functions ---
 
@@ -90,11 +90,7 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             collections = [];
         }
 
-        // Always inject defaults first; developer collections override via generic dedup
-        // Map keyed by slug — last-write-wins, so developer collections overwrite defaults
-        collections = Array.from(
-            new Map([defaultUsersCollection, ...collections].map(c => [c.slug, c])).values()
-        );
+
 
         // Sort collections by slug alphabetically to ensure deterministic schema generation
         collections.sort((a, b) => a.slug.localeCompare(b.slug));

package/src/schema/introspect-db-logic.ts

@@ -589,9 +589,16 @@ export function generateCollectionFile(
         // Array/Map heuristics (Fallback if not inferred)
         if (finalPropType === "array" && !inferenceExtra.includes("of: {")) {
             let innerType = "string";
+            let colType = "";
             if (col.udt_name.startsWith("_")) {
                 const baseType = col.udt_name.substring(1);
                 innerType = mapPgType(baseType);
+                if (innerType === "string") colType = "text[]";
+                else if (innerType === "number") colType = col.udt_name === "_numeric" ? "numeric[]" : "integer[]";
+                else if (innerType === "boolean") colType = "boolean[]";
+            }
+            if (colType) {
+                extra += `\n            columnType: "${colType}",`;
             }
             extra += `\n            of: { name: "${humanize(col.column_name)} Item", type: "${innerType}" },`;
         } else if (finalPropType === "map" && !inferenceExtra.includes("keyValue: true") && !inferenceExtra.includes("properties: {")) {

package/src/services/EntityFetchService.ts

@@ -1,6 +1,6 @@
 import { and, asc, count, desc, eq, getTableName, gt, lt, or, SQL, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
-import { Entity, EntityCollection, FilterValues, Relation } from "@rebasepro/types";
+import { Entity, EntityCollection, FilterValues, Relation, LogicalCondition } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRef, createRelationRefWithData } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
@@ -465,6 +465,7 @@ export class EntityFetchService {
             offset?: number;
             startAfter?: Record<string, unknown>;
             searchString?: string;
+            logical?: LogicalCondition;
         },
         collectionPath: string,
         withConfig?: Record<string, unknown>
@@ -494,6 +495,11 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (options.logical) {
+            const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+            if (logicalCondition) allConditions.push(logicalCondition);
+        }
+
         // Cursor-based pagination (startAfter)
         if (options.startAfter) {
             const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options, collectionPath);
@@ -700,6 +706,7 @@ export class EntityFetchService {
             searchString?: string;
             databaseId?: string;
             vectorSearch?: VectorSearchParams;
+            logical?: LogicalCondition;
         } = {}
     ): Promise<Entity<M>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
@@ -774,6 +781,11 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (options.logical) {
+            const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+            if (logicalCondition) allConditions.push(logicalCondition);
+        }
+
         // Vector distance threshold filter
         if (vectorMeta?.filter) {
             allConditions.push(vectorMeta.filter);