@rebasepro/server-postgres 0.10.1-canary.b1e3dbf → 0.10.1-canary.ed8caed

package/src/services/PersistService.ts

@@ -2,7 +2,7 @@ import { eq, and, sql, SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 // import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { CollectionConfig, Properties, Relation } from "@rebasepro/types";
-import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
+import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
     getCollectionByPath,
@@ -16,6 +16,13 @@ import { RelationService } from "./RelationService";
 import { FetchService } from "./FetchService";
 import { DrizzleClient } from "../interfaces";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+import {
+    assertWritableThrough,
+    isJunctionBackedRelation,
+    isNestedPath,
+    resolveNestedPath,
+    type NestedPathHop
+} from "./nested-path";
 import { ApiError, logger } from "@rebasepro/server";
 import { extractPgError, extractCauseMessage, pgErrorToFriendlyMessage } from "../utils/pg-error-utils";
 
@@ -80,6 +87,33 @@ export class PersistService {
      * Delete an row by ID
      */
     async delete(collectionPath: string, id: string | number, _databaseId?: string): Promise<void> {
+        // A nested address deletes *through* a relation, and what that removes
+        // depends on who owns the target row.
+        const hop = isNestedPath(collectionPath) ? resolveNestedPath(collectionPath, this.registry) : undefined;
+        if (hop) {
+            assertWritableThrough(hop, collectionPath);
+
+            if (!await this.relationService.isRelated(hop, id)) {
+                throw ApiError.notFound(`No row "${id}" in "${collectionPath}" to delete.`);
+            }
+
+            if (isJunctionBackedRelation(hop.relation)) {
+                // Shared target: drop the link, not the row.
+                if (!hop.relation.through) {
+                    throw ApiError.badRequest(
+                        `"${collectionPath}" reaches '${hop.targetCollection.slug}' through a multi-hop joinPath, ` +
+                        `so there is no single link to remove. Delete the row at "${hop.targetCollection.slug}" ` +
+                        "directly if that is what you meant.",
+                        "RELATION_NOT_UNLINKABLE"
+                    );
+                }
+                await this.relationService.unlinkRelatedEntity(this.db, hop, id);
+                return;
+            }
+            // Owned child (inverse FK): deleting the row is the right meaning,
+            // and membership above has established it is this parent's child.
+        }
+
         const collection = getCollectionByPath(collectionPath, this.registry);
         const table = getTableForCollection(collection, this.registry);
         const idInfoArray = getPrimaryKeys(collection, this.registry);
@@ -113,6 +147,44 @@ export class PersistService {
         await this.db.delete(table);
     }
 
+    /**
+     * The column on the *target* table that records the parent, for a create
+     * under a nested one-to-many path.
+     *
+     * Returns `undefined` when the link is not a column at all (a multi-hop
+     * `joinPath`), so the caller writes the row without stamping anything.
+     *
+     * `relation.localKey` is deliberately not consulted: it names a column on
+     * the *source* table. Falling back to it here — which is what this used to
+     * do, and first — stamped the parent's own foreign key onto the child row.
+     */
+    private resolveParentForeignKeyColumn(hop: NestedPathHop): string | undefined {
+        const { relation, relationKey, targetCollection } = hop;
+
+        if (relation.foreignKeyOnTarget) return relation.foreignKeyOnTarget;
+
+        if (relation.joinPath && relation.joinPath.length === 1) {
+            const joinStep = relation.joinPath[0];
+            const targetTableName = getTableName(targetCollection);
+            if (joinStep.table !== targetTableName) {
+                logger.warn(`Join step for relation '${relationKey}' targets '${joinStep.table}', not the target table '${targetTableName}'.`);
+            }
+            return DrizzleConditionBuilder.getColumnNamesFromColumns(joinStep.on.to)[0];
+        }
+
+        if (relation.joinPath && relation.joinPath.length > 1) {
+            // Multi-hop: the link lives in an intermediate table, not in a
+            // column on the target. Nothing to stamp.
+            return undefined;
+        }
+
+        throw ApiError.badRequest(
+            `Relation '${relationKey}' on '${hop.parentCollection.slug}' cannot be written through: it declares no ` +
+            "`foreignKeyOnTarget` (the column on " + `'${targetCollection.slug}'` + " that records the parent) and no `joinPath`.",
+            "RELATION_NOT_WRITABLE"
+        );
+    }
+
     /**
      * Save an row (create or update)
      *
@@ -129,93 +201,59 @@ export class PersistService {
         databaseId?: string,
         options?: { upsert?: boolean }
     ): Promise<Record<string, unknown>> {
-        // If saving under a nested relation path, resolve the parent and inject FK
+        // If saving under a nested relation path, resolve the relation it ends in.
         let effectiveCollectionPath = collectionPath;
         const effectiveValues: Partial<M> = { ...values };
         let junctionTableInfo: { parentCollection: CollectionConfig; parentId: string | number; relation: Relation; relationKey: string; } | undefined;
 
-        if (collectionPath.includes("/")) {
-            const segments = collectionPath.split("/").filter(Boolean);
-            if (segments.length >= 3 && segments.length % 2 === 1) {
-                const rootSegment = segments[0];
-                let currentCollection = getCollectionByPath(rootSegment, this.registry);
-                let currentId: string | number = segments[1];
-
-                for (let i = 2; i < segments.length; i += 2) {
-                    const relationKey = segments[i];
-                    const resolvedRelations = resolveCollectionRelations(currentCollection);
-                    const relation = findRelation(resolvedRelations, relationKey);
-
-                    if (!relation) {
-                        const available = Object.keys(resolvedRelations).join(", ") || "(none)";
-                        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'. Available relations: [${available}]`);
-                    }
-
-                    if (i === segments.length - 1) {
-                        const targetCollection = relation.target();
-                        effectiveCollectionPath = targetCollection.slug;
-
-                        // Handle many-to-many with junction table
-                        if (relation.cardinality === "many" && relation.through) {
-                            const parentIdInfoArray = getPrimaryKeys(currentCollection, this.registry);
-                            const parentIdInfo = parentIdInfoArray[0];
-                            const parsedParentIdObj = parseIdValues(currentId, parentIdInfoArray);
-                            const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
-
-                            junctionTableInfo = {
-                                parentCollection: currentCollection,
-                                parentId: parsedParentId,
-                                relation: relation,
-                                relationKey: relationKey
-                            };
-                            break;
-                        }
-
-                        // Find the FK column that should store the parent ID
-                        let targetColumnName: string;
-
-                        if (relation.localKey) {
-                            targetColumnName = relation.localKey;
-                        } else if (relation.foreignKeyOnTarget) {
-                            targetColumnName = relation.foreignKeyOnTarget;
-                        } else if (relation.joinPath && relation.joinPath.length === 1) {
-                            const targetTableName = getTableName(targetCollection);
-                            const relevantJoinStep = relation.joinPath.find(joinStep => joinStep.table === targetTableName);
-
-                            if (relevantJoinStep) {
-                                const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relevantJoinStep.on.to);
-                                targetColumnName = targetColumnNames[0];
-                            } else {
-                                logger.warn(`Could not find specific join step for target table ${targetTableName} in relation '${relationKey}'.`);
-                                const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to);
-                                targetColumnName = targetColumnNames[0];
-                            }
-                        } else if (relation.joinPath && relation.joinPath.length > 1) {
-                            // For multi-hop relations (like many-to-many through a junction table),
-                            // there is no direct foreign key on the target table pointing to the parent.
-                            // The relationship is managed via the junction table.
-                            // We shouldn't inject the parent ID directly into the target row payload.
-                            break;
-                        } else {
-                            throw new Error(`Relation '${relationKey}' lacks configuration for path-based saving.`);
-                        }
-
-                        const parentIdInfoArray = getPrimaryKeys(currentCollection, this.registry);
-                        const parentIdInfo = parentIdInfoArray[0];
-                        const parsedParentIdObj = parseIdValues(currentId, parentIdInfoArray);
-                        const parsedParentId = parsedParentIdObj[parentIdInfo.fieldName];
-
-                        const existingValue = (effectiveValues as Record<string, unknown>)[targetColumnName];
-                        if (existingValue !== undefined && existingValue !== null && existingValue !== parsedParentId) {
-                            logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
-                        }
-                        (effectiveValues as Record<string, unknown>)[targetColumnName] = parsedParentId;
-                        break;
-                    } else {
-                        const nextEntityId = segments[i + 1];
-                        currentCollection = relation.target();
-                        currentId = nextEntityId;
+        const hop = isNestedPath(collectionPath) ? resolveNestedPath(collectionPath, this.registry) : undefined;
+
+        if (hop) {
+            assertWritableThrough(hop, collectionPath);
+            effectiveCollectionPath = hop.targetCollection.slug;
+
+            const parentIdForWrite = () => {
+                const parentPks = getPrimaryKeys(hop.parentCollection, this.registry);
+                return parseIdValues(hop.parentId, parentPks)[parentPks[0].fieldName];
+            };
+
+            if (hop.relation.through) {
+                // A junction path addresses set membership, so a write through it
+                // asserts "this row is in this parent's set" — on create *and* on
+                // update. The junction row is written after the main write below,
+                // idempotently, which is what makes `PUT parent/id/child/childId`
+                // able to attach a row that already exists.
+                //
+                // Unlike an owning foreign key, this takes the row from nobody:
+                // its other parents keep it. That is why linking is safe here
+                // where reparenting (below) is not.
+                junctionTableInfo = {
+                    parentCollection: hop.parentCollection,
+                    parentId: parentIdForWrite(),
+                    relation: hop.relation,
+                    relationKey: hop.relationKey
+                };
+            } else if (id !== undefined) {
+                // Updating an existing row *through* an owning parent. The parent
+                // segment is an assertion about where the row already lives, not
+                // an instruction to move it there: injecting the FK here silently
+                // reparented whatever id was named, so `PUT authors/1/posts/43`
+                // stole post 43 from its real author. Check membership instead,
+                // and leave the FK to an explicit value in the body.
+                if (!await this.relationService.isRelated(hop, id)) {
+                    throw ApiError.notFound(`No row "${id}" in "${collectionPath}" to update.`);
+                }
+            } else {
+                // One-to-many create: stamp the parent's id onto the child's FK.
+                const targetColumnName = this.resolveParentForeignKeyColumn(hop);
+
+                if (targetColumnName) {
+                    const parsedParentId = parentIdForWrite();
+                    const existingValue = (effectiveValues as Record<string, unknown>)[targetColumnName];
+                    if (existingValue !== undefined && existingValue !== null && existingValue !== parsedParentId) {
+                        logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
                     }
+                    (effectiveValues as Record<string, unknown>)[targetColumnName] = parsedParentId;
                 }
             }
         }
@@ -372,8 +410,12 @@ export class PersistService {
                     await this.relationService.updateRelationsUsingJoins(tx, collection, currentId, relationValues);
                 }
 
-                // Handle junction table creation for many-to-many path-based saves
-                if (junctionTableInfo && !id) {
+                // Attach the row to the parent's set. Runs for updates as well as
+                // creates — it used to be gated on `!id`, which is why a row that
+                // already existed could never be added to a parent through its
+                // path. The insert is idempotent, so re-asserting a link is a
+                // no-op rather than a duplicate-key error.
+                if (junctionTableInfo) {
                     await this.relationService.handleJunctionTableCreation(tx, currentId, junctionTableInfo);
                 }
 

package/src/services/RelationService.ts

@@ -15,6 +15,7 @@ import {
 import { parseDataFromServer } from "../data-transformer";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { logger } from "@rebasepro/server";
+import type { NestedPathHop } from "./nested-path";
 
 /**
  * Typed wrapper for Drizzle dynamic query innerJoin.
@@ -333,6 +334,24 @@ export class RelationService {
             throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'. Available relations: [${available}]`);
         }
 
+        return this.countRelatedRows(parentCollection, parentId, relation, []);
+    }
+
+    /**
+     * Count the target rows a parent reaches through `relation`, narrowed by
+     * `additionalFilters` (conditions on the target table).
+     *
+     * Shared by the public count and by {@link isRelated}, so "how many children
+     * does this parent have" and "is this row one of them" are answered by the
+     * same join — a membership test that reconstructed the join separately would
+     * be free to disagree with the listing it is supposed to gate.
+     */
+    private async countRelatedRows(
+        parentCollection: CollectionConfig,
+        parentId: string | number,
+        relation: Relation,
+        additionalFilters: SQL[]
+    ): Promise<number> {
         const targetCollection = relation.target();
         const targetTable = getTableForCollection(targetCollection, this.registry);
         const targetPks = requirePrimaryKeys(targetCollection, this.registry);
@@ -350,9 +369,6 @@ export class RelationService {
         // Start count with distinct to avoid duplicates from junction tables
         let query = this.db.select({ count: sql<number>`count(distinct ${targetIdField})` }).from(targetTable).$dynamic();
 
-        // Build additional filter conditions
-        const additionalFilters: SQL[] = [];
-
         // Use unified count query builder from DrizzleConditionBuilder
         query = DrizzleConditionBuilder.buildRelationCountQuery(
             query,
@@ -370,6 +386,75 @@ export class RelationService {
         return Number(result[0]?.count || 0);
     }
 
+    /**
+     * Whether `targetId` is actually reachable from the parent named in `hop`.
+     *
+     * A nested address like `authors/1/posts/43` used to resolve to the target
+     * collection and then match on the primary key alone, so the parent segment
+     * decided nothing: the row came back, and was updated or deleted, whoever it
+     * belonged to. Reads, updates and deletes now all gate on this.
+     */
+    async isRelated(hop: NestedPathHop, targetId: string | number): Promise<boolean> {
+        const targetTable = getTableForCollection(hop.targetCollection, this.registry);
+        const targetPks = requirePrimaryKeys(hop.targetCollection, this.registry);
+        const parsedTargetId = parseIdValues(targetId, targetPks);
+
+        const identity: SQL[] = targetPks.map(pk => {
+            const column = targetTable[pk.fieldName as keyof typeof targetTable] as AnyPgColumn;
+            if (!column) {
+                throw new Error(`ID field '${pk.fieldName}' not found in table for collection '${hop.targetCollection.slug}'`);
+            }
+            return eq(column, parsedTargetId[pk.fieldName]);
+        });
+
+        return (await this.countRelatedRows(hop.parentCollection, hop.parentId, hop.relation, identity)) > 0;
+    }
+
+    /**
+     * Remove the junction row linking a parent to `targetId`, leaving the target
+     * row itself alone.
+     *
+     * This is what `DELETE authors/1/tags/5` has to mean for a many-to-many: the
+     * target is shared, so deleting the row would remove the tag from every other
+     * post that uses it. It used to do exactly that — resolve the path to the
+     * `tags` table and delete by primary key.
+     */
+    async unlinkRelatedEntity(
+        tx: DrizzleClient,
+        hop: NestedPathHop,
+        targetId: string | number
+    ): Promise<void> {
+        const through = hop.relation.through;
+        if (!through) {
+            throw new Error(`Relation '${hop.relationKey}' has no junction table to unlink through`);
+        }
+
+        const junctionTable = this.registry.getTable(through.table);
+        if (!junctionTable) {
+            throw new Error(`Junction table not found: ${through.table}`);
+        }
+
+        const sourceJunctionColumn = junctionTable[through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
+        const targetJunctionColumn = junctionTable[through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
+
+        if (!sourceJunctionColumn || !targetJunctionColumn) {
+            throw new Error(`Junction columns not found for relation '${hop.relationKey}' on table '${through.table}'`);
+        }
+
+        const parentPks = requirePrimaryKeys(hop.parentCollection, this.registry);
+        const parsedParentId = parseIdValues(hop.parentId, parentPks)[parentPks[0].fieldName];
+
+        const targetPks = requirePrimaryKeys(hop.targetCollection, this.registry);
+        const parsedTargetId = parseIdValues(targetId, targetPks)[targetPks[0].fieldName];
+
+        await tx.delete(junctionTable).where(and(
+            eq(sourceJunctionColumn, parsedParentId),
+            eq(targetJunctionColumn, parsedTargetId)
+        ));
+
+        logger.info(`Unlinked '${hop.relationKey}' ${parsedTargetId} from ${hop.parentCollection.slug} ${parsedParentId}`);
+    }
+
     /**
      * Batch fetch related rows for multiple parent rows to avoid N+1 queries
      */
@@ -1348,15 +1433,19 @@ parentSourceColName };
             const parsedNewEntityIdObj = parseIdValues(newEntityId, targetPks);
             const parsedNewEntityId = parsedNewEntityIdObj[targetIdInfo.fieldName];
 
-            // Create the junction table entry linking parent to the new row
+            // Create the junction table entry linking parent to the target row.
             const junctionData = {
                 [sourceJunctionColumn.name]: parentId,
                 [targetJunctionColumn.name]: parsedNewEntityId
             };
 
-            await tx.insert(junctionTable).values(junctionData);
+            // Idempotent: a link either exists or it does not, so asking for one
+            // twice is not an error. This is what lets `PUT parent/id/child/childId`
+            // mean "this row belongs to this parent's set" — the only way to
+            // attach an *existing* row, which previously had none.
+            await tx.insert(junctionTable).values(junctionData).onConflictDoNothing();
 
-            logger.info(`Created junction table entry for many-to-many relation '${relationKey}': ${JSON.stringify(junctionData)}`);
+            logger.info(`Linked '${relationKey}' ${parsedNewEntityId} to ${parentId}`);
         } catch (error) {
             logger.error(`Failed to create junction table entry for relation '${relationKey}'`, { error: error });
             throw error;

package/src/services/nested-path.ts

@@ -0,0 +1,130 @@
+import { CollectionConfig, Relation } from "@rebasepro/types";
+import { findRelation, resolveCollectionRelations } from "@rebasepro/common";
+import { ApiError } from "@rebasepro/server";
+
+import { getCollectionByPath } from "./collection-helpers";
+import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
+
+/**
+ * The last hop of a nested collection path, e.g. `authors/1/posts`.
+ *
+ * The walk that produces this was written out four separate times — in
+ * `FetchService.fetchCollectionFromPath`, `FetchService.countEntitiesFromPath`,
+ * `PersistService.save` and `CollectionRegistry.getCollectionByPath` — and had
+ * drifted, so the read path and the write path did not agree on which relation
+ * a path named. It lives here once now.
+ */
+export interface NestedPathHop {
+    /** The collection the final relation is declared on (e.g. `authors`). */
+    parentCollection: CollectionConfig;
+    /** The parent's id as it appeared in the path, unparsed. */
+    parentId: string;
+    /** The path segment that named the relation (e.g. `posts`). */
+    relationKey: string;
+    relation: Relation;
+    /** `relation.target()`, resolved once. */
+    targetCollection: CollectionConfig;
+}
+
+/**
+ * True when `path` addresses rows through a relation rather than a root
+ * collection.
+ *
+ * Any separator at all counts — a root collection slug never contains one — so
+ * a malformed path like `collection/id` is a *broken* nested path and gets
+ * reported as one by {@link resolveNestedPath}, rather than being looked up as
+ * a root collection whose slug happens to contain a slash.
+ */
+export function isNestedPath(path: string): boolean {
+    return path.includes("/");
+}
+
+export function splitPathSegments(path: string): string[] {
+    return path.split("/").filter(s => s && s !== "undefined");
+}
+
+/**
+ * Walk a nested collection path down to the relation it ends in.
+ *
+ * Returns `undefined` for a plain root-collection path so callers can keep the
+ * root case on its existing code path. Throws when the path is malformed, or
+ * when a segment names a relation that does not exist — the same errors the
+ * individual walks used to raise, with the available names attached.
+ */
+export function resolveNestedPath(
+    path: string,
+    registry: PostgresCollectionRegistry
+): NestedPathHop | undefined {
+    if (!isNestedPath(path)) return undefined;
+
+    const segments = splitPathSegments(path);
+    if (segments.length < 3 || segments.length % 2 === 0) {
+        throw new Error(`Invalid relation path: ${path}. Expected format: collection/id/relation`);
+    }
+
+    let parentCollection = getCollectionByPath(segments[0], registry);
+    let parentId = segments[1];
+
+    for (let i = 2; i < segments.length; i += 2) {
+        const relationKey = segments[i];
+        const resolvedRelations = resolveCollectionRelations(parentCollection);
+        const relation = findRelation(resolvedRelations, relationKey);
+
+        if (!relation) {
+            const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+            throw new Error(
+                `Relation '${relationKey}' not found in collection '${parentCollection.slug}'. Available relations: [${available}]`
+            );
+        }
+
+        const targetCollection = relation.target();
+
+        if (i === segments.length - 1) {
+            return {
+                parentCollection,
+                parentId,
+                relationKey,
+                relation,
+                targetCollection
+            };
+        }
+
+        parentCollection = targetCollection;
+        parentId = segments[i + 1];
+    }
+
+    // Unreachable: the loop returns on the final segment, and the odd-length
+    // check above guarantees there is one.
+    throw new Error(`Unable to resolve path: ${path}`);
+}
+
+/**
+ * A relation reached through a junction table — many-to-many, or a multi-hop
+ * `joinPath`. The target row is shared with other parents, so writing "through"
+ * such a path addresses the *link*, not the row.
+ */
+export function isJunctionBackedRelation(relation: Relation): boolean {
+    return Boolean(relation.through) || Boolean(relation.joinPath && relation.joinPath.length > 1);
+}
+
+/**
+ * Reject a nested write whose final segment is a to-one relation.
+ *
+ * There is no column on the target row that records a to-one parent — the
+ * foreign key lives on the *parent* table. The write path used to fall through
+ * to `relation.localKey` here and stamp the parent's own FK column onto the
+ * target row, which either raised an opaque "column does not exist" or, when a
+ * column of that name happened to exist on the target, silently wrote the wrong
+ * one.
+ */
+export function assertWritableThrough(hop: NestedPathHop, path: string): void {
+    if (hop.relation.cardinality !== "many") {
+        throw ApiError.badRequest(
+            `"${path}" ends in the to-one relation '${hop.relationKey}', which cannot be written through: ` +
+            `the foreign key for a to-one relation lives on '${hop.parentCollection.slug}', not on ` +
+            `'${hop.targetCollection.slug}'. Write the target row at "${hop.targetCollection.slug}" and set ` +
+            `'${hop.relationKey}' on the parent instead.`,
+            "RELATION_NOT_WRITABLE"
+        );
+    }
+}