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

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

@@ -1,23 +1,32 @@
-import { EntityCollection, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty } from "@rebasepro/types";
+import { EntityCollection, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollection, DateProperty, ArrayProperty, MapProperty, ReferenceProperty } from "@rebasepro/types";
 import { getPrimaryKeys } from "../services/entity-helpers";
-import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations } from "@rebasepro/common";
+import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
-
+import { createHash } from "crypto";
 // --- Helper Functions ---
 
-const getPrimaryKeyProp = (collection: EntityCollection): { name: string, type: "string" | "number" } => {
+const getPrimaryKeyProp = (collection: EntityCollection): { name: string, type: "string" | "number", isUuid: boolean } => {
     if (collection.properties) {
         const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in (prop as object) && Boolean((prop as unknown as Record<string, unknown>).isId));
         if (idPropEntry) {
-            return { name: idPropEntry[0], type: (idPropEntry[1] as Property).type === "number" ? "number" : "string" };
+            const prop = idPropEntry[1] as Property;
+            const isUuid = prop.type === "string" && "isId" in prop && (prop as StringProperty).isId === "uuid";
+            return { name: idPropEntry[0],
+type: prop.type === "number" ? "number" : "string",
+isUuid };
         }
     }
     // Fallback
     const idProp = collection.properties?.["id"] as Property | undefined;
     if (idProp?.type === "number") {
-        return { name: "id", type: "number" };
+        return { name: "id",
+type: "number",
+isUuid: false };
     }
-    return { name: "id", type: "string" };
+    const isUuid = idProp?.type === "string" && "isId" in idProp && (idProp as StringProperty).isId === "uuid";
+    return { name: "id",
+type: "string",
+isUuid: isUuid ?? false };
 };
 
 const isNumericId = (collection: EntityCollection): boolean => {
@@ -36,7 +45,7 @@ const isIdProperty = (propName: string, prop: Property, collection: EntityCollec
     return !hasExplicitId && propName === "id";
 };
 
-const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCollection): string | null => {
+const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCollection, collections: EntityCollection[]): string | null => {
     const colName = toSnakeCase(propName);
     let columnDefinition: string;
 
@@ -56,13 +65,13 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 columnDefinition = `varchar("${colName}")`;
             }
             if (isIdProperty(propName, prop, collection)) {
-                columnDefinition += `.primaryKey()`;
+                columnDefinition += ".primaryKey()";
             }
             if ("isId" in stringProp && stringProp.isId !== "manual" && stringProp.isId !== true) {
                 if (stringProp.isId === "uuid") {
-                    columnDefinition += `.defaultRandom()`;
+                    columnDefinition += ".defaultRandom()";
                 } else if (stringProp.isId === "cuid") {
-                    columnDefinition += `.default(sql\`cuid()\`)`;
+                    columnDefinition += ".default(sql`cuid()`)";
                 } else if (typeof stringProp.isId === "string") {
                     const sqlContent = stringProp.isId.startsWith("sql`") && stringProp.isId.endsWith("`")
                         ? stringProp.isId.substring(4, stringProp.isId.length - 1)
@@ -71,7 +80,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 }
             }
             if (stringProp.validation?.unique) {
-                columnDefinition += `.unique()`;
+                columnDefinition += ".unique()";
             }
             break;
         }
@@ -98,10 +107,10 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
 
             if (isId) {
-                columnDefinition += `.primaryKey()`;
+                columnDefinition += ".primaryKey()";
             }
             if (numProp.validation?.unique) {
-                columnDefinition += `.unique()`;
+                columnDefinition += ".unique()";
             }
             break;
         }
@@ -109,7 +118,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             columnDefinition = `boolean("${colName}")`;
             break;
         case "date": {
-            const dateProp = prop as import("@rebasepro/types").DateProperty;
+            const dateProp = prop as DateProperty;
             if (dateProp.columnType === "date") {
                 columnDefinition = `date("${colName}", { mode: 'string' })`;
             } else if (dateProp.columnType === "time") {
@@ -121,7 +130,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
         }
         case "map":
         case "array": {
-            const arrayOrMapProp = prop as import("@rebasepro/types").ArrayProperty | import("@rebasepro/types").MapProperty;
+            const arrayOrMapProp = prop as ArrayProperty | MapProperty;
             if (arrayOrMapProp.columnType === "json") {
                 columnDefinition = `json("${colName}")`;
             } else {
@@ -131,8 +140,8 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
         }
         case "relation": {
             const refProp = prop as RelationProperty;
-            const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
-            const relation = resolvedRelations[refProp.relationName ?? propName];
+            const resolvedRelations = resolveCollectionRelations(collection);
+            const relation = findRelation(resolvedRelations, refProp.relationName ?? propName);
 
             // Only owning one-to-one/many-to-one relations create a column here.
             if (!relation || relation.direction !== "owning" || relation.cardinality !== "one") {
@@ -160,10 +169,11 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
 
             const fkColumnName = toSnakeCase(relation.localKey);
             const targetTableVar = getTableVarName(getTableName(targetCollection));
-            const targetIdField = getPrimaryKeyName(targetCollection);
-            const baseColumn = isNumericId(targetCollection) ? `integer(\"${fkColumnName}\")` : `varchar(\"${fkColumnName}\")`;
+            const pkProp = getPrimaryKeyProp(targetCollection);
+            const targetIdField = pkProp.name;
+            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `varchar("${fkColumnName}")`);
 
-            const onUpdate = relation.onUpdate ? `onUpdate: \"${relation.onUpdate}\"` : "";
+            const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
             const required = prop.validation?.required;
             const onDeleteVal = relation.onDelete ?? (required ? "cascade" : "set null");
             const onDelete = `onDelete: \"${onDeleteVal}\"`;
@@ -179,6 +189,30 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
 
             return `    ${relation.localKey}: ${columnDef}`;
         }
+        case "reference": {
+            const refProp = prop as ReferenceProperty;
+            const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
+            if (!targetCollection) {
+                columnDefinition = `varchar("${colName}")`;
+                break;
+            }
+
+            const pkProp = getPrimaryKeyProp(targetCollection);
+            const targetTableVar = getTableVarName(getTableName(targetCollection));
+            const targetIdField = pkProp.name;
+            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `varchar("${colName}")`);
+
+            const required = prop.validation?.required;
+            const onDelete = required ? "cascade" : "set null";
+            const refOptions = `{ onDelete: "${onDelete}" }`;
+
+            columnDefinition = `${baseColumn}.references(() => ${targetTableVar}.${targetIdField}, ${refOptions})`;
+            if (required) {
+                columnDefinition += ".notNull()";
+            }
+            // Skip the standard notNull() handling below because we did it here with references
+            return `    ${propName}: ${columnDefinition}`;
+        }
         default:
             return null;
     }
@@ -205,7 +239,7 @@ const resolveRawSql = (expression: string): string => {
  * Generates: `(<clause>) AND (string_to_array(auth.roles(), ',') && ARRAY['<role1>','<role2>'])`
  */
 const wrapWithRoleCheck = (clause: string, roles: string[]): string => {
-    const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(',')}]`;
+    const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
     const roleCondition = `string_to_array(auth.roles(), ',') @> ${rolesArrayString}`;
     return `sql\`(${unwrapSql(clause)}) AND (${roleCondition})\``;
 };
@@ -226,7 +260,7 @@ const buildUsingClause = (rule: SecurityRule): string | null => {
         return resolveRawSql(rule.using);
     }
     if (rule.access === "public") {
-        return `sql\`true\``;
+        return "sql`true`";
     }
     if (rule.ownerField) {
         return `sql\`\${table.${rule.ownerField}} = auth.uid()\``;
@@ -246,6 +280,24 @@ const buildWithCheckClause = (rule: SecurityRule): string | null => {
     return buildUsingClause(rule);
 };
 
+/**
+ * Generates a deterministic hash based on the rule configuration.
+ */
+const getPolicyNameHash = (rule: SecurityRule): string => {
+    const data = JSON.stringify({
+        a: rule.access,
+        m: rule.mode,
+        op: rule.operation,
+        ops: rule.operations?.slice().sort(),
+        own: rule.ownerField,
+        rol: rule.roles?.slice().sort(),
+        pg: rule.pgRoles?.slice().sort(),
+        u: rule.using,
+        w: rule.withCheck
+    });
+    return createHash("sha1").update(data).digest("hex").substring(0, 7);
+};
+
 /**
  * Generates Drizzle pgPolicy() calls from a declarative SecurityRule definition.
  *
@@ -262,11 +314,13 @@ const generatePolicyCode = (tableName: string, rule: SecurityRule, index: number
         ? rule.operations
         : [rule.operation ?? "all"];
 
+    const ruleHash = getPolicyNameHash(rule);
+
     // Generate one pgPolicy per operation
     return ops.map((op, opIdx) => {
         const policyName = rule.name
             ? (ops.length > 1 ? `${rule.name}_${op}` : rule.name)
-            : `${tableName}_${op}_policy_${index}${ops.length > 1 ? `_${opIdx}` : ""}`;
+            : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`;
 
         return generateSinglePolicyCode(tableName, rule, op, policyName);
     }).join("");
@@ -277,7 +331,7 @@ const generatePolicyCode = (tableName: string, rule: SecurityRule, index: number
  */
 const generateSinglePolicyCode = (tableName: string, rule: SecurityRule, operation: SecurityOperation, policyName: string): string => {
     const mode = rule.mode ?? "permissive";
-    const roles = rule.roles;
+    const roles = rule.roles ? [...rule.roles].sort() : undefined;
 
     // Determine which clauses this operation needs:
     // SELECT, DELETE → USING only
@@ -296,30 +350,30 @@ const generateSinglePolicyCode = (tableName: string, rule: SecurityRule, operati
             usingClause = wrapWithRoleCheck(usingClause, roles);
         } else if (needsUsing) {
             // Roles-only rule (e.g. { operation: "select", roles: ["admin"] })
-            const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(',')}]`;
+            const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
             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(',')}]`;
+            const rolesArrayString = `ARRAY[${roles.map(r => `'${r}'`).join(",")}]`;
             withCheckClause = `sql\`string_to_array(auth.roles(), ',') @> ${rolesArrayString}\``;
         }
     }
 
     // Fallback: if we still have no clauses, deny all (safety net)
     if (!usingClause && needsUsing) {
-        usingClause = `sql\`false\``;
+        usingClause = "sql`false`";
     }
     if (!withCheckClause && needsWithCheck) {
-        withCheckClause = `sql\`false\``;
+        withCheckClause = "sql`false`";
     }
 
     // Build the policy options object
     const parts: string[] = [];
     parts.push(`as: "${mode}"`);
     parts.push(`for: "${operation}"`);
-    const toRoles = rule.pgRoles ?? ["public"];
+    const toRoles = rule.pgRoles ? [...rule.pgRoles].sort() : ["public"];
     parts.push(`to: [${toRoles.map(r => `"${r}"`).join(", ")}]`);
     if (usingClause) parts.push(`using: ${usingClause}`);
     if (withCheckClause) parts.push(`withCheck: ${withCheckClause}`);
@@ -327,8 +381,84 @@ const generateSinglePolicyCode = (tableName: string, rule: SecurityRule, operati
     return `    pgPolicy("${policyName}", { ${parts.join(", ")} }),\n`;
 };
 
+/**
+ * Computes a deterministic shared relation name for Drizzle.
+ *
+ * Drizzle requires both sides of a relation (owning + inverse) to use the
+ * exact same `relationName` string so it can pair them. Each collection
+ * definition may use a different local `relationName`, so we need a canonical
+ * form that both sides can independently compute.
+ *
+ * Strategy: `{owningTable}_{foreignKey}`
+ *   - owning  side → `{thisTable}_{localKey}`           e.g. "jobs_company_id"
+ *   - inverse side → `{targetTable}_{foreignKeyOnTarget}` e.g. "jobs_company_id"
+ *
+ * For M2M with junction tables the owning relation name is already shared via
+ * the junction table wiring, so we keep it as-is.
+ *
+ * Falls back to the local relation name when the counterpart can't be resolved.
+ */
+const computeSharedRelationName = (
+    rel: Relation,
+    sourceCollection: EntityCollection,
+    _collections: EntityCollection[]
+): string => {
+    const fallback = rel.relationName ?? toSnakeCase(rel.target().slug);
+
+    // --- owning one (belongs-to) ---
+    if (rel.direction === "owning" && rel.cardinality === "one" && rel.localKey) {
+        return `${getTableName(sourceCollection)}_${rel.localKey}`;
+    }
+
+    // --- 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
+        try {
+            const targetCollection = rel.target();
+            return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+        } catch {
+            return fallback;
+        }
+    }
+
+    // --- inverse one (one-to-one inverse) ---
+    if (rel.direction === "inverse" && rel.cardinality === "one") {
+        if (rel.foreignKeyOnTarget) {
+            // FK lives on the target table
+            try {
+                const targetCollection = rel.target();
+                return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+            } catch {
+                return fallback;
+            }
+        }
+        // No explicit foreignKeyOnTarget — try to find the corresponding owning relation
+        try {
+            const targetCollection = rel.target();
+            const targetResolvedRelations = resolveCollectionRelations(targetCollection);
+            const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
+                targetRel.direction === "owning" &&
+                targetRel.cardinality === "one" &&
+                targetRel.localKey &&
+                targetRel.target().slug === sourceCollection.slug
+            );
+            if (correspondingRelation && correspondingRelation.localKey) {
+                return `${getTableName(targetCollection)}_${correspondingRelation.localKey}`;
+            }
+        } catch {
+            // ignore
+        }
+        return fallback;
+    }
+
+    // --- M2M owning (through) — keep local name (already shared via junction wiring) ---
+    // --- M2M inverse — keep local name ---
+    // --- joinPath — not emitted as Drizzle relations ---
+    return fallback;
+};
+
 // --- Main Schema Generation Logic ---
-export const generateSchema = async (collections: EntityCollection[]): Promise<string> => {
+export const generateSchema = async (collections: EntityCollection[], stripPolicies = false): Promise<string> => {
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
     const hasUuid = collections.some(c =>
@@ -347,7 +477,7 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
     const pgCoreImports = ["primaryKey", "pgTable", "integer", "varchar", "text", "char", "boolean", "timestamp", "date", "time", "jsonb", "json", "pgEnum", "numeric", "real", "doublePrecision", "bigint", "serial", "bigserial", "pgPolicy"];
     if (hasUuid) pgCoreImports.push("uuid");
     schemaContent += `import { ${pgCoreImports.join(", ")} } from 'drizzle-orm/pg-core';\n`;
-    schemaContent += `import { relations as drizzleRelations, sql } from 'drizzle-orm';\n\n`;
+    schemaContent += "import { relations as drizzleRelations, sql } from 'drizzle-orm';\n\n";
 
     const exportedTableVars: string[] = [];
     const exportedEnumVars: string[] = [];
@@ -386,7 +516,7 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
             allTablesToGenerate.set(tableName, { collection });
         }
 
-        const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+        const resolvedRelations = resolveCollectionRelations(collection);
         for (const relation of Object.values(resolvedRelations)) {
             if (relation.through) { // Standard M2M junction table
                 const junctionTableName = relation.through.table;
@@ -424,22 +554,22 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
             const onDelete = relation.onDelete ?? "cascade";
             const refOptions = `{ onDelete: \"${onDelete}\" }`;
 
-            const sourceColType = isNumericId(sourceCollection) ? "integer" : "varchar";
-            const targetColType = isNumericId(targetCollection) ? "integer" : "varchar";
+            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "varchar");
+            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "varchar");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
             schemaContent += `export const ${tableVarName} = pgTable(\"${tableName}\", {\n`;
             schemaContent += `    ${sourceColumn}: ${sourceColType}(\"${toSnakeCase(sourceColumn)}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
             schemaContent += `    ${targetColumn}: ${targetColType}(\"${toSnakeCase(targetColumn)}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
-            schemaContent += `}, (table) => ({\n`;
+            schemaContent += "}, (table) => ({\n";
             schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })\n`;
-            schemaContent += `}));\n\n`;
+            schemaContent += "}));\n\n";
         } else if (!isJunction) {
             schemaContent += `export const ${tableVarName} = pgTable(\"${tableName}\", {\n`;
             const columns = new Set<string>();
             Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
-                const columnString = getDrizzleColumn(propName, prop as Property, collection);
+                const columnString = getDrizzleColumn(propName, prop as Property, collection, collections);
                 if (columnString) columns.add(columnString);
             });
 
@@ -447,13 +577,13 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
             // We should generate a basic id column if one was completely omitted.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));
             if (!hasIdColumn) {
-                columns.add(`    id: varchar(\"id\").primaryKey()`);
+                columns.add("    id: varchar(\"id\").primaryKey()");
             }
 
             schemaContent += `${Array.from(columns).join(",\n")}`;
 
-            const securityRules = (collection as import("@rebasepro/types").PostgresCollection<Record<string, unknown>, import("@rebasepro/types").User>).securityRules;
-            if (securityRules && securityRules.length > 0) {
+            const securityRules = isPostgresCollection(collection) ? collection.securityRules : undefined;
+            if (!stripPolicies && securityRules && securityRules.length > 0) {
                 schemaContent += "\n}, (table) => ([\n";
                 securityRules.forEach((rule: SecurityRule, idx: number) => {
                     schemaContent += generatePolicyCode(tableName, rule, idx);
@@ -500,7 +630,7 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
                 // inverse many() on the target table.
                 let inverseRelationName: string | null = null;
                 try {
-                    const targetRelations = resolveCollectionRelations(targetCollection as import("@rebasepro/types").PostgresCollection<any, any>);
+                    const targetRelations = resolveCollectionRelations(targetCollection);
                     for (const [, targetRel] of Object.entries(targetRelations)) {
                         if (targetRel.direction === "inverse" &&
                             targetRel.cardinality === "many" &&
@@ -514,37 +644,54 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
                 }
 
                 // Source side one(): pairs with owning table's many(junctionTable, { relationName })
-                tableRelations.push(`    ${relation.through.sourceColumn}: one(${sourceTableVar}, {\n        fields: [${tableVarName}.${relation.through.sourceColumn}],\n        references: [${sourceTableVar}.${sourceId}],\n        relationName: \"${owningRelationName}\"\n    })`);
+                tableRelations.push(`    "${relation.through.sourceColumn}": one(${sourceTableVar}, {\n        fields: [${tableVarName}.${relation.through.sourceColumn}],\n        references: [${sourceTableVar}.${sourceId}],\n        relationName: \"${owningRelationName}\"\n    })`);
 
                 // Target side one(): pairs with inverse table's many(junctionTable, { relationName })
                 const targetRelName = inverseRelationName ?? owningRelationName;
-                tableRelations.push(`    ${relation.through.targetColumn}: one(${targetTableVar}, {\n        fields: [${tableVarName}.${relation.through.targetColumn}],\n        references: [${targetTableVar}.${targetId}],\n        relationName: \"${targetRelName}\"\n    })`);
+                tableRelations.push(`    "${relation.through.targetColumn}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${relation.through.targetColumn}],\n        references: [${targetTableVar}.${targetId}],\n        relationName: \"${targetRelName}\"\n    })`);
             }
         } else {
-            const resolvedRelations = resolveCollectionRelations(collection as import("@rebasepro/types").PostgresCollection<any, any>);
+            const resolvedRelations = resolveCollectionRelations(collection);
+            // Defensive safety net: track emitted `drizzleRelationName` values
+            // to prevent duplicate one()/many() entries in the generated schema.
+            // The root deduplication happens inside resolveCollectionRelations,
+            // but this guards against any future regressions in that utility.
+            const emittedRelationNames = new Set<string>();
             for (const [relationKey, rel] of Object.entries(resolvedRelations)) {
                 try {
                     const target = rel.target();
                     const targetTableVar = getTableVarName(getTableName(target));
-                    const relationName = rel.relationName ?? relationKey;
 
-                    // Determine the correct relation name for Drizzle
-                    // For inverse relations, we should use the current relation's name, not the inverse name
-                    const drizzleRelationName = relationName;
+                    // Compute a deterministic shared relationName for Drizzle.
+                    // Both sides of an owning/inverse pair MUST share the same
+                    // relationName, otherwise Drizzle cannot pair them.
+                    //
+                    // Strategy: use "{ownerTable}_{foreignKey}" which is
+                    // computable from either side:
+                    //   - owning side:  {thisTable}_{localKey}
+                    //   - inverse side: {targetTable}_{foreignKeyOnTarget}
+                    const drizzleRelationName = computeSharedRelationName(rel, collection, collections);
+
+                    // Skip if we've already emitted a relation with this drizzleRelationName
+                    // for this table — prevents duplicate definitions when
+                    // resolveCollectionRelations returns alias entries for the same FK.
+                    const deduplicationKey = `${drizzleRelationName}::${rel.direction}`;
+                    if (emittedRelationNames.has(deduplicationKey)) continue;
+                    emittedRelationNames.add(deduplicationKey);
 
                     if (rel.cardinality === "one") {
                         if (rel.direction === "owning" && rel.localKey) {
-                            tableRelations.push(`    ${relationKey}: one(${targetTableVar}, {\n        fields: [${tableVarName}.${rel.localKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${rel.localKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                         } else if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
                             const sourceIdField = getPrimaryKeyName(collection);
-                            tableRelations.push(`    ${relationKey}: one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${rel.foreignKeyOnTarget}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${rel.foreignKeyOnTarget}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                         } else if (rel.direction === "inverse" && !rel.foreignKeyOnTarget) {
                             // Handle inverse one-to-one relations where the FK is on the target table
                             // but foreignKeyOnTarget is not explicitly specified
                             // In this case, we need to find the corresponding owning relation on the target
                             try {
                                 const targetCollection = rel.target();
-                                const targetResolvedRelations = resolveCollectionRelations(targetCollection as import("@rebasepro/types").PostgresCollection<any, any>);
+                                const targetResolvedRelations = resolveCollectionRelations(targetCollection);
 
                                 // Find the owning relation on the target that points back to this collection
                                 const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
@@ -555,7 +702,7 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
 
                                 if (correspondingRelation && correspondingRelation.localKey) {
                                     const sourceIdField = getPrimaryKeyName(collection);
-                                    tableRelations.push(`    ${relationKey}: one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${correspondingRelation.localKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${sourceIdField}],\n        references: [${targetTableVar}.${correspondingRelation.localKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                                 }
                             } catch (e) {
                                 console.warn(`Could not resolve inverse one-to-one relation '${relationKey}':`, e);
@@ -564,16 +711,16 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
                     } else if (rel.cardinality === "many") {
                         if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
                             // One-to-many inverse relation
-                            tableRelations.push(`    ${relationKey}: many(${targetTableVar}, { relationName: \"${drizzleRelationName}\" })`);
+                            tableRelations.push(`    "${relationKey}": many(${targetTableVar}, { relationName: \"${drizzleRelationName}\" })`);
                         } else if (rel.through) {
                             // Many-to-many owning relation with explicit junction table
                             const junctionTableVar = getTableVarName(rel.through.table);
-                            tableRelations.push(`    ${relationKey}: many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
+                            tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
                         } else if (rel.direction === "inverse" && rel.inverseRelationName) {
                             // Many-to-many inverse relation - find the corresponding owning relation's junction table
                             try {
                                 const targetCollection = rel.target();
-                                const targetResolvedRelations = resolveCollectionRelations(targetCollection as import("@rebasepro/types").PostgresCollection<any, any>);
+                                const targetResolvedRelations = resolveCollectionRelations(targetCollection);
 
                                 // Find the corresponding owning many-to-many relation on the target
                                 const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
@@ -585,7 +732,7 @@ export const generateSchema = async (collections: EntityCollection[]): Promise<s
 
                                 if (correspondingRelation && correspondingRelation.through) {
                                     const junctionTableVar = getTableVarName(correspondingRelation.through.table);
-                                    tableRelations.push(`    ${relationKey}: many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
+                                    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}'`);
                                 }

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

@@ -58,15 +58,15 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
         if (stats.isDirectory()) {
             const files = fs.readdirSync(resolvedPath);
             for (const file of files) {
-                if ((file.endsWith('.ts') || file.endsWith('.js')) &&
-                    !file.includes('.test.') &&
-                    !file.endsWith('.d.ts') &&
-                    file !== 'index.ts' && file !== 'index.js') {
+                if ((file.endsWith(".ts") || file.endsWith(".js")) &&
+                    !file.includes(".test.") &&
+                    !file.endsWith(".d.ts") &&
+                    file !== "index.ts" && file !== "index.js") {
 
                     const filePath = path.join(resolvedPath, file);
                     try {
                         const fileUrl = pathToFileURL(filePath).href;
-                        const dynamicImport = new Function('url', 'return import(url)');
+                        const dynamicImport = new Function("url", "return import(url)");
                         const module = await dynamicImport(fileUrl);
                         if (module && module.default) {
                             collections.push(module.default);
@@ -79,7 +79,7 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             }
         } else {
             const fileUrl = pathToFileURL(resolvedPath).href + `?t=${Date.now()}`;
-            const dynamicImport = new Function('url', 'return import(url)');
+            const dynamicImport = new Function("url", "return import(url)");
             const imported = await dynamicImport(fileUrl);
             collections = imported.backendCollections || imported.collections;
         }

package/src/schema/test-schema.ts

@@ -0,0 +1,11 @@
+import { pgTable, text, pgPolicy } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+
+export const testTable = pgTable("test", {
+  id: text("id").primaryKey()
+}, (t) => [
+  pgPolicy("renamed_policy", { as: "permissive",
+to: "public",
+for: "select",
+using: sql`true` })
+]);

package/src/services/BranchService.ts

@@ -103,7 +103,7 @@ export class BranchService {
             if (msg.includes("being accessed by other users")) {
                 throw new Error(
                     `Cannot create branch: the source database "${sourceDb}" has active connections. ` +
-                    `Close other clients or connections and try again.`
+                    "Close other clients or connections and try again."
                 );
             }
             throw err;
@@ -119,7 +119,7 @@ export class BranchService {
         return {
             name: sanitizedName,
             parentDatabase: sourceDb,
-            createdAt: now,
+            createdAt: now
         };
     }
 
@@ -156,7 +156,7 @@ export class BranchService {
             if (msg.includes("being accessed by other users")) {
                 throw new Error(
                     `Cannot delete branch "${sanitizedName}": the database has active connections. ` +
-                    `Close other clients and try again.`
+                    "Close other clients and try again."
                 );
             }
             throw err;
@@ -188,7 +188,7 @@ export class BranchService {
             name: row.name as string,
             parentDatabase: row.parent_db as string,
             createdAt: new Date(row.created_at as string),
-            sizeBytes: row.size_bytes != null ? Number(row.size_bytes) : undefined,
+            sizeBytes: row.size_bytes != null ? Number(row.size_bytes) : undefined
         }));
     }
 
@@ -231,7 +231,7 @@ export class BranchService {
             name: row.name as string,
             parentDatabase: row.parent_db as string,
             createdAt: new Date(row.created_at as string),
-            sizeBytes,
+            sizeBytes
         };
     }
 }