Composite Primary Keys Using EntitySchema

[CobaltOcean]

How do you create a composite primary key using EntitySchema? With decorated classes, you can place @PrimaryKey above multiple properties. I've tried using primary: true in more than one property of my schema definition, but that yields an error telling me:
limit 1 - row value misused

I've also tried putting [PrimaryKeyProp]?: ['<propname1>', '<propname2>'] on the class itself as outlined in the docs, but that didn't seem to have any effect.

After searching for 'composite primary key' here on GitHub and also on the web in general (with mikro orm), I started to get worried that all the examples I saw were of traditional decorator style entities. Please let me know if this is possible and what I can do to get it working.

Thanks!
MikroORM v. 6.1.9

[B4nan]

I've tried using primary: true in more than one property

That's exactly how. Provide a repro if it doesn't work for you.

I've also tried putting [PrimaryKeyProp]?: ['', ''] on the class itself as outlined in the docs, but that didn't seem to have any effect.

That is only for type level - it's a type, there is no value here. But keep that, it's valid for EntitySchema approach too.

[CobaltOcean]

After boiling it down, I was able to get a composite key of three integers. But I neglected to mention that one of my original columns was embedded. So below was the attempt to make that work. And it was unsuccessful.

import {
    EntityManager,
    EntitySchema,
    MikroORM,
    PrimaryKeyProp
} from '@mikro-orm/better-sqlite';
import { BetterSqliteMikroORM } from '@mikro-orm/better-sqlite/BetterSqliteMikroORM';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';

class EmbeddedID {
    value: number;
    type: string;

    constructor(value: number) {
        this.value = value;
        /*  
        ... convoluted logic
         */
        this.type = 'someType';
    }
}

class TripleIDClass {
    firstID: number;
    secondID: EmbeddedID;
    thirdID: number;
    label: string;

    [PrimaryKeyProp]?: ['firstID', 'secondID', 'thirdID'];

    constructor(firstID: number, secondID: EmbeddedID, thirdID: number) {
        this.firstID = firstID;
        this.secondID = secondID;
        this.thirdID = thirdID;
        this.label = 'default text';
    }
}

const EmbeddedIDSchema = new EntitySchema({
    class: EmbeddedID,
    embeddable: true,
    properties: {
        value: { type: 'number' },
        type: { type: 'string' }
    }
});

const TripleIDSchema = new EntitySchema({
    class: TripleIDClass,
    properties: {
        firstID: {
            type: 'integer',
            primary: true
        },
        secondID: {
            kind: 'embedded',
            entity: 'EmbeddedID',
            primary: true
        },
        thirdID: {
            type: 'integer',
            primary: true
        },
        label: {
            type: 'string'
        }
    }
});

describe('Composite Embedded Primary Key', () => {
    let orm: BetterSqliteMikroORM;
    let em: EntityManager;

    beforeAll(async () => {
        orm = await MikroORM.init({
            entities: [TripleIDSchema, EmbeddedIDSchema],
            dbName: ':memory:',
            debug: true,
            dynamicImportProvider: (id) => import(id)
        });
        await orm.schema.refreshDatabase();
        em = orm.em.fork();
    });

    afterAll(async () => {
        await orm.close();
    });

    it('should save two records with the same first two ids but a different third', async () => {
        const sameEmbeddedID = new EmbeddedID(6);
        const oneRecord = new TripleIDClass(5, sameEmbeddedID, 7);
        const anotherRecord = new TripleIDClass(5, sameEmbeddedID, 8);

        await em.persistAndFlush(oneRecord);
        await em.persistAndFlush(anotherRecord);

        em.clear();

        const persistedRecord = await em.findOneOrFail(TripleIDClass, [
            5,
            sameEmbeddedID,
            8
        ]);

        expect(persistedRecord).toBeInstanceOf(TripleIDClass);
        expect(persistedRecord.firstID).toBe(5);
        expect(persistedRecord.secondID).toStrictEqual(sameEmbeddedID);
        expect(persistedRecord.thirdID).toBe(8);
    });
});

This error was returned:

InvalidFieldNameException: create table `triple_idclass` (`first_id` integer not null, `third_id` integer not null, `second_id_value` integer not null, `second_id_type` text not null default 'someType', `label` text not null default 'default text', primary key (`first_id`, `second_id`, `third_id`)); - no such column: second_id

Am I missing something obvious? Or are embedded primary keys not supported? Thank you for the quick reply earlier.

[B4nan]

PKs cannot be embedded.

[CobaltOcean]

Ok. I'll try another strategy. Thank you.