Function computeManyToManyRelation

packages/orm/src/client/query-utils.ts:344–391

(schema: SchemaDef, model: string, field: string)

}

function computeManyToManyRelation(schema: SchemaDef, model: string, field: string) {
    const fieldDef = requireField(schema, model, field);
    if (!fieldDef.array || !fieldDef.relation?.opposite) {
        return undefined;
    }

    // in case the m2m relation field is inherited from a delegate base, get the base model
    const realModel = fieldDef.originModel ?? model;

    const oppositeFieldDef = requireField(schema, fieldDef.type, fieldDef.relation.opposite);
    if (oppositeFieldDef.array) {
        // Prisma's convention for many-to-many relation:
        // - model are sorted alphabetically by name
        // - join table is named _<model1>To<model2>, unless an explicit name is provided by `@relation`
        // - foreign keys are named A and B (based on the order of the model)
        const sortedModelNames = [realModel, fieldDef.type].sort();

        let orderedFK: [string, string];
        if (realModel !== fieldDef.type) {
            // not a self-relation, model name's sort order determines fk order
            orderedFK = sortedModelNames[0] === realModel ? ['A', 'B'] : ['B', 'A'];
        } else {
            // for self-relations, since model names are identical, relation field name's
            // sort order determines fk order
            const sortedFieldNames = [field, oppositeFieldDef.name].sort();
            orderedFK = sortedFieldNames[0] === field ? ['A', 'B'] : ['B', 'A'];
        }

        const modelIdFields = requireIdFields(schema, realModel);
        invariant(modelIdFields.length === 1, 'Only single-field ID is supported for many-to-many relation');
        const otherIdFields = requireIdFields(schema, fieldDef.type);
        invariant(otherIdFields.length === 1, 'Only single-field ID is supported for many-to-many relation');

        return {
            parentFkName: orderedFK[0],
            parentPKName: modelIdFields[0]!,
            otherModel: fieldDef.type,
            otherField: fieldDef.relation.opposite,
            otherFkName: orderedFK[1],
            otherPKName: otherIdFields[0]!,
            joinTable: fieldDef.relation.name
                ? `_${fieldDef.relation.name}`
                : `_${sortedModelNames[0]}To${sortedModelNames[1]}`,
        };
    } else {
        return undefined;
    }
}

/**
 * Convert filter like `{ id1_id2: { id1: 1, id2: 1 } }` to `{ id1: 1, id2: 1 }`