@rebasepro/server-postgresql 0.2.5 → 0.4.0

package/dist/server-postgresql/src/auth/ensure-tables.d.ts

@@ -1,7 +1,10 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import type { EntityCollection } from "@rebasepro/types";
 /**
- * Auto-create auth tables if they don't exist
- * This runs on startup to ensure the database is ready for auth
+ * Auto-create auth tables if they don't exist.
+ *
+ * @param db         — Drizzle database instance
+ * @param collection — The collection that represents auth users.
+ *                     When omitted, a default `rebase.users` table is created.
  */
-export declare function ensureAuthTablesExist(db: NodePgDatabase, registry?: PostgresCollectionRegistry): Promise<void>;
+export declare function ensureAuthTablesExist(db: NodePgDatabase, collection?: EntityCollection): Promise<void>;

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

@@ -1,6 +1,6 @@
 import { SQL } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
-import { Entity, FilterValues } from "@rebasepro/types";
+import { Entity, FilterValues, LogicalCondition } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { RelationService } from "./RelationService";
 import { DrizzleClient } from "../interfaces";
@@ -104,6 +104,7 @@ export declare class EntityFetchService {
         searchString?: string;
         databaseId?: string;
         vectorSearch?: VectorSearchParams;
+        logical?: LogicalCondition;
     }): Promise<Entity<M>[]>;
     /**
      * Fallback path used when db.query is unavailable.

package/dist/server-postgresql/src/utils/drizzle-conditions.d.ts

@@ -1,6 +1,6 @@
 import { SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
-import { FilterValues, WhereFilterOp, Relation } from "@rebasepro/types";
+import { FilterValues, WhereFilterOp, Relation, LogicalCondition, FilterCondition } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 /** Drizzle dynamic query builder — accepts innerJoin + where chaining */
 export interface DrizzleDynamicQuery {
@@ -22,6 +22,10 @@ export declare class DrizzleConditionBuilder {
      * Build filter conditions from FilterValues
      */
     static buildFilterConditions<M extends Record<string, unknown>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    /**
+     * Build logical conditions recursively from LogicalCondition or FilterCondition
+     */
+    static buildLogicalConditions(cond: LogicalCondition | FilterCondition, table: PgTable<any>, collectionPath: string): SQL | null;
     /**
      * Build a single filter condition for a specific operator and value
      */

package/dist/types/src/controllers/data.d.ts

@@ -16,7 +16,17 @@ import { Entity, EntityValues } from "../types/entities";
  *
  * @group Data
  */
-export type WhereFieldValue = string | number | boolean | null | [WhereFilterOpShort, any];
+export type WhereFieldValue = string | number | boolean | null | [WhereFilterOpShort, any] | [WhereFilterOpShort, any][];
+export type WhereValue<T> = T | T[] | null;
+export interface LogicalCondition {
+    type: "and" | "or";
+    conditions: (FilterCondition | LogicalCondition)[];
+}
+export interface FilterCondition {
+    column: string;
+    operator: FilterOperator;
+    value: unknown;
+}
 /** Short operator strings accepted in the tuple syntax. */
 export type WhereFilterOpShort = "==" | "!=" | ">" | ">=" | "<" | "<=" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "not-in" | "array-contains" | "array-contains-any" | "cs" | "csa";
 export interface FindParams {
@@ -51,6 +61,8 @@ export interface FindParams {
      * ```
      */
     where?: Record<string, WhereFieldValue>;
+    /** Logical grouping conditions (AND/OR) */
+    logical?: LogicalCondition;
     /**
      * Sort order. Format: "field:direction".
      * @example "created_at:desc", "name:asc"
@@ -82,7 +94,8 @@ export type FilterOperator = WhereFilterOpShort;
  * @group Data
  */
 export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
+    where(logicalCondition: LogicalCondition): this;
     orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
     limit(count: number): this;
     offset(count: number): this;
@@ -143,7 +156,8 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      * Count the number of records matching the given filter.
      */
     count?(params?: FindParams): Promise<number>;
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilderInterface<M>;
+    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilderInterface<M>;
+    where(logicalCondition: LogicalCondition): QueryBuilderInterface<M>;
     orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilderInterface<M>;
     limit(count: number): QueryBuilderInterface<M>;
     offset(count: number): QueryBuilderInterface<M>;

package/dist/types/src/controllers/email.d.ts

@@ -31,4 +31,6 @@ export interface EmailService {
     send(options: EmailSendOptions): Promise<void>;
     /** Returns `true` when the service has valid credentials / is ready to send. */
     isConfigured(): boolean;
+    /** Verify connection/credentials with the email provider. */
+    verifyConnection?(): Promise<boolean>;
 }

package/dist/types/src/types/collections.d.ts

@@ -7,7 +7,7 @@ import type { EntityOverrides } from "./entity_overrides";
 import type { User } from "../users";
 import type { RebaseContext } from "../rebase_context";
 import type { Relation } from "./relations";
-import type { EntityCustomView, EntityDetailViewConfig } from "./entity_views";
+import type { EntityCustomView, FormViewConfig } from "./entity_views";
 import type { EntityAction } from "./entity_actions";
 import type { ComponentRef } from "./component_ref";
 /**
@@ -124,10 +124,14 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     defaultEntityAction?: "view" | "edit";
     /**
-     * Customization options for the read-only detail view.
-     * Only used when `defaultEntityAction` is `"view"`.
+     * Replace the default entity form with a custom component.
+     * The Builder receives the same props as entity view tabs
+     * (entity, formContext, collection, etc.) and has full control over the UI.
+     *
+     * Works in both edit mode and read-only mode (when `defaultEntityAction`
+     * is `"view"`). In read-only mode, `formContext.readOnly` will be `true`.
      */
-    detailView?: EntityDetailViewConfig;
+    formView?: FormViewConfig;
     /**
      * Prevent default actions from being displayed or executed on this collection.
      */
@@ -566,7 +570,7 @@ export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-conta
  *
  * @group Models
  */
-export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown]>>;
+export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
 /**
  * A pre-defined filter preset for quick access in the collection toolbar.
  * Users can select a preset to instantly apply a set of filters and

package/dist/types/src/types/entity_views.d.ts

@@ -56,41 +56,32 @@ export type EntityCustomView<M extends Record<string, unknown> = Record<string,
     Builder?: ComponentRef<EntityCustomViewParams<M>>;
     position?: "start" | "end";
 };
-export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
-    collection: EntityCollection<M>;
-    entity?: Entity<M>;
-    modifiedValues?: EntityValues<M>;
-    formContext: FormContext<M>;
-    parentCollectionSlugs?: string[];
-    parentEntityIds?: string[];
-}
 /**
- * Configuration for customizing the read-only detail view of an entity.
- * Only used when `defaultEntityAction` is set to `"view"` on the collection.
+ * Configuration to replace the default entity form with a custom component.
+ * The Builder receives the same props as entity view tabs (entity, formContext, etc.)
+ * and has full control over the UI.
+ *
+ * The form tab still appears in the tab bar but renders your Builder
+ * instead of the auto-generated field form.
+ *
  * @group Models
  */
-export type EntityDetailViewConfig<M extends Record<string, unknown> = Record<string, unknown>> = {
-    /**
-     * Custom component rendered above the property display in the detail view.
-     */
-    Header?: ComponentRef<EntityDetailViewParams<M>>;
+export type FormViewConfig<M extends Record<string, unknown> = Record<string, unknown>> = {
     /**
-     * Custom component rendered below the property display in the detail view.
+     * Custom component that replaces the default form.
      */
-    Footer?: ComponentRef<EntityDetailViewParams<M>>;
+    Builder: ComponentRef<EntityCustomViewParams<M>>;
     /**
-     * Completely replace the default detail view with a custom component.
-     * When set, Header and Footer are ignored.
+     * If true, the save/delete action bar is rendered alongside the custom view.
+     * Defaults to true.
      */
-    Builder?: ComponentRef<EntityDetailViewParams<M>>;
+    includeActions?: boolean;
 };
-/**
- * Props passed to detail view customization components (Header, Footer, Builder).
- * @group Models
- */
-export interface EntityDetailViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
     collection: EntityCollection<M>;
-    entity: Entity<M>;
-    path: string;
-    onEditClick: () => void;
+    entity?: Entity<M>;
+    modifiedValues?: EntityValues<M>;
+    formContext: FormContext<M>;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 }

package/dist/types/src/types/properties.d.ts

@@ -104,8 +104,8 @@ export interface BaseUIConfig<CustomProps = unknown> {
     disabled?: boolean | PropertyDisabledConfig;
     widthPercentage?: number;
     customProps?: CustomProps;
-    Field?: ComponentRef;
-    Preview?: ComponentRef;
+    Field?: ComponentRef<any>;
+    Preview?: ComponentRef<any>;
 }
 export interface BaseProperty<CustomProps = unknown> {
     ui?: BaseUIConfig<CustomProps>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.2.5",
+  "version": "0.4.0",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -68,11 +68,11 @@
     "hono": "^4.12.21",
     "pg": "^8.21.0",
     "ws": "^8.20.1",
-    "@rebasepro/common": "0.2.5",
-    "@rebasepro/utils": "0.2.5",
-    "@rebasepro/server-core": "0.2.5",
-    "@rebasepro/sdk-generator": "0.2.5",
-    "@rebasepro/types": "0.2.5"
+    "@rebasepro/sdk-generator": "0.4.0",
+    "@rebasepro/server-core": "0.4.0",
+    "@rebasepro/types": "0.4.0",
+    "@rebasepro/common": "0.4.0",
+    "@rebasepro/utils": "0.4.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/PostgresBootstrapper.ts

@@ -180,31 +180,44 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
         },
 
         async initializeAuth(config: unknown, driverResult: InitializedDriver): Promise<BootstrappedAuth | undefined> {
-            const authConfig = config as AuthConfig | undefined;
+            const authConfig = config as Record<string, unknown> | undefined;
             if (!authConfig) return undefined;
 
             const internals = driverResult.internals as PostgresDriverInternals;
             const db = internals.db;
             const registry = internals.registry;
 
-            await ensureAuthTablesExist(db, registry);
+            // Resolve the auth collection from the explicit config.
+            // This replaces the old `registry.getTable("users")` magic string lookup.
+            const authCollection = authConfig.collection as EntityCollection | undefined;
+
+            // ensureAuthTablesExist works with the collection abstraction — no Drizzle leakage.
+            await ensureAuthTablesExist(db, authCollection);
 
             let emailService: EmailService | undefined;
             if (authConfig.email) {
-                emailService = createEmailService(authConfig.email);
+                emailService = createEmailService(authConfig.email as EmailConfig);
             }
 
-            const customUsersTable = registry?.getTable("users");
+            // Resolve the Drizzle table for the internal UserService/AuthRepository.
+            // These are internal Postgres-specific services that need the Drizzle table reference.
+            const tableName = authCollection
+                ? ("table" in authCollection && typeof authCollection.table === "string"
+                    ? authCollection.table
+                    : authCollection.slug)
+                : undefined;
+            const usersTable = tableName
+                ? registry.getTable(tableName) as (PgTable & Record<string, AnyPgColumn>) | undefined
+                : undefined;
 
             let usersSchemaName = "rebase";
-
-            if (customUsersTable) {
-                usersSchemaName = getTableConfig(customUsersTable).schema || "public";
+            if (authCollection && "schema" in authCollection && typeof authCollection.schema === "string") {
+                usersSchemaName = authCollection.schema;
             }
 
             const authTables = createAuthSchema(usersSchemaName) as unknown as AuthSchemaTables;
-            if (customUsersTable) {
-                authTables.users = customUsersTable as unknown as PgTable & Record<string, AnyPgColumn>;
+            if (usersTable) {
+                authTables.users = usersTable as unknown as PgTable & Record<string, AnyPgColumn>;
             }
 
             const userService = new UserService(db, authTables);

package/src/auth/ensure-tables.ts

@@ -1,44 +1,46 @@
 import { sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { getTableConfig, AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
-import { getColumnMeta } from "../services/entity-helpers";
-import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { logger } from "@rebasepro/server-core";
+import type { EntityCollection } from "@rebasepro/types";
 
 
 
 /**
- * Auto-create auth tables if they don't exist
- * This runs on startup to ensure the database is ready for auth
+ * Auto-create auth tables if they don't exist.
+ *
+ * @param db         — Drizzle database instance
+ * @param collection — The collection that represents auth users.
+ *                     When omitted, a default `rebase.users` table is created.
  */
-export async function ensureAuthTablesExist(db: NodePgDatabase, registry?: PostgresCollectionRegistry): Promise<void> {
+export async function ensureAuthTablesExist(db: NodePgDatabase, collection?: EntityCollection): Promise<void> {
     logger.info("🔍 Checking auth tables...");
 
     try {
-        // Resolve dynamic user table name and ID type
-        let usersTableName = '"users"';
+        // Resolve dynamic user table name and ID type from the collection
+        let usersTableName = '"rebase"."users"';
         let userIdType = "TEXT";
-        let usersSchema = "public";
-        if (registry) {
-            const usersTable = registry.getTable("users") as (PgTable & Record<string, AnyPgColumn>) | undefined;
-            if (usersTable) {
-                const { getTableName } = await import("drizzle-orm");
-                usersSchema = getTableConfig(usersTable).schema || "public";
-                usersTableName = usersSchema === "public" ? `"${getTableName(usersTable)}"` : `"${usersSchema}"."${getTableName(usersTable)}"`;
-
-                // Inspect users.id column to match referenced column type
-                if (usersTable.id) {
-                    const col = usersTable.id;
-                    const meta = getColumnMeta(col);
-                    const columnType = meta.columnType;
-                    if (columnType === "PgUUID") {
-                        userIdType = "UUID";
-                    } else if (columnType === "PgSerial" || columnType === "PgInteger") {
-                        userIdType = "INTEGER";
-                    } else if (columnType === "PgBigInt" || columnType === "PgBigSerial") {
-                        userIdType = "BIGINT";
-                    }
+        let usersSchema = "rebase";
+        if (collection) {
+            const rawTable = ("table" in collection && typeof collection.table === "string")
+                ? collection.table
+                : collection.slug;
+            usersSchema = ("schema" in collection && typeof collection.schema === "string")
+                ? collection.schema
+                : "public";
+            usersTableName = usersSchema === "public"
+                ? `"${rawTable}"`
+                : `"${usersSchema}"."${rawTable}"`;
+
+            // Derive ID column type from collection properties
+            const idProp = collection.properties?.id;
+            if (idProp) {
+                const isId = ("isId" in idProp) ? (idProp as unknown as Record<string, unknown>).isId : undefined;
+                if (isId === "uuid") {
+                    userIdType = "UUID";
+                } else if (isId === "autoincrement") {
+                    userIdType = "INTEGER";
                 }
+                // Otherwise keep TEXT as default
             }
         }
 

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/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);

package/src/utils/drizzle-conditions.ts

@@ -1,6 +1,6 @@
 import { and, eq, or, sql, SQL, ilike, inArray } from "drizzle-orm";
 import { AnyPgColumn, PgTable, PgVarchar, PgText, PgChar } from "drizzle-orm/pg-core";
-import { FilterValues, WhereFilterOp, Relation, JoinStep } from "@rebasepro/types";
+import { FilterValues, WhereFilterOp, Relation, JoinStep, LogicalCondition, FilterCondition } from "@rebasepro/types";
 import { getColumnName, resolveCollectionRelations } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { ConditionBuilderStatic } from "../interfaces";
@@ -37,7 +37,6 @@ export class DrizzleConditionBuilder {
         for (const [field, filterParam] of Object.entries(filter)) {
             if (!filterParam) continue;
 
-            const [op, value] = filterParam as [WhereFilterOp, any];
             let fieldColumn = table[field as keyof typeof table] as AnyPgColumn;
 
             if (!fieldColumn) {
@@ -53,15 +52,51 @@ export class DrizzleConditionBuilder {
                 continue;
             }
 
-            const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
-            if (condition) {
-                conditions.push(condition);
+            const paramsList = Array.isArray(filterParam) && filterParam.length > 0 && Array.isArray(filterParam[0])
+                ? (filterParam as [WhereFilterOp, any][])
+                : [filterParam as [WhereFilterOp, any]];
+
+            for (const [op, value] of paramsList) {
+                const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
+                if (condition) {
+                    conditions.push(condition);
+                }
             }
         }
 
         return conditions;
     }
 
+    /**
+     * Build logical conditions recursively from LogicalCondition or FilterCondition
+     */
+    static buildLogicalConditions(
+        cond: LogicalCondition | FilterCondition,
+        table: PgTable<any>,
+        collectionPath: string
+    ): SQL | null {
+        if ("type" in cond) {
+            const subSQLs = cond.conditions
+                .map(c => this.buildLogicalConditions(c, table, collectionPath))
+                .filter((sql): sql is SQL => sql !== null);
+            if (subSQLs.length === 0) return null;
+            return (cond.type === "or" ? or(...subSQLs) : and(...subSQLs)) ?? null;
+        } else {
+            let fieldColumn = table[cond.column as keyof typeof table] as AnyPgColumn;
+            if (!fieldColumn) {
+                const relationKey = `${cond.column}_id`;
+                if (relationKey in table) {
+                    fieldColumn = table[relationKey as keyof typeof table] as AnyPgColumn;
+                }
+            }
+            if (!fieldColumn) {
+                console.warn(`Filtering by field '${cond.column}', but it does not exist in table for collection '${collectionPath}'`);
+                return null;
+            }
+            return this.buildSingleFilterCondition(fieldColumn, cond.operator as WhereFilterOp, cond.value);
+        }
+    }
+
     /**
      * Build a single filter condition for a specific operator and value
      */

package/src/websocket.ts

@@ -547,15 +547,13 @@ colors: true }));
                     }
                         break;
 
-                    // Route subscription messages to RealtimeService
+                    // Route subscription messages, broadcast channels, and presence to RealtimeService
                     case "subscribe_collection":
                     case "subscribe_entity":
                     case "unsubscribe":
-                    // Broadcast channels
                     case "join_channel":
                     case "leave_channel":
                     case "broadcast":
-                    // Presence
                     case "presence_track":
                     case "presence_untrack":
                     case "presence_state": {