add support for mapped unique keys in externalIdMapping

Author: lsmith77

packages/server/src/api/rest/index.ts

@@ -1338,20 +1338,81 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
             return Object.values(modelDef.fields).filter((f) => modelDef.idFields.includes(f.name));
         }
 
-        // map external ID name to unique constraint field
         const externalIdName = this.externalIdMapping[modelLower];
-        for (const [name, info] of Object.entries(modelDef.uniqueFields)) {
-            if (name === externalIdName) {
-                if (typeof info.type === 'string') {
-                    // single unique field
-                    return [this.requireField(model, info.type)];
-                } else {
-                    // compound unique fields
-                    return Object.keys(info).map((f) => this.requireField(model, f));
+
+        // 1. Model-level @@unique(map: ...) (compound keys only)
+        if (Array.isArray(modelDef.attributes)) {
+            const uniqueAttr = modelDef.attributes.find(
+                (attr: any) =>
+                    attr.name === '@@unique' &&
+                    Array.isArray(attr.args) &&
+                    attr.args.some((a: any) => a.name === 'map' && a.value?.value === externalIdName),
+            );
+            if (uniqueAttr) {
+                const fieldsArg = uniqueAttr.args.find((a: any) => a.name === 'fields');
+                if (fieldsArg && Array.isArray(fieldsArg.value?.items) && fieldsArg.value.items.length >= 1) {
+                    const fieldNames = fieldsArg.value.items.map((item: any) => {
+                        let fieldName: string | undefined = undefined;
+                        if (typeof item.field === 'string' && modelDef.fields[item.field]) {
+                            fieldName = item.field;
+                        } else if (
+                            typeof item.value === 'object' &&
+                            typeof item.value.name === 'string' &&
+                            modelDef.fields[item.value.name]
+                        ) {
+                            fieldName = item.value.name;
+                        }
+                        if (!fieldName) {
+                            throw new Error(`Invalid unique field mapping in model ${model}: ${JSON.stringify(item)}`);
+                        }
+                        return fieldName;
+                    });
+                    return fieldNames.map((fieldName: string) => this.requireField(model, fieldName));
                 }
             }
         }
 
+        // 2. uniqueFields by key name
+        const uniqueFieldEntry = Object.entries(modelDef.uniqueFields).find(([name]) => name === externalIdName);
+        if (uniqueFieldEntry) {
+            const [name, info] = uniqueFieldEntry;
+            if (typeof info.type === 'string') {
+                return [this.requireField(model, name)];
+            }
+            const fieldNames = Object.keys(info).filter((f) => {
+                if (!(f in modelDef.fields)) {
+                    return false;
+                }
+                const fieldInfo = (info as Record<string, any>)[f];
+                return typeof fieldInfo === 'object' && fieldInfo !== null && typeof fieldInfo.type === 'string';
+            });
+            if (fieldNames.length === 0) {
+                throw new Error(
+                    `No valid field names found for compound unique key ${externalIdName} in model ${model}`,
+                );
+            }
+            return fieldNames.map((f) => this.requireField(model, f));
+        }
+
+
+        // 3. Field-level unique attribute with @unique(map: ...)
+        const field = Object.values(modelDef.fields).find((fieldDef) => {
+            if (!Array.isArray(fieldDef.attributes)) {
+                return false;
+            }
+            // @unique(map: ...)
+            return fieldDef.attributes.some(
+                (attr: any) =>
+                    attr.name === '@unique' &&
+                    Array.isArray(attr.args) &&
+                    attr.args.some((a: any) => a.name === 'map' && a.value?.value === externalIdName),
+            );
+        });
+
+        if (field) {
+            return [field];
+        }
+
         throw new Error(`Model ${model} does not have unique key ${externalIdName}`);
     }
 
@@ -2060,9 +2121,7 @@ export class RestApiHandler<Schema extends SchemaDef = SchemaDef> implements Api
             }
         } else {
             if (op === 'between') {
-                const parts = value
-                    .split(',')
-                    .map((v) => this.coerce(fieldDef, v));
+                const parts = value.split(',').map((v) => this.coerce(fieldDef, v));
                 if (parts.length !== 2) {
                     throw new InvalidValueError(`"between" expects exactly 2 comma-separated values`);
                 }

packages/server/test/api/rest.test.ts

@@ -3185,6 +3185,28 @@ describe('REST server tests', () => {
         title String
         author User? @relation(fields: [authorId], references: [id])
         authorId Int?
+        comments Comment[]
+        images Image[]
+    }
+
+    model Comment {
+        
+        id Int @id @default(autoincrement())
+        content String
+        short_title String
+        post_id Int
+        post Post @relation(fields: [post_id], references: [id])
+
+        @@unique([short_title, post_id], map: "short_title_post")
+    }
+
+    model Image {
+        
+        id Int @id @default(autoincrement())
+        content String
+        short_title String @unique(map: "short_title")
+        post_id Int
+        post Post @relation(fields: [post_id], references: [id])
     }
     `;
         beforeEach(async () => {
@@ -3195,16 +3217,27 @@ describe('REST server tests', () => {
                 endpoint: 'http://localhost/api',
                 externalIdMapping: {
                     User: 'name_source',
+                    Image: 'short_title',
+                    Comment: 'short_title_post',
                 },
             });
             handler = (args) => _handler.handleRequest({ ...args, url: new URL(`http://localhost/${args.path}`) });
-        });
 
-        it('works with id mapping', async () => {
             await client.user.create({
                 data: { id: 1, name: 'User1', source: 'a' },
             });
+            await client.post.create({
+                data: { id: 2, title: 'Some title', authorId: 1 },
+            });
+            await client.comment.create({
+                data: { id: 3, short_title: 'comment-title', post_id: 2, content: 'Comment1' },
+            });
+            await client.image.create({
+                data: { id: 1, short_title: 'image-title', post_id: 2, content: 'Image1' },
+            });
+        });
 
+        it('works with id mapping', async () => {
             // user is no longer exposed using the `id` field
             let r = await handler({
                 method: 'get',
@@ -3248,6 +3281,29 @@ describe('REST server tests', () => {
                 id: 'User1_a',
             });
         });
+
+        it('works with externalIdMapping as single column with underscore (single unique index)', async () => {
+            const r = await handler({
+                method: 'get',
+                path: '/image/image-title',
+                query: {},
+                client,
+            });
+            expect(r.status).toBe(200);
+            expect(r.body.data.attributes.content).toBe('Image1');
+        });
+
+        it('works with externalIdMapping using mapped compound unique name', async () => {
+            const r = await handler({
+                method: 'get',
+                path: '/comment/comment-title_2',
+                query: {},
+                client,
+            });
+            expect(r.status).toBe(200);
+            expect(r.body.data.attributes.short_title).toBe('comment-title');
+            expect(r.body.data.attributes.post_id).toBe(2);
+        });
     });
 
     describe('REST server tests - procedures', () => {