jacob/munch-ease-frontend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Stricter api changes

Browse source
This commit is contained in:
jableader 2025-10-26 15:13:33 +11:00
parent 211489ca55
commit f2dee9ca30
6 changed files with 203 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
README.md
View file

@ -98,3 +98,15 @@ Environment
Testing Testing
- Unit tests use MSW; the client defaults to a localhost base in tests for easy mocking - Unit tests use MSW; the client defaults to a localhost base in tests for easy mocking
### CurrentShoppingList item kinds
The OpenAPI spec models current shopping list items as distinct kinds:
- outstandingItems: ListIngredientItem[]
- requestedMeals: RequestedMealItem[]
- purchasedItems: ListIngredientItem[]
The SDK maps these to a domain DTO (`CurrentShoppingListDTO`) and may attach refs (`ingredient`, `recipe`, `meal`, `list`) for convenience. UI code should:
- Prefer stable IDs (`ingredientId`, `mealId`, `recipeId`, `listId`) for actions and lookups
- Treat attached refs as optional view helpers (never required)
- Keep all normalization at the boundary (decoders); avoid casts and runtime type checks in app code

71
src/api/sdk.ts
View file

@ -1,12 +1,25 @@
import { api } from '@/api/client' import { api } from '@/api/client'
import type { components } from '@/api/types' import type { components } from '@/api/types'
import { toDate, decodeMeal, decodeRecipe, decodeIngredients, decodeShoppingList, decodeShoppingListItems, decodeIngredient, decodeLookup } from '@/domain/decoders' import {
toDate,
decodeMeal,
decodeRecipe,
decodeIngredients,
decodeShoppingList,
decodeShoppingListItems,
decodeListIngredientItems,
decodeRequestedMealItems,
decodeIngredient,
decodeLookup,
} from '@/domain/decoders'
import type { import type {
Recipe, Recipe,
Meal, Meal,
Ingredient, Ingredient,
ShoppingList, ShoppingList,
ShoppingListItemWithRefs, ShoppingListItemWithRefs,
ListIngredientItemWithRefs,
RequestedMealItemWithRefs,
CurrentShoppingListDTO, CurrentShoppingListDTO,
PurchasedShoppingListDTO, PurchasedShoppingListDTO,
ShoppingLookups, ShoppingLookups,
@ -24,34 +37,32 @@ function httpError(response: Response, error: unknown): Error {
// Shopping list mapped view types now come from domain/types // Shopping list mapped view types now come from domain/types
function attachItemRefs( function attachItemRefs(
items: Array<ShoppingListItemWithRefs> | null | undefined, items: Array<ShoppingListItemWithRefs | ListIngredientItemWithRefs | RequestedMealItemWithRefs> | null | undefined,
lookups: ShoppingLookups lookups: ShoppingLookups
): void { ): void {
if (!Array.isArray(items)) return if (!Array.isArray(items)) return
for (const item of items) { for (const item of items) {
const ingredientId = item.ingredientId ?? undefined // ingredient ref
const mealId = item.mealId ?? undefined if ('ingredientId' in item && item.ingredientId !== undefined && lookups.ingredientsLookup) {
const recipeId = item.recipeId ?? undefined const v = lookups.ingredientsLookup[String(item.ingredientId)]
const listId = item.listId ?? undefined
const created = item.createdDate
if (ingredientId !== undefined && lookups.ingredientsLookup) {
const v = lookups.ingredientsLookup[String(ingredientId)]
if (v !== undefined) item.ingredient = v if (v !== undefined) item.ingredient = v
} }
if (mealId !== undefined && lookups.mealsLookup) { // meal ref (present on all item types)
const v = lookups.mealsLookup[String(mealId)] if ('mealId' in item && item.mealId !== undefined && lookups.mealsLookup) {
const v = lookups.mealsLookup[String(item.mealId)]
if (v !== undefined) item.meal = v if (v !== undefined) item.meal = v
} }
if (recipeId !== undefined && lookups.recipesLookup) { // recipe ref
const v = lookups.recipesLookup[String(recipeId)] if ('recipeId' in item && item.recipeId !== undefined && lookups.recipesLookup) {
const v = lookups.recipesLookup[String(item.recipeId)]
if (v !== undefined) item.recipe = v if (v !== undefined) item.recipe = v
} }
if (listId !== undefined && lookups.shoppingListLookup) { // list ref
const v = lookups.shoppingListLookup[String(listId)] if ('listId' in item && item.listId !== undefined && lookups.shoppingListLookup) {
const v = lookups.shoppingListLookup[String(item.listId)]
if (v !== undefined) item.list = v if (v !== undefined) item.list = v
} }
if (created !== undefined) item.createdDate = toDate(created) if ('createdDate' in item) item.createdDate = toDate(item.createdDate)
} }
} }
@ -115,9 +126,9 @@ export function mapCurrentShoppingList(dto: components['schemas']['CurrentShoppi
} }
const dtoOut: CurrentShoppingListDTO = { const dtoOut: CurrentShoppingListDTO = {
outstandingItems: decodeShoppingListItems(outstandingRaw ?? []), outstandingItems: decodeListIngredientItems(outstandingRaw ?? []),
requestedMeals: decodeShoppingListItems(requestedRaw ?? []), requestedMeals: decodeRequestedMealItems(requestedRaw ?? []),
purchasedItems: decodeShoppingListItems(purchasedRaw ?? []), purchasedItems: decodeListIngredientItems(purchasedRaw ?? []),
...(ingredientsLookup && { ingredientsLookup }), ...(ingredientsLookup && { ingredientsLookup }),
...(mealsLookup && { mealsLookup }), ...(mealsLookup && { mealsLookup }),
...(recipesLookup && { recipesLookup }), ...(recipesLookup && { recipesLookup }),
@ -308,24 +319,18 @@ export async function purchaseShoppingList(
): Promise<import('@/domain/types').ShoppingListWithRefs | null> { ): Promise<import('@/domain/types').ShoppingListWithRefs | null> {
if (!Array.isArray(completedRequests) || completedRequests.length === 0) return null if (!Array.isArray(completedRequests) || completedRequests.length === 0) return null
// Map incoming requests: if id provided and >= 0, use it; otherwise send identifiers for ingredient/recipe/meal // Map incoming requests: if id provided and >= 0, use it; otherwise send identifiers for ingredient/recipe/meal
const items: components['schemas']['ShoppingListItem'][] = completedRequests.map((i) => const items: components['schemas']['IngredientPurchaseItemIn'][] = completedRequests.map((i) => ({
i.type === 'existing'
? { id: i.id, personId: i.personId, ingredientId: i.ingredientId ?? null }
: {
id: -1,
personId: i.personId, personId: i.personId,
ingredientId: i.ingredientId ?? null, ingredientId: i.ingredientId ?? -1,
recipeId: i.recipeId ?? null, recipeId: i.type === 'refs' ? i.recipeId ?? null : null,
mealId: i.mealId ?? null, mealId: i.type === 'refs' ? i.mealId ?? null : null,
} createdDate: null,
) }))
if (items.length === 0) return null if (items.length === 0) return null
const body: components['schemas']['ShoppingList'] = { const body: components['schemas']['PurchaseListIn'] = {
id: -1,
storeName: '', storeName: '',
purchasedById: -1,
items, items,
} }
const { data, error, response } = await api.POST('/api/v1/shopping', { const { data, error, response } = await api.POST('/api/v1/shopping', {

122
src/api/types.ts
View file

@ -340,11 +340,11 @@ export interface components {
/** CurrentShoppingList */ /** CurrentShoppingList */
CurrentShoppingList: { CurrentShoppingList: {
/** Outstandingitems */ /** Outstandingitems */
outstandingItems: components["schemas"]["ShoppingListItem"][]; outstandingItems: components["schemas"]["ListIngredientItem"][];
/** Requestedmeals */ /** Requestedmeals */
requestedMeals: components["schemas"]["ShoppingListItem"][]; requestedMeals: components["schemas"]["RequestedMealItem"][];
/** Purchaseditems */ /** Purchaseditems */
purchasedItems?: components["schemas"]["ShoppingListItem"][]; purchasedItems?: components["schemas"]["ListIngredientItem"][];
/** Ingredientslookup */ /** Ingredientslookup */
ingredientsLookup?: { ingredientsLookup?: {
[key: string]: components["schemas"]["Ingredient"]; [key: string]: components["schemas"]["Ingredient"];
@ -355,7 +355,7 @@ export interface components {
}; };
/** Shoppinglistlookup */ /** Shoppinglistlookup */
shoppingListLookup?: { shoppingListLookup?: {
[key: string]: components["schemas"]["ShoppingList"]; [key: string]: components["schemas"]["ShoppingListOut"];
}; };
/** Recipeslookup */ /** Recipeslookup */
recipesLookup?: { recipesLookup?: {
@ -404,6 +404,49 @@ export interface components {
mealId?: number | null; mealId?: number | null;
product?: components["schemas"]["Product"] | null; product?: components["schemas"]["Product"] | null;
}; };
/** IngredientPurchaseItemIn */
IngredientPurchaseItemIn: {
/** Ingredientid */
ingredientId: number;
/** Personid */
personId: number;
/** Createddate */
createdDate?: string | null;
/** Mealid */
mealId?: number | null;
/** Recipeid */
recipeId?: number | null;
};
/** ListIngredientItem */
ListIngredientItem: {
/**
* Kind
* @default ingredient
* @constant
* @enum {string}
*/
kind: "ingredient";
/**
* Id
* @default -1
*/
id: number;
/** Ingredientid */
ingredientId: number;
/** Personid */
personId: number;
/**
* Createddate
* Format: date-time
*/
createdDate: string;
/** Listid */
listId?: number | null;
/** Mealid */
mealId?: number | null;
/** Recipeid */
recipeId?: number | null;
};
/** LoginBody */ /** LoginBody */
LoginBody: { LoginBody: {
/** Username */ /** Username */
@ -585,9 +628,15 @@ export interface components {
/** Tags */ /** Tags */
tags?: string[]; tags?: string[];
}; };
/** PurchaseListIn */
PurchaseListIn: {
storeName: components["schemas"]["StoreEnum"];
/** Items */
items: components["schemas"]["IngredientPurchaseItemIn"][];
};
/** PurchasedShoppingList */ /** PurchasedShoppingList */
PurchasedShoppingList: { PurchasedShoppingList: {
list: components["schemas"]["ShoppingList"]; list: components["schemas"]["ShoppingListOut"];
/** Mealslookup */ /** Mealslookup */
mealsLookup?: { mealsLookup?: {
[key: string]: components["schemas"]["Meal-Output"]; [key: string]: components["schemas"]["Meal-Output"];
@ -667,54 +716,45 @@ export interface components {
hiddenById?: number | null; hiddenById?: number | null;
hiddenBy?: components["schemas"]["Person"] | null; hiddenBy?: components["schemas"]["Person"] | null;
}; };
/** ShoppingList */ /** RequestedMealItem */
ShoppingList: { RequestedMealItem: {
/**
* Kind
* @default requestedMeal
* @constant
* @enum {string}
*/
kind: "requestedMeal";
/** /**
* Id * Id
* @default -1 * @default -1
*/ */
id: number; id: number;
/** Personid */
personId: number;
/** Mealid */
mealId: number;
/** /**
* Createddate * Createddate
* Format: date-time * Format: date-time
*/ */
createdDate?: string; createdDate: string;
/** @default */ };
storeName: components["schemas"]["StoreEnum"]; /** ShoppingListOut */
ShoppingListOut: {
/** Id */
id: number;
/** /**
* Purchasedbyid * Createddate
* @default -1 * Format: date-time
*/ */
createdDate: string;
storeName: components["schemas"]["StoreEnum"];
/** Purchasedbyid */
purchasedById: number; purchasedById: number;
purchasedBy?: components["schemas"]["Person"] | null; purchasedBy?: components["schemas"]["Person"] | null;
/** Items */ /** Items */
items?: components["schemas"]["ShoppingListItem"][]; items?: components["schemas"]["ListIngredientItem"][];
};
/** ShoppingListItem */
ShoppingListItem: {
/**
* Id
* @default -1
*/
id: number;
/** Listid */
listId?: number | null;
/**
* Personid
* @default -1
*/
personId: number;
/** Ingredientid */
ingredientId?: number | null;
/** Recipeid */
recipeId?: number | null;
/** Mealid */
mealId?: number | null;
/**
* Createddate
* Format: date-time
*/
createdDate?: string;
}; };
/** /**
* StoreEnum * StoreEnum
@ -1293,7 +1333,7 @@ export interface operations {
}; };
requestBody: { requestBody: {
content: { content: {
"application/json": components["schemas"]["ShoppingList"]; "application/json": components["schemas"]["PurchaseListIn"];
}; };
}; };
responses: { responses: {
@ -1415,7 +1455,7 @@ export interface operations {
[name: string]: unknown; [name: string]: unknown;
}; };
content: { content: {
"application/json": components["schemas"]["ShoppingListItem"]; "application/json": components["schemas"]["RequestedMealItem"];
}; };
}; };
404: components["responses"]["Problem404"]; 404: components["responses"]["Problem404"];

24
src/composables/useShopping.ts
View file

@ -1,15 +1,15 @@
import * as sdk from '@/api/sdk' import * as sdk from '@/api/sdk'
import type { ShoppingListItemWithRefs, Product, Meal } from '@/domain/types' import type { ListIngredientItemWithRefs, RequestedMealItemWithRefs, Product, Meal } from '@/domain/types'
export type GroupByProduct = { type: 'product'; product: Product; shoppingListItems: ShoppingListItemWithRefs[] } export type GroupByProduct = { type: 'product'; product: Product; shoppingListItems: ListIngredientItemWithRefs[] }
export type GroupByName = { type: 'name'; name: string; shoppingListItems: ShoppingListItemWithRefs[] } export type GroupByName = { type: 'name'; name: string; shoppingListItems: ListIngredientItemWithRefs[] }
export type Group = GroupByProduct | GroupByName export type Group = GroupByProduct | GroupByName
export function groupsToItems(groups: Group[]): ShoppingListItemWithRefs[] { export function groupsToItems(groups: Group[]): ListIngredientItemWithRefs[] {
return groups.map((g) => g.shoppingListItems).flat() return groups.map((g) => g.shoppingListItems).flat()
} }
export function uniqueMeals(shoppingListItems: ShoppingListItemWithRefs[]): Meal[] { export function uniqueMeals(shoppingListItems: Array<ListIngredientItemWithRefs | RequestedMealItemWithRefs>): Meal[] {
const mealsWithDuplicates = shoppingListItems.map((item) => item.meal).filter((m): m is Meal => !!m) const mealsWithDuplicates = shoppingListItems.map((item) => item.meal).filter((m): m is Meal => !!m)
const mealsLookup: Record<string | number, Meal> = mealsWithDuplicates.reduce<Record<string | number, Meal>>( const mealsLookup: Record<string | number, Meal> = mealsWithDuplicates.reduce<Record<string | number, Meal>>(
(acc, meal) => { (acc, meal) => {
@ -21,7 +21,7 @@ export function uniqueMeals(shoppingListItems: ShoppingListItemWithRefs[]): Meal
return Object.values(mealsLookup) return Object.values(mealsLookup)
} }
export function itemsToGroups(shoppingListItems: ShoppingListItemWithRefs[]): Group[] { export function itemsToGroups(shoppingListItems: ListIngredientItemWithRefs[]): Group[] {
const ingredients_by_product_id: Record<string | number, GroupByProduct> = {} const ingredients_by_product_id: Record<string | number, GroupByProduct> = {}
const ingredients_by_name: Record<string, GroupByName> = {} const ingredients_by_name: Record<string, GroupByName> = {}
for (const item of shoppingListItems) { for (const item of shoppingListItems) {
@ -52,8 +52,8 @@ export function itemsToGroups(shoppingListItems: ShoppingListItemWithRefs[]): Gr
} }
export function useShopping() { export function useShopping() {
const groupsFrom = (items?: ShoppingListItemWithRefs[]): Group[] => itemsToGroups(items ?? []) const groupsFrom = (items?: ListIngredientItemWithRefs[]): Group[] => itemsToGroups(items ?? [])
const mealsFrom = (items?: ShoppingListItemWithRefs[]): Meal[] => uniqueMeals(items ?? []) const mealsFrom = (items?: Array<ListIngredientItemWithRefs | RequestedMealItemWithRefs>): Meal[] => uniqueMeals(items ?? [])
return { return {
getCurrentShoppingList: sdk.getCurrentShoppingList, getCurrentShoppingList: sdk.getCurrentShoppingList,
getShoppingList: sdk.getShoppingList, getShoppingList: sdk.getShoppingList,
@ -68,14 +68,14 @@ export function useShopping() {
async purchaseFromGroups(groups: Group[]) { async purchaseFromGroups(groups: Group[]) {
const items = groupsToItems(groups).map((i): sdk.PurchaseRequest => { const items = groupsToItems(groups).map((i): sdk.PurchaseRequest => {
if (typeof i.id === 'number' && i.id >= 0) { if (typeof i.id === 'number' && i.id >= 0) {
return { type: 'existing', id: i.id, personId: i.personId, ingredientId: i.ingredient?.id ?? null } return { type: 'existing', id: i.id, personId: i.personId, ingredientId: i.ingredientId ?? null }
} }
return { return {
type: 'refs', type: 'refs',
personId: i.personId, personId: i.personId,
ingredientId: i.ingredient?.id ?? null, ingredientId: i.ingredientId ?? null,
recipeId: i.recipe?.id ?? null, recipeId: i.recipeId ?? null,
mealId: i.meal?.id ?? null, mealId: i.mealId ?? null,
} }
}) })
if (!items?.length) return null if (!items?.length) return null

50
src/domain/decoders.ts
View file

@ -1,4 +1,19 @@
import type { RecipeOut, Recipe, MealOut, Meal, MealRecipe, Ingredient as DomainIngredient, ShoppingList, ShoppingListItem, ShoppingListItemWithRefs, MealInput } from './types' import type {
RecipeOut,
Recipe,
MealOut,
Meal,
MealRecipe,
Ingredient as DomainIngredient,
ShoppingList,
ShoppingListItem,
ShoppingListItemWithRefs,
MealInput,
ListIngredientItem,
RequestedMealItem,
ListIngredientItemWithRefs,
RequestedMealItemWithRefs,
} from './types'
import type { components } from '@/api/types' import type { components } from '@/api/types'
export function toDate(value: string | Date | null | undefined): Date | null { export function toDate(value: string | Date | null | undefined): Date | null {
@ -70,7 +85,7 @@ export function decodeIngredients(list: components['schemas']['Ingredient'][] |
return list.map((i) => decodeIngredient(i)) return list.map((i) => decodeIngredient(i))
} }
function decodeShoppingListItem(i: components['schemas']['ShoppingListItem'] | null | undefined): ShoppingListItem { function decodeShoppingListItem(i: components['schemas']['ListIngredientItem'] | null | undefined): ShoppingListItem {
if (!i) throw new Error('Invalid shopping list item payload') if (!i) throw new Error('Invalid shopping list item payload')
return { return {
...i, ...i,
@ -78,13 +93,13 @@ function decodeShoppingListItem(i: components['schemas']['ShoppingListItem'] | n
} }
} }
export function decodeShoppingListItems(list: components['schemas']['ShoppingListItem'][] | null | undefined): ShoppingListItemWithRefs[] { export function decodeShoppingListItems(list: components['schemas']['ListIngredientItem'][] | null | undefined): ShoppingListItemWithRefs[] {
if (!Array.isArray(list)) return [] if (!Array.isArray(list)) return []
// Build a new array with item clones to allow optional refs to be attached later // Build a new array with item clones to allow optional refs to be attached later
return list.map((raw) => ({ ...decodeShoppingListItem(raw) })) return list.map((raw) => ({ ...decodeShoppingListItem(raw) }))
} }
export function decodeShoppingList(v: components['schemas']['ShoppingList'] | null | undefined): ShoppingList { export function decodeShoppingList(v: components['schemas']['ShoppingListOut'] | null | undefined): ShoppingList {
if (!v) throw new Error('Invalid shopping list payload') if (!v) throw new Error('Invalid shopping list payload')
const { items: rawItems, ...rest } = v const { items: rawItems, ...rest } = v
const items = Array.isArray(rawItems) ? decodeShoppingListItems(rawItems) : undefined const items = Array.isArray(rawItems) ? decodeShoppingListItems(rawItems) : undefined
@ -95,6 +110,33 @@ export function decodeShoppingList(v: components['schemas']['ShoppingList'] | nu
} }
} }
// New item decoders for tightened CurrentShoppingList
function decodeListIngredientItem(i: components['schemas']['ListIngredientItem'] | null | undefined): ListIngredientItem {
if (!i) throw new Error('Invalid list ingredient item payload')
return {
...i,
createdDate: toDate(i.createdDate),
}
}
export function decodeListIngredientItems(list: components['schemas']['ListIngredientItem'][] | null | undefined): ListIngredientItemWithRefs[] {
if (!Array.isArray(list)) return []
return list.map((raw) => ({ ...decodeListIngredientItem(raw) }))
}
function decodeRequestedMealItem(i: components['schemas']['RequestedMealItem'] | null | undefined): RequestedMealItem {
if (!i) throw new Error('Invalid requested meal item payload')
return {
...i,
createdDate: toDate(i.createdDate),
}
}
export function decodeRequestedMealItems(list: components['schemas']['RequestedMealItem'][] | null | undefined): RequestedMealItemWithRefs[] {
if (!Array.isArray(list)) return []
return list.map((raw) => ({ ...decodeRequestedMealItem(raw) }))
}
// Helper to convert domain Meal to MealInput, keeping Date→string conversion in boundary // Helper to convert domain Meal to MealInput, keeping Date→string conversion in boundary
export function toMealInput(meal: Meal): MealInput { export function toMealInput(meal: Meal): MealInput {
return { return {

19
src/domain/types.ts
View file

@ -39,12 +39,19 @@ export type Meal = Replace<
> >
// Shopping domain shapes with dates normalized // Shopping domain shapes with dates normalized
export type ShoppingListItem = WithDates<components['schemas']['ShoppingListItem'], 'createdDate'> // Items inside purchased lists and current lists share the ListIngredientItem shape
type ShoppingListBase = WithDates<components['schemas']['ShoppingList'], 'createdDate'> export type ShoppingListItem = WithDates<components['schemas']['ListIngredientItem'], 'createdDate'>
type ShoppingListBase = WithDates<components['schemas']['ShoppingListOut'], 'createdDate'>
export type ShoppingList = Replace<ShoppingListBase, { items?: ShoppingListItem[] | undefined }> export type ShoppingList = Replace<ShoppingListBase, { items?: ShoppingListItem[] | undefined }>
// Refs attached to shopping list items // Current shopping list item types (tightened OpenAPI)
export type ListIngredientItem = WithDates<components['schemas']['ListIngredientItem'], 'createdDate'>
export type RequestedMealItem = WithDates<components['schemas']['RequestedMealItem'], 'createdDate'>
// Refs attached to items
export type ShoppingListItemWithRefs = WithRefs<ShoppingListItem, { ingredient: Ingredient; recipe: Recipe; meal: Meal; list: ShoppingList }> export type ShoppingListItemWithRefs = WithRefs<ShoppingListItem, { ingredient: Ingredient; recipe: Recipe; meal: Meal; list: ShoppingList }>
export type ListIngredientItemWithRefs = WithRefs<ListIngredientItem, { ingredient: Ingredient; recipe: Recipe; meal: Meal; list: ShoppingList }>
export type RequestedMealItemWithRefs = WithRefs<RequestedMealItem, { meal: Meal }>
export type ShoppingListWithRefs = Replace<ShoppingList, { items?: ShoppingListItemWithRefs[] }> export type ShoppingListWithRefs = Replace<ShoppingList, { items?: ShoppingListItemWithRefs[] }>
@ -58,9 +65,9 @@ export type ShoppingLookups = {
// DTO shapes returned by SDK for shopping pages // DTO shapes returned by SDK for shopping pages
export type CurrentShoppingListDTO = { export type CurrentShoppingListDTO = {
outstandingItems: ShoppingListItemWithRefs[] outstandingItems: ListIngredientItemWithRefs[]
requestedMeals: ShoppingListItemWithRefs[] requestedMeals: RequestedMealItemWithRefs[]
purchasedItems: ShoppingListItemWithRefs[] purchasedItems: ListIngredientItemWithRefs[]
} & ShoppingLookups } & ShoppingLookups
export type PurchasedShoppingListDTO = ShoppingLookups & { export type PurchasedShoppingListDTO = ShoppingLookups & {