@rebasepro/server-postgresql 0.2.1 → 0.2.4

package/src/schema/auth-schema.ts

@@ -8,8 +8,8 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     const rolesSchema = rolesSchemaName === "public" ? null : pgSchema(rolesSchemaName);
     const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
-    const rolesTableCreator: any = rolesSchema ? rolesSchema.table.bind(rolesSchema) : pgTable;
-    const usersTableCreator: any = usersSchema ? usersSchema.table.bind(usersSchema) : pgTable;
+    const rolesTableCreator = (rolesSchema ? rolesSchema.table.bind(rolesSchema) : pgTable) as typeof pgTable;
+    const usersTableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
 
     /**
      * Users table - stores both email/password and OAuth users
@@ -23,7 +23,8 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         emailVerified: boolean("email_verified").default(false).notNull(),
         emailVerificationToken: varchar("email_verification_token", { length: 255 }),
         emailVerificationSentAt: timestamp("email_verification_sent_at"),
-        metadata: jsonb("metadata").$type<Record<string, any>>().default({}).notNull(),
+        isAnonymous: boolean("is_anonymous").default(false).notNull(),
+        metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}).notNull(),
         createdAt: timestamp("created_at").defaultNow().notNull(),
         updatedAt: timestamp("updated_at").defaultNow().notNull()
     });
@@ -48,12 +49,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
                 edit?: boolean;
                 delete?: boolean;
             }>
-        >(),
-        config: jsonb("config").$type<{
-            createCollections?: boolean;
-            editCollections?: "own" | "all" | boolean;
-            deleteCollections?: "own" | "all" | boolean;
-        }>()
+        >()
     });
 
     /**
@@ -62,7 +58,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     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: any) => ({
+    }, (table) => ({
         pk: primaryKey({ columns: [table.userId, table.roleId] })
     }));
 
@@ -77,7 +73,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         userAgent: varchar("user_agent", { length: 500 }),
         ipAddress: varchar("ip_address", { length: 45 }),
         createdAt: timestamp("created_at").defaultNow().notNull()
-    }, (table: any) => ({
+    }, (table) => ({
         uniqueDeviceSession: unique("unique_device_session").on(table.userId, table.userAgent, table.ipAddress)
     }));
 
@@ -113,10 +109,47 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         profileData: jsonb("profile_data"),
         createdAt: timestamp("created_at").defaultNow().notNull(),
         updatedAt: timestamp("updated_at").defaultNow().notNull()
-    }, (table: any) => ({
+    }, (table) => ({
         uniqueProviderId: unique("unique_provider_id").on(table.provider, table.providerId)
     }));
 
+    /**
+     * MFA factors table - stores enrolled MFA methods
+     */
+    const mfaFactors = rolesTableCreator("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'
+        secretEncrypted: varchar("secret_encrypted", { length: 500 }).notNull(),
+        friendlyName: varchar("friendly_name", { length: 255 }),
+        verified: boolean("verified").default(false).notNull(),
+        createdAt: timestamp("created_at").defaultNow().notNull(),
+        updatedAt: timestamp("updated_at").defaultNow().notNull()
+    });
+
+    /**
+     * MFA challenges table - tracks active MFA verification attempts
+     */
+    const mfaChallenges = rolesTableCreator("mfa_challenges", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        factorId: uuid("factor_id").notNull().references(() => mfaFactors.id, { onDelete: "cascade" }),
+        createdAt: timestamp("created_at").defaultNow().notNull(),
+        verifiedAt: timestamp("verified_at"),
+        ipAddress: varchar("ip_address", { length: 45 }),
+        expiresAt: timestamp("expires_at").notNull()
+    });
+
+    /**
+     * Recovery codes table - backup codes for MFA
+     */
+    const recoveryCodes = rolesTableCreator("recovery_codes", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+        codeHash: varchar("code_hash", { length: 255 }).notNull(),
+        usedAt: timestamp("used_at"),
+        createdAt: timestamp("created_at").defaultNow().notNull()
+    });
+
     return {
         rolesSchema,
         usersSchema,
@@ -126,7 +159,10 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         refreshTokens,
         passwordResetTokens,
         appConfig,
-        userIdentities
+        userIdentities,
+        mfaFactors,
+        mfaChallenges,
+        recoveryCodes
     };
 }
 
@@ -143,13 +179,18 @@ export const refreshTokens = defaultAuthSchema.refreshTokens;
 export const passwordResetTokens = defaultAuthSchema.passwordResetTokens;
 export const appConfig = defaultAuthSchema.appConfig;
 export const userIdentities = defaultAuthSchema.userIdentities;
+export const mfaFactors = defaultAuthSchema.mfaFactors;
+export const mfaChallenges = defaultAuthSchema.mfaChallenges;
+export const recoveryCodes = defaultAuthSchema.recoveryCodes;
 
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
     userRoles: many(userRoles),
     refreshTokens: many(refreshTokens),
     passwordResetTokens: many(passwordResetTokens),
-    userIdentities: many(userIdentities)
+    userIdentities: many(userIdentities),
+    mfaFactors: many(mfaFactors),
+    recoveryCodes: many(recoveryCodes)
 }));
 
 export const rolesRelations = relations(roles, ({ many }) => ({
@@ -188,6 +229,28 @@ export const userIdentitiesRelations = relations(userIdentities, ({ one }) => ({
     })
 }));
 
+export const mfaFactorsRelations = relations(mfaFactors, ({ one, many }) => ({
+    user: one(users, {
+        fields: [mfaFactors.userId],
+        references: [users.id]
+    }),
+    challenges: many(mfaChallenges)
+}));
+
+export const mfaChallengesRelations = relations(mfaChallenges, ({ one }) => ({
+    factor: one(mfaFactors, {
+        fields: [mfaChallenges.factorId],
+        references: [mfaFactors.id]
+    })
+}));
+
+export const recoveryCodesRelations = relations(recoveryCodes, ({ one }) => ({
+    user: one(users, {
+        fields: [recoveryCodes.userId],
+        references: [users.id]
+    })
+}));
+
 // Type exports
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
@@ -199,3 +262,6 @@ export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;
 export type UserIdentity = typeof userIdentities.$inferSelect;
 export type NewUserIdentity = typeof userIdentities.$inferInsert;
+export type MfaFactorRow = typeof mfaFactors.$inferSelect;
+export type MfaChallengeRow = typeof mfaChallenges.$inferSelect;
+export type RecoveryCodeRow = typeof recoveryCodes.$inferSelect;

package/src/schema/default-collections.ts

@@ -5,6 +5,7 @@ export const defaultUsersCollection: PostgresCollection = {
     singularName: "User",
     slug: "users",
     table: "users",
+    schema: "rebase",
     icon: "Users",
     group: "Settings",
     properties: {

package/src/schema/doctor.ts

@@ -265,6 +265,8 @@ export async function checkCollectionsVsSdk(
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
 
 interface DbColumn {
+    table_schema: string;
+    table_name: string;
     column_name: string;
     data_type: string;
     is_nullable: string;
@@ -288,27 +290,45 @@ export async function checkCollectionsVsDatabase(
     const { Pool } = pgModule.default ?? pgModule;
     const pool = new Pool({ connectionString: databaseUrl });
 
+    // Determine all schemas defined by the collections, plus public and rebase
+    const schemas = Array.from(new Set([
+        "public",
+        "rebase",
+        ...collections
+            .filter(isPostgresCollection)
+            .map(c => c.schema)
+            .filter((s): s is string => !!s)
+    ]));
+
     try {
-        // Fetch all tables in the public schema
-        const tablesResult = await pool.query<{ table_name: string }>(
-            "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'"
+        // Fetch all tables in the defined schemas
+        const tablesResult = await pool.query<{ table_schema: string; table_name: string }>(
+            `SELECT table_schema, table_name 
+             FROM information_schema.tables 
+             WHERE table_schema = ANY($1) AND table_type = 'BASE TABLE'`,
+            [schemas]
         );
-        const existingTables = new Set(tablesResult.rows.map((r) => r.table_name));
+        const existingTables = new Set(tablesResult.rows.map((r) => 
+            r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`
+        ));
 
-        // Fetch all columns
+        // Fetch all columns in the defined schemas
         const columnsResult = await pool.query<DbColumn>(
-            `SELECT table_name, column_name, data_type, is_nullable, udt_name
+            `SELECT table_schema, table_name, column_name, data_type, is_nullable, udt_name
              FROM information_schema.columns
-             WHERE table_schema = 'public'
-             ORDER BY table_name, ordinal_position`
+             WHERE table_schema = ANY($1)
+             ORDER BY table_schema, table_name, ordinal_position`,
+            [schemas]
         );
         const columnsByTable = new Map<string, DbColumn[]>();
         for (const row of columnsResult.rows) {
-            const tableName = (row as unknown as Record<string, string>).table_name;
-            if (!columnsByTable.has(tableName)) {
-                columnsByTable.set(tableName, []);
+            const tableSchema = row.table_schema;
+            const tableName = row.table_name;
+            const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+            if (!columnsByTable.has(key)) {
+                columnsByTable.set(key, []);
             }
-            columnsByTable.get(tableName)!.push(row);
+            columnsByTable.get(key)!.push(row);
         }
 
         // Fetch enums
@@ -326,18 +346,22 @@ export async function checkCollectionsVsDatabase(
             enumsByName.get(row.enum_name)!.push(row.enum_value);
         }
 
-        // Fetch foreign key constraints
+        // Fetch foreign key constraints in the defined schemas
         const fksResult = await pool.query<{
             constraint_name: string;
+            table_schema: string;
             table_name: string;
             column_name: string;
+            foreign_table_schema: string;
             foreign_table_name: string;
             foreign_column_name: string;
         }>(
             `SELECT
                 tc.constraint_name,
+                tc.table_schema,
                 tc.table_name,
                 kcu.column_name,
+                ccu.table_schema AS foreign_table_schema,
                 ccu.table_name AS foreign_table_name,
                 ccu.column_name AS foreign_column_name
              FROM information_schema.table_constraints AS tc
@@ -345,14 +369,18 @@ export async function checkCollectionsVsDatabase(
                  ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
              JOIN information_schema.constraint_column_usage AS ccu
                  ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
-             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'`
+             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = ANY($1)`,
+            [schemas]
         );
         const fksByTable = new Map<string, typeof fksResult.rows>();
         for (const row of fksResult.rows) {
-            if (!fksByTable.has(row.table_name)) {
-                fksByTable.set(row.table_name, []);
+            const tableSchema = row.table_schema;
+            const tableName = row.table_name;
+            const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+            if (!fksByTable.has(key)) {
+                fksByTable.set(key, []);
             }
-            fksByTable.get(row.table_name)!.push(row);
+            fksByTable.get(key)!.push(row);
         }
 
         // ── Compare each collection against the database ─────────────────
@@ -361,20 +389,22 @@ export async function checkCollectionsVsDatabase(
 
         for (const collection of postgresCollections) {
             const tableName = getTableName(collection);
+            const schemaName = collection.schema || "public";
+            const fullTableName = schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
 
             // Check table existence
-            if (!existingTables.has(tableName)) {
+            if (!existingTables.has(fullTableName)) {
                 issues.push({
                     severity: "error",
                     category: "missing_table",
-                    table: tableName,
-                    message: `Table "${tableName}" does not exist in the database.`,
+                    table: fullTableName,
+                    message: `Table "${fullTableName}" does not exist in the database.`,
                     fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                 });
                 continue; // Skip column checks for missing tables
             }
 
-            const dbColumns = columnsByTable.get(tableName) ?? [];
+            const dbColumns = columnsByTable.get(fullTableName) ?? [];
             const dbColumnMap = new Map(dbColumns.map((c) => [c.column_name, c]));
 
             // System columns that Rebase always creates
@@ -392,27 +422,36 @@ export async function checkCollectionsVsDatabase(
                             issues.push({
                                 severity: "error",
                                 category: "missing_column",
-                                table: tableName,
+                                table: fullTableName,
                                 column: fkColName,
-                                message: `Foreign key column "${fkColName}" for relation "${propName}" is missing from table "${tableName}".`,
+                                message: `Foreign key column "${fkColName}" for relation "${propName}" is missing from table "${fullTableName}".`,
                                 fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                             });
                         }
 
                         // Check FK constraint exists
-                        const tableFks = fksByTable.get(tableName) ?? [];
-                        const hasFk = tableFks.some((fk) => fk.column_name === fkColName);
+                        const tableFks = fksByTable.get(fullTableName) ?? [];
+                        let targetTableName = "unknown";
+                        let targetSchemaName = "public";
+                        try {
+                            const targetColl = relation.target();
+                            targetTableName = getTableName(targetColl);
+                            targetSchemaName = targetColl.schema || "public";
+                        } catch { /* ignore */ }
+
+                        const hasFk = tableFks.some((fk) => 
+                            fk.column_name === fkColName && 
+                            fk.foreign_table_name === targetTableName &&
+                            fk.foreign_table_schema === targetSchemaName
+                        );
+
                         if (dbColumnMap.has(fkColName) && !hasFk) {
-                            let targetTableName = "unknown";
-                            try {
-                                targetTableName = getTableName(relation.target());
-                            } catch { /* ignore */ }
                             issues.push({
                                 severity: "warning",
                                 category: "missing_foreign_key",
-                                table: tableName,
+                                table: fullTableName,
                                 column: fkColName,
-                                message: `Column "${fkColName}" exists but has no FOREIGN KEY constraint referencing "${targetTableName}".`,
+                                message: `Column "${fkColName}" exists but has no FOREIGN KEY constraint referencing "${targetSchemaName === "public" ? targetTableName : `${targetSchemaName}.${targetTableName}`}".`,
                                 fix: "Run `rebase db push` or add the constraint manually"
                             });
                         }
@@ -430,9 +469,9 @@ export async function checkCollectionsVsDatabase(
                     issues.push({
                         severity: "error",
                         category: "missing_column",
-                        table: tableName,
+                        table: fullTableName,
                         column: colName,
-                        message: `Column "${colName}" is defined in collection "${collection.slug}" but missing from table "${tableName}".`,
+                        message: `Column "${colName}" is defined in collection "${collection.slug}" but missing from table "${fullTableName}".`,
                         fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                     });
                     continue;
@@ -450,11 +489,11 @@ export async function checkCollectionsVsDatabase(
                         issues.push({
                             severity: "warning",
                             category: "type_mismatch",
-                            table: tableName,
+                            table: fullTableName,
                             column: colName,
                             expected: prop.type === "vector" ? "vector" : expectedType,
                             actual: dbCol.udt_name === "vector" ? "vector" : actualType,
-                            message: `Column "${colName}" in table "${tableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
+                            message: `Column "${colName}" in table "${fullTableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
                             fix: "Review collection property type or run a migration"
                         });
                     }
@@ -470,7 +509,7 @@ export async function checkCollectionsVsDatabase(
                             issues.push({
                                 severity: "warning",
                                 category: "missing_enum",
-                                table: tableName,
+                                table: fullTableName,
                                 column: colName,
                                 expected: enumName,
                                 message: `Enum type "${enumName}" is defined in collection but not found in the database.`,
@@ -492,11 +531,11 @@ export async function checkCollectionsVsDatabase(
                                 issues.push({
                                     severity: "warning",
                                     category: "enum_value_mismatch",
-                                    table: tableName,
+                                    table: fullTableName,
                                     column: colName,
                                     expected: expectedValues.join(", "),
                                     actual: dbEnumValues.join(", "),
-                                    message: `Enum values for "${colName}" in table "${tableName}" are out of sync (${parts.join("; ")}).`,
+                                    message: `Enum values for "${colName}" in table "${fullTableName}" are out of sync (${parts.join("; ")}).`,
                                     fix: "Run `rebase db push` to update the enum"
                                 });
                             }
@@ -510,12 +549,14 @@ export async function checkCollectionsVsDatabase(
             for (const relation of Object.values(resolvedRelations)) {
                 if (relation.cardinality === "many" && relation.direction === "owning" && relation.through) {
                     const junctionTable = relation.through.table;
-                    if (!existingTables.has(junctionTable)) {
+                    const junctionSchema = collection.schema || "public";
+                    const fullJunctionTable = junctionSchema === "public" ? junctionTable : `${junctionSchema}.${junctionTable}`;
+                    if (!existingTables.has(fullJunctionTable)) {
                         issues.push({
                             severity: "error",
                             category: "missing_table",
-                            table: junctionTable,
-                            message: `Junction table "${junctionTable}" for many-to-many relation "${relation.relationName}" is missing.`,
+                            table: fullJunctionTable,
+                            message: `Junction table "${fullJunctionTable}" for many-to-many relation "${relation.relationName}" is missing.`,
                             fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                         });
                     }

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 "./default-collections";
+import { defaultUsersCollection } from "@rebasepro/common";
 
 // --- Helper Functions ---
 
@@ -90,11 +90,11 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             collections = [];
         }
 
-        // Inject default collections if not overridden by the developer
-        const hasUsersCollection = collections.some(c => c.slug === "users");
-        if (!hasUsersCollection) {
-            collections.push(defaultUsersCollection);
-        }
+        // 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/services/EntityFetchService.ts

@@ -1,6 +1,7 @@
 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 type { VectorSearchParams } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRef, createRelationRefWithData } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
@@ -698,6 +699,7 @@ export class EntityFetchService {
             startAfter?: Record<string, unknown>;
             searchString?: string;
             databaseId?: string;
+            vectorSearch?: VectorSearchParams;
         } = {}
     ): Promise<Entity<M>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
@@ -722,7 +724,9 @@ export class EntityFetchService {
         const withConfig = this.buildWithConfig(collection);
         const hasRelations = withConfig && Object.keys(withConfig).length > 0;
 
-        if (qb && !options.searchString && !hasRelations) {
+        // Skip db.query path when vectorSearch is present — it doesn't support
+        // custom SELECT expressions needed for the _distance column.
+        if (qb && !options.searchString && !hasRelations && !options.vectorSearch) {
             try {
                 const queryOpts = this.buildDrizzleQueryOptions<M>(
                     table, idField, idInfo, options, collectionPath, undefined
@@ -746,7 +750,15 @@ export class EntityFetchService {
         }
 
         // Fallback: db.select + processEntityResults (N+1 for relations)
-        let query = this.db.select().from(table).$dynamic();
+        // When vectorSearch is present, add _distance to the SELECT.
+        let vectorMeta: { orderBy: SQL; filter?: SQL; distanceSelect: SQL } | undefined;
+        if (options.vectorSearch) {
+            vectorMeta = DrizzleConditionBuilder.buildVectorSearchConditions(table, options.vectorSearch);
+        }
+
+        let query = vectorMeta
+            ? this.db.select({ table_row: table, _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
+            : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
         if (options.searchString) {
@@ -762,13 +774,21 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        // Vector distance threshold filter
+        if (vectorMeta?.filter) {
+            allConditions.push(vectorMeta.filter);
+        }
+
         if (allConditions.length > 0) {
             const finalCondition = DrizzleConditionBuilder.combineConditionsWithAnd(allConditions);
             if (finalCondition) query = query.where(finalCondition);
         }
 
         const orderExpressions = [];
-        if (options.orderBy) {
+        // Vector search overrides ORDER BY with distance (ascending = closest first)
+        if (vectorMeta) {
+            orderExpressions.push(asc(vectorMeta.orderBy));
+        } else if (options.orderBy) {
             const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
             if (orderByField) {
                 orderExpressions.push(options.order === "asc" ? asc(orderByField) : desc(orderByField));
@@ -786,13 +806,24 @@ export class EntityFetchService {
             }
         }
 
-        const limitValue = options.searchString ? (options.limit || 50) : options.limit;
+        const limitValue = options.vectorSearch
+            ? (options.limit || 10)
+            : options.searchString ? (options.limit || 50) : options.limit;
         if (limitValue) query = query.limit(limitValue);
 
         // Offset (numeric pagination)
         if (options.offset && options.offset > 0) query = query.offset(options.offset);
 
-        const results = await query;
+        const rawResults = await query;
+
+        // When vector search is active, unwrap the nested select shape and
+        // attach _distance to each entity's values.
+        const results = vectorMeta
+            ? (rawResults as { table_row: Record<string, unknown>; _distance: unknown }[]).map(r => ({
+                ...r.table_row,
+                _distance: typeof r._distance === "number" ? r._distance : parseFloat(String(r._distance))
+            }))
+            : rawResults as Record<string, unknown>[];
 
         return this.processEntityResults<M>(results, collection, collectionPath, idInfo, options.databaseId, false, idInfoArray);
     }
@@ -919,6 +950,7 @@ export class EntityFetchService {
             startAfter?: Record<string, unknown>;
             searchString?: string;
             databaseId?: string;
+            vectorSearch?: VectorSearchParams;
         } = {}
     ): Promise<Entity<M>[]> {
         // Handle multi-segment paths by resolving through relations
@@ -1164,6 +1196,7 @@ export class EntityFetchService {
             startAfter?: Record<string, unknown>;
             searchString?: string;
             databaseId?: string;
+            vectorSearch?: VectorSearchParams;
         } = {},
         include?: string[]
     ): Promise<Record<string, unknown>[]> {
@@ -1181,7 +1214,8 @@ export class EntityFetchService {
         const tableName = getTableName(table);
 
         const qb = this.getQueryBuilder(tableName);
-        if (qb && !options.searchString) {
+        // Skip db.query path when vectorSearch is present — needs custom SELECT
+        if (qb && !options.searchString && !options.vectorSearch) {
             try {
                 const withConfig = (include && include.length > 0)
                     ? this.buildWithConfig(collection, include)
@@ -1389,6 +1423,7 @@ export class EntityFetchService {
             offset?: number;
             startAfter?: Record<string, unknown>;
             searchString?: string;
+            vectorSearch?: VectorSearchParams;
         } = {}
     ): Promise<Record<string, unknown>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
@@ -1397,7 +1432,14 @@ export class EntityFetchService {
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
-        let query = this.db.select().from(table).$dynamic();
+        let vectorMeta: { orderBy: SQL; filter?: SQL; distanceSelect: SQL } | undefined;
+        if (options.vectorSearch) {
+            vectorMeta = DrizzleConditionBuilder.buildVectorSearchConditions(table, options.vectorSearch);
+        }
+
+        let query = vectorMeta
+            ? this.db.select({ table_row: table, _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
+            : this.db.select().from(table).$dynamic();
         const allConditions: SQL[] = [];
 
         if (options.searchString) {
@@ -1413,13 +1455,19 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (vectorMeta?.filter) {
+            allConditions.push(vectorMeta.filter);
+        }
+
         if (allConditions.length > 0) {
             const finalCondition = DrizzleConditionBuilder.combineConditionsWithAnd(allConditions);
             if (finalCondition) query = query.where(finalCondition);
         }
 
         const orderExpressions = [];
-        if (options.orderBy) {
+        if (vectorMeta) {
+            orderExpressions.push(asc(vectorMeta.orderBy));
+        } else if (options.orderBy) {
             const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
             if (orderByField) {
                 orderExpressions.push(options.order === "asc" ? asc(orderByField) : desc(orderByField));
@@ -1428,13 +1476,24 @@ export class EntityFetchService {
         orderExpressions.push(desc(idField));
         if (orderExpressions.length > 0) query = query.orderBy(...orderExpressions);
 
-        const limitValue = options.searchString ? (options.limit || 50) : options.limit;
+        const limitValue = options.vectorSearch
+            ? (options.limit || 10)
+            : options.searchString ? (options.limit || 50) : options.limit;
         if (limitValue) query = query.limit(limitValue);
 
         // Offset (numeric pagination)
         if (options.offset && options.offset > 0) query = query.offset(options.offset);
 
-        return await query as Record<string, unknown>[];
+        const rawResults = await query;
+
+        if (vectorMeta) {
+            return (rawResults as { table_row: Record<string, unknown>; _distance: unknown }[]).map(r => ({
+                ...r.table_row,
+                _distance: typeof r._distance === "number" ? r._distance : parseFloat(String(r._distance))
+            }));
+        }
+
+        return rawResults as Record<string, unknown>[];
     }
 
     /**

package/src/services/entityService.ts

@@ -1,5 +1,6 @@
 // import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { Entity, FilterValues } from "@rebasepro/types";
+import type { VectorSearchParams } from "@rebasepro/types";
 import { EntityFetchService } from "./EntityFetchService";
 import { EntityPersistService } from "./EntityPersistService";
 import { RelationService } from "./RelationService";
@@ -66,6 +67,7 @@ export class EntityService implements EntityRepository {
             startAfter?: Record<string, unknown>;
             searchString?: string;
             databaseId?: string;
+            vectorSearch?: VectorSearchParams;
         } = {}
     ): Promise<Entity<M>[]> {
         return this.fetchService.fetchCollection<M>(collectionPath, options);