@rebasepro/server-postgres 0.10.1-canary.7609565 → 0.10.1-canary.7801eed

package/src/services/PersistService.ts

@@ -1,8 +1,8 @@
 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 { CollectionConfig, Properties, ResolvedRelation, type ResolvedManyToMany, isManyToMany } from "@rebasepro/types";
+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 (!isManyToMany(hop.relation)) {
+                    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,40 @@ 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 } = hop;
+
+        switch (relation.kind) {
+            case "hasOne":
+            case "hasMany":
+                return relation.foreignKeyOnTarget;
+
+            case "via":
+                // The link lives in an intermediate table, not in a column on
+                // the target — nothing to stamp.
+                return relation.joinPath.length === 1
+                    ? DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to)[0]
+                    : undefined;
+
+            default:
+                // `belongsTo` names a column on the *parent*, and `manyToMany`
+                // is written as a junction row. Neither is a column here, and
+                // `assertWritableThrough` has already rejected the first.
+                return undefined;
+        }
+    }
+
     /**
      * Save an row (create or update)
      *
@@ -129,93 +197,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;
+        let junctionTableInfo: { parentCollection: CollectionConfig; parentId: string | number; relation: ResolvedManyToMany; relationKey: string; } | undefined;
+
+        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 (isManyToMany(hop.relation)) {
+                // 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 +406,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);
                 }