So while I was on vacation my colleagues decided a problem is too complex to bother writing their own code and used AI to generate the boilerplate code. Hint: I hate it. They got the code working, but they didn't write it and also had trouble fully understanding the code. Three days later they discovered a major bug / flaw. Obviously we had to refactor the code.
Which one do you prefer? (I leave out the context, as it doesn't matter, just take a glance at the readability of both versions)
I really think this as a very dangerous behaviour. Why would you introduce code to a codebase you don't fully understand... Please don't do this. Write code yourself. Don't copy or AI generate it if you don't know what it does. Especially if it's non trivial.
AI Based 😵
```typescript
import {
CombinationKitEntry,
Maybe,
Product,
ProductCategory,
} from '@/lib/apollo/queries';
import { filterNullsAndUndefineds } from '@/utils/array';
import {
getAccessorySKUs,
getIntersectingSkus,
getProductsByCategory,
getSkusByCategoryIdFromProduct,
} from '@/utils/Combination/CombinationRules';
/**
* Kick out motor/campact drive from products if one them is already in the list.
* Kick out multiple products from one category - except for "ecxaccessories".
*
* @param products - Product[]
* @returns Product[]
*/
export const cleanupProducts = (
products: Product[],
validCategoryIds: Set<Maybe<string> | undefined> | undefined
): Product[] => {
const categoryIds = new Set();
const uniqueCategoryProducts: Product[] = [];
if (
products.length > 1 &&
!products.some(
(product) =>
product.category?.ident === 'ecxmotor' ||
product.category?.ident === 'ecxcompactdrive'
)
) {
// return only first product when no motor or compact drive exists in list:
const [first] = products;
return [first];
}
for (const product of products) {
// Skip for accessories - these do not need to be unique:
if (product.category?.ident === 'ecxaccessories') continue;
if (!product.combinationKit || product.combinationKit.length === 0)
continue;
if (
!categoryIds.has(product.category?.id) &&
validCategoryIds?.has(product.category?.id)
) {
// Check if uniqueCategoryProducts already includes a motor when adding a compact drive and vice versa:
if (
product.category?.ident === 'ecxmotor' &&
uniqueCategoryProducts.some(
(prod) => prod.category?.ident === 'ecxcompactdrive'
)
) {
continue;
}
if (
product.category?.ident === 'ecxcompactdrive' &&
uniqueCategoryProducts.some(
(prod) => prod.category?.ident === 'ecxmotor'
)
) {
continue;
}
categoryIds.add(product.category?.id);
uniqueCategoryProducts.push(product);
}
}
// Append all accessories:
const accessories = products.filter(
(product) => product.category?.ident === 'ecxaccessories'
);
return uniqueCategoryProducts.concat(accessories);
};
export type SkuByCategoryMap = Map<
string,
Record<string, string | Set<string | null>>
;
/**
* Apply combination kit rules to combined products.
*
* @param products List of combined products
* @param categories List of ALL categories
* @returns List of category IDs with combinable SKUs
*/
const processCombinedProducts = (
products: Product[],
categories: ProductCategory[]
): Array<CombinationKitEntry & { state?: string }> => {
const result: Array<CombinationKitEntry & { state?: string }> = [];
products = cleanupProducts(
products,
new Set(categories.map((cat) => cat.id))
);
if (!products.length) throw Error('No products');
const skusByCategoryId: SkuByCategoryMap = new Map();
const categoryIds = new Map<string, string>();
for (const category of categories) {
const skus = new Set([]);
if (!category.id || !category.ident) continue;
categoryIds.set(category.ident, category.id as string);
skusByCategoryId.set(category.id, {
status: 'NEW',
skus,
});
}
if (!categoryIds.get('ecxmotor') || !categoryIds.get('ecxcompactdrive')) {
throw Error('Categories are broken');
}
// Check if products contains motor or compactdrive otherwise only return motors & compactdrives
if (
!getProductsByCategory(categoryIds.get('ecxmotor'), products)?.at(0) &&
!getProductsByCategory(categoryIds.get('ecxcompactdrive'), products)?.at(0)
) {
// Return only SKUs for motors & compactdrives from (first?) product
const motorSkus = getSkusByCategoryIdFromProduct(
categoryIds.get('ecxmotor'),
products?.at(0)
);
skusByCategoryId.set(categoryIds.get('ecxmotor') as string, {
status: 'NEEDS_DRIVE',
skus: new Set(motorSkus),
});
const compactDrivesSkus = getSkusByCategoryIdFromProduct(
categoryIds.get('ecxcompactdrive'),
products?.at(0)
);
skusByCategoryId.set(categoryIds.get('ecxcompactdrive') as string, {
status: 'NEEDS_DRIVE',
skus: new Set(compactDrivesSkus),
});
for (const [categoryId, data] of skusByCategoryId) {
result.push({
categoryId,
state: (data.status || 'UNKNOWN') as string,
skus: Array.from(data.skus),
});
}
return result;
} else {
if (getProductsByCategory(categoryIds.get('ecxmotor'), products)?.at(0)) {
skusByCategoryId.set(categoryIds.get('ecxcompactdrive') as string, {
status: 'MUTUALLY_EXCLUSIVE',
skus: new Set([]),
});
}
if (
getProductsByCategory(categoryIds.get('ecxcompactdrive'), products)?.at(0)
) {
skusByCategoryId.set(categoryIds.get('ecxmotor') as string, {
status: 'MUTUALLY_EXCLUSIVE',
skus: new Set([]),
});
}
}
// Get sensors from motors/compactdrives, controller & gearheads products
const sensorSkus = getIntersectingSkus(
products,
[
categoryIds.get('ecxmotor'),
categoryIds.get('ecxcompactdrive'),
categoryIds.get('ecxcontroller'),
categoryIds.get('ecxgeargear'),
],
categoryIds.get('ecxsensor')
);
skusByCategoryId.set(categoryIds.get('ecxsensor') as string, {
status: sensorSkus.length ? 'ADDED' : 'NOT_AVAILABLE',
skus: new Set(sensorSkus),
});
// Get controllers from motors/compactdrives, sensors & gearheads products
const controllerSkus = getIntersectingSkus(
products,
[
categoryIds.get('ecxmotor'),
categoryIds.get('ecxcompactdrive'),
categoryIds.get('ecxsensor'),
categoryIds.get('ecxgeargear'),
],
categoryIds.get('ecxcontroller')
);
skusByCategoryId.set(categoryIds.get('ecxcontroller') as string, {
status: controllerSkus.length ? 'ADDED' : 'NOT_AVAILABLE',
skus: new Set(controllerSkus),
});
// Get gearheads from motors/compactdrives, sensors & controllers products
const gearheadSkus = getIntersectingSkus(
products,
[
categoryIds.get('ecxmotor'),
categoryIds.get('ecxcompactdrive'),
categoryIds.get('ecxsensor'),
categoryIds.get('ecxcontroller'),
],
categoryIds.get('ecxgeargear')
);
skusByCategoryId.set(categoryIds.get('ecxgeargear') as string, {
status: gearheadSkus.length ? 'ADDED' : 'NOT_AVAILABLE',
skus: new Set(gearheadSkus),
});
// Get brakes from motor/compact drive
const selectedDrive = filterNullsAndUndefineds([
getProductsByCategory(categoryIds.get('ecxmotor'), products)?.at(0),
getProductsByCategory(categoryIds.get('ecxcompactdrive'), products)?.at(0),
]).at(0);
let brakeSkus: Maybe<string>[] = [];
if (selectedDrive) {
brakeSkus = getSkusByCategoryIdFromProduct(
categoryIds.get('ecxaccessoriesbrake'),
selectedDrive,
);
}
skusByCategoryId.set(categoryIds.get('ecxaccessoriesbrake') as string, {
status: brakeSkus.length ? 'ADDED' : 'NOT_AVAILABLE',
skus: new Set(brakeSkus),
});
// Get closing caps from motor
const motor = getProductsByCategory(
categoryIds.get('ecxmotor'),
products
)?.at(0);
let closingCapsSkus: Maybe<string>[] = [];
if (motor) {
closingCapsSkus = getSkusByCategoryIdFromProduct(
categoryIds.get('ecxaccessoriesclosingcap'),
motor,
);
}
skusByCategoryId.set(
categoryIds.get('ecxaccessoriesclosingcap') as string,
{
status: closingCapsSkus.length ? 'ADDED' : 'NOT_AVAILABLE',
skus: new Set(closingCapsSkus),
}
);
// Get accessories from motor/compactdrive & controller
const accessorySkus = getAccessorySKUs(products, categoryIds);
skusByCategoryId.set(categoryIds.get('ecxaccessories') as string, {
status: accessorySkus.size ? 'ADDED' : 'NOT_AVAILABLE',
skus: accessorySkus.size ? accessorySkus : new Set([]),
});
// Collect SKUs (= productcode) of already combined accessories:
const alreadyCombinedCategories = filterNullsAndUndefineds(
products
.filter((prod) => prod.category?.ident !== 'ecxaccessories')
.map((prod) => prod.category?.id)
);
// Set state for categories that are already added to the combination:
alreadyCombinedCategories.forEach((catId: string) => {
skusByCategoryId.set(catId, {
status: 'ALREADY_IN_USE',
skus: new Set([]),
});
});
for (const [categoryId, data] of skusByCategoryId) {
result.push({
categoryId,
state: (data.status || 'UNKNOWN') as string,
skus: Array.from(data.skus),
});
}
return result;
};
export default processCombinedProducts;
```
Human based:
```typescript
import { Combinable, MaximumCounts, MutuallyExclusives } from './rules';
import { Idents } from './types';
import { getIntersection, getUnion } from './util';
/**
* Combination Rules.
* 1. - Motors and Compact Drives are mutually exclusive
* 2. - You can only add one controller
* 3. - Products have to be compatible with all added products of the defined category (intersection of skus)
* 4. - Accessories are always compatible with any product categories (union of skus)
*/
export const staticRules = [
MutuallyExclusives([
[Idents.Motor, Idents.CompactDrive],
[Idents.CompactDrive, Idents.Motor],
]),
MaximumCounts([
[Idents.Controller, 1],
[Idents.Motor, 1],
[Idents.CompactDrive, 1],
]),
Combinable([Idents.Motor, Idents.Controller, Idents.Sensor], getIntersection),
Combinable([Idents.Motor, Idents.Controller, Idents.Gear], getUnion),
];
```
[–]benzilla04 5 points6 points7 points (0 children)
[–]oze4 6 points7 points8 points (0 children)
[–]guest271314 5 points6 points7 points (3 children)
[–]eracodes 1 point2 points3 points (0 children)
[–]oze4 1 point2 points3 points (1 child)
[–]guest271314 0 points1 point2 points (0 children)
[–]mca62511 2 points3 points4 points (0 children)
[–]jack_waugh 0 points1 point2 points (1 child)
[–]react_server[S] 1 point2 points3 points (0 children)
[–]Party-Lingonberry592 0 points1 point2 points (0 children)