@rebasepro/server-postgresql 0.5.0 → 0.6.0

package/src/data-transformer.ts

@@ -6,6 +6,7 @@ import { getTableName, resolveCollectionRelations, findRelation, createRelationR
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
 import { getPrimaryKeys, buildCompositeId } from "./services/entity-helpers";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Data transformation utilities for converting between frontend and database formats.
@@ -90,7 +91,9 @@ export function serializeDataToServer<M extends Record<string, unknown>>(
     collection?: EntityCollection,
     registry?: PostgresCollectionRegistry
 ): SerializedEntityData {
-    if (!entity || !properties) return { scalarData: entity ?? {}, inverseRelationUpdates: [], joinPathRelationUpdates: [] };
+    if (!entity || !properties) return { scalarData: entity ?? {},
+inverseRelationUpdates: [],
+joinPathRelationUpdates: [] };
 
     const result: Record<string, unknown> = {};
 
@@ -128,7 +131,6 @@ export function serializeDataToServer<M extends Record<string, unknown>>(
         }
 
 
-
         // Handle relation properties specially
         if (property.type === "relation" && collection) {
             const relation = findRelation(resolvedRelations, key);
@@ -320,7 +322,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             const targetCollection = relation.target();
                             result[propKey] = createRelationRef(fkValue.toString(), targetCollection.slug);
                         } catch (e) {
-                            console.warn(`Could not resolve target collection for relation property: ${propKey}`, e);
+                            logger.warn(`Could not resolve target collection for relation property: ${propKey}`, { error: e });
                         }
                     }
                 } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget && db && registry) {
@@ -350,7 +352,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                     } else {
                                         // One-to-many: return array of relation objects
                                         const targetPks = getPrimaryKeys(targetCollection, registry!);
-                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) => 
+                                        result[propKey] = relatedEntities.map((entity: Record<string, unknown>) =>
                                             createRelationRef(buildCompositeId(entity, targetPks), targetCollection.slug)
                                         );
                                     }
@@ -358,7 +360,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             }
                         }
                     } catch (e) {
-                        console.warn(`Could not resolve inverse relation property: ${propKey}`, e);
+                        logger.warn(`Could not resolve inverse relation property: ${propKey}`, { error: e });
                     }
                 } else if (relation.direction === "inverse" && relation.joinPath && db && registry) {
                     // Join path relation: Multi-hop relation using joins
@@ -371,7 +373,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             // Build the join query following the join path
                             const sourceTable = registry.getTable(getTableName(collection));
                             if (!sourceTable) {
-                                console.warn(`Source table not found for collection: ${collection.slug}`);
+                                logger.warn(`Source table not found for collection: ${collection.slug}`);
                                 continue;
                             }
 
@@ -382,7 +384,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             for (const join of relation.joinPath) {
                                 const joinTable = registry.getTable(join.table);
                                 if (!joinTable) {
-                                    console.warn(`Join table not found: ${join.table}`);
+                                    logger.warn(`Join table not found: ${join.table}`);
                                     break;
                                 }
 
@@ -400,7 +402,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                 const toCol = joinTable[toColName as keyof typeof joinTable] as AnyPgColumn;
 
                                 if (!fromCol || !toCol) {
-                                    console.warn(`Join columns not found: ${fromColumn} -> ${toColumn}`);
+                                    logger.warn(`Join columns not found: ${fromColumn} -> ${toColumn}`);
                                     break;
                                 }
 
@@ -414,7 +416,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                                 query = query.where(eq(sourceIdField, currentEntityId)) as typeof query;
                             } else {
                                 // For composite keys, we would need to map the split parts. For now log a warning.
-                                console.warn(`Join path resolution for composite primary keys is not yet fully supported: ${collection.slug}`);
+                                logger.warn(`Join path resolution for composite primary keys is not yet fully supported: ${collection.slug}`);
                             }
 
                             // Build additional conditions array
@@ -453,7 +455,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             }
                         }
                     } catch (e) {
-                        console.warn(`Could not resolve join path relation property: ${propKey}`, e);
+                        logger.warn(`Could not resolve join path relation property: ${propKey}`, { error: e });
                     }
                 }
             }
@@ -519,13 +521,13 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
 
         case "string": {
             if (typeof value === "string") return value;
-            
+
             // Handle Buffer objects (e.g. from PostgreSQL bytea columns)
             const buf = tryResolveBuffer(value);
             if (buf) {
                 return bufferToStringOrBase64(buf);
             }
-            
+
             if (typeof value === "object" && value !== null) {
                 try {
                     return JSON.stringify(value);
@@ -549,7 +551,7 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
                 }
 
                 if (!relationDef) {
-                    console.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
+                    logger.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
                     return value;
                 }
 
@@ -557,7 +559,7 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
                     const targetCollection = relationDef.target();
                     return createRelationRef(value.toString(), targetCollection.slug);
                 } catch (e) {
-                    console.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, e);
+                    logger.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, { error: e });
                     return value;
                 }
             }

package/src/databasePoolManager.ts

@@ -1,6 +1,7 @@
 import { Pool } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 export class DatabasePoolManager {
     private pools: Map<string, Pool> = new Map();
@@ -47,7 +48,7 @@ export class DatabasePoolManager {
 
         // Prevent idle client errors from crashing the Node.js process
         pool.on("error", (err) => {
-            console.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, err);
+            logger.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, { error: err });
         });
 
         this.pools.set(databaseName, pool);
@@ -76,7 +77,7 @@ export class DatabasePoolManager {
     public async shutdown(): Promise<void> {
         const promises = [];
         for (const [dbName, pool] of this.pools.entries()) {
-            console.log(`[DatabasePoolManager] Shutting down pool for ${dbName}`);
+            logger.info(`[DatabasePoolManager] Shutting down pool for ${dbName}`);
             promises.push(pool.end());
         }
         await Promise.all(promises);

package/src/history/HistoryService.ts

@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 export interface HistoryEntry {
     id: string;
@@ -99,10 +100,10 @@ export class HistoryService {
 
             // Non-blocking prune for this specific entity
             this.pruneEntity(tableName, entityId).catch(err =>
-                console.error("History prune failed:", err)
+                logger.error("History prune failed", { error: err })
             );
         } catch (error) {
-            console.error("Failed to record entity history:", error);
+            logger.error("Failed to record entity history", { error: error });
         }
     }
 

package/src/history/ensure-history-table.ts

@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Auto-create the entity history table if it doesn't exist.
@@ -7,7 +8,7 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
  * pattern as `ensureAuthTablesExist`.
  */
 export async function ensureHistoryTableExists(db: NodePgDatabase): Promise<void> {
-    console.log("🔍 Checking entity history table...");
+    logger.info("🔍 Checking entity history table...");
 
     try {
         // Create the rebase schema (idempotent — may already exist from auth init)
@@ -37,9 +38,9 @@ export async function ensureHistoryTableExists(db: NodePgDatabase): Promise<void
             ON rebase.entity_history(table_name, entity_id, updated_at DESC)
         `);
 
-        console.log("✅ Entity history table ready");
+        logger.info("✅ Entity history table ready");
     } catch (error) {
-        console.error("❌ Failed to create entity history table:", error);
-        console.warn("⚠️ Continuing without creating history table.");
+        logger.error("❌ Failed to create entity history table", { error: error });
+        logger.warn("⚠️ Continuing without creating history table.");
     }
 }

package/src/schema/auth-schema.ts

@@ -4,7 +4,7 @@ import { relations } from "drizzle-orm";
 /**
  * Factory function to dynamically create the auth tables bound to the specified schema names.
  */
-export function createAuthSchema(usersSchemaName: string = "rebase") {
+export function createAuthSchema(usersSchemaName = "rebase") {
     const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
     const tableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
@@ -30,7 +30,6 @@ export function createAuthSchema(usersSchemaName: string = "rebase") {
     });
 
 
-
     /**
      * Refresh tokens for long-lived sessions
      */

package/src/schema/doctor-cli.ts

@@ -7,6 +7,7 @@ import path from "path";
 import chalk from "chalk";
 import fs from "fs";
 import { runDoctor } from "./doctor";
+import { logger } from "@rebasepro/server-core";
 
 async function main() {
     const collectionsArg = process.argv.find((a) => a.startsWith("--collections="));
@@ -46,6 +47,6 @@ async function main() {
 }
 
 main().catch((err) => {
-    console.error(chalk.red("  ✗ Doctor failed:"), err instanceof Error ? err.message : String(err));
+    logger.error(chalk.red("  ✗ Doctor failed"), { error: err });
     process.exit(1);
 });

package/src/schema/doctor.ts

@@ -17,6 +17,7 @@ import { generateSchema } from "./generate-drizzle-schema-logic";
 import { generateTypedefs } from "@rebasepro/sdk-generator";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
+import { logger } from "@rebasepro/server-core";
 
 /**
  * Resolve the SQL column name for a property.
@@ -149,7 +150,7 @@ export async function loadCollections(collectionsPath: string): Promise<EntityCo
                     }
                 } catch (err: unknown) {
                     const message = err instanceof Error ? err.message : String(err);
-                    console.error(chalk.yellow(`  ⚠ Could not load ${file}: ${message}`));
+                    logger.error(chalk.yellow(`  ⚠ Could not load ${file}: ${message}`));
                 }
             }
         }
@@ -244,7 +245,8 @@ export async function checkCollectionsVsSdk(
             message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
             fix: "Run `rebase generate-sdk`"
         });
-        return { passed: false, issues };
+        return { passed: false,
+issues };
     }
 
     try {
@@ -277,7 +279,8 @@ export async function checkCollectionsVsSdk(
         });
     }
 
-    return { passed: issues.length === 0, issues };
+    return { passed: issues.length === 0,
+issues };
 }
 
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
@@ -326,7 +329,7 @@ export async function checkCollectionsVsDatabase(
              WHERE table_schema = ANY($1) AND table_type = 'BASE TABLE'`,
             [schemas]
         );
-        const existingTables = new Set(tablesResult.rows.map((r) => 
+        const existingTables = new Set(tablesResult.rows.map((r) =>
             r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`
         ));
 
@@ -457,8 +460,8 @@ export async function checkCollectionsVsDatabase(
                             targetSchemaName = targetColl.schema || "public";
                         } catch { /* ignore */ }
 
-                        const hasFk = tableFks.some((fk) => 
-                            fk.column_name === fkColName && 
+                        const hasFk = tableFks.some((fk) =>
+                            fk.column_name === fkColName &&
                             fk.foreign_table_name === targetTableName &&
                             fk.foreign_table_schema === targetSchemaName
                         );
@@ -615,10 +618,10 @@ issues };
 // ── Report Rendering ─────────────────────────────────────────────────────
 
 export function renderReport(report: DoctorReport): void {
-    console.log("");
-    console.log(chalk.bold("  🩺 Rebase Schema Doctor"));
-    console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
-    console.log("");
+    logger.info("");
+    logger.info(chalk.bold("  🩺 Rebase Schema Doctor"));
+    logger.info(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    logger.info("");
 
     // Phase 1
     renderPhase(
@@ -642,7 +645,7 @@ export function renderReport(report: DoctorReport): void {
     );
 
     // Summary
-    console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
+    logger.info(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
     const { passed, warnings, errors } = report.summary;
 
     const parts: string[] = [];
@@ -650,50 +653,50 @@ export function renderReport(report: DoctorReport): void {
     if (warnings > 0) parts.push(chalk.yellow(`${warnings} warnings`));
     if (errors > 0) parts.push(chalk.red(`${errors} errors`));
 
-    console.log(`  Summary: ${parts.join(", ")}`);
-    console.log("");
+    logger.info(`  Summary: ${parts.join(", ")}`);
+    logger.info("");
 
     if (errors > 0) {
-        console.log(chalk.red.bold("  ✗ Schema drift detected. Run the suggested fixes above."));
+        logger.info(chalk.red.bold("  ✗ Schema drift detected. Run the suggested fixes above."));
     } else if (warnings > 0) {
-        console.log(chalk.yellow.bold("  ⚠ Minor issues detected. Consider running the suggested fixes."));
+        logger.info(chalk.yellow.bold("  ⚠ Minor issues detected. Consider running the suggested fixes."));
     } else {
-        console.log(chalk.green.bold("  ✓ All schemas are in sync!"));
+        logger.info(chalk.green.bold("  ✓ All schemas are in sync!"));
     }
-    console.log("");
+    logger.info("");
 }
 
 function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): void {
     if (passed) {
-        console.log(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
+        logger.info(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
     } else {
         const errorCount = issues.filter((i) => i.severity === "error").length;
         const warnCount = issues.filter((i) => i.severity === "warning").length;
         const parts: string[] = [];
         if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
         if (warnCount > 0) parts.push(`${warnCount} warning${warnCount > 1 ? "s" : ""}`);
-        console.log(`  ${chalk.yellow("⚠️")}  ${label}: ${chalk.yellow(parts.join(", "))}`);
+        logger.info(`  ${chalk.yellow("⚠️")}  ${label}: ${chalk.yellow(parts.join(", "))}`);
     }
-    console.log("");
+    logger.info("");
 
     for (const issue of issues) {
         const severityIcon = issue.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
         const categoryLabel = formatCategory(issue.category);
-        console.log(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
+        logger.info(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
 
         if (issue.table) {
             const colPart = issue.column ? ` │ Column: ${chalk.cyan(issue.column)}` : "";
-            console.log(`  ${chalk.gray("│")} Table: ${chalk.cyan(issue.table)}${colPart}`);
+            logger.info(`  ${chalk.gray("│")} Table: ${chalk.cyan(issue.table)}${colPart}`);
         }
 
         if (issue.expected && issue.actual) {
-            console.log(`  ${chalk.gray("│")} Expected: ${chalk.green(issue.expected)} │ Actual: ${chalk.red(issue.actual)}`);
+            logger.info(`  ${chalk.gray("│")} Expected: ${chalk.green(issue.expected)} │ Actual: ${chalk.red(issue.actual)}`);
         }
 
-        console.log(`  ${chalk.gray("│")} ${issue.message}`);
-        console.log(`  ${chalk.gray("│")} Fix: ${chalk.blue(issue.fix)}`);
-        console.log(`  ${chalk.gray("└" + "─".repeat(48))}`);
-        console.log("");
+        logger.info(`  ${chalk.gray("│")} ${issue.message}`);
+        logger.info(`  ${chalk.gray("│")} Fix: ${chalk.blue(issue.fix)}`);
+        logger.info(`  ${chalk.gray("└" + "─".repeat(48))}`);
+        logger.info("");
     }
 }
 
@@ -720,33 +723,33 @@ export async function runDoctor(options: {
     sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport> {
-    console.log("");
-    console.log(chalk.bold("  🩺 Loading collections..."));
+    logger.info("");
+    logger.info(chalk.bold("  🩺 Loading collections..."));
     const collections = await loadCollections(options.collectionsPath);
     if (collections.length === 0) {
-        console.error(chalk.red("  ✗ No collections found."));
+        logger.error(chalk.red("  ✗ No collections found."));
         process.exit(1);
     }
-    console.log(chalk.gray(`  Found ${collections.length} collection(s)`));
-    console.log("");
+    logger.info(chalk.gray(`  Found ${collections.length} collection(s)`));
+    logger.info("");
 
     // Phase 1: Collections ↔ Generated Schema
-    console.log(chalk.gray("  Checking Collections → Generated Schema..."));
+    logger.info(chalk.gray("  Checking Collections → Generated Schema..."));
     const collectionsToSchema = await checkCollectionsVsSchema(collections, options.schemaPath);
 
     // Phase 2: Collections ↔ Database (only if we have a DATABASE_URL)
     let schemaToDatabase: { passed: boolean; issues: DoctorIssue[] } = { passed: true,
 issues: [] };
     if (options.databaseUrl) {
-        console.log(chalk.gray("  Checking Collections → Database..."));
+        logger.info(chalk.gray("  Checking Collections → Database..."));
         schemaToDatabase = await checkCollectionsVsDatabase(collections, options.databaseUrl);
     } else {
-        console.log(chalk.yellow("  ⚠ DATABASE_URL not set — skipping database comparison."));
-        console.log(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
+        logger.info(chalk.yellow("  ⚠ DATABASE_URL not set — skipping database comparison."));
+        logger.info(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
     }
 
     // Phase 3: Collections ↔ SDK Types
-    console.log(chalk.gray("  Checking Collections → SDK Types..."));
+    logger.info(chalk.gray("  Checking Collections → SDK Types..."));
     const collectionsToSdk = await checkCollectionsVsSdk(collections, options.sdkPath);
 
     const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues, ...collectionsToSdk.issues];

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

@@ -3,6 +3,7 @@ import { getPrimaryKeys } from "../services/entity-helpers";
 import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 import { createHash } from "crypto";
+import { logger } from "@rebasepro/server-core";
 // --- Helper Functions ---
 
 /**
@@ -41,6 +42,31 @@ type: "string",
 isUuid: isUuid ?? false };
 };
 
+/**
+ * Given a raw DB column name (e.g. "client_id"), find the Drizzle property key
+ * on the collection that maps to that column. A property matches if:
+ *   (a) it has an explicit `columnName` equal to the given column, OR
+ *   (b) its snake_case form equals the given column.
+ *
+ * Returns the property key (the Drizzle object key) if found, or the original
+ * column name as a fallback.
+ */
+const resolvePropertyKeyForColumn = (collection: EntityCollection, column: string): string => {
+    if (!collection.properties) return column;
+    for (const [propKey, prop] of Object.entries(collection.properties)) {
+        const p = prop as Property;
+        // Explicit columnName match
+        if ("columnName" in p && typeof (p as unknown as Record<string, unknown>).columnName === "string") {
+            if ((p as unknown as Record<string, unknown>).columnName === column) return propKey;
+        }
+        // Convention match: snake_case(propKey) === column
+        if (toSnakeCase(propKey) === column) return propKey;
+        // Exact match (propKey is already the column name)
+        if (propKey === column) return propKey;
+    }
+    return column;
+};
+
 const isNumericId = (collection: EntityCollection): boolean => {
     return getPrimaryKeyProp(collection).type === "number";
 };
@@ -143,7 +169,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             // autoValue: database-level default for initial value on INSERT
             if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
-                columnDefinition += `.default(sql\`now()\`)`;
+                columnDefinition += ".default(sql`now()`)";
             }
             break;
         }
@@ -206,7 +232,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
 
             // The localKey property is the source of truth for the FK column name.
             if (!relation.localKey) {
-                console.warn(`Could not generate column for owning relation '${relation.relationName}' on '${collection.name}': 'localKey' is not defined.`);
+                logger.warn(`Could not generate column for owning relation '${relation.relationName}' on '${collection.name}': 'localKey' is not defined.`);
                 return null;
             }
 
@@ -296,7 +322,7 @@ const resolveRawSql = (expression: string): string => {
  */
 const wrapWithRoleCheck = (clause: string, roles: string[]): string => {
     const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-    const roleCondition = `string_to_array(auth.roles(), ',') @> ${rolesArrayString}`;
+    const roleCondition = `string_to_array(auth.roles(), ',') && ${rolesArrayString}`;
     return `sql\`(${unwrapSql(clause)}) AND (${roleCondition})\``;
 };
 
@@ -410,13 +436,13 @@ const generateSinglePolicyCode = (collection: EntityCollection, rule: SecurityRu
         } else if (needsUsing) {
             // Roles-only rule (e.g. { operation: "select", roles: ["admin"] })
             const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-            usingClause = `sql\`string_to_array(auth.roles(), ',') @> ${rolesArrayString}\``;
+            usingClause = `sql\`string_to_array(auth.roles(), ',') && ${rolesArrayString}\``;
         }
         if (withCheckClause) {
             withCheckClause = wrapWithRoleCheck(withCheckClause, roles);
         } else if (needsWithCheck) {
             const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
-            withCheckClause = `sql\`string_to_array(auth.roles(), ',') @> ${rolesArrayString}\``;
+            withCheckClause = `sql\`string_to_array(auth.roles(), ',') && ${rolesArrayString}\``;
         }
     }
 
@@ -466,15 +492,22 @@ const computeSharedRelationName = (
 
     // --- owning one (belongs-to) ---
     if (rel.direction === "owning" && rel.cardinality === "one" && rel.localKey) {
-        return `${getTableName(sourceCollection)}_${rel.localKey}`;
+        // Normalise the localKey to the actual Drizzle property name so that
+        // the owning side produces the same relation name as the inverse side
+        // (which resolves foreignKeyOnTarget via the same helper).
+        const normalisedKey = resolvePropertyKeyForColumn(sourceCollection, rel.localKey);
+        return `${getTableName(sourceCollection)}_${normalisedKey}`;
     }
 
     // --- inverse many (one-to-many has-many) ---
     if (rel.direction === "inverse" && rel.cardinality === "many" && rel.foreignKeyOnTarget) {
-        // The owning table is the *target*, the FK column is foreignKeyOnTarget
+        // The owning table is the *target*, the FK column is foreignKeyOnTarget.
+        // Resolve to the Drizzle property key on the target so it matches the
+        // owning side's normalised localKey.
         try {
             const targetCollection = rel.target();
-            return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+            const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
+            return `${getTableName(targetCollection)}_${normalisedFK}`;
         } catch {
             return fallback;
         }
@@ -483,10 +516,11 @@ const computeSharedRelationName = (
     // --- inverse one (one-to-one inverse) ---
     if (rel.direction === "inverse" && rel.cardinality === "one") {
         if (rel.foreignKeyOnTarget) {
-            // FK lives on the target table
+            // FK lives on the target table — resolve to Drizzle property key
             try {
                 const targetCollection = rel.target();
-                return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+                const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
+                return `${getTableName(targetCollection)}_${normalisedFK}`;
             } catch {
                 return fallback;
             }
@@ -521,7 +555,6 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
 
-
     const hasUuid = collections.some(c =>
         c.properties && Object.values(c.properties).some(
             (p: Property) => p.type === "string" && ((p as unknown as Record<string, unknown>).autoValue === "uuid" || (p as unknown as Record<string, unknown>).isId === "uuid")
@@ -812,23 +845,23 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                                     const junctionTableVar = getTableVarName(correspondingRelation.through.table);
                                     tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
                                 } else {
-                                    console.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
+                                    logger.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
                                 }
                             } catch (e) {
-                                console.warn(`Could not resolve inverse many-to-many relation '${relationKey}':`, e);
+                                logger.warn(`Could not resolve inverse many-to-many relation '${relationKey}'`, { error: e });
                             }
                         }
                         // joinPath relations don't generate Drizzle relations - they use existing user tables
                     }
                 } catch (e) {
-                    console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, e);
+                    logger.warn(`Could not generate relation ${relationKey} for ${collection.name}`, { error: e });
                 }
             }
 
             // Synthesize missing reciprocal relations
             for (const otherCollection of collections) {
                 if (otherCollection.slug === collection.slug) continue;
-                
+
                 const otherRelations = resolveCollectionRelations(otherCollection);
                 for (const [otherKey, otherRel] of Object.entries(otherRelations)) {
                     if (otherRel.direction === "inverse" && otherRel.foreignKeyOnTarget) {
@@ -837,11 +870,16 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                             if (otherTarget.slug === collection.slug) {
                                 const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
                                 const deduplicationKey = `${drizzleRelationName}::owning`;
-                                
+
                                 if (!emittedRelationNames.has(deduplicationKey)) {
                                     const otherTableVar = getTableVarName(getTableName(otherCollection));
-                                    const synthKey = `_synth_${otherTableVar}_${otherRel.foreignKeyOnTarget}`;
-                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${otherRel.foreignKeyOnTarget}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    // Resolve foreignKeyOnTarget to the Drizzle property key
+                                    // on THIS collection (the owning table). The raw FK column
+                                    // name (e.g. "client_id") may differ from the property key
+                                    // (e.g. "clientId") when `columnName` is set.
+                                    const drizzleFieldKey = resolvePropertyKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+                                    const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
+                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                                     emittedRelationNames.add(deduplicationKey);
                                 }
                             }