@rebasepro/server-postgresql 0.0.1-canary.eae7889 → 0.1.0

package/examples/sdk-demo/node_modules/esbuild/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "esbuild",
+  "version": "0.27.3",
+  "description": "An extremely fast JavaScript and CSS bundler and minifier.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "main": "lib/main.js",
+  "types": "lib/main.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "esbuild": "bin/esbuild"
+  },
+  "optionalDependencies": {
+    "@esbuild/aix-ppc64": "0.27.3",
+    "@esbuild/android-arm": "0.27.3",
+    "@esbuild/android-arm64": "0.27.3",
+    "@esbuild/android-x64": "0.27.3",
+    "@esbuild/darwin-arm64": "0.27.3",
+    "@esbuild/darwin-x64": "0.27.3",
+    "@esbuild/freebsd-arm64": "0.27.3",
+    "@esbuild/freebsd-x64": "0.27.3",
+    "@esbuild/linux-arm": "0.27.3",
+    "@esbuild/linux-arm64": "0.27.3",
+    "@esbuild/linux-ia32": "0.27.3",
+    "@esbuild/linux-loong64": "0.27.3",
+    "@esbuild/linux-mips64el": "0.27.3",
+    "@esbuild/linux-ppc64": "0.27.3",
+    "@esbuild/linux-riscv64": "0.27.3",
+    "@esbuild/linux-s390x": "0.27.3",
+    "@esbuild/linux-x64": "0.27.3",
+    "@esbuild/netbsd-arm64": "0.27.3",
+    "@esbuild/netbsd-x64": "0.27.3",
+    "@esbuild/openbsd-arm64": "0.27.3",
+    "@esbuild/openbsd-x64": "0.27.3",
+    "@esbuild/openharmony-arm64": "0.27.3",
+    "@esbuild/sunos-x64": "0.27.3",
+    "@esbuild/win32-arm64": "0.27.3",
+    "@esbuild/win32-ia32": "0.27.3",
+    "@esbuild/win32-x64": "0.27.3"
+  },
+  "license": "MIT"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.0.1-canary.eae7889",
+  "version": "0.1.0",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -60,13 +60,14 @@
   "dependencies": {
     "arg": "^5.0.2",
     "chalk": "^4.1.2",
+    "chokidar": "5.0.0",
     "drizzle-orm": "^0.44.4",
     "execa": "^4.1.0",
     "pg": "^8.11.3",
-    "@rebasepro/common": "0.0.1-canary.eae7889",
-    "@rebasepro/server-core": "0.0.1-canary.eae7889",
-    "@rebasepro/utils": "0.0.1-canary.eae7889",
-    "@rebasepro/types": "0.0.1-canary.eae7889"
+    "@rebasepro/server-core": "0.1.0",
+    "@rebasepro/common": "0.1.0",
+    "@rebasepro/utils": "0.1.0",
+    "@rebasepro/types": "0.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/PostgresBackendDriver.ts

@@ -4,9 +4,9 @@ import { BranchService } from "./services/BranchService";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { DrizzleClient } from "./interfaces";
-import { User } from "@rebasepro/types";
+import { User, RebaseClient } from "@rebasepro/types";
 import { sql as drizzleSql } from "drizzle-orm";
-import { buildPropertyCallbacks } from "@rebasepro/common";
+import { buildPropertyCallbacks, updateDateAutoValues } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import {
     DataDriver,
@@ -44,6 +44,7 @@ export class PostgresBackendDriver implements DataDriver {
     public branchService?: BranchService;
     public user?: User;
     public data: RebaseData;
+    public client?: RebaseClient;
 
     /**
      * When true, realtime notifications are deferred until after the
@@ -101,6 +102,15 @@ export class PostgresBackendDriver implements DataDriver {
         };
     }
 
+    /**
+     * REST-optimised fetch service (include-aware eager-loading).
+     * Delegates to the underlying EntityFetchService which already
+     * implements the matching method signatures.
+     */
+    get restFetchService() {
+        return this.entityService.getFetchService();
+    }
+
 
     private resolveCollectionCallbacks<M extends Record<string, unknown>>(collection: EntityCollection<M> | undefined, path: string) {
         if (!collection && !path) return { collection: undefined,
@@ -154,7 +164,8 @@ propertyCallbacks: undefined };
             const contextForCallback = {
                 user: this.user,
                 driver: this,
-                data: this.data
+                data: this.data,
+                client: this.client
             } as unknown as RebaseCallContext; // Backend context
             return Promise.all(entities.map(async (entity) => {
                 let fetched = entity;
@@ -263,7 +274,8 @@ propertyCallbacks: undefined };
             const contextForCallback = {
                 user: this.user,
                 driver: this,
-                data: this.data
+                data: this.data,
+                client: this.client
             } as unknown as RebaseCallContext; // Backend context
             if (callbacks?.afterRead) {
                 entity = await callbacks.afterRead({
@@ -345,7 +357,8 @@ propertyCallbacks: undefined };
         const contextForCallback = {
             user: this.user,
             driver: this,
-            data: this.data
+            data: this.data,
+            client: this.client
         } as unknown as RebaseCallContext;
 
         // Fetch previous values for callbacks AND history recording
@@ -386,6 +399,17 @@ propertyCallbacks: undefined };
 
         }
 
+        // Apply autoValue timestamps (on_create / on_update) at the application layer.
+        // This handles updated_at fields for all writes that flow through the Rebase backend.
+        if (resolvedCollection?.properties) {
+            updatedValues = updateDateAutoValues({
+                inputValues: updatedValues,
+                properties: resolvedCollection.properties,
+                status: status ?? "new",
+                timestampNowValue: new Date()
+            });
+        }
+
         try {
             let savedEntity = await this.entityService.saveEntity<M>(
                 path,
@@ -508,7 +532,8 @@ propertyCallbacks: undefined };
         const contextForCallback = {
             user: this.user,
             driver: this,
-            data: this.data
+            data: this.data,
+            client: this.client
         } as unknown as RebaseCallContext;
 
         if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
@@ -931,6 +956,7 @@ roles: userRoles })}, true)
             txDelegate.entityService = txEntityService;
             txDelegate._deferNotifications = true;
             txDelegate._pendingNotifications = pendingNotifications;
+            txDelegate.client = this.delegate.client;
 
             return await operation(txDelegate);
         });

package/src/cli.ts

@@ -43,7 +43,7 @@ export async function runPluginCommand(args: string[]) {
 }
 
 async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
-    const VALID_ACTIONS = ["push", "pull", "generate", "migrate", "studio", "branch"];
+    const VALID_ACTIONS = ["push", "generate", "migrate", "studio", "branch"];
     if (!subcommand || !VALID_ACTIONS.includes(subcommand)) {
         console.error(chalk.red(`Unknown db command. Valid: ${VALID_ACTIONS.join(", ")}`));
         process.exit(1);
@@ -68,6 +68,12 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
         console.log("");
         console.log(`  You can now run ${chalk.bold.green("rebase db migrate")} to apply the migrations to your database.`);
         console.log("");
+    } else if (subcommand === "pull") {
+        console.log("");
+        console.log(chalk.yellow("  ⚠ \"rebase db pull\" has been removed."));
+        console.log(chalk.gray("  Use \"rebase schema introspect\" instead."));
+        console.log("");
+        process.exit(1);
     } else {
         console.log("");
         console.log(chalk.bold(`  🗄️  Rebase DB ${subcommand.charAt(0).toUpperCase() + subcommand.slice(1)}`));
@@ -408,9 +414,16 @@ async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void>
 
     const interactive = ["generate", "push"].includes(action);
 
+    // For push: always use --strict (prompts before destructive ops) and --verbose
+    // (shows all SQL). This ensures unmapped tables are never silently dropped.
+    const drizzleKitArgs = [action];
+    if (action === "push") {
+        drizzleKitArgs.push("--strict", "--verbose");
+    }
+
     try {
         if (interactive) {
-            await execa(drizzleKitBin, [action], {
+            await execa(drizzleKitBin, drizzleKitArgs, {
                 cwd: process.cwd(),
                 stdio: "inherit",
                 env
@@ -527,6 +540,59 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
             console.error(chalk.red(`✗ Failed to run schema generator: ${err instanceof Error ? err.message : String(err)}`));
             process.exit(1);
         }
+    } else if (subcommand === "introspect") {
+        const argsList = arg(
+            {
+                "--output": String,
+                "--collections": String,
+                "--force": Boolean,
+                "--schema": String,
+                "-o": "--output",
+                "-c": "--collections",
+                "-f": "--force"
+            },
+            {
+                argv: rawArgs.slice(2),
+                permissive: true
+            }
+        );
+
+        const introspectScript = path.join(__dirname, "schema", "introspect-db.ts");
+        if (!fs.existsSync(introspectScript)) {
+            console.error(chalk.red(`✗ Could not find introspect-db.ts at ${introspectScript}`));
+            process.exit(1);
+        }
+
+        const tsxBin = resolveLocalBin("tsx");
+        if (!tsxBin) {
+            console.error(chalk.red("✗ Could not find tsx binary."));
+            process.exit(1);
+        }
+
+        const outputPath = argsList["--output"] || argsList["--collections"] || path.join("..", "config", "collections");
+
+        console.log("");
+        console.log(chalk.bold("  🔍 Rebase Schema Introspector"));
+        console.log("");
+
+        const cmdParts = [
+            tsxBin,
+            introspectScript,
+            `--output=${outputPath}`,
+            ...(argsList["--force"] ? ["--force"] : []),
+            ...(argsList["--schema"] ? [`--schema=${argsList["--schema"]}`] : [])
+        ];
+
+        try {
+            await execa(cmdParts[0], cmdParts.slice(1), {
+                cwd: process.cwd(),
+                stdio: "inherit",
+                env: { ...process.env as Record<string, string> }
+            });
+        } catch (err: unknown) {
+            console.error(chalk.red(`✗ Failed to run schema introspector: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
     } else {
         console.error(chalk.red("Unknown schema command."));
         process.exit(1);

package/src/data-transformer.ts

@@ -258,7 +258,26 @@ export function serializePropertyToServer(value: unknown, property: Property): u
             }
             return value;
 
+        case "string":
+            if (typeof value === "string") {
+                if (value.startsWith("data:application/octet-stream;base64,")) {
+                    const base64Data = value.split(",")[1];
+                    if (base64Data) {
+                        return Buffer.from(base64Data, "base64");
+                    }
+                }
+            }
+            return value;
+
         default:
+            if (typeof value === "string") {
+                if (value.startsWith("data:application/octet-stream;base64,")) {
+                    const base64Data = value.split(",")[1];
+                    if (base64Data) {
+                        return Buffer.from(base64Data, "base64");
+                    }
+                }
+            }
             return value;
     }
 }
@@ -447,6 +466,45 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
     }
 
     switch (property.type) {
+        case "string": {
+            if (typeof value === "string") return value;
+            
+            // Handle Buffer objects (e.g. from PostgreSQL bytea columns)
+            let isBuffer = false;
+            let buf: Buffer | null = null;
+            
+            if (Buffer.isBuffer(value)) {
+                isBuffer = true;
+                buf = value;
+            } else if (typeof value === "object" && value !== null && (value as any).type === "Buffer" && Array.isArray((value as any).data)) {
+                isBuffer = true;
+                buf = Buffer.from((value as any).data);
+            }
+            
+            if (isBuffer && buf) {
+                // Heuristic: if all bytes are printable ASCII, return utf8, else base64
+                let isPrintable = true;
+                for (let i = 0; i < buf.length; i++) {
+                    const b = buf[i];
+                    // Allow standard printable ASCII + common whitespace (\r, \n, \t)
+                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+                        isPrintable = false;
+                        break;
+                    }
+                }
+                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            }
+            
+            if (typeof value === "object" && value !== null) {
+                try {
+                    return JSON.stringify(value);
+                } catch {
+                    return String(value);
+                }
+            }
+            return String(value);
+        }
+
         case "relation":
             // Transform ID back to relation object with type information
             if (typeof value === "string" || typeof value === "number") {
@@ -538,8 +596,33 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             return null;
         }
 
-        default:
+        default: {
+            // Fallback for buffers in case they are mapped to something other than string
+            let isBuffer = false;
+            let buf: Buffer | null = null;
+            
+            if (Buffer.isBuffer(value)) {
+                isBuffer = true;
+                buf = value;
+            } else if (typeof value === "object" && value !== null && (value as any).type === "Buffer" && Array.isArray((value as any).data)) {
+                isBuffer = true;
+                buf = Buffer.from((value as any).data);
+            }
+            
+            if (isBuffer && buf) {
+                let isPrintable = true;
+                for (let i = 0; i < buf.length; i++) {
+                    const b = buf[i];
+                    if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+                        isPrintable = false;
+                        break;
+                    }
+                }
+                return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            }
+            
             return value;
+        }
     }
 }
 

package/src/schema/doctor.ts

@@ -17,6 +17,18 @@ import { generateSchema } from "./generate-drizzle-schema-logic";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 
+/**
+ * Resolve the SQL column name for a property.
+ * Uses the explicit `columnName` when set (e.g. from introspection),
+ * falling back to `toSnakeCase(propName)` for manually-authored collections.
+ */
+const resolveColumnName = (propName: string, prop?: Property | null): string => {
+    if (prop && "columnName" in prop && typeof prop.columnName === "string") {
+        return prop.columnName;
+    }
+    return toSnakeCase(propName);
+};
+
 // ── Types ────────────────────────────────────────────────────────────────
 
 export type IssueSeverity = "error" | "warning" | "info";
@@ -316,7 +328,7 @@ export async function checkCollectionsVsDatabase(
                     const resolvedRelations = resolveCollectionRelations(collection);
                     const relation = findRelation(resolvedRelations, (prop as RelationProperty).relationName ?? propName);
                     if (relation?.direction === "owning" && relation.cardinality === "one" && relation.localKey) {
-                        const fkColName = toSnakeCase(relation.localKey);
+                        const fkColName = relation.localKey;
                         if (!dbColumnMap.has(fkColName)) {
                             issues.push({
                                 severity: "error",
@@ -349,7 +361,7 @@ export async function checkCollectionsVsDatabase(
                     continue;
                 }
 
-                const colName = toSnakeCase(propName);
+                const colName = resolveColumnName(propName, prop);
 
                 // Skip system columns — they're handled automatically
                 if (systemColumns.has(colName)) continue;

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

@@ -5,6 +5,18 @@ import { toSnakeCase } from "@rebasepro/utils";
 import { createHash } from "crypto";
 // --- Helper Functions ---
 
+/**
+ * Resolve the SQL column name for a property.
+ * Uses the explicit `columnName` when set (e.g. from introspection),
+ * falling back to `toSnakeCase(propName)` for manually-authored collections.
+ */
+const resolveColumnName = (propName: string, prop?: Property | null): string => {
+    if (prop && "columnName" in prop && typeof prop.columnName === "string") {
+        return prop.columnName;
+    }
+    return toSnakeCase(propName);
+};
+
 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));
@@ -46,7 +58,7 @@ const isIdProperty = (propName: string, prop: Property, collection: EntityCollec
 };
 
 const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCollection, collections: EntityCollection[]): string | null => {
-    const colName = toSnakeCase(propName);
+    const colName = resolveColumnName(propName, prop);
     let columnDefinition: string;
 
     switch (prop.type) {
@@ -126,6 +138,10 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             } else {
                 columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
             }
+            // autoValue: database-level default for initial value on INSERT
+            if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+                columnDefinition += `.default(sql\`now()\`)`;
+            }
             break;
         }
         case "map":
@@ -167,7 +183,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 return null; // Cannot resolve target
             }
 
-            const fkColumnName = toSnakeCase(relation.localKey);
+            const fkColumnName = relation.localKey;
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
@@ -461,6 +477,8 @@ const computeSharedRelationName = (
 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 =>
         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")
@@ -496,7 +514,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
         Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
             if (("enum" in prop) && (prop.type === "string" || prop.type === "number") && prop.enum) {
                 const enumVarName = getEnumVarName(collectionPath, propName);
-                const enumDbName = `${collectionPath}_${toSnakeCase(propName)}`;
+                const enumDbName = `${collectionPath}_${resolveColumnName(propName, prop)}`;
                 const values = Array.isArray(prop.enum)
                     ? prop.enum.map(v => String(v.id ?? v))
                     : Object.keys(prop.enum);
@@ -560,8 +578,8 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             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 += `    ${sourceColumn}: ${sourceColType}(\"${sourceColumn}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
+            schemaContent += `    ${targetColumn}: ${targetColType}(\"${targetColumn}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
             schemaContent += "}, (table) => ({\n";
             schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })\n`;
             schemaContent += "}));\n\n";
@@ -571,6 +589,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
                 const columnString = getDrizzleColumn(propName, prop as Property, collection, collections);
                 if (columnString) columns.add(columnString);
+
             });
 
             // Backwards compatibility: if no id/primary key column is found in properties, but `id` wasn't explicitly provided
@@ -682,31 +701,13 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                     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    })`);
-                        } 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    })`);
-                        } 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);
-
-                                // Find the owning relation on the target that points back to this collection
-                                const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
-                                    targetRel.direction === "owning" &&
-                                    targetRel.cardinality === "one" &&
-                                    targetRel.target().slug === collection.slug
-                                );
-
-                                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    })`);
-                                }
-                            } catch (e) {
-                                console.warn(`Could not resolve inverse one-to-one relation '${relationKey}':`, e);
-                            }
+                        } else if (rel.direction === "inverse") {
+                            // Inverse one-to-one: the FK lives on the TARGET table, not here.
+                            // Drizzle pairs inverse relations via `relationName` alone — specifying
+                            // `fields`/`references` on the inverse side is invalid and causes
+                            // `normalizeRelation` to crash with "Cannot read properties of
+                            // undefined (reading 'referencedTable')".
+                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        relationName: \"${drizzleRelationName}\"\n    })`);
                         }
                     } else if (rel.cardinality === "many") {
                         if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
@@ -746,6 +747,33 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                     console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, 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) {
+                        try {
+                            const otherTarget = otherRel.target();
+                            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    })`);
+                                    emittedRelationNames.add(deduplicationKey);
+                                }
+                            }
+                        } catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
         }
 
         if (tableRelations.length > 0) {
@@ -763,3 +791,4 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
 
     return schemaContent;
 };
+