The code doesn't properly handle cases where model1PrimaryKeyInfo or model2PrimaryKeyInfo could be null. While there's a check before using them, the convertToPostgresColumnType function is called unconditionally which could lead to runtime errors.
if (model1PrimaryKeyInfo && model2PrimaryKeyInfo) {
const model1PrimaryKeyColumnType = convertToPostgresColumnType(
model1PrimaryKeyInfo.type,
null,
null,
)
const model2PrimaryKeyColumnType = convertToPostgresColumnType(
model2PrimaryKeyInfo.type,
null,
null,
)
const joinTableName = createManyToManyJoinTableName(
relation.model1,
relation.model2,
)
// Create join table
tables[joinTableName] = createManyToManyJoinTable(
joinTableName,
model1PrimaryKeyColumnType,
model2PrimaryKeyColumnType,
)
// Add relationships for the join table
const joinTableRelationships = createManyToManyRelationships(
joinTableName,
relation.model1,
model1PrimaryKeyInfo.name,
relation.model2,
model2PrimaryKeyInfo.name,
)
// Add the relationships to the global relationships object
Object.assign(relationships, joinTableRelationships)
}
The function getPrimaryKeyInfo returns null in error cases, but there's no error logging or handling when primary key information can't be found, which could lead to silent failures in many-to-many relationship processing.
function getPrimaryKeyInfo(table: Table, models: readonly DMMF.Model[]) {
const tableName = table?.name
const model = models.find((m) => m.name === tableName)
if (!model) {
return null // or throw an error if model is required
}
const tableIndexes = table?.indexes
const primaryKeyIndex = tableIndexes[`${tableName}_pkey`]
const primaryKeyColumnName = primaryKeyIndex?.columns[0]
if (!primaryKeyColumnName) {
return null // no primary key found
}
// Find the field in the model that matches the primary key column name
const primaryKeyField = model.fields.find(
(field) =>
field.name === primaryKeyColumnName ||
field.dbName === primaryKeyColumnName,
)
return primaryKeyField
}
✅ Check both tables existSuggestion Impact:The commit implements the suggestion's intent by checking if both model1PrimaryKeyInfo and model2PrimaryKeyInfo exist before proceeding with creating join tables and relationships. This is functionally equivalent to checking if table_A and table_B exist.
code diff:
+ if (model1PrimaryKeyInfo && model2PrimaryKeyInfo) {
The code only checks if both tables are undefined before continuing, but doesn't handle the case where one table exists and the other doesn't. This could lead to errors when trying to create relationships with non-existent tables. Add a check to ensure both tables exist before proceeding.
// Get primary key info for model1 if table_A exists
const model1PrimaryKeyInfo = table_A
? getPrimaryKeyInfo(table_A, dmmf.datamodel.models)
: null
// Get primary key info for model2 if table_B exists
const model2PrimaryKeyInfo = table_B
? getPrimaryKeyInfo(table_B, dmmf.datamodel.models)
: null
+
+// Skip if either table is undefined
+if (!table_A || !table_B) continue
[Suggestion has been applied]
Suggestion importance[1-10]: 8
__
Why: This suggestion addresses a critical issue where the code only checks if both tables are undefined but doesn't handle cases where one table exists and the other doesn't. This could lead to runtime errors when trying to create relationships with non-existent tables.
Medium
✅ Ensure consistent join table namingSuggestion Impact:The commit implemented the suggestion's intent by refactoring the code to use sorted model names for consistent join table naming. The commit introduces a new getSortedModelPair function (lines 263-265) that sorts model names, and uses this in the storeManyToManyRelation function.
The code creates a join table name using the model names in the order they appear in the relation, but this can lead to inconsistent naming. Since you're already sorting model names when creating the relation ID, you should use the same sorted order when creating the join table name to ensure consistency.
Why: The suggestion correctly identifies a potential inconsistency in join table naming. Using sorted model names would ensure that the same relationship always produces the same join table name regardless of which side initiates the relationship, preventing potential bugs and data inconsistencies.
liam-hq
![changeset-bot[bot] avatar](https://avatars.githubusercontent.com/in/28616?v=4 "Published by a pub.dev verified publisher"){kind=small}
![vercel[bot] avatar](https://avatars.githubusercontent.com/in/8329?v=4 "Published by a pub.dev verified publisher"){kind=small}
![qodo-free-for-open-source-projects[bot] avatar](https://avatars.githubusercontent.com/in/1068000?v=4 "Published by a pub.dev verified publisher"){kind=small}
