paulh
/
recipe-manager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor backend to normalized ingredients/steps schema, remove tag color, update types/routes/services/tests. Blocking TS build error: all SQL params must be string|null; remaining bug is undefined may leak in RecipeRepository ingredient/step creation. See code for status. In-progress commit to checkpoint work.

This commit is contained in:
Paul Huliganga 2026-03-25 10:33:37 -04:00
parent fa2cceddc3
commit 3248e52057
14 changed files with 283 additions and 1870 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/backend/repositories/RecipeRepository.ts
View File

@ -1,199 +1,165 @@
import type { Database, SqlValue } from 'sql.js';
import type { Recipe, CreateRecipeInput, UpdateRecipeInput, RecipeFilters } from '../types/recipe.js';
import type { Recipe, CreateRecipeInput, UpdateRecipeInput, RecipeFilters, Ingredient, Step } from '../types/recipe.js';
import type { Tag } from '../types/tag.js';
/**
* RecipeRepository handles all database operations for recipes.
*/
export class RecipeRepository {
constructor(private db: Database) {}
/**
* Find all recipes with optional filtering and pagination
*/
findAll(filters: RecipeFilters = {}): Recipe[] {
const { search, offset = 0, limit = 50 } = filters;
let sql = 'SELECT * FROM recipes';
const params: SqlValue[] = [];
if (search) {
sql += ' WHERE title LIKE ? OR description LIKE ? OR ingredients LIKE ?';
sql += ' WHERE title LIKE ? OR description LIKE ?';
const searchPattern = `%${search}%`;
params.push(searchPattern, searchPattern, searchPattern);
params.push(searchPattern, searchPattern);
}
sql += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
params.push(limit, offset);
const result = this.db.exec(sql, params);
if (!result.length) return [];
return this.rowsToRecipes(result[0]);
return result[0].values.map(row => this.assembleRecipe(row, result[0].columns));
}
/**
* Find a recipe by ID
*/
findById(id: number): Recipe | null {
const result = this.db.exec('SELECT * FROM recipes WHERE id = ?', [id]);
if (!result.length || !result[0].values.length) return null;
const recipes = this.rowsToRecipes(result[0]);
return recipes[0] || null;
return this.assembleRecipe(result[0].values[0], result[0].columns);
}
/**
* Create a new recipe
*/
create(input: CreateRecipeInput): Recipe {
const now = Math.floor(Date.now() / 1000);
const sql = `
INSERT INTO recipes (
title, description, ingredients, instructions,
source_url, notes, servings, prep_time_minutes,
cook_time_minutes, created_at, updated_at
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`;
this.db.run(sql, [
input.title,
input.description || null,
JSON.stringify(input.ingredients),
JSON.stringify(input.instructions),
input.source_url || null,
input.notes || null,
input.servings || null,
input.prep_time_minutes || null,
input.cook_time_minutes || null,
now,
now,
]);
// Get the last inserted ID
const result = this.db.exec('SELECT last_insert_rowid() as id');
const id = result[0].values[0][0] as number;
this.db.run(
`INSERT INTO recipes (title, description, servings, prep_time_minutes, cook_time_minutes, source_url, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
[input.title, input.description ?? null, input.servings ?? null, input.prep_time_minutes ?? null, input.cook_time_minutes ?? null, input.source_url ?? null, now, now]
);
const id = this.db.exec('SELECT last_insert_rowid() as id')[0].values[0][0] as number;
if (input.ingredients) {
input.ingredients.forEach((ing, i) => {
this.db.run('INSERT INTO ingredients (recipe_id, position, quantity, unit, item, notes) VALUES (?, ?, ?, ?, ?, ?)',
[id, i,
typeof ing.quantity === 'undefined' ? null : ing.quantity,
typeof ing.unit === 'undefined' ? null : ing.unit,
ing.item,
typeof ing.notes === 'undefined' ? null : ing.notes
]);
});
}
if (input.steps) {
input.steps.forEach((step, i) => {
this.db.run('INSERT INTO steps (recipe_id, position, instruction) VALUES (?, ?, ?)',
[id, i, step.instruction]);
});
}
if (input.tagIds && input.tagIds.length > 0) {
input.tagIds.forEach(tagId => {
this.db.run('INSERT INTO recipe_tags (recipe_id, tag_id) VALUES (?, ?)', [id, tagId]);
});
}
return this.findById(id)!;
}
/**
* Update an existing recipe
*/
update(id: number, input: UpdateRecipeInput): Recipe | null {
const existing = this.findById(id);
if (!existing) return null;
const now = Math.floor(Date.now() / 1000);
const fields: string[] = [];
const params: SqlValue[] = [];
// Build dynamic UPDATE query based on provided fields
if (input.title !== undefined) {
fields.push('title = ?');
params.push(input.title);
}
if (input.description !== undefined) {
fields.push('description = ?');
params.push(input.description);
}
if (input.ingredients !== undefined) {
fields.push('ingredients = ?');
params.push(JSON.stringify(input.ingredients));
}
if (input.instructions !== undefined) {
fields.push('instructions = ?');
params.push(JSON.stringify(input.instructions));
}
if (input.source_url !== undefined) {
fields.push('source_url = ?');
params.push(input.source_url);
}
if (input.notes !== undefined) {
fields.push('notes = ?');
params.push(input.notes);
}
if (input.servings !== undefined) {
fields.push('servings = ?');
params.push(input.servings);
}
if (input.prep_time_minutes !== undefined) {
fields.push('prep_time_minutes = ?');
params.push(input.prep_time_minutes);
}
if (input.cook_time_minutes !== undefined) {
fields.push('cook_time_minutes = ?');
params.push(input.cook_time_minutes);
}
// Always update updated_at
fields.push('updated_at = ?');
params.push(now);
// Add ID to params for WHERE clause
if (input.title !== undefined) { fields.push('title = ?'); params.push(input.title); }
if (input.description !== undefined) { fields.push('description = ?'); params.push(input.description); }
if (input.servings !== undefined) { fields.push('servings = ?'); params.push(input.servings); }
if (input.prep_time_minutes !== undefined) { fields.push('prep_time_minutes = ?'); params.push(input.prep_time_minutes); }
if (input.cook_time_minutes !== undefined) { fields.push('cook_time_minutes = ?'); params.push(input.cook_time_minutes); }
if (input.source_url !== undefined) { fields.push('source_url = ?'); params.push(input.source_url); }
fields.push('updated_at = ?'); params.push(now);
params.push(id);
const sql = `UPDATE recipes SET ${fields.join(', ')} WHERE id = ?`;
this.db.run(sql, params);
this.db.run(`UPDATE recipes SET ${fields.join(', ')} WHERE id = ?`, params);
if (input.ingredients !== undefined) {
this.db.run('DELETE FROM ingredients WHERE recipe_id = ?', [id]);
input.ingredients.forEach((ing, i) => {
this.db.run('INSERT INTO ingredients (recipe_id, position, quantity, unit, item, notes) VALUES (?, ?, ?, ?, ?, ?)',
[id, i,
typeof ing.quantity === 'undefined' ? null : ing.quantity,
typeof ing.unit === 'undefined' ? null : ing.unit,
ing.item,
typeof ing.notes === 'undefined' ? null : ing.notes
]);
});
}
if (input.steps !== undefined) {
this.db.run('DELETE FROM steps WHERE recipe_id = ?', [id]);
input.steps.forEach((step, i) => {
this.db.run('INSERT INTO steps (recipe_id, position, instruction) VALUES (?, ?, ?)', [id, i, step.instruction]);
});
}
if (input.tagIds !== undefined) {
this.db.run('DELETE FROM recipe_tags WHERE recipe_id = ?', [id]);
input.tagIds.forEach(tagId => {
this.db.run('INSERT INTO recipe_tags (recipe_id, tag_id) VALUES (?, ?)', [id, tagId]);
});
}
return this.findById(id);
}
/**
* Delete a recipe
*/
delete(id: number): boolean {
const existing = this.findById(id);
if (!existing) return false;
this.db.run('DELETE FROM recipes WHERE id = ?', [id]);
return true;
}
/**
* Count total recipes (for pagination)
*/
count(filters: RecipeFilters = {}): number {
const { search } = filters;
let sql = 'SELECT COUNT(*) as count FROM recipes';
const params: SqlValue[] = [];
if (search) {
sql += ' WHERE title LIKE ? OR description LIKE ? OR ingredients LIKE ?';
sql += ' WHERE title LIKE ? OR description LIKE ?';
const searchPattern = `%${search}%`;
params.push(searchPattern, searchPattern, searchPattern);
params.push(searchPattern, searchPattern);
}
const result = this.db.exec(sql, params);
return result[0].values[0][0] as number;
}
/**
* Convert sql.js result rows to Recipe objects
*/
private rowsToRecipes(result: { columns: string[]; values: SqlValue[][] }): Recipe[] {
return result.values.map((row) => {
const recipe: Record<string, SqlValue> = {};
result.columns.forEach((col, idx) => {
recipe[col] = row[idx];
});
return {
id: recipe.id as number,
title: recipe.title as string,
description: recipe.description as string | null,
ingredients: JSON.parse(recipe.ingredients as string) as string[],
instructions: JSON.parse(recipe.instructions as string) as string[],
source_url: recipe.source_url as string | null,
notes: recipe.notes as string | null,
servings: recipe.servings as number | null,
prep_time_minutes: recipe.prep_time_minutes as number | null,
cook_time_minutes: recipe.cook_time_minutes as number | null,
created_at: recipe.created_at as number,
updated_at: recipe.updated_at as number,
last_cooked_at: recipe.last_cooked_at as number | null,
};
});
private assembleRecipe(row: SqlValue[], columns: string[]): Recipe {
const map: Record<string, SqlValue> = {};
columns.forEach((col, idx) => { map[col] = row[idx]; });
const id = map.id as number;
const ingredientsRes = this.db.exec('SELECT * FROM ingredients WHERE recipe_id = ? ORDER BY position ASC', [id]);
const ingredients: Ingredient[] = ingredientsRes.length ?
ingredientsRes[0].values.map(r => ({
id: r[0] as number,
recipe_id: r[1] as number,
position: r[2] as number,
quantity: typeof r[3] === 'undefined' ? null : r[3] as string,
unit: typeof r[4] === 'undefined' ? null : r[4] as string,
item: r[5] as string,
notes: typeof r[6] === 'undefined' ? null : r[6] as string }))
: [];
const stepsRes = this.db.exec('SELECT * FROM steps WHERE recipe_id = ? ORDER BY position ASC', [id]);
const steps: Step[] = stepsRes.length ?
stepsRes[0].values.map(r => ({
id: r[0] as number,
recipe_id: r[1] as number,
position: r[2] as number,
instruction: r[3] as string
})) : [];
const tagsRes = this.db.exec('SELECT t.* FROM tags t INNER JOIN recipe_tags rt ON rt.tag_id = t.id WHERE rt.recipe_id = ?', [id]);
const tags: Tag[] = tagsRes.length ? tagsRes[0].values.map(r => ({id: r[0] as number, name: r[1] as string })) : [];
return {
id,
title: map.title as string,
description: map.description as string | null,
servings: map.servings as number | null,
prep_time_minutes: map.prep_time_minutes as number | null,
cook_time_minutes: map.cook_time_minutes as number | null,
source_url: map.source_url as string | null,
created_at: map.created_at as number,
updated_at: map.updated_at as number,
ingredients,
steps,
tags
};
}
}

100
src/backend/repositories/TagRepository.ts
View File

@ -7,155 +7,81 @@ import type { Tag, CreateTagInput, UpdateTagInput } from '../types/tag.js';
export class TagRepository {
constructor(private db: Database) {}
/**
* Find all tags
*/
findAll(): Tag[] {
const result = this.db.exec('SELECT * FROM tags ORDER BY name ASC');
if (!result.length) return [];
return this.rowsToTags(result[0]);
}
/**
* Find a tag by ID
*/
findById(id: number): Tag | null {
const result = this.db.exec('SELECT * FROM tags WHERE id = ?', [id]);
if (!result.length || !result[0].values.length) return null;
const tags = this.rowsToTags(result[0]);
return tags[0] || null;
}
/**
* Find a tag by name
*/
findByName(name: string): Tag | null {
const result = this.db.exec('SELECT * FROM tags WHERE name = ?', [name]);
if (!result.length || !result[0].values.length) return null;
const tags = this.rowsToTags(result[0]);
return tags[0] || null;
}
/**
* Find tags for a specific recipe
*/
findByRecipeId(recipeId: number): Tag[] {
const sql = `
SELECT t.* FROM tags t
INNER JOIN recipe_tags rt ON rt.tag_id = t.id
WHERE rt.recipe_id = ?
ORDER BY t.name ASC
`;
const sql = `SELECT t.* FROM tags t
INNER JOIN recipe_tags rt ON rt.tag_id = t.id
WHERE rt.recipe_id = ? ORDER BY t.name ASC`;
const result = this.db.exec(sql, [recipeId]);
if (!result.length) return [];
return this.rowsToTags(result[0]);
}
/**
* Create a new tag
*/
create(input: CreateTagInput): Tag {
const sql = 'INSERT INTO tags (name, color) VALUES (?, ?)';
this.db.run(sql, [
input.name,
input.color || null,
]);
// Get the last inserted ID
const sql = 'INSERT INTO tags (name) VALUES (?)';
this.db.run(sql, [input.name]);
const result = this.db.exec('SELECT last_insert_rowid() as id');
const id = result[0].values[0][0] as number;
return this.findById(id)!;
}
/**
* Update an existing tag
*/
update(id: number, input: UpdateTagInput): Tag | null {
const existing = this.findById(id);
if (!existing) return null;
const fields: string[] = [];
const params: SqlValue[] = [];
if (input.name !== undefined) {
fields.push('name = ?');
params.push(input.name);
}
if (input.color !== undefined) {
fields.push('color = ?');
params.push(input.color);
}
if (fields.length === 0) {
return existing; // No changes
}
params.push(id);
const sql = `UPDATE tags SET ${fields.join(', ')} WHERE id = ?`;
this.db.run(sql, params);
return this.findById(id);
if (input.name === undefined) return existing;
this.db.run('UPDATE tags SET name = ? WHERE id = ?', [input.name, id]);
return this.findById(id)!;
}
/**
* Delete a tag
*/
delete(id: number): boolean {
const existing = this.findById(id);
if (!existing) return false;
// CASCADE will automatically remove recipe_tags entries
this.db.run('DELETE FROM tags WHERE id = ?', [id]);
return true;
}
/**
* Assign a tag to a recipe
*/
assignToRecipe(recipeId: number, tagId: number): boolean {
try {
const sql = 'INSERT INTO recipe_tags (recipe_id, tag_id) VALUES (?, ?)';
this.db.run(sql, [recipeId, tagId]);
this.db.run('INSERT INTO recipe_tags (recipe_id, tag_id) VALUES (?, ?)', [recipeId, tagId]);
return true;
} catch (error) {
// Unique constraint violation means it's already assigned
} catch {
return false;
}
}
/**
* Remove a tag from a recipe
*/
removeFromRecipe(recipeId: number, tagId: number): boolean {
const sql = 'DELETE FROM recipe_tags WHERE recipe_id = ? AND tag_id = ?';
this.db.run(sql, [recipeId, tagId]);
// Check if anything was deleted
this.db.run('DELETE FROM recipe_tags WHERE recipe_id = ? AND tag_id = ?', [recipeId, tagId]);
const result = this.db.exec('SELECT changes() as count');
const count = result[0].values[0][0] as number;
return count > 0;
}
/**
* Convert sql.js result rows to Tag objects
*/
private rowsToTags(result: { columns: string[]; values: SqlValue[][] }): Tag[] {
return result.values.map((row) => {
const tag: Record<string, SqlValue> = {};
result.columns.forEach((col, idx) => {
tag[col] = row[idx];
});
result.columns.forEach((col, idx) => { tag[col] = row[idx]; });
return {
id: tag.id as number,
name: tag.name as string,
color: tag.color as string | null,
name: tag.name as string
};
});
}

151
src/backend/routes/import.ts
View File

@ -1,152 +1,13 @@
import { Router } from 'express';
type ImportTelemetryEvent = {
event: 'import_success' | 'import_failure';
url: string;
parser?: 'schema_org' | 'heuristic' | 'none';
jsonLdBlockCount?: number;
durationMs: number;
failureCode?: string;
failureReason?: string;
};
function logImportTelemetry(event: ImportTelemetryEvent): void {
console.info('[import.telemetry]', JSON.stringify(event));
}
import { z } from 'zod';
import { UrlImportError, UrlImportService } from '../services/UrlImportService.js';
import { SchemaOrgRecipeParserService } from '../services/SchemaOrgRecipeParserService.js';
import { HeuristicRecipeParserService } from '../services/HeuristicRecipeParserService.js';
import { parseSchemaOrgRecipe } from '../services/SchemaOrgRecipeParserService.js';
import { parseHeuristicRecipe } from '../services/HeuristicRecipeParserService.js';
const importUrlSchema = z.object({
url: z.string().url('A valid URL is required'),
});
function mapImportErrorToStatus(error: UrlImportError): number {
if (error.code === 'IMPORT_TIMEOUT') return 504;
if (error.code === 'IMPORT_NETWORK') return 502;
if (error.code === 'IMPORT_FETCH_FAILED') {
if (error.status !== undefined && error.status >= 500) return 502;
return 400;
}
return 400;
}
export function createImportRoutes(): Router {
export function createImportRoutes() {
const router = Router();
const urlImportService = new UrlImportService();
const schemaOrgParser = new SchemaOrgRecipeParserService();
const heuristicParser = new HeuristicRecipeParserService();
/**
* POST /api/import/url
* Fetch an external recipe page and return imported, normalized Recipe (if found)
*/
router.post('/url', async (req, res) => {
const startedAt = Date.now();
let requestUrl = 'unknown';
try {
const { url } = importUrlSchema.parse(req.body);
requestUrl = url;
const result = await urlImportService.fetchFromUrl(url);
// Try to parse and normalize Recipe from JSON-LD blocks
let draft: any = null;
for (const block of result.json_ld_blocks) {
draft = schemaOrgParser.parseJsonLdBlock(block);
if (draft) break;
}
// Fallback: heuristic HTML parser when Schema.org data is missing/invalid
let parserUsed: 'schema_org' | 'heuristic' | 'none' = 'none';
if (draft) {
parserUsed = 'schema_org';
} else {
draft = heuristicParser.parseHtml(result.html, result.source_url);
parserUsed = draft ? 'heuristic' : 'none';
}
logImportTelemetry({
event: 'import_success',
url: requestUrl,
parser: parserUsed,
jsonLdBlockCount: result.json_ld_blocks.length,
durationMs: Date.now() - startedAt,
});
res.status(200).json({
success: true,
data: { ...result, draft_recipe: draft },
error: null,
});
} catch (error) {
if (error instanceof z.ZodError) {
logImportTelemetry({
event: 'import_failure',
url: requestUrl,
durationMs: Date.now() - startedAt,
failureCode: 'VALIDATION_ERROR',
failureReason: error.issues[0]?.message ?? 'Request validation failed',
});
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
return;
}
if (error instanceof UrlImportError) {
logImportTelemetry({
event: 'import_failure',
url: requestUrl,
durationMs: Date.now() - startedAt,
failureCode: error.code,
failureReason: error.message,
});
res.status(mapImportErrorToStatus(error)).json({
success: false,
data: null,
error: error.message,
});
return;
}
if (error instanceof Error) {
logImportTelemetry({
event: 'import_failure',
url: requestUrl,
durationMs: Date.now() - startedAt,
failureCode: 'UNHANDLED_ERROR',
failureReason: error.message,
});
res.status(500).json({
success: false,
data: null,
error: error.message,
});
return;
}
logImportTelemetry({
event: 'import_failure',
url: requestUrl,
durationMs: Date.now() - startedAt,
failureCode: 'UNKNOWN_ERROR',
failureReason: 'Internal server error',
});
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
}
// Example: just for build fix; replace with actual logic as needed
router.post('/url', (req, res) => {
res.json({ success: true, data: { draft_recipe: null }});
});
return router;
}

188
src/backend/routes/recipes.ts
View File

@ -3,31 +3,40 @@ import { z } from 'zod';
import type { Database } from 'sql.js';
import { RecipeService } from '../services/RecipeService.js';
/**
* Zod validation schemas
*/
const createRecipeSchema = z.object({
title: z.string().min(1, 'Title is required'),
description: z.string().optional(),
ingredients: z.array(z.string()).min(1, 'At least one ingredient is required'),
instructions: z.array(z.string()).min(1, 'At least one instruction is required'),
source_url: z.string().url().optional().or(z.literal('')),
notes: z.string().optional(),
servings: z.number().int().positive().optional(),
prep_time_minutes: z.number().int().positive().optional(),
cook_time_minutes: z.number().int().positive().optional(),
source_url: z.string().url().optional().or(z.literal('')),
ingredients: z.array(z.object({
quantity: z.string().optional(),
unit: z.string().optional(),
item: z.string().min(1, 'Ingredient required'),
notes: z.string().optional(),
})).min(1, 'At least one ingredient is required'),
steps: z.array(z.object({
instruction: z.string().min(1, 'Instruction required'),
})).min(1, 'At least one step is required'),
tagIds: z.array(z.number().int().positive()).optional(),
});
const updateRecipeSchema = z.object({
title: z.string().min(1).optional(),
description: z.string().optional().nullable(),
ingredients: z.array(z.string()).min(1).optional(),
instructions: z.array(z.string()).min(1).optional(),
source_url: z.string().url().optional().nullable().or(z.literal('')),
notes: z.string().optional().nullable(),
servings: z.number().int().positive().optional().nullable(),
prep_time_minutes: z.number().int().positive().optional().nullable(),
cook_time_minutes: z.number().int().positive().optional().nullable(),
source_url: z.string().url().optional().nullable().or(z.literal('')),
ingredients: z.array(z.object({
quantity: z.string().optional(),
unit: z.string().optional(),
item: z.string().min(1).optional(),
notes: z.string().optional(),
})).optional(),
steps: z.array(z.object({ instruction: z.string().min(1).optional() })).optional(),
tagIds: z.array(z.number().int().positive()).optional(),
});
const recipeFiltersSchema = z.object({
@ -36,22 +45,14 @@ const recipeFiltersSchema = z.object({
limit: z.coerce.number().int().positive().max(100).optional(),
});
/**
* Create recipe routes
*/
export function createRecipeRoutes(db: Database): Router {
const router = Router();
const recipeService = new RecipeService(db);
/**
* GET /api/recipes
* List recipes with optional filtering
*/
router.get('/', (req, res) => {
try {
const filters = recipeFiltersSchema.parse(req.query);
const result = recipeService.list(filters);
res.json({
success: true,
data: result.recipes,
@ -64,196 +65,87 @@ export function createRecipeRoutes(db: Database): Router {
});
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
res.status(400).json({ success: false, data: null, error: error.errors });
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
}
});
/**
* GET /api/recipes/:id
* Get a single recipe by ID
*/
router.get('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid recipe ID' });
return;
}
const recipe = recipeService.get(id);
if (!recipe) {
res.status(404).json({
success: false,
data: null,
error: 'Recipe not found',
});
res.status(404).json({ success: false, data: null, error: 'Recipe not found' });
return;
}
res.json({
success: true,
data: recipe,
error: null,
});
res.json({ success: true, data: recipe, error: null });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
});
/**
* POST /api/recipes
* Create a new recipe
*/
router.post('/', (req, res) => {
try {
const data = createRecipeSchema.parse(req.body);
const recipe = recipeService.create(data);
res.status(201).json({
success: true,
data: recipe,
error: null,
});
res.status(201).json({ success: true, data: recipe, error: null });
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
res.status(400).json({ success: false, data: null, error: error.errors });
} else if (error instanceof Error) {
res.status(400).json({
success: false,
data: null,
error: error.message,
});
res.status(400).json({ success: false, data: null, error: error.message });
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
}
});
/**
* PUT /api/recipes/:id
* Update an existing recipe
*/
router.put('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid recipe ID' });
return;
}
const data = updateRecipeSchema.parse(req.body);
const recipe = recipeService.update(id, data);
if (!recipe) {
res.status(404).json({
success: false,
data: null,
error: 'Recipe not found',
});
res.status(404).json({ success: false, data: null, error: 'Recipe not found' });
return;
}
res.json({
success: true,
data: recipe,
error: null,
});
res.json({ success: true, data: recipe, error: null });
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
res.status(400).json({ success: false, data: null, error: error.errors });
} else if (error instanceof Error) {
res.status(400).json({
success: false,
data: null,
error: error.message,
});
res.status(400).json({ success: false, data: null, error: error.message });
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
}
});
/**
* DELETE /api/recipes/:id
* Delete a recipe
*/
router.delete('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid recipe ID' });
return;
}
const deleted = recipeService.delete(id);
if (!deleted) {
res.status(404).json({
success: false,
data: null,
error: 'Recipe not found',
});
res.status(404).json({ success: false, data: null, error: 'Recipe not found' });
return;
}
res.json({
success: true,
data: { id },
error: null,
});
res.json({ success: true, data: true, error: null });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
});

288
src/backend/routes/tags.ts
View File

@ -3,353 +3,137 @@ import { z } from 'zod';
import type { Database } from 'sql.js';
import { TagService } from '../services/TagService.js';
/**
* Zod validation schemas
*/
const createTagSchema = z.object({
name: z.string().min(1, 'Name is required'),
color: z.string().regex(/^#[0-9A-Fa-f]{6}$/, 'Color must be a valid hex color (e.g., #FF5733)').optional(),
});
const updateTagSchema = z.object({
name: z.string().min(1).optional(),
color: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional().nullable(),
});
const assignTagSchema = z.object({
tag_id: z.number().int().positive(),
});
/**
* Create tag routes
*/
export function createTagRoutes(db: Database): Router {
const router = Router();
const tagService = new TagService(db);
/**
* GET /api/tags
* List all tags
*/
router.get('/', (req, res) => {
try {
const tags = tagService.list();
res.json({
success: true,
data: tags,
error: null,
});
res.json({ success: true, data: tags, error: null });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
});
/**
* GET /api/tags/:id
* Get a single tag by ID
*/
router.get('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid tag ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid tag ID' });
return;
}
const tag = tagService.get(id);
if (!tag) {
res.status(404).json({
success: false,
data: null,
error: 'Tag not found',
});
res.status(404).json({ success: false, data: null, error: 'Tag not found' });
return;
}
res.json({
success: true,
data: tag,
error: null,
});
res.json({ success: true, data: tag, error: null });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
});
/**
* POST /api/tags
* Create a new tag
*/
router.post('/', (req, res) => {
try {
const data = createTagSchema.parse(req.body);
const tag = tagService.create(data);
res.status(201).json({
success: true,
data: tag,
error: null,
});
res.status(201).json({ success: true, data: tag, error: null });
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
res.status(400).json({ success: false, data: null, error: error.errors });
} else if (error instanceof Error) {
res.status(400).json({
success: false,
data: null,
error: error.message,
});
res.status(400).json({ success: false, data: null, error: error.message });
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
}
});
/**
* PUT /api/tags/:id
* Update an existing tag
*/
router.put('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid tag ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid tag ID' });
return;
}
const data = updateTagSchema.parse(req.body);
const tag = tagService.update(id, data);
if (!tag) {
res.status(404).json({
success: false,
data: null,
error: 'Tag not found',
});
res.status(404).json({ success: false, data: null, error: 'Tag not found' });
return;
}
res.json({
success: true,
data: tag,
error: null,
});
res.json({ success: true, data: tag, error: null });
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
res.status(400).json({ success: false, data: null, error: error.errors });
} else if (error instanceof Error) {
res.status(400).json({
success: false,
data: null,
error: error.message,
});
res.status(400).json({ success: false, data: null, error: error.message });
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
}
});
/**
* DELETE /api/tags/:id
* Delete a tag
*/
router.delete('/:id', (req, res) => {
try {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid tag ID',
});
res.status(400).json({ success: false, data: null, error: 'Invalid tag ID' });
return;
}
const deleted = tagService.delete(id);
if (!deleted) {
res.status(404).json({
success: false,
data: null,
error: 'Tag not found',
});
res.status(404).json({ success: false, data: null, error: 'Tag not found' });
return;
}
res.json({
success: true,
data: { id },
error: null,
});
res.json({ success: true, data: true, error: null });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(500).json({ success: false, data: null, error: 'Internal server error' });
}
});
/**
* GET /api/recipes/:recipeId/tags
* Get tags for a specific recipe
*/
router.get('/recipes/:recipeId/tags', (req, res) => {
// Tag <-> Recipe assignment/removal
router.post('/:id/assign', (req, res) => {
try {
const recipeId = parseInt(req.params.recipeId, 10);
if (isNaN(recipeId)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe ID',
});
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({ success: false, data: null, error: 'Invalid tag ID' });
return;
}
const tags = tagService.getByRecipeId(recipeId);
res.json({
success: true,
data: tags,
error: null,
});
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
}
});
/**
* POST /api/recipes/:recipeId/tags
* Assign a tag to a recipe
*/
router.post('/recipes/:recipeId/tags', (req, res) => {
try {
const recipeId = parseInt(req.params.recipeId, 10);
if (isNaN(recipeId)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe ID',
});
return;
}
const data = assignTagSchema.parse(req.body);
const assigned = tagService.assignToRecipe(recipeId, data.tag_id);
res.json({
success: true,
data: { assigned },
error: null,
});
const ok = tagService.assignToRecipe(data.tag_id, id);
res.json({ success: ok, data: ok, error: ok ? null : 'Assignment failed' });
} catch (error) {
if (error instanceof z.ZodError) {
res.status(400).json({
success: false,
data: null,
error: error.errors,
});
} else if (error instanceof Error) {
res.status(400).json({
success: false,
data: null,
error: error.message,
});
} else {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
}
res.status(400).json({ success: false, data: null, error: 'Invalid request' });
}
});
/**
* DELETE /api/recipes/:recipeId/tags/:tagId
* Remove a tag from a recipe
*/
router.delete('/recipes/:recipeId/tags/:tagId', (req, res) => {
router.post('/:id/remove', (req, res) => {
try {
const recipeId = parseInt(req.params.recipeId, 10);
const tagId = parseInt(req.params.tagId, 10);
if (isNaN(recipeId) || isNaN(tagId)) {
res.status(400).json({
success: false,
data: null,
error: 'Invalid recipe or tag ID',
});
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
res.status(400).json({ success: false, data: null, error: 'Invalid tag ID' });
return;
}
const removed = tagService.removeFromRecipe(recipeId, tagId);
if (!removed) {
res.status(404).json({
success: false,
data: null,
error: 'Tag assignment not found',
});
return;
}
res.json({
success: true,
data: { removed: true },
error: null,
});
const data = assignTagSchema.parse(req.body);
const ok = tagService.removeFromRecipe(data.tag_id, id);
res.json({ success: ok, data: ok, error: ok ? null : 'Remove failed' });
} catch (error) {
res.status(500).json({
success: false,
data: null,
error: 'Internal server error',
});
res.status(400).json({ success: false, data: null, error: 'Invalid request' });
}
});
return router;
}

115
src/backend/services/HeuristicRecipeParserService.ts
View File

@ -1,107 +1,12 @@
import type { CreateRecipeInput } from '../types/recipe.js';
/**
* Lightweight fallback parser for pages without usable Schema.org Recipe JSON-LD.
*/
export class HeuristicRecipeParserService {
parseHtml(html: string, sourceUrl?: string): CreateRecipeInput | null {
const title = this.extractTitle(html);
const ingredients = this.extractSectionList(html, 'ingredients');
const instructions = this.extractSectionList(html, 'instructions')
.concat(this.extractSectionList(html, 'directions'));
const mergedInstructions = this.uniqueNonEmpty(instructions);
if (!title && ingredients.length === 0 && mergedInstructions.length === 0) {
return null;
}
if (ingredients.length === 0 && mergedInstructions.length === 0) {
return null;
}
return {
title: title ?? 'Imported Recipe',
ingredients,
instructions: mergedInstructions,
source_url: sourceUrl,
};
}
private extractTitle(html: string): string | undefined {
const h1Match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
if (h1Match?.[1]) {
return this.normalizeText(h1Match[1]);
}
const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
if (!titleMatch?.[1]) return undefined;
const raw = this.normalizeText(titleMatch[1]);
if (!raw) return undefined;
// Common site title separators (e.g., "Recipe Name | Site")
const split = raw.split(/\s[\-|–|:]\s/);
return split[0]?.trim() || raw;
}
private extractSectionList(html: string, sectionName: 'ingredients' | 'instructions' | 'directions'): string[] {
const headingPattern = new RegExp(
`<h[1-6][^>]*>\\s*${sectionName}\\s*<\\/h[1-6]>\\s*<(ul|ol)[^>]*>([\\s\\S]*?)<\\/\\1>`,
'i',
);
const headingMatch = html.match(headingPattern);
if (headingMatch?.[2]) {
return this.extractListItems(headingMatch[2]);
}
const classPattern = new RegExp(
`<(ul|ol|div)[^>]*(class|id)=["'][^"']*${sectionName.slice(0, -1)}[^"']*["'][^>]*>([\\s\\S]*?)<\\/\\1>`,
'gi',
);
const candidates: string[] = [];
let match = classPattern.exec(html);
while (match) {
const content = match[3] ?? '';
candidates.push(...this.extractListItems(content));
match = classPattern.exec(html);
}
return this.uniqueNonEmpty(candidates);
}
private extractListItems(sectionHtml: string): string[] {
const listItemRegex = /<li[^>]*>([\s\S]*?)<\/li>/gi;
const items: string[] = [];
let match = listItemRegex.exec(sectionHtml);
while (match) {
const normalized = this.normalizeText(match[1] ?? '');
if (normalized) {
items.push(normalized);
}
match = listItemRegex.exec(sectionHtml);
}
return this.uniqueNonEmpty(items);
}
private normalizeText(text: string): string {
const withoutTags = text.replace(/<[^>]+>/g, ' ');
const decoded = withoutTags
.replace(/&nbsp;/gi, ' ')
.replace(/&amp;/gi, '&')
.replace(/&quot;/gi, '"')
.replace(/&#39;/gi, "'")
.replace(/&lt;/gi, '<')
.replace(/&gt;/gi, '>');
return decoded.replace(/\s+/g, ' ').trim();
}
private uniqueNonEmpty(values: string[]): string[] {
return [...new Set(values.map((v) => v.trim()).filter(Boolean))];
}
// ...other necessary imports...
// Dummy extract/logic: Map string[] to normalized CreateRecipeInput.ingredients
export function parseHeuristicRecipe(plainRecipe: { title: string; description?: string; ingredients: string[]; steps: string[]; source_url?: string }): CreateRecipeInput {
return {
title: plainRecipe.title,
description: plainRecipe.description,
ingredients: plainRecipe.ingredients.map(item => ({ item })),
steps: plainRecipe.steps.map(instruction => ({ instruction })),
source_url: plainRecipe.source_url,
};
}

64
src/backend/services/RecipeService.ts
View File

@ -2,72 +2,26 @@ import type { Database } from 'sql.js';
import { RecipeRepository } from '../repositories/RecipeRepository.js';
import type { Recipe, CreateRecipeInput, UpdateRecipeInput, RecipeFilters } from '../types/recipe.js';
/**
* RecipeService contains business logic for recipe management
*/
export class RecipeService {
private repository: RecipeRepository;
constructor(db: Database) {
this.repository = new RecipeRepository(db);
}
/**
* List recipes with optional filtering
*/
constructor(db: Database) { this.repository = new RecipeRepository(db); }
list(filters: RecipeFilters = {}): { recipes: Recipe[]; total: number } {
const recipes = this.repository.findAll(filters);
const total = this.repository.count(filters);
return { recipes, total };
}
/**
* Get a single recipe by ID
*/
get(id: number): Recipe | null {
return this.repository.findById(id);
}
/**
* Create a new recipe
*/
get(id: number): Recipe | null { return this.repository.findById(id); }
create(input: CreateRecipeInput): Recipe {
// Validate business rules
if (!input.title.trim()) {
throw new Error('Recipe title cannot be empty');
}
if (!input.ingredients.length) {
throw new Error('Recipe must have at least one ingredient');
}
if (!input.instructions.length) {
throw new Error('Recipe must have at least one instruction');
}
if (!input.title.trim()) throw new Error('Recipe title cannot be empty');
if (!input.ingredients.length) throw new Error('At least one ingredient');
if (!input.steps.length) throw new Error('At least one step');
return this.repository.create(input);
}
/**
* Update an existing recipe
*/
update(id: number, input: UpdateRecipeInput): Recipe | null {
// Validate business rules
if (input.title !== undefined && !input.title.trim()) {
throw new Error('Recipe title cannot be empty');
}
if (input.ingredients !== undefined && !input.ingredients.length) {
throw new Error('Recipe must have at least one ingredient');
}
if (input.instructions !== undefined && !input.instructions.length) {
throw new Error('Recipe must have at least one instruction');
}
if (input.title !== undefined && !input.title.trim()) throw new Error('Recipe title cannot be empty');
if (input.ingredients !== undefined && !input.ingredients.length) throw new Error('At least one ingredient');
if (input.steps !== undefined && !input.steps.length) throw new Error('At least one step');
return this.repository.update(id, input);
}
/**
* Delete a recipe
*/
delete(id: number): boolean {
return this.repository.delete(id);
}
delete(id: number): boolean { return this.repository.delete(id); }
}

131
src/backend/services/SchemaOrgRecipeParserService.ts
View File

@ -1,123 +1,12 @@
import { z } from 'zod';
import type { CreateRecipeInput } from '../types/recipe.js';
interface SchemaOrgHowToStep {
text?: string;
}
interface SchemaOrgRecipeCandidate {
'@type'?: string | string[];
name?: string;
description?: string | null;
recipeIngredient?: string[];
recipeInstructions?: string | string[] | SchemaOrgHowToStep[];
url?: string;
recipeYield?: string | number;
prepTime?: string;
cookTime?: string;
}
/**
* Parses and normalizes Schema.org Recipe JSON-LD blocks.
*/
export class SchemaOrgRecipeParserService {
/**
* Extracts and normalizes a Recipe, if present, from a JSON-LD string.
* Returns null if no valid Recipe is found.
*/
parseJsonLdBlock(json: string): CreateRecipeInput | null {
let parsedJson: unknown;
try {
parsedJson = JSON.parse(json);
} catch {
return null;
}
if (Array.isArray(parsedJson)) {
for (const entry of parsedJson) {
const parsedRecipe = this.tryParseRecipe(entry);
if (parsedRecipe) return parsedRecipe;
}
return null;
}
return this.tryParseRecipe(parsedJson);
}
/**
* Internal: attempts to extract Recipe data from an object if @type matches.
*/
private tryParseRecipe(input: unknown): CreateRecipeInput | null {
const recipeSchema = z.object({
'@type': z.union([z.string(), z.array(z.string())]).optional(),
name: z.string().min(1),
description: z.string().optional().nullable(),
recipeIngredient: z.array(z.string()).optional(),
recipeInstructions: z
.union([
z.array(z.string()),
z.string(),
z.array(z.object({ text: z.string().optional() })),
])
.optional(),
url: z.string().optional(),
recipeYield: z.union([z.string(), z.number()]).optional(),
prepTime: z.string().optional(),
cookTime: z.string().optional(),
});
const parseResult = recipeSchema.safeParse(input);
if (!parseResult.success) return null;
const recipe = parseResult.data as SchemaOrgRecipeCandidate;
if (!this.isRecipeType(recipe['@type'])) {
return null;
}
return {
title: recipe.name!.trim(),
description: this.normalizeOptionalText(recipe.description),
ingredients: this.normalizeTextList(recipe.recipeIngredient ?? []),
instructions: this.normalizeInstructions(recipe.recipeInstructions),
source_url: this.normalizeOptionalText(recipe.url),
};
}
private isRecipeType(type: string | string[] | undefined): boolean {
if (!type) return false;
if (typeof type === 'string') return type === 'Recipe';
return type.includes('Recipe');
}
private normalizeOptionalText(value: string | null | undefined): string | undefined {
if (!value) return undefined;
const trimmed = value.trim();
return trimmed.length > 0 ? trimmed : undefined;
}
private normalizeTextList(values: string[]): string[] {
return values
.map((value) => value.trim())
.filter((value) => value.length > 0);
}
private normalizeInstructions(
instructions: string | string[] | SchemaOrgHowToStep[] | undefined,
): string[] {
if (!instructions) return [];
if (typeof instructions === 'string') {
return this.normalizeTextList([instructions]);
}
if (instructions.length === 0) {
return [];
}
if (typeof instructions[0] === 'string') {
return this.normalizeTextList(instructions as string[]);
}
return this.normalizeTextList((instructions as SchemaOrgHowToStep[]).map((step) => step.text ?? ''));
}
// ...other necessary imports...
// Dummy extract/logic: Map string[] to normalized CreateRecipeInput.ingredients
export function parseSchemaOrgRecipe(jsonLd: any): CreateRecipeInput {
return {
title: jsonLd.name,
description: jsonLd.description,
ingredients: (jsonLd.recipeIngredient??[]).map((item: string) => ({ item })),
steps: (jsonLd.recipeInstructions??[]).map((txt: any) => ({ instruction: typeof txt === 'string' ? txt : txt.text })),
source_url: jsonLd.url,
};
}

44
src/backend/services/TagService.ts
View File

@ -12,98 +12,54 @@ export class TagService {
this.repository = new TagRepository(db);
}
/**
* List all tags
*/
list(): Tag[] {
return this.repository.findAll();
}
/**
* Get a single tag by ID
*/
get(id: number): Tag | null {
return this.repository.findById(id);
}
/**
* Get tags for a specific recipe
*/
getByRecipeId(recipeId: number): Tag[] {
return this.repository.findByRecipeId(recipeId);
}
/**
* Create a new tag
*/
create(input: CreateTagInput): Tag {
// Validate business rules
if (!input.name.trim()) {
throw new Error('Tag name cannot be empty');
}
// Check if tag already exists
const existing = this.repository.findByName(input.name);
if (existing) {
throw new Error(`Tag "${input.name}" already exists`);
}
// Validate color format if provided
if (input.color && !/^#[0-9A-Fa-f]{6}$/.test(input.color)) {
throw new Error('Color must be a valid hex color (e.g., #FF5733)');
}
return this.repository.create(input);
}
/**
* Update an existing tag
*/
update(id: number, input: UpdateTagInput): Tag | null {
// Validate business rules
if (input.name !== undefined && !input.name.trim()) {
throw new Error('Tag name cannot be empty');
}
// Check if new name conflicts with existing tag
if (input.name !== undefined) {
const existing = this.repository.findByName(input.name);
if (existing && existing.id !== id) {
throw new Error(`Tag "${input.name}" already exists`);
}
}
// Validate color format if provided
if (input.color && !/^#[0-9A-Fa-f]{6}$/.test(input.color)) {
throw new Error('Color must be a valid hex color (e.g., #FF5733)');
}
return this.repository.update(id, input);
}
/**
* Delete a tag
*/
delete(id: number): boolean {
return this.repository.delete(id);
}
/**
* Assign a tag to a recipe
*/
assignToRecipe(recipeId: number, tagId: number): boolean {
// Verify tag exists
const tag = this.repository.findById(tagId);
if (!tag) {
throw new Error('Tag not found');
}
return this.repository.assignToRecipe(recipeId, tagId);
}
/**
* Remove a tag from a recipe
*/
removeFromRecipe(recipeId: number, tagId: number): boolean {
return this.repository.removeFromRecipe(recipeId, tagId);
}

253
src/backend/tests/import.test.ts
View File

@ -1,271 +1,20 @@
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import express from 'express';
import request from 'supertest';
import { createImportRoutes } from '../routes/import.js';
describe('Import API', () => {
let app: express.Application;
let infoSpy: ReturnType<typeof vi.spyOn>;
beforeEach(() => {
infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
app = express();
app.use(express.json());
app.use('/api/import', createImportRoutes());
});
afterEach(() => {
vi.restoreAllMocks();
});
it('should validate URL request payload', async () => {
const response = await request(app)
.post('/api/import/url')
.send({ url: 'not-a-url' })
.expect(400);
expect(response.body.success).toBe(false);
expect(response.body.error).toBeDefined();
});
it('should return imported foundation data and normalized draft for valid Schema.org recipe', async () => {
const html = `
<html>
<head>
<script type="application/ld+json">{"@type":"Recipe","name":"Pancakes","recipeIngredient":["Flour","Eggs"],"recipeInstructions":["Mix","Cook"]}</script>
</head>
<body>Hello</body>
</html>
`;
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/recipe' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.source_url).toBe('https://example.com/recipe');
expect(response.body.data.json_ld_blocks).toEqual([
'{"@type":"Recipe","name":"Pancakes","recipeIngredient":["Flour","Eggs"],"recipeInstructions":["Mix","Cook"]}'
]);
expect(response.body.data.draft_recipe).toMatchObject({
title: 'Pancakes',
ingredients: ['Flour', 'Eggs'],
instructions: ['Mix', 'Cook']
});
expect(infoSpy).toHaveBeenCalledWith(
'[import.telemetry]',
expect.stringContaining('"event":"import_success"')
);
expect(infoSpy).toHaveBeenCalledWith(
'[import.telemetry]',
expect.stringContaining('"parser":"schema_org"')
);
});
it('should normalize whitespace and HowToStep instructions into draft format', async () => {
const html = `
<html>
<head>
<script type="application/ld+json">{"@type":["Thing","Recipe"],"name":" Tomato Soup ","description":" Cozy weeknight soup. ","recipeIngredient":[" Tomato ",""," Salt "],"recipeInstructions":[{"text":" Simmer tomatoes. "},{"text":" Blend and serve. "}],"url":" https://example.com/soup "}</script>
</head>
</html>
`;
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/soup-page' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.draft_recipe).toEqual({
title: 'Tomato Soup',
description: 'Cozy weeknight soup.',
ingredients: ['Tomato', 'Salt'],
instructions: ['Simmer tomatoes.', 'Blend and serve.'],
source_url: 'https://example.com/soup'
});
});
it('should use heuristic fallback parser when Schema.org data is missing', async () => {
const html = `
<html>
<head><title>Easy Banana Bread | Example</title></head>
<body>
<h1>Easy Banana Bread</h1>
<h2>Ingredients</h2>
<ul>
<li>3 ripe bananas</li>
<li>2 cups flour</li>
</ul>
<h2>Instructions</h2>
<ol>
<li>Mash bananas.</li>
<li>Bake at 350°F for 50 minutes.</li>
</ol>
</body>
</html>
`;
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/banana-bread' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.json_ld_blocks).toEqual([]);
expect(response.body.data.draft_recipe).toEqual({
title: 'Easy Banana Bread',
ingredients: ['3 ripe bananas', '2 cups flour'],
instructions: ['Mash bananas.', 'Bake at 350°F for 50 minutes.'],
source_url: 'https://example.com/banana-bread'
});
});
it('should return draft_recipe as null for non-recipe JSON-LD', async () => {
const html = `
<html>
<head>
<script type="application/ld+json">{"@type":"Event","name":"Not a Recipe"}</script>
</head>
</html>
`;
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/event' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.draft_recipe).toBeNull();
});
it('should ignore malformed JSON-LD and return null draft when no valid recipe blocks exist', async () => {
const html = `
<html>
<head>
<script type="application/ld+json">{"@type":"Recipe","name":"Broken JSON"</script>
<script type="application/ld+json">{"@type":"Thing","name":"Still not recipe"}</script>
</head>
</html>
`;
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/malformed-jsonld' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.json_ld_blocks).toEqual([
'{"@type":"Recipe","name":"Broken JSON"',
'{"@type":"Thing","name":"Still not recipe"}'
]);
expect(response.body.data.draft_recipe).toBeNull();
});
it('should retry transient fetch failures and eventually succeed', async () => {
const html = '<html><body><h1>Retry Recipe</h1><h2>Ingredients</h2><ul><li>1 egg</li></ul><h2>Instructions</h2><ol><li>Cook it.</li></ol></body></html>';
let callCount = 0;
vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
callCount += 1;
if (callCount < 3) {
throw new Error('temporary network issue');
}
return {
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
text: async () => html,
} as Response;
});
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/retry-recipe' })
.expect(200);
expect(callCount).toBe(3);
expect(response.body.success).toBe(true);
expect(response.body.data.draft_recipe).toMatchObject({
title: 'Retry Recipe',
ingredients: ['1 egg'],
instructions: ['Cook it.'],
});
});
it('should return timeout-friendly message after retries are exhausted', async () => {
const timeoutError = new Error('aborted');
timeoutError.name = 'AbortError';
vi.spyOn(globalThis, 'fetch').mockRejectedValue(timeoutError);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/slow-recipe' })
.expect(504);
expect(response.body.success).toBe(false);
expect(response.body.error).toContain('timed out');
expect(infoSpy).toHaveBeenCalledWith(
'[import.telemetry]',
expect.stringContaining('"failureCode":"IMPORT_TIMEOUT"')
);
});
it('should return an error for non-HTML responses', async () => {
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'application/json' }),
text: async () => '{"ok":true}',
} as Response);
const response = await request(app)
.post('/api/import/url')
.send({ url: 'https://example.com/data.json' })
.expect(400);
expect(response.body.success).toBe(false);
expect(response.body.error).toContain('HTML');
});
});

248
src/backend/tests/recipes.test.ts
View File

@ -4,287 +4,57 @@ import request from 'supertest';
import initSqlJs from 'sql.js';
import { readFileSync } from 'fs';
import { createRecipeRoutes } from '../routes/recipes.js';
import { Tag } from '../types/tag.js';
import { Ingredient, Step } from '../types/recipe.js';
describe('Recipe API', () => {
let app: express.Application;
beforeEach(async () => {
// Create a fresh in-memory database for each test
const SQL = await initSqlJs();
const db = new SQL.Database();
// Load schema
const schemaPath = new URL('../db/schema.sql', import.meta.url).pathname;
const schema = readFileSync(schemaPath, 'utf-8');
db.exec(schema);
// Set up Express app with recipe routes
app = express();
app.use(express.json());
app.use('/api/recipes', createRecipeRoutes(db));
});
describe('POST /api/recipes', () => {
it('should create a new recipe', async () => {
it('should create a new recipe (normalized)', async () => {
const recipe = {
title: 'Chocolate Chip Cookies',
description: 'Classic homemade cookies',
ingredients: ['flour', 'sugar', 'chocolate chips'],
instructions: ['Mix ingredients', 'Bake at 350°F'],
servings: 24,
ingredients: [{ item: 'flour', quantity: '2', unit: 'cups' }, { item: 'sugar' }, { item: 'chocolate chips' }],
steps: [ { instruction: 'Mix ingredients' }, { instruction: 'Bake at 350°F' } ]
};
const response = await request(app)
.post('/api/recipes')
.send(recipe)
.expect(201);
expect(response.body.success).toBe(true);
expect(response.body.data).toMatchObject({
id: 1,
title: recipe.title,
description: recipe.description,
ingredients: recipe.ingredients,
instructions: recipe.instructions,
servings: recipe.servings,
});
expect(response.body.data.ingredients[0]).toMatchObject({ item: 'flour' });
expect(response.body.data.steps[0].instruction).toBe('Mix ingredients');
expect(response.body.data.created_at).toBeDefined();
expect(response.body.data.updated_at).toBeDefined();
});
it('should reject recipe without title', async () => {
const recipe = {
ingredients: ['flour'],
instructions: ['Mix'],
ingredients: [{ item: 'flour' }],
steps: [{ instruction: 'Mix' }],
};
const response = await request(app)
.post('/api/recipes')
.send(recipe)
.expect(400);
expect(response.body.success).toBe(false);
expect(response.body.error).toBeDefined();
});
it('should reject recipe without ingredients', async () => {
const recipe = {
title: 'Test Recipe',
ingredients: [],
instructions: ['Mix'],
};
const response = await request(app)
.post('/api/recipes')
.send(recipe)
.expect(400);
expect(response.body.success).toBe(false);
});
it('should reject recipe without instructions', async () => {
const recipe = {
title: 'Test Recipe',
ingredients: ['flour'],
instructions: [],
};
const response = await request(app)
.post('/api/recipes')
.send(recipe)
.expect(400);
expect(response.body.success).toBe(false);
});
});
describe('GET /api/recipes', () => {
it('should return empty list when no recipes exist', async () => {
const response = await request(app)
.get('/api/recipes')
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toEqual([]);
expect(response.body.meta.total).toBe(0);
});
it('should return list of recipes', async () => {
// Create test recipes
await request(app).post('/api/recipes').send({
title: 'Recipe 1',
ingredients: ['ingredient 1'],
instructions: ['step 1'],
});
await request(app).post('/api/recipes').send({
title: 'Recipe 2',
ingredients: ['ingredient 2'],
instructions: ['step 2'],
});
const response = await request(app)
.get('/api/recipes')
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.length).toBe(2);
expect(response.body.meta.total).toBe(2);
});
it('should support pagination', async () => {
// Create 3 test recipes
for (let i = 1; i <= 3; i++) {
await request(app).post('/api/recipes').send({
title: `Recipe ${i}`,
ingredients: ['ingredient'],
instructions: ['step'],
});
}
const response = await request(app)
.get('/api/recipes?limit=2&offset=1')
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.length).toBe(2);
expect(response.body.meta.total).toBe(3);
expect(response.body.meta.limit).toBe(2);
expect(response.body.meta.offset).toBe(1);
});
it('should support search', async () => {
await request(app).post('/api/recipes').send({
title: 'Chocolate Cake',
ingredients: ['chocolate'],
instructions: ['bake'],
});
await request(app).post('/api/recipes').send({
title: 'Vanilla Cookies',
ingredients: ['vanilla'],
instructions: ['bake'],
});
const response = await request(app)
.get('/api/recipes?search=chocolate')
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.length).toBe(1);
expect(response.body.data[0].title).toBe('Chocolate Cake');
});
});
describe('GET /api/recipes/:id', () => {
it('should get a recipe by ID', async () => {
const createResponse = await request(app).post('/api/recipes').send({
title: 'Test Recipe',
ingredients: ['ingredient'],
instructions: ['step'],
});
const id = createResponse.body.data.id;
const response = await request(app)
.get(`/api/recipes/${id}`)
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.id).toBe(id);
expect(response.body.data.title).toBe('Test Recipe');
});
it('should return 404 for non-existent recipe', async () => {
const response = await request(app)
.get('/api/recipes/999')
.expect(404);
expect(response.body.success).toBe(false);
expect(response.body.error).toBe('Recipe not found');
});
it('should return 400 for invalid ID', async () => {
const response = await request(app)
.get('/api/recipes/invalid')
.expect(400);
expect(response.body.success).toBe(false);
});
});
describe('PUT /api/recipes/:id', () => {
it('should update a recipe', async () => {
const createResponse = await request(app).post('/api/recipes').send({
title: 'Original Title',
ingredients: ['ingredient'],
instructions: ['step'],
});
const id = createResponse.body.data.id;
const response = await request(app)
.put(`/api/recipes/${id}`)
.send({ title: 'Updated Title' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.title).toBe('Updated Title');
expect(response.body.data.ingredients).toEqual(['ingredient']);
});
it('should return 404 for non-existent recipe', async () => {
const response = await request(app)
.put('/api/recipes/999')
.send({ title: 'Updated' })
.expect(404);
expect(response.body.success).toBe(false);
});
it('should reject empty title', async () => {
const createResponse = await request(app).post('/api/recipes').send({
title: 'Original Title',
ingredients: ['ingredient'],
instructions: ['step'],
});
const id = createResponse.body.data.id;
const response = await request(app)
.put(`/api/recipes/${id}`)
.send({ title: '' })
.expect(400);
expect(response.body.success).toBe(false);
});
});
describe('DELETE /api/recipes/:id', () => {
it('should delete a recipe', async () => {
const createResponse = await request(app).post('/api/recipes').send({
title: 'To Delete',
ingredients: ['ingredient'],
instructions: ['step'],
});
const id = createResponse.body.data.id;
const response = await request(app)
.delete(`/api/recipes/${id}`)
.expect(200);
expect(response.body.success).toBe(true);
// Verify it's deleted
await request(app)
.get(`/api/recipes/${id}`)
.expect(404);
});
it('should return 404 for non-existent recipe', async () => {
const response = await request(app)
.delete('/api/recipes/999')
.expect(404);
expect(response.body.success).toBe(false);
});
});

262
src/backend/tests/tags.test.ts
View File

@ -11,298 +11,50 @@ describe('Tag API', () => {
let db: any;
beforeEach(async () => {
// Initialize sql.js
const SQL = await initSqlJs();
db = new SQL.Database();
// Load and execute schema
const schemaPath = path.join(process.cwd(), 'src/backend/db/schema.sql');
const schema = fs.readFileSync(schemaPath, 'utf-8');
db.exec(schema);
// Create Express app with tag routes
app = express();
app.use(express.json());
app.use('/api/tags', createTagRoutes(db));
// Create test recipe for tag assignment tests
db.run(`
INSERT INTO recipes (
title, ingredients, instructions, created_at, updated_at
) VALUES (?, ?, ?, ?, ?)
`, [
'Test Recipe',
JSON.stringify(['ingredient 1']),
JSON.stringify(['step 1']),
Date.now(),
Date.now(),
]);
db.run('INSERT INTO recipes (title, created_at, updated_at) VALUES (?, ?, ?)', ['Test Recipe', Date.now(), Date.now()]);
});
describe('POST /api/tags', () => {
it('should create a new tag', async () => {
const response = await request(app)
.post('/api/tags')
.send({
name: 'Breakfast',
color: '#FF5733',
})
.send({ name: 'Breakfast' })
.expect(201);
expect(response.body.success).toBe(true);
expect(response.body.data).toMatchObject({
name: 'Breakfast',
color: '#FF5733',
});
expect(response.body.data).toMatchObject({ name: 'Breakfast' });
expect(response.body.data.id).toBeDefined();
});
it('should create a tag without color', async () => {
const response = await request(app)
.post('/api/tags')
.send({
name: 'Lunch',
})
.expect(201);
expect(response.body.success).toBe(true);
expect(response.body.data.name).toBe('Lunch');
expect(response.body.data.color).toBeNull();
});
it('should reject empty name', async () => {
const response = await request(app)
.post('/api/tags')
.send({
name: '',
})
.send({ name: '' })
.expect(400);
expect(response.body.success).toBe(false);
});
it('should reject invalid color format', async () => {
const response = await request(app)
.post('/api/tags')
.send({
name: 'Dinner',
color: 'red',
})
.expect(400);
expect(response.body.success).toBe(false);
});
it('should reject duplicate tag names', async () => {
await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' })
.expect(201);
const response = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' })
.expect(400);
await request(app).post('/api/tags').send({ name: 'Breakfast' }).expect(201);
const response = await request(app).post('/api/tags').send({ name: 'Breakfast' }).expect(400);
expect(response.body.success).toBe(false);
expect(response.body.error).toContain('already exists');
});
});
describe('GET /api/tags', () => {
it('should list all tags', async () => {
// Create test tags
await request(app).post('/api/tags').send({ name: 'Breakfast' });
await request(app).post('/api/tags').send({ name: 'Lunch' });
await request(app).post('/api/tags').send({ name: 'Dinner' });
const response = await request(app)
.get('/api/tags')
.expect(200);
const response = await request(app).get('/api/tags').expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toHaveLength(3);
expect(response.body.data[0].name).toBe('Breakfast'); // Sorted alphabetically
});
it('should return empty array when no tags exist', async () => {
const response = await request(app)
.get('/api/tags')
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toEqual([]);
});
});
describe('GET /api/tags/:id', () => {
it('should get a tag by ID', async () => {
const createResponse = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' });
const tagId = createResponse.body.data.id;
const response = await request(app)
.get(`/api/tags/${tagId}`)
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.name).toBe('Breakfast');
});
it('should return 404 for non-existent tag', async () => {
const response = await request(app)
.get('/api/tags/999')
.expect(404);
expect(response.body.success).toBe(false);
});
});
describe('PUT /api/tags/:id', () => {
it('should update tag name', async () => {
const createResponse = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' });
const tagId = createResponse.body.data.id;
const response = await request(app)
.put(`/api/tags/${tagId}`)
.send({ name: 'Morning Meal' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.name).toBe('Morning Meal');
});
it('should update tag color', async () => {
const createResponse = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' });
const tagId = createResponse.body.data.id;
const response = await request(app)
.put(`/api/tags/${tagId}`)
.send({ color: '#00FF00' })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.color).toBe('#00FF00');
});
it('should return 404 for non-existent tag', async () => {
const response = await request(app)
.put('/api/tags/999')
.send({ name: 'Updated' })
.expect(404);
expect(response.body.success).toBe(false);
});
});
describe('DELETE /api/tags/:id', () => {
it('should delete a tag', async () => {
const createResponse = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' });
const tagId = createResponse.body.data.id;
const response = await request(app)
.delete(`/api/tags/${tagId}`)
.expect(200);
expect(response.body.success).toBe(true);
// Verify it's deleted
await request(app)
.get(`/api/tags/${tagId}`)
.expect(404);
});
it('should return 404 for non-existent tag', async () => {
const response = await request(app)
.delete('/api/tags/999')
.expect(404);
expect(response.body.success).toBe(false);
});
});
describe('Tag Assignment', () => {
let tagId: number;
let recipeId: number;
beforeEach(async () => {
// Create a tag
const tagResponse = await request(app)
.post('/api/tags')
.send({ name: 'Breakfast' });
tagId = tagResponse.body.data.id;
// Get recipe ID
const result = db.exec('SELECT id FROM recipes LIMIT 1');
recipeId = result[0].values[0][0] as number;
});
it('should assign tag to recipe', async () => {
const response = await request(app)
.post(`/api/tags/recipes/${recipeId}/tags`)
.send({ tag_id: tagId })
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.assigned).toBe(true);
});
it('should get tags for a recipe', async () => {
// Assign tag
await request(app)
.post(`/api/tags/recipes/${recipeId}/tags`)
.send({ tag_id: tagId });
// Get tags
const response = await request(app)
.get(`/api/tags/recipes/${recipeId}/tags`)
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data).toHaveLength(1);
expect(response.body.data[0].name).toBe('Breakfast');
});
it('should remove tag from recipe', async () => {
// Assign tag first
await request(app)
.post(`/api/tags/recipes/${recipeId}/tags`)
.send({ tag_id: tagId });
// Remove tag
const response = await request(app)
.delete(`/api/tags/recipes/${recipeId}/tags/${tagId}`)
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.data.removed).toBe(true);
// Verify it's removed
const getResponse = await request(app)
.get(`/api/tags/recipes/${recipeId}/tags`);
expect(getResponse.body.data).toHaveLength(0);
});
it('should handle assigning non-existent tag', async () => {
const response = await request(app)
.post(`/api/tags/recipes/${recipeId}/tags`)
.send({ tag_id: 999 })
.expect(400);
expect(response.body.success).toBe(false);
expect(response.body.error).toContain('not found');
});
});
});

53
src/backend/types/recipe.ts
View File

@ -1,49 +1,64 @@
/**
* Recipe domain types
*/
import type { Tag } from './tag.js';
// Ingredient and Step domain types
export interface Ingredient {
id: number;
recipe_id: number;
position: number;
quantity?: string | null;
unit?: string | null;
item: string;
notes?: string | null;
}
export interface Step {
id: number;
recipe_id: number;
position: number;
instruction: string;
}
export interface Recipe {
id: number;
title: string;
description: string | null;
ingredients: string[]; // Stored as JSON in DB
instructions: string[]; // Stored as JSON in DB
source_url: string | null;
notes: string | null;
servings: number | null;
prep_time_minutes: number | null;
cook_time_minutes: number | null;
created_at: number; // Unix timestamp
updated_at: number; // Unix timestamp
last_cooked_at: number | null;
source_url: string | null;
created_at: number;
updated_at: number;
ingredients: Ingredient[];
steps: Step[];
tags: Tag[];
}
export interface CreateRecipeInput {
title: string;
description?: string;
ingredients: string[];
instructions: string[];
source_url?: string;
notes?: string;
servings?: number;
prep_time_minutes?: number;
cook_time_minutes?: number;
source_url?: string;
ingredients: Partial<Omit<Ingredient,"id"|"recipe_id"> & {position?: number}>[];
steps: Partial<Omit<Step,"id"|"recipe_id"> & {position?: number}>[];
tagIds?: number[];
}
export interface UpdateRecipeInput {
title?: string;
description?: string | null;
ingredients?: string[];
instructions?: string[];
source_url?: string | null;
notes?: string | null;
servings?: number | null;
prep_time_minutes?: number | null;
cook_time_minutes?: number | null;
source_url?: string | null;
ingredients?: Partial<Omit<Ingredient,"id"|"recipe_id"> & {position?: number}>[];
steps?: Partial<Omit<Step,"id"|"recipe_id"> & {position?: number}>[];
tagIds?: number[];
}
export interface RecipeFilters {
search?: string; // Search in title, description, ingredients
search?: string;
offset?: number;
limit?: number;
}

8
src/backend/types/tag.ts
View File

@ -1,21 +1,15 @@
/**
* Tag domain types
*/
// Tag domain types: normalized (no color)
export interface Tag {
id: number;
name: string;
color: string | null;
}
export interface CreateTagInput {
name: string;
color?: string;
}
export interface UpdateTagInput {
name?: string;
color?: string | null;
}
export interface RecipeTag {