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

package/src/data-transformer.ts

@@ -1,8 +1,8 @@
 import { eq, SQL } from "drizzle-orm";
 import { AnyPgColumn } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { EntityCollection, Properties, Property, Relation, RelationProperty } from "@rebasepro/types";
-import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
+import { CollectionWithRelations, EntityCollection, Properties, Property, Relation, RelationProperty } from "@rebasepro/types";
+import { getTableName, resolveCollectionRelations, findRelation, createRelationRef, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
 import { getPrimaryKeys, buildCompositeId } from "./services/entity-helpers";
@@ -11,6 +11,28 @@ import { getPrimaryKeys, buildCompositeId } from "./services/entity-helpers";
  * Data transformation utilities for converting between frontend and database formats.
  */
 
+/**
+ * Typed result from `serializeDataToServer`.
+ * Replaces the hidden `__inverseRelationUpdates` / `__joinPathRelationUpdates`
+ * dunder-property mutation pattern with explicit, typed state management.
+ */
+export interface SerializedEntityData {
+    /** Scalar column values ready for INSERT/UPDATE. */
+    scalarData: Record<string, unknown>;
+    /** Inverse relation updates that must be applied to target tables. */
+    inverseRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newValue: unknown;
+        currentEntityId?: string | number;
+    }>;
+    /** JoinPath relation updates that require multi-hop writes. */
+    joinPathRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newTargetId: string | number | null;
+    }>;
+}
 /**
  * Helper function to sanitize and convert dates to ISO strings
  */
@@ -62,18 +84,18 @@ export function sanitizeAndConvertDates(obj: unknown): unknown {
 /**
  * Transform relations for database storage (relation objects to IDs)
  */
-export function serializeDataToServer<M extends Record<string, any>>(
+export function serializeDataToServer<M extends Record<string, unknown>>(
     entity: M,
     properties: Properties,
     collection?: EntityCollection,
     registry?: PostgresCollectionRegistry
-): Record<string, unknown> {
-    if (!entity || !properties) return entity;
+): SerializedEntityData {
+    if (!entity || !properties) return { scalarData: entity ?? {}, inverseRelationUpdates: [], joinPathRelationUpdates: [] };
 
     const result: Record<string, unknown> = {};
 
     // Get normalized relations if collection is provided
-    const resolvedRelations = collection ? resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>) : {};
+    const resolvedRelations = collection ? resolveCollectionRelations(collection) : {};
 
     // Track inverse relations that need to be handled separately
     const inverseRelationUpdates: Array<{
@@ -88,39 +110,49 @@ export function serializeDataToServer<M extends Record<string, any>>(
         newTargetId: string | number | null;
     }> = [];
 
+    // Pre-calculate all local keys used as foreign keys
+    const foreignKeys = new Set<string>();
+    Object.values(resolvedRelations).forEach(relation => {
+        if (relation.localKey) foreignKeys.add(relation.localKey);
+    });
+
     for (const [key, value] of Object.entries(entity)) {
         const property = properties[key as keyof M] as Property;
+
+        // Coerce empty strings to null for any field that acts as a foreign key
+        const effectiveValue = (foreignKeys.has(key) && value === "") ? null : value;
+
         if (!property) {
-            result[key] = value;
+            result[key] = effectiveValue;
             continue;
         }
 
         // Handle relation properties specially
         if (property.type === "relation" && collection) {
-            const relation = resolvedRelations[key];
+            const relation = findRelation(resolvedRelations, key);
             if (relation) {
                 if (relation.direction === "owning" && relation.localKey) {
                     // Owning relation: Map relation object to FK column on current table
-                    const serializedValue = serializePropertyToServer(value, property);
-                    if (serializedValue !== null && serializedValue !== undefined) {
+                    const serializedValue = serializePropertyToServer(effectiveValue, property);
+                    if (serializedValue !== undefined) {
                         result[relation.localKey] = serializedValue;
                     }
                     // Don't add the original relation property to the result
                     continue;
                 } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
                     // Inverse relation: Need to update the target table's FK
-                    const serializedValue = serializePropertyToServer(value, property);
+                    const serializedValue = serializePropertyToServer(effectiveValue, property);
                     const pks = getPrimaryKeys(collection, registry!);
                     inverseRelationUpdates.push({
                         relationKey: key,
                         relation,
                         newValue: serializedValue,
-                        currentEntityId: entity.id || buildCompositeId(entity, pks)
+                        currentEntityId: (entity.id as string | number | undefined) || buildCompositeId(entity, pks)
                     });
                     // Don't add the original relation property to the result
                     continue;
                 } else if (relation.direction === "inverse" && relation.joinPath && relation.joinPath.length > 0) {
-                    const serializedValue = serializePropertyToServer(value, property);
+                    const serializedValue = serializePropertyToServer(effectiveValue, property);
                     if (relation.cardinality === "one") {
                         // One-to-one inverse joinPath: route through joinPathRelationUpdates.
                         // The write ordering in EntityPersistService ensures these are processed
@@ -139,14 +171,14 @@ export function serializeDataToServer<M extends Record<string, any>>(
                             relationKey: key,
                             relation,
                             newValue: serializedValue,
-                            currentEntityId: entity.id || buildCompositeId(entity, pks)
+                            currentEntityId: (entity.id as string | number | undefined) || buildCompositeId(entity, pks)
                         });
                     }
                     // Don't add the original relation property to the result
                     continue;
                 } else if (relation.cardinality === "one" && relation.direction === "owning" && relation.joinPath && relation.joinPath.length > 0) {
                     // Owning one-to-one via joinPath: capture as a write intent
-                    const serializedValue = serializePropertyToServer(value, property);
+                    const serializedValue = serializePropertyToServer(effectiveValue, property);
                     joinPathRelationUpdates.push({
                         relationKey: key,
                         relation,
@@ -158,17 +190,14 @@ export function serializeDataToServer<M extends Record<string, any>>(
             }
         }
 
-        result[key] = serializePropertyToServer(value, property);
+        result[key] = serializePropertyToServer(effectiveValue, property);
     }
 
-    if (inverseRelationUpdates.length > 0) {
-        (result as Record<string, unknown>).__inverseRelationUpdates = inverseRelationUpdates;
-    }
-    if (joinPathRelationUpdates.length > 0) {
-        (result as Record<string, unknown>).__joinPathRelationUpdates = joinPathRelationUpdates;
-    }
-
-    return result;
+    return {
+        scalarData: result,
+        inverseRelationUpdates,
+        joinPathRelationUpdates
+    };
 }
 
 /**
@@ -188,11 +217,29 @@ export function serializePropertyToServer(value: unknown, property: Property): u
             } else if (typeof value === "object" && value !== null && "id" in value) {
                 return (value as Record<string, unknown>).id;
             }
+            if (value === "") return null;
             return value;
 
         case "array":
-            if (Array.isArray(value) && property.of) {
-                return value.map(item => serializePropertyToServer(item, property.of as Property));
+            if (Array.isArray(value)) {
+                if (property.of) {
+                    return value.map(item => serializePropertyToServer(item, property.of as Property));
+                } else if (property.oneOf) {
+                    const typeField = property.oneOf.typeField ?? DEFAULT_ONE_OF_TYPE;
+                    const valueField = property.oneOf.valueField ?? DEFAULT_ONE_OF_VALUE;
+                    return value.map((e) => {
+                        if (e === null) return null;
+                        if (typeof e !== "object") return e;
+                        const rec = e as Record<string, unknown>;
+                        const type = rec[typeField] as string;
+                        const childProperty = property.oneOf?.properties[type];
+                        if (!type || !childProperty) return e;
+                        return {
+                            [typeField]: type,
+                            [valueField]: serializePropertyToServer(rec[valueField], childProperty)
+                        };
+                    });
+                }
             }
             return value;
 
@@ -219,50 +266,26 @@ export function serializePropertyToServer(value: unknown, property: Property): u
 /**
  * Transform IDs back to relation objects for frontend
  */
-export async function parseDataFromServer<M extends Record<string, any>>(
+export async function parseDataFromServer<M extends Record<string, unknown>>(
     data: M,
     collection: EntityCollection,
-    db?: NodePgDatabase<any>,
+    db?: NodePgDatabase<Record<string, unknown>>,
     registry?: PostgresCollectionRegistry
 ): Promise<M> {
     const properties = collection.properties;
     if (!data || !properties) return data;
 
-    const result: Record<string, unknown> = {};
-
     // Get the normalized relations once
-    const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+    const resolvedRelations = resolveCollectionRelations(collection);
 
-    // Get list of FK columns that are used only for relations and not defined as properties
-    const internalFKColumns = new Set<string>();
-    Object.values(resolvedRelations).forEach(relation => {
-        if (relation.localKey && !properties[relation.localKey]) {
-            // This FK is used internally but not exposed as a property
-            internalFKColumns.add(relation.localKey);
-        }
-    });
-
-    // Process only the properties that are defined in the collection
-    for (const [key, value] of Object.entries(data)) {
-        // Skip internal FK columns that aren't defined as properties
-        if (internalFKColumns.has(key)) {
-            continue;
-        }
-
-        const property = properties[key as keyof M] as Property;
-        if (!property) {
-            // Also skip any other database columns not defined in properties
-            continue;
-        }
-
-        result[key] = parsePropertyFromServer(value, property, collection, key);
-    }
+    // Shared scalar + relation value normalization
+    const result = normalizeScalarValues(data, properties, collection, resolvedRelations, { skipRelations: false });
 
     // Add relation properties that should be populated from FK values or inverse queries
     for (const [propKey, property] of Object.entries(properties)) {
         if (property.type === "relation" && !(propKey in result)) {
             // Find the normalized relation for this property
-            const relation = resolvedRelations[propKey];
+            const relation = findRelation(resolvedRelations, propKey);
             if (relation) {
                 if (relation.direction === "owning" && relation.localKey && relation.localKey in data) {
                     // Owning relation: FK is in current table
@@ -270,11 +293,7 @@ export async function parseDataFromServer<M extends Record<string, any>>(
                     if (fkValue !== null && fkValue !== undefined) {
                         try {
                             const targetCollection = relation.target();
-                            result[propKey] = {
-                                id: fkValue.toString(),
-                                path: targetCollection.slug,
-                                __type: "relation"
-                            };
+                            result[propKey] = createRelationRef(fkValue.toString(), targetCollection.slug);
                         } catch (e) {
                             console.warn(`Could not resolve target collection for relation property: ${propKey}`, e);
                         }
@@ -302,19 +321,13 @@ export async function parseDataFromServer<M extends Record<string, any>>(
                                         // One-to-one: return single relation object
                                         const targetPks = getPrimaryKeys(targetCollection, registry!);
                                         const relatedEntity = relatedEntities[0] as Record<string, unknown>;
-                                        result[propKey] = {
-                                            id: buildCompositeId(relatedEntity, targetPks),
-                                            path: targetCollection.slug,
-                                            __type: "relation"
-                                        };
+                                        result[propKey] = createRelationRef(buildCompositeId(relatedEntity, targetPks), targetCollection.slug);
                                     } else {
                                         // One-to-many: return array of relation objects
                                         const targetPks = getPrimaryKeys(targetCollection, registry!);
-                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) => ({
-                                            id: buildCompositeId(entity, targetPks),
-                                            path: targetCollection.slug,
-                                            __type: "relation"
-                                        }));
+                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) => 
+                                            createRelationRef(buildCompositeId(entity, targetPks), targetCollection.slug)
+                                        );
                                     }
                                 }
                             }
@@ -403,21 +416,13 @@ export async function parseDataFromServer<M extends Record<string, any>>(
                                 if (relation.cardinality === "one") {
                                     // One-to-one: return single relation object
                                     const joinResult = joinResults[0] as Record<string, unknown>;
-                                    const targetEntity = joinResult[targetTableName] || joinResult;
-                                    result[propKey] = {
-                                        id: buildCompositeId(targetEntity, targetPks),
-                                        path: targetCollection.slug,
-                                        __type: "relation"
-                                    };
+                                    const targetEntity = (joinResult[targetTableName] || joinResult) as Record<string, unknown>;
+                                    result[propKey] = createRelationRef(buildCompositeId(targetEntity, targetPks), targetCollection.slug);
                                 } else {
                                     // One-to-many: return array of relation objects
                                     result[propKey] = joinResults.map((joinResult: Record<string, unknown>) => {
-                                        const targetEntity = joinResult[targetTableName] || joinResult;
-                                        return {
-                                            id: buildCompositeId(targetEntity, targetPks),
-                                            path: targetCollection.slug,
-                                            __type: "relation"
-                                        };
+                                        const targetEntity = (joinResult[targetTableName] || joinResult) as Record<string, unknown>;
+                                        return createRelationRef(buildCompositeId(targetEntity, targetPks), targetCollection.slug);
                                     });
                                 }
                             }
@@ -447,35 +452,48 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             if (typeof value === "string" || typeof value === "number") {
                 let relationDef: Relation | undefined = (property as RelationProperty).relation;
                 if (!relationDef && propertyKey) {
-                    const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
-                    relationDef = resolvedRelations[propertyKey];
+                    const resolvedRelations = resolveCollectionRelations(collection);
+                    relationDef = findRelation(resolvedRelations, propertyKey);
                 }
                 if (!relationDef) {
-                    relationDef = (collection as import("@rebasepro/types").PostgresCollection<any, any>).relations?.find((rel) => rel.relationName === (property as RelationProperty).relationName);
+                    relationDef = (collection as CollectionWithRelations).relations?.find((rel: Relation) => rel.relationName === (property as RelationProperty).relationName);
                 }
-                
+
                 if (!relationDef) {
-                    console.warn(`Relation not defined in property for key: ${propertyKey || 'unknown'}`);
+                    console.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
                     return value;
                 }
-                
+
                 try {
                     const targetCollection = relationDef.target();
-                    return {
-                        id: value.toString(),
-                        path: targetCollection.slug,
-                        __type: "relation"
-                    };
+                    return createRelationRef(value.toString(), targetCollection.slug);
                 } catch (e) {
-                    console.warn(`Could not resolve target collection for relation property: ${propertyKey || 'unknown'}`, e);
+                    console.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, e);
                     return value;
                 }
             }
             return value;
 
         case "array":
-            if (Array.isArray(value) && property.of) {
-                return value.map(item => parsePropertyFromServer(item, property.of as Property, collection));
+            if (Array.isArray(value)) {
+                if (property.of) {
+                    return value.map(item => parsePropertyFromServer(item, property.of as Property, collection));
+                } else if (property.oneOf) {
+                    const typeField = property.oneOf.typeField ?? DEFAULT_ONE_OF_TYPE;
+                    const valueField = property.oneOf.valueField ?? DEFAULT_ONE_OF_VALUE;
+                    return value.map((e) => {
+                        if (e === null) return null;
+                        if (typeof e !== "object") return e;
+                        const rec = e as Record<string, unknown>;
+                        const type = rec[typeField] as string;
+                        const childProperty = property.oneOf?.properties[type];
+                        if (!type || !childProperty) return e;
+                        return {
+                            [typeField]: type,
+                            [valueField]: parsePropertyFromServer(rec[valueField], childProperty, collection)
+                        };
+                    });
+                }
             }
             return value;
 
@@ -526,25 +544,24 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
 }
 
 /**
- * Lightweight value normalization for db.query results.
- * Only handles type coercion (dates, numbers, NaN) and property filtering.
- * Does NOT query the database for relations — those are already resolved
- * by Drizzle's relational query API.
+ * Shared internal helper: normalizes scalar column values from a DB row
+ * into frontend format. Handles FK-column preservation, type coercion
+ * (dates, numbers, NaN), and property filtering.
  *
- * Use this instead of `parseDataFromServer` when processing results from
- * `db.query.findFirst/findMany` which return pre-hydrated relation data.
+ * @param skipRelations  When `true`, relation-typed properties are omitted
+ *                       from the result (used by `normalizeDbValues` where
+ *                       Drizzle's relational API already hydrates them).
  */
-export function normalizeDbValues<M extends Record<string, any>>(
+function normalizeScalarValues<M extends Record<string, unknown>>(
     data: M,
-    collection: EntityCollection
-): M {
-    const properties = collection.properties;
-    if (!data || !properties) return data;
-
+    properties: Properties,
+    collection: EntityCollection,
+    resolvedRelations: Record<string, Relation>,
+    options: { skipRelations: boolean }
+): Record<string, unknown> {
     const result: Record<string, unknown> = {};
 
-    // Get FK columns that are used internally for relations and not defined as properties
-    const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+    // Identify FK columns used only for relations and not exposed as properties
     const internalFKColumns = new Set<string>();
     Object.values(resolvedRelations).forEach(relation => {
         if (relation.localKey && !properties[relation.localKey]) {
@@ -553,17 +570,39 @@ export function normalizeDbValues<M extends Record<string, any>>(
     });
 
     for (const [key, value] of Object.entries(data)) {
-        // Skip internal FK columns
-        if (internalFKColumns.has(key)) continue;
+        // Keep internal FK columns as primitives
+        if (internalFKColumns.has(key)) {
+            result[key] = value === null ? null : (typeof value === "number" ? value : String(value));
+            continue;
+        }
 
         const property = properties[key as keyof M] as Property;
         if (!property) continue; // Skip DB columns not defined in properties
 
-        // Skip relation properties — they're already handled by db.query
-        if (property.type === "relation") continue;
+        if (options.skipRelations && property.type === "relation") continue;
 
         result[key] = parsePropertyFromServer(value, property, collection, key);
     }
 
-    return result as M;
+    return result;
+}
+
+/**
+ * Lightweight value normalization for db.query results.
+ * Only handles type coercion (dates, numbers, NaN) and property filtering.
+ * Does NOT query the database for relations — those are already resolved
+ * by Drizzle's relational query API.
+ *
+ * Use this instead of `parseDataFromServer` when processing results from
+ * `db.query.findFirst/findMany` which return pre-hydrated relation data.
+ */
+export function normalizeDbValues<M extends Record<string, unknown>>(
+    data: M,
+    collection: EntityCollection
+): M {
+    const properties = collection.properties;
+    if (!data || !properties) return data;
+
+    const resolvedRelations = resolveCollectionRelations(collection);
+    return normalizeScalarValues(data, properties, collection, resolvedRelations, { skipRelations: true }) as M;
 }

package/src/databasePoolManager.ts

@@ -1,6 +1,6 @@
-import { Pool } from 'pg';
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
 
 export class DatabasePoolManager {
     private pools: Map<string, Pool> = new Map();
@@ -41,11 +41,12 @@ export class DatabasePoolManager {
         const pool = new Pool({
             connectionString: url.toString(),
             max: 10, // Default sensible limit, can be tuned later
-            idleTimeoutMillis: 30000,
+            idleTimeoutMillis: 10000, // Reduced from 30000 for aggressive cleanup
+            allowExitOnIdle: true // Prevent idle clients from hanging the Node.js process
         });
 
         // Prevent idle client errors from crashing the Node.js process
-        pool.on('error', (err) => {
+        pool.on("error", (err) => {
             console.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, err);
         });
 

package/src/history/HistoryService.ts

@@ -50,7 +50,8 @@ export class HistoryService {
         private db: NodePgDatabase,
         retention?: Partial<HistoryRetentionConfig>
     ) {
-        this.retention = { ...DEFAULT_RETENTION, ...retention };
+        this.retention = { ...DEFAULT_RETENTION,
+...retention };
     }
 
     /**
@@ -74,19 +75,9 @@ export class HistoryService {
             ? findChangedFields(previousValues, values)
             : null;
 
-        try {
-            require('fs').appendFileSync(
-                '/Users/francesco/rebase/packages/backend/history_diff.log', 
-                `[recordHistory: ${tableName}/${entityId} - ${action}]\n` +
-                `CHANGED FIELDS: ${JSON.stringify(changedFields)}\n` +
-                `PREVIOUS: ${JSON.stringify(previousValues, null, 2)}\n` +
-                `NEW:      ${JSON.stringify(values, null, 2)}\n\n`
-            );
-        } catch (e) {
-            console.error("DEBUG FILE WRITE ERROR:", e);
-        }
 
         // Skip recording if this is an update with zero actual changes
+
         if (action === "update" && (!changedFields || changedFields.length === 0)) {
             return;
         }

package/src/interfaces.ts

@@ -1,12 +1,12 @@
 /**
  * Database Abstraction Interfaces
- * 
+ *
  * These interfaces define the contracts that any database backend must implement
  * to be used with Rebase. This allows for pluggable database backends like
  * PostgreSQL, MongoDB, MySQL, etc.
  */
 
-import { 
+import {
     Entity,
     EntityCollection,
     FilterValues,
@@ -37,7 +37,7 @@ import { PgTransaction } from "drizzle-orm/pg-core";
  * Note: `any` is intentional here — it represents a Drizzle client with
  * a dynamic schema, enabling `db.query[tableName]` access without casts.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 export type DrizzleClient = NodePgDatabase<any> | PgTransaction<any, any, any>;
 
 export type {

package/src/schema/auth-schema.ts

@@ -16,8 +16,6 @@ export const users = rebaseSchema.table("users", {
     passwordHash: varchar("password_hash", { length: 255 }), // NULL for OAuth-only users
     displayName: varchar("display_name", { length: 255 }),
     photoUrl: varchar("photo_url", { length: 500 }),
-    provider: varchar("provider", { length: 50 }).notNull().default("email"), // 'email' | 'google'
-    googleId: varchar("google_id", { length: 255 }).unique(),
     emailVerified: boolean("email_verified").default(false).notNull(),
     emailVerificationToken: varchar("email_verification_token", { length: 255 }),
     emailVerificationSentAt: timestamp("email_verification_sent_at"),
@@ -99,11 +97,27 @@ export const appConfig = rebaseSchema.table("app_config", {
     updatedAt: timestamp("updated_at").defaultNow().notNull()
 });
 
+/**
+ * User identities - maps external OAuth profiles back to local users
+ */
+export const userIdentities = rebaseSchema.table("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'
+    providerId: varchar("provider_id", { length: 255 }).notNull(),
+    profileData: jsonb("profile_data"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => ({
+    uniqueProviderId: unique("unique_provider_id").on(table.provider, table.providerId)
+}));
+
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
     userRoles: many(userRoles),
     refreshTokens: many(refreshTokens),
-    passwordResetTokens: many(passwordResetTokens)
+    passwordResetTokens: many(passwordResetTokens),
+    userIdentities: many(userIdentities)
 }));
 
 export const rolesRelations = relations(roles, ({ many }) => ({
@@ -135,6 +149,13 @@ export const passwordResetTokensRelations = relations(passwordResetTokens, ({ on
     })
 }));
 
+export const userIdentitiesRelations = relations(userIdentities, ({ one }) => ({
+    user: one(users, {
+        fields: [userIdentities.userId],
+        references: [users.id]
+    })
+}));
+
 // Type exports
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
@@ -144,3 +165,5 @@ export type UserRole = typeof userRoles.$inferSelect;
 export type RefreshToken = typeof refreshTokens.$inferSelect;
 export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;
+export type UserIdentity = typeof userIdentities.$inferSelect;
+export type NewUserIdentity = typeof userIdentities.$inferInsert;

package/src/schema/doctor-cli.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for `rebase doctor`.
+ * Invoked via tsx by the server-postgresql CLI plugin.
+ */
+import path from "path";
+import chalk from "chalk";
+import { runDoctor } from "./doctor";
+
+async function main() {
+    const collectionsArg = process.argv.find((a) => a.startsWith("--collections="));
+    const schemaArg = process.argv.find((a) => a.startsWith("--schema="));
+
+    const collectionsPath = collectionsArg?.split("=")[1] ?? path.join("..", "shared", "collections");
+    const schemaPath = schemaArg?.split("=")[1] ?? path.join("src", "schema.generated.ts");
+
+    // Load .env
+    try {
+        const dotenv = await import("dotenv");
+        const envPath = process.env.DOTENV_CONFIG_PATH;
+        if (envPath) {
+            dotenv.config({ path: envPath });
+        } else {
+            dotenv.config();
+        }
+    } catch {
+        // dotenv may not be installed
+    }
+
+    const databaseUrl = process.env.DATABASE_URL || process.env.ADMIN_CONNECTION_STRING;
+
+    const report = await runDoctor({
+        collectionsPath: path.resolve(process.cwd(), collectionsPath),
+        schemaPath: path.resolve(process.cwd(), schemaPath),
+        databaseUrl: databaseUrl ?? undefined
+    });
+
+    // Exit with non-zero code if there are errors
+    if (report.summary.errors > 0) {
+        process.exit(1);
+    }
+}
+
+main().catch((err) => {
+    console.error(chalk.red("  ✗ Doctor failed:"), err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});