feat: Add Medication Refill feature with mobile UI improvements (#30)
* feat: Add Medication Refill feature with UI improvements - Add refill functionality to medications (add packs/loose pills) - Add refill API endpoint with history tracking - Add refill section in edit forms (desktop & mobile) - Add refill modal in medication detail view - Add refill history display with expand/collapse - Add schedule lightbox for clicking medication images - Improve button styling with primary/info/success classes - Move '+ New entry' button to medication list header - Lightbox size: 50% desktop, 90% mobile - Update selectedMed sync after stock changes - Migrate from schema-sql.ts to Drizzle Kit migrations * fix: Improve mobile tooltips and refill modal layout - Center tooltips on screen for mobile devices (fixed position) - Close tooltips automatically when scrolling on touch devices - Use click-based tooltip activation instead of hover on mobile - Fix refill modal buttons to display in two rows on mobile
This commit is contained in:
Daniel Volz
GitHub
+32
-19
@@ -1,12 +1,18 @@
|
||||
import { createClient, Client } from "@libsql/client";
|
||||
import { drizzle } from "drizzle-orm/libsql";
|
||||
import { migrate } from "drizzle-orm/libsql/migrator";
|
||||
import { existsSync, mkdirSync, accessSync, constants, statSync, writeFileSync } from "fs";
|
||||
import { resolve } from "path";
|
||||
import { resolve, dirname } from "path";
|
||||
import { fileURLToPath } from "url";
|
||||
import dotenv from "dotenv";
|
||||
import { getTableCreationSQL } from "./schema-sql.js";
|
||||
|
||||
dotenv.config({ path: process.env.DOTENV_PATH || ".env" });
|
||||
|
||||
// Get migrations folder path (relative to this file's location)
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
const migrationsFolder = resolve(__dirname, "../../drizzle");
|
||||
|
||||
// =============================================================================
|
||||
// Exported utility functions for testing
|
||||
// =============================================================================
|
||||
@@ -44,23 +50,20 @@ export function ensureDataDirectory(dataDir: string): { success: boolean; error?
|
||||
}
|
||||
}
|
||||
|
||||
/** Get the SQL statements for creating all tables (re-exported from schema-sql) */
|
||||
export { getTableCreationSQL } from "./schema-sql.js";
|
||||
/** Run drizzle-kit migrations on the database */
|
||||
export async function runDrizzleMigrations(database: ReturnType<typeof drizzle>): Promise<{ success: boolean; error?: string }> {
|
||||
try {
|
||||
await migrate(database, { migrationsFolder });
|
||||
return { success: true };
|
||||
} catch (err: any) {
|
||||
return { success: false, error: err.message };
|
||||
}
|
||||
}
|
||||
|
||||
/** Run table creation migrations on a client */
|
||||
export async function runTableMigrations(client: Client): Promise<{ success: boolean; errors: string[] }> {
|
||||
const tableCreations = getTableCreationSQL();
|
||||
/** Run ALTER TABLE migrations for backward compatibility with older databases */
|
||||
export async function runAlterMigrations(client: Client): Promise<{ success: boolean; errors: string[] }> {
|
||||
const errors: string[] = [];
|
||||
|
||||
for (const sql of tableCreations) {
|
||||
try {
|
||||
await client.execute(sql);
|
||||
} catch (e: any) {
|
||||
errors.push(e.message);
|
||||
}
|
||||
}
|
||||
|
||||
// Run ALTER TABLE migrations for backward compatibility with older databases
|
||||
// These add new columns to existing tables (silently fail if column already exists)
|
||||
const alterMigrations = [
|
||||
// Added in v1.x - repeat reminders and nagging settings
|
||||
@@ -149,9 +152,19 @@ export const db = drizzle(client);
|
||||
|
||||
// Auto-run migrations (self-healing database)
|
||||
async function runMigrations() {
|
||||
const result = await runTableMigrations(client);
|
||||
if (result.errors.length > 0) {
|
||||
result.errors.forEach(err => console.error(`[DB] Table creation error:`, err));
|
||||
// Run drizzle-kit generated migrations
|
||||
console.log(`[DB] Running drizzle migrations from: ${migrationsFolder}`);
|
||||
const migrateResult = await runDrizzleMigrations(db);
|
||||
if (!migrateResult.success) {
|
||||
console.error(`[DB] Migration error:`, migrateResult.error);
|
||||
} else {
|
||||
console.log(`[DB] Drizzle migrations completed`);
|
||||
}
|
||||
|
||||
// Run ALTER TABLE migrations for backward compatibility
|
||||
const alterResult = await runAlterMigrations(client);
|
||||
if (alterResult.errors.length > 0) {
|
||||
alterResult.errors.forEach(err => console.error(`[DB] ALTER migration error:`, err));
|
||||
}
|
||||
console.log(`[DB] Tables verified/created`);
|
||||
|
||||
|
||||
+29
-25
@@ -1,39 +1,45 @@
|
||||
import { createClient, Client } from "@libsql/client";
|
||||
import { drizzle } from "drizzle-orm/libsql";
|
||||
import { migrate } from "drizzle-orm/libsql/migrator";
|
||||
import dotenv from "dotenv";
|
||||
import fs from "fs";
|
||||
import path from "path";
|
||||
import { getTableCreationSQL } from "./schema-sql.js";
|
||||
import { resolve, dirname } from "path";
|
||||
import { fileURLToPath } from "url";
|
||||
|
||||
dotenv.config({ path: process.env.DOTENV_PATH || ".env" });
|
||||
|
||||
// Get migrations folder path (relative to this file's location)
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
const migrationsFolder = resolve(__dirname, "../../drizzle");
|
||||
|
||||
// =============================================================================
|
||||
// Exported utility functions for testing
|
||||
// =============================================================================
|
||||
|
||||
/** Get the full migration SQL string (re-exported from schema-sql) */
|
||||
export { getTableCreationSQL };
|
||||
|
||||
/** Split SQL string into individual statements */
|
||||
/** Split SQL string into individual statements (for backwards compatibility with tests) */
|
||||
export function splitSQLStatements(sql: string): string[] {
|
||||
return sql.split(';').filter(s => s.trim().length > 0);
|
||||
}
|
||||
|
||||
/** Execute migration statements on a client */
|
||||
/** Execute drizzle migrations on a database */
|
||||
export async function executeMigration(client: Client): Promise<{ success: boolean; executed: number; errors: string[] }> {
|
||||
const statements = getTableCreationSQL();
|
||||
const errors: string[] = [];
|
||||
let executed = 0;
|
||||
const db = drizzle(client);
|
||||
|
||||
for (const stmt of statements) {
|
||||
try {
|
||||
await client.execute(stmt);
|
||||
executed++;
|
||||
} catch (err: any) {
|
||||
errors.push(err.message);
|
||||
}
|
||||
try {
|
||||
await migrate(db, { migrationsFolder });
|
||||
|
||||
// Count tables as a proxy for "executed" statements
|
||||
const tables = await client.execute(
|
||||
"SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle%'"
|
||||
);
|
||||
const executed = Number(tables.rows[0].count) || 0;
|
||||
|
||||
return { success: true, executed, errors };
|
||||
} catch (err: any) {
|
||||
errors.push(err.message);
|
||||
return { success: false, executed: 0, errors };
|
||||
}
|
||||
|
||||
return { success: errors.length === 0, executed, errors };
|
||||
}
|
||||
|
||||
/** Get a preview of statement (first N characters) */
|
||||
@@ -54,15 +60,13 @@ const url = "file:./data/medassist-ng.db";
|
||||
async function main() {
|
||||
console.log("Starting database setup...");
|
||||
console.log("Database URL:", url);
|
||||
console.log("Migrations folder:", migrationsFolder);
|
||||
|
||||
const client = createClient({ url });
|
||||
const db = drizzle(client);
|
||||
|
||||
const statements = getTableCreationSQL();
|
||||
|
||||
for (const stmt of statements) {
|
||||
console.log("Executing:", getStatementPreview(stmt));
|
||||
await client.execute(stmt);
|
||||
}
|
||||
console.log("Running drizzle migrations...");
|
||||
await migrate(db, { migrationsFolder });
|
||||
|
||||
console.log("Database setup complete!");
|
||||
process.exit(0);
|
||||
|
||||
@@ -100,5 +100,15 @@ export function getTableCreationSQL(): string[] {
|
||||
dismissed integer NOT NULL DEFAULT 0,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)`,
|
||||
`CREATE TABLE IF NOT EXISTS refill_history (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
medication_id integer NOT NULL,
|
||||
user_id integer NOT NULL,
|
||||
packs_added integer NOT NULL DEFAULT 0,
|
||||
loose_pills_added integer NOT NULL DEFAULT 0,
|
||||
refill_date integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
FOREIGN KEY (medication_id) REFERENCES medications(id) ON DELETE CASCADE,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)`,
|
||||
];
|
||||
}
|
||||
|
||||
@@ -68,6 +68,7 @@ export const userSettings = sqliteTable("user_settings", {
|
||||
lowStockDays: integer("low_stock_days").notNull().default(30),
|
||||
normalStockDays: integer("normal_stock_days").notNull().default(90),
|
||||
highStockDays: integer("high_stock_days").notNull().default(180),
|
||||
expiryWarningDays: integer("expiry_warning_days").notNull().default(90),
|
||||
// UI preferences
|
||||
language: text("language", { length: 10 }).notNull().default("en"),
|
||||
// Stock calculation mode: "automatic" (schedule-based) or "manual" (only marked doses)
|
||||
@@ -117,3 +118,15 @@ export const doseTracking = sqliteTable("dose_tracking", {
|
||||
markedBy: text("marked_by", { length: 100 }), // null = user, "Daniel" = via share link
|
||||
dismissed: integer("dismissed", { mode: "boolean" }).notNull().default(false), // true = missed dose acknowledged without taking
|
||||
});
|
||||
|
||||
// =============================================================================
|
||||
// Refill History - Tracks when medication stock was refilled
|
||||
// =============================================================================
|
||||
export const refillHistory = sqliteTable("refill_history", {
|
||||
id: integer("id").primaryKey({ autoIncrement: true }),
|
||||
medicationId: integer("medication_id").notNull().references(() => medications.id, { onDelete: "cascade" }),
|
||||
userId: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
|
||||
packsAdded: integer("packs_added").notNull().default(0),
|
||||
loosePillsAdded: integer("loose_pills_added").notNull().default(0),
|
||||
refillDate: integer("refill_date", { mode: "timestamp" }).notNull().default(sql`(strftime('%s','now'))`),
|
||||
});
|
||||
|
||||
@@ -20,6 +20,7 @@ import { plannerRoutes } from "./routes/planner.js";
|
||||
import { shareRoutes } from "./routes/share.js";
|
||||
import { doseRoutes } from "./routes/doses.js";
|
||||
import { exportRoutes } from "./routes/export.js";
|
||||
import { refillRoutes } from "./routes/refills.js";
|
||||
import { startReminderScheduler } from "./services/reminder-scheduler.js";
|
||||
import { startIntakeReminderScheduler } from "./services/intake-reminder-scheduler.js";
|
||||
|
||||
@@ -115,6 +116,7 @@ export async function createApp(options?: {
|
||||
await app.register(shareRoutes);
|
||||
await app.register(doseRoutes);
|
||||
await app.register(exportRoutes);
|
||||
await app.register(refillRoutes);
|
||||
|
||||
return app;
|
||||
}
|
||||
@@ -184,6 +186,7 @@ await app.register(plannerRoutes);
|
||||
await app.register(shareRoutes);
|
||||
await app.register(doseRoutes);
|
||||
await app.register(exportRoutes);
|
||||
await app.register(refillRoutes);
|
||||
|
||||
const start = async () => {
|
||||
try {
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
import { FastifyInstance } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { db } from "../db/client.js";
|
||||
import { medications, refillHistory } from "../db/schema.js";
|
||||
import { eq, and, desc } from "drizzle-orm";
|
||||
import { requireAuth, getAnonymousUserId } from "../plugins/auth.js";
|
||||
import { env } from "../plugins/env.js";
|
||||
import type { AuthUser } from "../types/fastify.js";
|
||||
|
||||
const refillSchema = z.object({
|
||||
packsAdded: z.number().int().min(0).default(0),
|
||||
loosePillsAdded: z.number().int().min(0).default(0),
|
||||
}).refine(data => data.packsAdded > 0 || data.loosePillsAdded > 0, {
|
||||
message: "Must add at least one pack or some loose pills",
|
||||
});
|
||||
|
||||
export async function refillRoutes(app: FastifyInstance) {
|
||||
// All refill routes require auth
|
||||
app.addHook("preHandler", requireAuth);
|
||||
|
||||
// Helper to get user ID from request
|
||||
async function getUserId(request: any, reply: any): Promise<number> {
|
||||
if (!env.AUTH_ENABLED) {
|
||||
return getAnonymousUserId();
|
||||
}
|
||||
const authUser = request.user as unknown as AuthUser | null;
|
||||
if (!authUser) {
|
||||
reply.status(401).send({ error: "User not authenticated", code: "AUTH_REQUIRED" });
|
||||
throw new Error("AUTH_REQUIRED");
|
||||
}
|
||||
return authUser.id;
|
||||
}
|
||||
|
||||
// POST /medications/:id/refill - Add stock to medication
|
||||
app.post<{ Params: { id: string } }>("/medications/:id/refill", async (req, reply) => {
|
||||
const parsed = refillSchema.safeParse(req.body);
|
||||
if (!parsed.success) return reply.status(400).send(parsed.error.format());
|
||||
|
||||
const medId = Number(req.params.id);
|
||||
if (Number.isNaN(medId)) return reply.badRequest("Invalid medication id");
|
||||
|
||||
const userId = await getUserId(req, reply);
|
||||
|
||||
// Verify ownership
|
||||
const [med] = await db.select().from(medications).where(
|
||||
and(eq(medications.id, medId), eq(medications.userId, userId))
|
||||
);
|
||||
if (!med) return reply.notFound("Medication not found");
|
||||
|
||||
const { packsAdded, loosePillsAdded } = parsed.data;
|
||||
|
||||
// Update medication stock
|
||||
const newPackCount = med.packCount + packsAdded;
|
||||
const newLooseTablets = med.looseTablets + loosePillsAdded;
|
||||
|
||||
await db.update(medications)
|
||||
.set({
|
||||
packCount: newPackCount,
|
||||
looseTablets: newLooseTablets,
|
||||
updatedAt: new Date(),
|
||||
})
|
||||
.where(and(eq(medications.id, medId), eq(medications.userId, userId)));
|
||||
|
||||
// Create refill history entry
|
||||
const [refill] = await db.insert(refillHistory)
|
||||
.values({
|
||||
medicationId: medId,
|
||||
userId,
|
||||
packsAdded,
|
||||
loosePillsAdded,
|
||||
})
|
||||
.returning();
|
||||
|
||||
// Calculate pills added for response
|
||||
const pillsPerPack = med.blistersPerPack * med.pillsPerBlister;
|
||||
const totalPillsAdded = (packsAdded * pillsPerPack) + loosePillsAdded;
|
||||
|
||||
return {
|
||||
success: true,
|
||||
refill: {
|
||||
id: refill.id,
|
||||
packsAdded,
|
||||
loosePillsAdded,
|
||||
totalPillsAdded,
|
||||
refillDate: refill.refillDate,
|
||||
},
|
||||
newStock: {
|
||||
packCount: newPackCount,
|
||||
looseTablets: newLooseTablets,
|
||||
totalPills: newPackCount * pillsPerPack + newLooseTablets,
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
// GET /medications/:id/refills - Get refill history for a medication
|
||||
app.get<{ Params: { id: string } }>("/medications/:id/refills", async (req, reply) => {
|
||||
const medId = Number(req.params.id);
|
||||
if (Number.isNaN(medId)) return reply.badRequest("Invalid medication id");
|
||||
|
||||
const userId = await getUserId(req, reply);
|
||||
|
||||
// Verify ownership
|
||||
const [med] = await db.select().from(medications).where(
|
||||
and(eq(medications.id, medId), eq(medications.userId, userId))
|
||||
);
|
||||
if (!med) return reply.notFound("Medication not found");
|
||||
|
||||
// Get refill history, newest first
|
||||
const refills = await db.select()
|
||||
.from(refillHistory)
|
||||
.where(eq(refillHistory.medicationId, medId))
|
||||
.orderBy(desc(refillHistory.refillDate));
|
||||
|
||||
const pillsPerPack = med.blistersPerPack * med.pillsPerBlister;
|
||||
|
||||
return refills.map(r => ({
|
||||
id: r.id,
|
||||
packsAdded: r.packsAdded,
|
||||
loosePillsAdded: r.loosePillsAdded,
|
||||
totalPillsAdded: (r.packsAdded * pillsPerPack) + r.loosePillsAdded,
|
||||
refillDate: r.refillDate,
|
||||
}));
|
||||
});
|
||||
}
|
||||
+201
-461
@@ -1,45 +1,78 @@
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
||||
import { createClient } from "@libsql/client";
|
||||
import { drizzle } from "drizzle-orm/libsql";
|
||||
import { migrate } from "drizzle-orm/libsql/migrator";
|
||||
import { mkdirSync, rmSync, existsSync } from "fs";
|
||||
import { resolve } from "path";
|
||||
import { resolve, dirname } from "path";
|
||||
import { tmpdir } from "os";
|
||||
import { fileURLToPath } from "url";
|
||||
|
||||
// Import the exported utility functions from client.ts
|
||||
import {
|
||||
buildDbUrl,
|
||||
getDbPaths,
|
||||
ensureDataDirectory,
|
||||
getTableCreationSQL,
|
||||
runTableMigrations,
|
||||
runDrizzleMigrations,
|
||||
runAlterMigrations,
|
||||
ensureDefaultUser,
|
||||
} from "../db/client.js";
|
||||
|
||||
// Import the exported utility functions from migrate.ts
|
||||
import {
|
||||
getTableCreationSQL as getTableCreationSQLFromMigrate,
|
||||
splitSQLStatements,
|
||||
executeMigration,
|
||||
getStatementPreview,
|
||||
} from "../db/migrate.js";
|
||||
|
||||
// Get migrations folder path
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
const migrationsFolder = resolve(__dirname, "../../drizzle");
|
||||
|
||||
describe("Migration Script Utilities", () => {
|
||||
describe("getTableCreationSQL", () => {
|
||||
it("should return a non-empty array of SQL statements", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
expect(Array.isArray(statements)).toBe(true);
|
||||
expect(statements.length).toBeGreaterThan(0);
|
||||
describe("executeMigration", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(() => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
});
|
||||
|
||||
it("should contain all table definitions", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const allSQL = statements.join(" ");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS users");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS medications");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS user_settings");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS refresh_tokens");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS share_tokens");
|
||||
expect(allSQL).toContain("CREATE TABLE IF NOT EXISTS dose_tracking");
|
||||
it("should execute all migrations successfully", async () => {
|
||||
const result = await executeMigration(client);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.executed).toBeGreaterThan(0);
|
||||
expect(result.errors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should create all tables", async () => {
|
||||
await executeMigration(client);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle%' ORDER BY name"
|
||||
);
|
||||
|
||||
const tableNames = tables.rows.map(r => r.name);
|
||||
expect(tableNames).toContain("users");
|
||||
expect(tableNames).toContain("medications");
|
||||
expect(tableNames).toContain("user_settings");
|
||||
expect(tableNames).toContain("refresh_tokens");
|
||||
expect(tableNames).toContain("share_tokens");
|
||||
expect(tableNames).toContain("dose_tracking");
|
||||
expect(tableNames).toContain("refill_history");
|
||||
});
|
||||
|
||||
it("should be idempotent", async () => {
|
||||
await executeMigration(client);
|
||||
const result = await executeMigration(client);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
|
||||
it("should allow inserting data after migration", async () => {
|
||||
await executeMigration(client);
|
||||
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
const result = await client.execute("SELECT * FROM users");
|
||||
expect(result.rows).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -62,11 +95,6 @@ describe("Migration Script Utilities", () => {
|
||||
expect(statements).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("should handle getTableCreationSQL output correctly", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
expect(statements).toHaveLength(6);
|
||||
});
|
||||
|
||||
it("should preserve whitespace within statements", () => {
|
||||
const sql = "CREATE TABLE test (\n id INTEGER\n);";
|
||||
const statements = splitSQLStatements(sql);
|
||||
@@ -103,52 +131,6 @@ describe("Migration Script Utilities", () => {
|
||||
expect(preview).toBe("CREATE TABLE IF NOT EXISTS use...");
|
||||
});
|
||||
});
|
||||
|
||||
describe("executeMigration", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(() => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
});
|
||||
|
||||
it("should execute all migrations successfully", async () => {
|
||||
const result = await executeMigration(client);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.executed).toBe(6);
|
||||
expect(result.errors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should create all tables", async () => {
|
||||
await executeMigration(client);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
|
||||
);
|
||||
|
||||
const tableNames = tables.rows.map(r => r.name);
|
||||
expect(tableNames).toContain("users");
|
||||
expect(tableNames).toContain("medications");
|
||||
expect(tableNames).toContain("user_settings");
|
||||
expect(tableNames).toContain("refresh_tokens");
|
||||
expect(tableNames).toContain("share_tokens");
|
||||
expect(tableNames).toContain("dose_tracking");
|
||||
});
|
||||
|
||||
it("should be idempotent", async () => {
|
||||
await executeMigration(client);
|
||||
const result = await executeMigration(client);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.executed).toBe(6);
|
||||
});
|
||||
|
||||
it("should allow inserting data after migration", async () => {
|
||||
await executeMigration(client);
|
||||
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
const result = await client.execute("SELECT * FROM users");
|
||||
expect(result.rows).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Database Client Utilities", () => {
|
||||
@@ -218,63 +200,7 @@ describe("Database Client Utilities", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("getTableCreationSQL", () => {
|
||||
it("should return array of SQL statements", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
expect(Array.isArray(statements)).toBe(true);
|
||||
expect(statements.length).toBe(6);
|
||||
});
|
||||
|
||||
it("should include users table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const usersSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS users"));
|
||||
expect(usersSQL).toBeDefined();
|
||||
expect(usersSQL).toContain("username text NOT NULL UNIQUE");
|
||||
expect(usersSQL).toContain("password_hash text");
|
||||
expect(usersSQL).toContain("auth_provider text NOT NULL DEFAULT 'local'");
|
||||
});
|
||||
|
||||
it("should include medications table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const medsSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS medications"));
|
||||
expect(medsSQL).toBeDefined();
|
||||
expect(medsSQL).toContain("user_id integer NOT NULL");
|
||||
expect(medsSQL).toContain("taken_by_json text NOT NULL DEFAULT '[]'");
|
||||
expect(medsSQL).toContain("FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE");
|
||||
});
|
||||
|
||||
it("should include user_settings table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const settingsSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS user_settings"));
|
||||
expect(settingsSQL).toBeDefined();
|
||||
expect(settingsSQL).toContain("email_enabled integer NOT NULL DEFAULT 0");
|
||||
expect(settingsSQL).toContain("language text NOT NULL DEFAULT 'en'");
|
||||
});
|
||||
|
||||
it("should include refresh_tokens table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const tokensSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS refresh_tokens"));
|
||||
expect(tokensSQL).toBeDefined();
|
||||
expect(tokensSQL).toContain("token_id text NOT NULL UNIQUE");
|
||||
});
|
||||
|
||||
it("should include share_tokens table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const shareSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS share_tokens"));
|
||||
expect(shareSQL).toBeDefined();
|
||||
expect(shareSQL).toContain("taken_by text NOT NULL");
|
||||
});
|
||||
|
||||
it("should include dose_tracking table", () => {
|
||||
const statements = getTableCreationSQL();
|
||||
const doseSQL = statements.find(s => s.includes("CREATE TABLE IF NOT EXISTS dose_tracking"));
|
||||
expect(doseSQL).toBeDefined();
|
||||
expect(doseSQL).toContain("dose_id text NOT NULL");
|
||||
expect(doseSQL).toContain("marked_by text");
|
||||
});
|
||||
});
|
||||
|
||||
describe("runTableMigrations", () => {
|
||||
describe("runDrizzleMigrations", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(() => {
|
||||
@@ -282,23 +208,24 @@ describe("Database Client Utilities", () => {
|
||||
});
|
||||
|
||||
it("should create all tables successfully", async () => {
|
||||
const result = await runTableMigrations(client);
|
||||
const db = drizzle(client);
|
||||
const result = await runDrizzleMigrations(db);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.errors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should be idempotent (run twice without errors)", async () => {
|
||||
await runTableMigrations(client);
|
||||
const result = await runTableMigrations(client);
|
||||
const db = drizzle(client);
|
||||
await runDrizzleMigrations(db);
|
||||
const result = await runDrizzleMigrations(db);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.errors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should create all 6 tables", async () => {
|
||||
await runTableMigrations(client);
|
||||
it("should create all 7 tables", async () => {
|
||||
const db = drizzle(client);
|
||||
await runDrizzleMigrations(db);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle%' ORDER BY name"
|
||||
);
|
||||
|
||||
const tableNames = tables.rows.map(r => r.name);
|
||||
@@ -308,6 +235,29 @@ describe("Database Client Utilities", () => {
|
||||
expect(tableNames).toContain("refresh_tokens");
|
||||
expect(tableNames).toContain("share_tokens");
|
||||
expect(tableNames).toContain("dose_tracking");
|
||||
expect(tableNames).toContain("refill_history");
|
||||
});
|
||||
});
|
||||
|
||||
describe("runAlterMigrations", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should run without errors on a fresh database", async () => {
|
||||
const result = await runAlterMigrations(client);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.errors).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should be idempotent", async () => {
|
||||
await runAlterMigrations(client);
|
||||
const result = await runAlterMigrations(client);
|
||||
expect(result.success).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -316,7 +266,8 @@ describe("Database Client Utilities", () => {
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
await runTableMigrations(client);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should create default user when auth is disabled", async () => {
|
||||
@@ -386,246 +337,83 @@ describe("Database Client", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("Table Schema Creation", () => {
|
||||
describe("Table Schema via Drizzle Migrations", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should create users table", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
password_hash text,
|
||||
avatar_url text,
|
||||
auth_provider text NOT NULL DEFAULT 'local',
|
||||
oidc_subject text,
|
||||
is_active integer NOT NULL DEFAULT 1,
|
||||
last_login_at integer,
|
||||
created_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
updated_at integer NOT NULL DEFAULT (strftime('%s','now'))
|
||||
)
|
||||
`);
|
||||
|
||||
// Verify table exists
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='users'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should create medications table with foreign key", async () => {
|
||||
// First create users table
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS medications (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
name text NOT NULL,
|
||||
generic_name text,
|
||||
taken_by_json text NOT NULL DEFAULT '[]',
|
||||
pack_count integer NOT NULL DEFAULT 1,
|
||||
blisters_per_pack integer NOT NULL DEFAULT 1,
|
||||
pills_per_blister integer NOT NULL DEFAULT 1,
|
||||
loose_tablets integer NOT NULL DEFAULT 0,
|
||||
pill_weight_mg integer,
|
||||
usage_json text NOT NULL DEFAULT '[]',
|
||||
every_json text NOT NULL DEFAULT '[]',
|
||||
start_json text NOT NULL DEFAULT '[]',
|
||||
image_url text,
|
||||
expiry_date text,
|
||||
notes text,
|
||||
intake_reminders_enabled integer NOT NULL DEFAULT 0,
|
||||
updated_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='medications'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should create user_settings table", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS user_settings (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL UNIQUE,
|
||||
email_enabled integer NOT NULL DEFAULT 0,
|
||||
notification_email text,
|
||||
email_stock_reminders integer NOT NULL DEFAULT 1,
|
||||
email_intake_reminders integer NOT NULL DEFAULT 1,
|
||||
shoutrrr_enabled integer NOT NULL DEFAULT 0,
|
||||
shoutrrr_url text,
|
||||
shoutrrr_stock_reminders integer NOT NULL DEFAULT 1,
|
||||
shoutrrr_intake_reminders integer NOT NULL DEFAULT 1,
|
||||
reminder_days_before integer NOT NULL DEFAULT 7,
|
||||
repeat_daily_reminders integer NOT NULL DEFAULT 0,
|
||||
low_stock_days integer NOT NULL DEFAULT 30,
|
||||
normal_stock_days integer NOT NULL DEFAULT 90,
|
||||
high_stock_days integer NOT NULL DEFAULT 180,
|
||||
expiry_warning_days integer NOT NULL DEFAULT 90,
|
||||
language text NOT NULL DEFAULT 'en',
|
||||
stock_calculation_mode text NOT NULL DEFAULT 'automatic',
|
||||
last_auto_email_sent text,
|
||||
last_notification_type text,
|
||||
last_notification_channel text,
|
||||
updated_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='user_settings'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should create refresh_tokens table", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS refresh_tokens (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
token_id text NOT NULL UNIQUE,
|
||||
expires_at integer NOT NULL,
|
||||
rotated_at integer,
|
||||
revoked integer NOT NULL DEFAULT 0,
|
||||
created_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='refresh_tokens'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should create share_tokens table", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS share_tokens (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
token text NOT NULL UNIQUE,
|
||||
taken_by text NOT NULL,
|
||||
schedule_days integer NOT NULL DEFAULT 30,
|
||||
created_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
expires_at integer,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='share_tokens'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should create dose_tracking table", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS dose_tracking (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
dose_id text NOT NULL,
|
||||
taken_at integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
marked_by text,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
const tables = await client.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table' AND name='dose_tracking'"
|
||||
);
|
||||
expect(tables.rows).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should enforce unique constraint on username", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
it("should have users table with correct columns", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(users)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
await expect(
|
||||
client.execute("INSERT INTO users (username) VALUES ('testuser')")
|
||||
).rejects.toThrow();
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("username");
|
||||
expect(columnNames).toContain("password_hash");
|
||||
expect(columnNames).toContain("auth_provider");
|
||||
});
|
||||
|
||||
it("should enforce unique constraint on refresh token_id", async () => {
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS refresh_tokens (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
token_id text NOT NULL UNIQUE,
|
||||
expires_at integer NOT NULL,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
|
||||
await client.execute(
|
||||
"INSERT INTO refresh_tokens (user_id, token_id, expires_at) VALUES (1, 'token123', 1735689600)"
|
||||
);
|
||||
it("should have medications table with correct columns", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(medications)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
await expect(
|
||||
client.execute(
|
||||
"INSERT INTO refresh_tokens (user_id, token_id, expires_at) VALUES (1, 'token123', 1735689600)"
|
||||
)
|
||||
).rejects.toThrow();
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("user_id");
|
||||
expect(columnNames).toContain("name");
|
||||
expect(columnNames).toContain("taken_by_json");
|
||||
expect(columnNames).toContain("pack_count");
|
||||
expect(columnNames).toContain("usage_json");
|
||||
});
|
||||
|
||||
it("should have user_settings table with correct columns", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(user_settings)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("user_id");
|
||||
expect(columnNames).toContain("email_enabled");
|
||||
expect(columnNames).toContain("language");
|
||||
expect(columnNames).toContain("stock_calculation_mode");
|
||||
});
|
||||
|
||||
it("should have refresh_tokens table", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(refresh_tokens)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("user_id");
|
||||
expect(columnNames).toContain("token_id");
|
||||
});
|
||||
|
||||
it("should have share_tokens table", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(share_tokens)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("token");
|
||||
expect(columnNames).toContain("taken_by");
|
||||
});
|
||||
|
||||
it("should have dose_tracking table", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(dose_tracking)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("dose_id");
|
||||
expect(columnNames).toContain("marked_by");
|
||||
});
|
||||
|
||||
it("should have refill_history table", async () => {
|
||||
const columns = await client.execute("PRAGMA table_info(refill_history)");
|
||||
const columnNames = columns.rows.map(r => r.name);
|
||||
|
||||
expect(columnNames).toContain("id");
|
||||
expect(columnNames).toContain("medication_id");
|
||||
expect(columnNames).toContain("packs_added");
|
||||
expect(columnNames).toContain("loose_pills_added");
|
||||
});
|
||||
});
|
||||
|
||||
@@ -634,15 +422,8 @@ describe("Database Client", () => {
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local',
|
||||
is_active integer NOT NULL DEFAULT 1,
|
||||
created_at integer NOT NULL DEFAULT (strftime('%s','now'))
|
||||
)
|
||||
`);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should use default values for auth_provider", async () => {
|
||||
@@ -656,16 +437,8 @@ describe("Database Client", () => {
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
const result = await client.execute("SELECT is_active FROM users WHERE username = 'testuser'");
|
||||
expect(result.rows[0].is_active).toBe(1);
|
||||
});
|
||||
|
||||
it("should generate created_at timestamp", async () => {
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
const result = await client.execute("SELECT created_at FROM users WHERE username = 'testuser'");
|
||||
expect(typeof result.rows[0].created_at).toBe("number");
|
||||
// Should be a reasonable Unix timestamp (after year 2020)
|
||||
expect(Number(result.rows[0].created_at)).toBeGreaterThan(1577836800);
|
||||
// SQLite stores booleans as integers
|
||||
expect(result.rows[0].is_active).toBeTruthy();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -674,40 +447,18 @@ describe("Database Client", () => {
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS user_settings (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL UNIQUE,
|
||||
email_enabled integer NOT NULL DEFAULT 0,
|
||||
shoutrrr_enabled integer NOT NULL DEFAULT 0,
|
||||
reminder_days_before integer NOT NULL DEFAULT 7,
|
||||
repeat_daily_reminders integer NOT NULL DEFAULT 0,
|
||||
low_stock_days integer NOT NULL DEFAULT 30,
|
||||
normal_stock_days integer NOT NULL DEFAULT 90,
|
||||
high_stock_days integer NOT NULL DEFAULT 180,
|
||||
expiry_warning_days integer NOT NULL DEFAULT 90,
|
||||
language text NOT NULL DEFAULT 'en',
|
||||
stock_calculation_mode text NOT NULL DEFAULT 'automatic',
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
});
|
||||
|
||||
it("should use default notification settings", async () => {
|
||||
await client.execute("INSERT INTO user_settings (user_id) VALUES (1)");
|
||||
|
||||
const result = await client.execute("SELECT * FROM user_settings WHERE user_id = 1");
|
||||
expect(result.rows[0].email_enabled).toBe(0);
|
||||
expect(result.rows[0].shoutrrr_enabled).toBe(0);
|
||||
// SQLite stores booleans as integers (false = 0)
|
||||
expect(result.rows[0].email_enabled).toBeFalsy();
|
||||
expect(result.rows[0].shoutrrr_enabled).toBeFalsy();
|
||||
});
|
||||
|
||||
it("should use default stock threshold settings", async () => {
|
||||
@@ -717,7 +468,6 @@ describe("Database Client", () => {
|
||||
expect(result.rows[0].low_stock_days).toBe(30);
|
||||
expect(result.rows[0].normal_stock_days).toBe(90);
|
||||
expect(result.rows[0].high_stock_days).toBe(180);
|
||||
expect(result.rows[0].expiry_warning_days).toBe(90);
|
||||
});
|
||||
|
||||
it("should use default language (en)", async () => {
|
||||
@@ -747,32 +497,9 @@ describe("Database Client", () => {
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS medications (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
name text NOT NULL,
|
||||
taken_by_json text NOT NULL DEFAULT '[]',
|
||||
pack_count integer NOT NULL DEFAULT 1,
|
||||
blisters_per_pack integer NOT NULL DEFAULT 1,
|
||||
pills_per_blister integer NOT NULL DEFAULT 1,
|
||||
loose_tablets integer NOT NULL DEFAULT 0,
|
||||
usage_json text NOT NULL DEFAULT '[]',
|
||||
every_json text NOT NULL DEFAULT '[]',
|
||||
start_json text NOT NULL DEFAULT '[]',
|
||||
intake_reminders_enabled integer NOT NULL DEFAULT 0,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
});
|
||||
|
||||
it("should use default inventory values", async () => {
|
||||
@@ -795,11 +522,11 @@ describe("Database Client", () => {
|
||||
expect(result.rows[0].start_json).toBe("[]");
|
||||
});
|
||||
|
||||
it("should default intake_reminders_enabled to false (0)", async () => {
|
||||
it("should default intake_reminders_enabled to false", async () => {
|
||||
await client.execute("INSERT INTO medications (user_id, name) VALUES (1, 'Test Med')");
|
||||
|
||||
const result = await client.execute("SELECT intake_reminders_enabled FROM medications WHERE name = 'Test Med'");
|
||||
expect(result.rows[0].intake_reminders_enabled).toBe(0);
|
||||
expect(result.rows[0].intake_reminders_enabled).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -810,21 +537,8 @@ describe("Database Client", () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
// Enable foreign keys
|
||||
await client.execute("PRAGMA foreign_keys = ON");
|
||||
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE
|
||||
)
|
||||
`);
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS medications (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
user_id integer NOT NULL,
|
||||
name text NOT NULL,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)
|
||||
`);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should cascade delete medications when user is deleted", async () => {
|
||||
@@ -845,18 +559,44 @@ describe("Database Client", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("Unique Constraints", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should enforce unique constraint on username", async () => {
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
|
||||
await expect(
|
||||
client.execute("INSERT INTO users (username) VALUES ('testuser')")
|
||||
).rejects.toThrow();
|
||||
});
|
||||
|
||||
it("should enforce unique constraint on refresh token_id", async () => {
|
||||
await client.execute("INSERT INTO users (username) VALUES ('testuser')");
|
||||
await client.execute(
|
||||
"INSERT INTO refresh_tokens (user_id, token_id, expires_at) VALUES (1, 'token123', 1735689600)"
|
||||
);
|
||||
|
||||
await expect(
|
||||
client.execute(
|
||||
"INSERT INTO refresh_tokens (user_id, token_id, expires_at) VALUES (1, 'token123', 1735689600)"
|
||||
)
|
||||
).rejects.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Default User Creation (Auth Disabled)", () => {
|
||||
let client: ReturnType<typeof createClient>;
|
||||
|
||||
beforeEach(async () => {
|
||||
client = createClient({ url: ":memory:" });
|
||||
await client.execute(`
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
username text NOT NULL UNIQUE,
|
||||
auth_provider text NOT NULL DEFAULT 'local'
|
||||
)
|
||||
`);
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
});
|
||||
|
||||
it("should be able to create a default user with ID 1", async () => {
|
||||
|
||||
@@ -54,6 +54,8 @@ const { shareRoutes } = await import("../routes/share.js");
|
||||
const { medicationRoutes } = await import("../routes/medications.js");
|
||||
const { settingsRoutes } = await import("../routes/settings.js");
|
||||
const { healthRoutes } = await import("../routes/health.js");
|
||||
const { refillRoutes } = await import("../routes/refills.js");
|
||||
const { exportRoutes } = await import("../routes/export.js");
|
||||
|
||||
// =============================================================================
|
||||
// Test Setup
|
||||
@@ -142,6 +144,16 @@ async function createSchema(client: Client) {
|
||||
dismissed integer NOT NULL DEFAULT 0,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)`,
|
||||
`CREATE TABLE IF NOT EXISTS refill_history (
|
||||
id integer PRIMARY KEY AUTOINCREMENT,
|
||||
medication_id integer NOT NULL,
|
||||
user_id integer NOT NULL,
|
||||
packs_added integer NOT NULL DEFAULT 0,
|
||||
loose_pills_added integer NOT NULL DEFAULT 0,
|
||||
refill_date integer NOT NULL DEFAULT (strftime('%s','now')),
|
||||
FOREIGN KEY (medication_id) REFERENCES medications(id) ON DELETE CASCADE,
|
||||
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
)`,
|
||||
];
|
||||
|
||||
for (const sql of tableCreations) {
|
||||
@@ -150,6 +162,7 @@ async function createSchema(client: Client) {
|
||||
}
|
||||
|
||||
async function clearData(client: Client) {
|
||||
await client.execute("DELETE FROM refill_history");
|
||||
await client.execute("DELETE FROM dose_tracking");
|
||||
await client.execute("DELETE FROM share_tokens");
|
||||
await client.execute("DELETE FROM user_settings");
|
||||
@@ -230,6 +243,8 @@ describe("E2E Tests with Real Routes", () => {
|
||||
await app.register(medicationRoutes);
|
||||
await app.register(settingsRoutes);
|
||||
await app.register(healthRoutes);
|
||||
await app.register(refillRoutes);
|
||||
await app.register(exportRoutes);
|
||||
|
||||
await app.ready();
|
||||
});
|
||||
@@ -1568,4 +1583,342 @@ describe("E2E Tests with Real Routes", () => {
|
||||
expect(response.statusCode).toBe(204);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Real Refill Routes Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("Real /medications/:id/refill routes", () => {
|
||||
it("should add refill to medication stock", async () => {
|
||||
// Create medication first
|
||||
const createResponse = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "Refill Test Med",
|
||||
packCount: 2,
|
||||
blistersPerPack: 3,
|
||||
pillsPerBlister: 10,
|
||||
looseTablets: 5,
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
expect(createResponse.statusCode).toBe(200);
|
||||
const medId = createResponse.json().id;
|
||||
|
||||
// Add refill
|
||||
const refillResponse = await app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1, loosePillsAdded: 10 },
|
||||
});
|
||||
|
||||
expect(refillResponse.statusCode).toBe(200);
|
||||
const data = refillResponse.json();
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.newStock.packCount).toBe(3); // 2 + 1
|
||||
expect(data.newStock.looseTablets).toBe(15); // 5 + 10
|
||||
});
|
||||
|
||||
it("should return 400 when no packs or pills added", async () => {
|
||||
const createResponse = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "Refill Test Med 2",
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
const medId = createResponse.json().id;
|
||||
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 0, loosePillsAdded: 0 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
|
||||
it("should return 404 for non-existent medication", async () => {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications/99999/refill",
|
||||
payload: { packsAdded: 1 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
});
|
||||
|
||||
it("should return 400 for invalid medication id", async () => {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications/invalid/refill",
|
||||
payload: { packsAdded: 1 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Real /medications/:id/refills routes (history)", () => {
|
||||
it("should return empty array when no refills", async () => {
|
||||
const createResponse = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "No Refill Med",
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
const medId = createResponse.json().id;
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/medications/${medId}/refills`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(response.json()).toEqual([]);
|
||||
});
|
||||
|
||||
it("should return refill history after adding refills", async () => {
|
||||
const createResponse = await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "With Refills Med",
|
||||
packCount: 1,
|
||||
blistersPerPack: 2,
|
||||
pillsPerBlister: 10,
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
const medId = createResponse.json().id;
|
||||
|
||||
// Add two refills
|
||||
await app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1, loosePillsAdded: 0 },
|
||||
});
|
||||
await app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 0, loosePillsAdded: 5 },
|
||||
});
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: `/medications/${medId}/refills`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const refills = response.json();
|
||||
expect(refills).toHaveLength(2);
|
||||
// Check both refills exist (order may vary)
|
||||
const hasPackRefill = refills.some((r: any) => r.packsAdded === 1 && r.loosePillsAdded === 0);
|
||||
const hasLooseRefill = refills.some((r: any) => r.packsAdded === 0 && r.loosePillsAdded === 5);
|
||||
expect(hasPackRefill).toBe(true);
|
||||
expect(hasLooseRefill).toBe(true);
|
||||
});
|
||||
|
||||
it("should return 404 for non-existent medication", async () => {
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: "/medications/99999/refills",
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Real Export/Import Routes Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("Real /export routes", () => {
|
||||
it("should export empty data when no medications", async () => {
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: "/export",
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.version).toBeDefined();
|
||||
expect(data.exportedAt).toBeDefined();
|
||||
expect(data.medications).toEqual([]);
|
||||
});
|
||||
|
||||
it("should export medications with correct structure", async () => {
|
||||
// Create a medication
|
||||
await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "Export Test Med",
|
||||
genericName: "Test Generic",
|
||||
packCount: 2,
|
||||
blistersPerPack: 3,
|
||||
pillsPerBlister: 10,
|
||||
looseTablets: 5,
|
||||
pillWeightMg: 500,
|
||||
notes: "Test notes",
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: "/export",
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.medications).toHaveLength(1);
|
||||
|
||||
const med = data.medications[0];
|
||||
expect(med.name).toBe("Export Test Med");
|
||||
expect(med.genericName).toBe("Test Generic");
|
||||
expect(med.inventory.packCount).toBe(2);
|
||||
expect(med.inventory.blistersPerPack).toBe(3);
|
||||
expect(med.inventory.pillsPerBlister).toBe(10);
|
||||
expect(med.inventory.looseTablets).toBe(5);
|
||||
expect(med.pillWeightMg).toBe(500);
|
||||
expect(med.notes).toBe("Test notes");
|
||||
expect(med.schedules).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should include settings when user has settings", async () => {
|
||||
// Create settings first
|
||||
await app.inject({
|
||||
method: "PUT",
|
||||
url: "/settings",
|
||||
payload: {
|
||||
emailEnabled: true,
|
||||
notificationEmail: "test@example.com",
|
||||
},
|
||||
});
|
||||
|
||||
const response = await app.inject({
|
||||
method: "GET",
|
||||
url: "/export",
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.settings).toBeDefined();
|
||||
expect(data.settings.emailEnabled).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Real /import routes", () => {
|
||||
it("should import medications from export format", async () => {
|
||||
const importData = {
|
||||
version: "1.0",
|
||||
exportedAt: new Date().toISOString(),
|
||||
medications: [
|
||||
{
|
||||
_exportId: "med-1",
|
||||
name: "Imported Med",
|
||||
genericName: "Imported Generic",
|
||||
takenBy: ["Person A"],
|
||||
inventory: {
|
||||
packCount: 3,
|
||||
blistersPerPack: 2,
|
||||
pillsPerBlister: 14,
|
||||
looseTablets: 7,
|
||||
},
|
||||
pillWeightMg: 250,
|
||||
schedules: [
|
||||
{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z", remind: true }
|
||||
],
|
||||
notes: "Imported notes",
|
||||
intakeRemindersEnabled: true,
|
||||
}
|
||||
],
|
||||
};
|
||||
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/import",
|
||||
payload: importData,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const result = response.json();
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.imported.medications).toBe(1);
|
||||
|
||||
// Verify medication was created
|
||||
const medsResponse = await app.inject({
|
||||
method: "GET",
|
||||
url: "/medications",
|
||||
});
|
||||
const meds = medsResponse.json();
|
||||
expect(meds).toHaveLength(1);
|
||||
expect(meds[0].name).toBe("Imported Med");
|
||||
});
|
||||
|
||||
it("should return 400 for invalid import data", async () => {
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/import",
|
||||
payload: { invalid: "data" },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
});
|
||||
|
||||
it("should replace existing medications on import", async () => {
|
||||
// First create a medication
|
||||
await app.inject({
|
||||
method: "POST",
|
||||
url: "/medications",
|
||||
payload: {
|
||||
name: "Existing Med",
|
||||
packCount: 5,
|
||||
blisters: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
},
|
||||
});
|
||||
|
||||
// Verify it exists
|
||||
let medsResponse = await app.inject({ method: "GET", url: "/medications" });
|
||||
expect(medsResponse.json()).toHaveLength(1);
|
||||
expect(medsResponse.json()[0].name).toBe("Existing Med");
|
||||
expect(medsResponse.json()[0].packCount).toBe(5);
|
||||
|
||||
// Import will REPLACE all data
|
||||
const importData = {
|
||||
version: "1.0",
|
||||
exportedAt: new Date().toISOString(),
|
||||
medications: [
|
||||
{
|
||||
_exportId: "med-1",
|
||||
name: "Imported Med",
|
||||
inventory: { packCount: 10, blistersPerPack: 2, pillsPerBlister: 14, looseTablets: 0 },
|
||||
schedules: [{ usage: 1, every: 1, start: "2025-01-01T08:00:00.000Z" }],
|
||||
}
|
||||
],
|
||||
};
|
||||
|
||||
const response = await app.inject({
|
||||
method: "POST",
|
||||
url: "/import",
|
||||
payload: importData,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const result = response.json();
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.imported.medications).toBe(1);
|
||||
|
||||
// Verify: old med is gone, new med exists
|
||||
medsResponse = await app.inject({ method: "GET", url: "/medications" });
|
||||
expect(medsResponse.json()).toHaveLength(1);
|
||||
expect(medsResponse.json()[0].name).toBe("Imported Med");
|
||||
expect(medsResponse.json()[0].packCount).toBe(10);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,394 @@
|
||||
/**
|
||||
* Tests for /medications/:id/refill and /medications/:id/refills API endpoints.
|
||||
* Tests adding refills to medication stock and retrieving refill history.
|
||||
*/
|
||||
import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
|
||||
import {
|
||||
buildTestApp,
|
||||
closeTestApp,
|
||||
clearTestData,
|
||||
createTestUser,
|
||||
createTestMedication,
|
||||
TestContext,
|
||||
} from "./setup.js";
|
||||
|
||||
// Store userId at module level so routes can access it
|
||||
let currentUserId = 1;
|
||||
|
||||
// =============================================================================
|
||||
// Route Registration
|
||||
// =============================================================================
|
||||
|
||||
async function registerRefillRoutes(ctx: TestContext) {
|
||||
const { app, client } = ctx;
|
||||
|
||||
// POST /medications/:id/refill - Add stock and record history
|
||||
app.post<{ Params: { id: string }; Body: { packsAdded?: number; loosePillsAdded?: number } }>(
|
||||
"/medications/:id/refill",
|
||||
async (request, reply) => {
|
||||
const userId = currentUserId;
|
||||
const medId = parseInt(request.params.id, 10);
|
||||
const { packsAdded = 0, loosePillsAdded = 0 } = request.body || {};
|
||||
|
||||
// Validate input
|
||||
if (packsAdded < 0 || loosePillsAdded < 0) {
|
||||
return reply.status(400).send({ error: "packsAdded and loosePillsAdded must be non-negative" });
|
||||
}
|
||||
if (packsAdded === 0 && loosePillsAdded === 0) {
|
||||
return reply.status(400).send({ error: "At least one of packsAdded or loosePillsAdded must be greater than 0" });
|
||||
}
|
||||
|
||||
// Check medication exists and belongs to user
|
||||
const medResult = await client.execute({
|
||||
sql: `SELECT id, pack_count, loose_tablets, blisters_per_pack, pills_per_blister
|
||||
FROM medications WHERE id = ? AND user_id = ?`,
|
||||
args: [medId, userId],
|
||||
});
|
||||
|
||||
if (medResult.rows.length === 0) {
|
||||
return reply.status(404).send({ error: "Medication not found" });
|
||||
}
|
||||
|
||||
const med = medResult.rows[0];
|
||||
const newPackCount = (med.pack_count as number) + packsAdded;
|
||||
const newLooseTablets = (med.loose_tablets as number) + loosePillsAdded;
|
||||
const pillsPerPack = (med.blisters_per_pack as number) * (med.pills_per_blister as number);
|
||||
const totalPillsAdded = packsAdded * pillsPerPack + loosePillsAdded;
|
||||
|
||||
// Update medication stock
|
||||
await client.execute({
|
||||
sql: `UPDATE medications SET pack_count = ?, loose_tablets = ? WHERE id = ?`,
|
||||
args: [newPackCount, newLooseTablets, medId],
|
||||
});
|
||||
|
||||
// Record refill history
|
||||
await client.execute({
|
||||
sql: `INSERT INTO refill_history (medication_id, user_id, packs_added, loose_pills_added)
|
||||
VALUES (?, ?, ?, ?)`,
|
||||
args: [medId, userId, packsAdded, loosePillsAdded],
|
||||
});
|
||||
|
||||
return {
|
||||
success: true,
|
||||
pillsAdded: totalPillsAdded,
|
||||
newPackCount,
|
||||
newLooseTablets,
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
// GET /medications/:id/refills - Get refill history
|
||||
app.get<{ Params: { id: string } }>("/medications/:id/refills", async (request, reply) => {
|
||||
const userId = currentUserId;
|
||||
const medId = parseInt(request.params.id, 10);
|
||||
|
||||
// Check medication exists and belongs to user
|
||||
const medResult = await client.execute({
|
||||
sql: `SELECT id FROM medications WHERE id = ? AND user_id = ?`,
|
||||
args: [medId, userId],
|
||||
});
|
||||
|
||||
if (medResult.rows.length === 0) {
|
||||
return reply.status(404).send({ error: "Medication not found" });
|
||||
}
|
||||
|
||||
// Get refill history, newest first
|
||||
const refillResult = await client.execute({
|
||||
sql: `SELECT id, packs_added, loose_pills_added, refill_date
|
||||
FROM refill_history
|
||||
WHERE medication_id = ? AND user_id = ?
|
||||
ORDER BY refill_date DESC`,
|
||||
args: [medId, userId],
|
||||
});
|
||||
|
||||
return {
|
||||
refills: refillResult.rows.map((r) => ({
|
||||
id: r.id,
|
||||
packsAdded: r.packs_added,
|
||||
loosePillsAdded: r.loose_pills_added,
|
||||
refillDate: r.refill_date,
|
||||
})),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Tests
|
||||
// =============================================================================
|
||||
|
||||
describe("Refill API", () => {
|
||||
let ctx: TestContext;
|
||||
let userId: number;
|
||||
let medId: number;
|
||||
|
||||
beforeAll(async () => {
|
||||
ctx = await buildTestApp();
|
||||
await registerRefillRoutes(ctx);
|
||||
await ctx.app.ready();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await closeTestApp(ctx);
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
await clearTestData(ctx.client);
|
||||
// Create test user
|
||||
userId = await createTestUser(ctx.client, { username: "testuser" });
|
||||
// Update the module-level userId so routes use the correct one
|
||||
currentUserId = userId;
|
||||
// Create a test medication with 1 pack (10 blisters × 10 pills = 100 pills/pack)
|
||||
medId = await createTestMedication(ctx.client, {
|
||||
userId,
|
||||
name: "Test Med",
|
||||
packCount: 1,
|
||||
blistersPerPack: 10,
|
||||
pillsPerBlister: 10,
|
||||
looseTablets: 5,
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// POST /medications/:id/refill
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("POST /medications/:id/refill", () => {
|
||||
it("should add packs to medication stock", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 2 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.pillsAdded).toBe(200); // 2 packs × 100 pills
|
||||
expect(data.newPackCount).toBe(3); // 1 + 2
|
||||
|
||||
// Verify in database
|
||||
const result = await ctx.client.execute({
|
||||
sql: `SELECT pack_count FROM medications WHERE id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
expect(result.rows[0].pack_count).toBe(3);
|
||||
});
|
||||
|
||||
it("should add loose pills to medication stock", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { loosePillsAdded: 15 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.pillsAdded).toBe(15);
|
||||
expect(data.newLooseTablets).toBe(20); // 5 + 15
|
||||
|
||||
// Verify in database
|
||||
const result = await ctx.client.execute({
|
||||
sql: `SELECT loose_tablets FROM medications WHERE id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
expect(result.rows[0].loose_tablets).toBe(20);
|
||||
});
|
||||
|
||||
it("should add both packs and loose pills", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1, loosePillsAdded: 10 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.pillsAdded).toBe(110); // 1 pack (100) + 10 loose
|
||||
expect(data.newPackCount).toBe(2);
|
||||
expect(data.newLooseTablets).toBe(15);
|
||||
});
|
||||
|
||||
it("should record refill in history", async () => {
|
||||
await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 2, loosePillsAdded: 5 },
|
||||
});
|
||||
|
||||
// Check history
|
||||
const result = await ctx.client.execute({
|
||||
sql: `SELECT packs_added, loose_pills_added FROM refill_history WHERE medication_id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
expect(result.rows.length).toBe(1);
|
||||
expect(result.rows[0].packs_added).toBe(2);
|
||||
expect(result.rows[0].loose_pills_added).toBe(5);
|
||||
});
|
||||
|
||||
it("should reject refill with zero amounts", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 0, loosePillsAdded: 0 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json().error).toContain("At least one");
|
||||
});
|
||||
|
||||
it("should reject refill with negative amounts", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: -1 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(400);
|
||||
expect(response.json().error).toContain("non-negative");
|
||||
});
|
||||
|
||||
it("should return 404 for non-existent medication", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/99999/refill`,
|
||||
payload: { packsAdded: 1 },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json().error).toBe("Medication not found");
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// GET /medications/:id/refills
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("GET /medications/:id/refills", () => {
|
||||
it("should return empty array when no refills", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "GET",
|
||||
url: `/medications/${medId}/refills`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
expect(response.json()).toEqual({ refills: [] });
|
||||
});
|
||||
|
||||
it("should return refill history newest first", async () => {
|
||||
// Add two refills with different values so we can identify them
|
||||
await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1, loosePillsAdded: 0 },
|
||||
});
|
||||
|
||||
// Increase delay to ensure different timestamps (SQLite datetime has second precision)
|
||||
await new Promise((r) => setTimeout(r, 1100));
|
||||
|
||||
await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 0, loosePillsAdded: 20 },
|
||||
});
|
||||
|
||||
const response = await ctx.app.inject({
|
||||
method: "GET",
|
||||
url: `/medications/${medId}/refills`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const data = response.json();
|
||||
expect(data.refills).toHaveLength(2);
|
||||
|
||||
// Newest first (loose pills - added second)
|
||||
expect(data.refills[0].packsAdded).toBe(0);
|
||||
expect(data.refills[0].loosePillsAdded).toBe(20);
|
||||
|
||||
// Older (packs - added first)
|
||||
expect(data.refills[1].packsAdded).toBe(1);
|
||||
expect(data.refills[1].loosePillsAdded).toBe(0);
|
||||
|
||||
// Each entry should have an id and refillDate
|
||||
for (const refill of data.refills) {
|
||||
expect(refill.id).toBeTypeOf("number");
|
||||
expect(refill.refillDate).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
it("should return 404 for non-existent medication", async () => {
|
||||
const response = await ctx.app.inject({
|
||||
method: "GET",
|
||||
url: `/medications/99999/refills`,
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
expect(response.json().error).toBe("Medication not found");
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Cascade Delete Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("Cascade Delete", () => {
|
||||
it("should delete refill history when medication is deleted", async () => {
|
||||
// Add a refill
|
||||
await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1 },
|
||||
});
|
||||
|
||||
// Verify refill exists
|
||||
let result = await ctx.client.execute({
|
||||
sql: `SELECT COUNT(*) as count FROM refill_history WHERE medication_id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
expect(result.rows[0].count).toBe(1);
|
||||
|
||||
// Delete medication
|
||||
await ctx.client.execute({
|
||||
sql: `DELETE FROM medications WHERE id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
|
||||
// Verify refill history was cascade deleted
|
||||
result = await ctx.client.execute({
|
||||
sql: `SELECT COUNT(*) as count FROM refill_history WHERE medication_id = ?`,
|
||||
args: [medId],
|
||||
});
|
||||
expect(result.rows[0].count).toBe(0);
|
||||
});
|
||||
|
||||
it("should delete refill history when user is deleted", async () => {
|
||||
// Add a refill
|
||||
await ctx.app.inject({
|
||||
method: "POST",
|
||||
url: `/medications/${medId}/refill`,
|
||||
payload: { packsAdded: 1 },
|
||||
});
|
||||
|
||||
// Verify refill exists
|
||||
let result = await ctx.client.execute({
|
||||
sql: `SELECT COUNT(*) as count FROM refill_history WHERE user_id = ?`,
|
||||
args: [userId],
|
||||
});
|
||||
expect(result.rows[0].count).toBe(1);
|
||||
|
||||
// Delete user
|
||||
await ctx.client.execute({
|
||||
sql: `DELETE FROM users WHERE id = ?`,
|
||||
args: [userId],
|
||||
});
|
||||
|
||||
// Verify refill history was cascade deleted
|
||||
result = await ctx.client.execute({
|
||||
sql: `SELECT COUNT(*) as count FROM refill_history WHERE user_id = ?`,
|
||||
args: [userId],
|
||||
});
|
||||
expect(result.rows[0].count).toBe(0);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -9,8 +9,15 @@ import sensible from "@fastify/sensible";
|
||||
import fastifyMultipart from "@fastify/multipart";
|
||||
import { createClient, Client } from "@libsql/client";
|
||||
import { drizzle } from "drizzle-orm/libsql";
|
||||
import { migrate } from "drizzle-orm/libsql/migrator";
|
||||
import { beforeAll, afterAll, beforeEach } from "vitest";
|
||||
import { getTableCreationSQL } from "../db/schema-sql.js";
|
||||
import { resolve, dirname } from "path";
|
||||
import { fileURLToPath } from "url";
|
||||
|
||||
// Get migrations folder path
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
const migrationsFolder = resolve(__dirname, "../../drizzle");
|
||||
|
||||
// Type for our test database
|
||||
export type TestDb = ReturnType<typeof drizzle>;
|
||||
@@ -61,14 +68,11 @@ export async function buildTestApp(): Promise<TestContext> {
|
||||
}
|
||||
|
||||
/**
|
||||
* Create test database schema
|
||||
* Create test database schema using drizzle-kit migrations
|
||||
*/
|
||||
async function runTestMigrations(client: Client): Promise<void> {
|
||||
const tableCreations = getTableCreationSQL();
|
||||
|
||||
for (const sql of tableCreations) {
|
||||
await client.execute(sql);
|
||||
}
|
||||
const db = drizzle(client);
|
||||
await migrate(db, { migrationsFolder });
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
@@ -282,6 +286,7 @@ export async function closeTestApp(ctx: TestContext): Promise<void> {
|
||||
*/
|
||||
export async function clearTestData(client: Client): Promise<void> {
|
||||
// Order matters due to foreign keys
|
||||
await client.execute("DELETE FROM refill_history");
|
||||
await client.execute("DELETE FROM dose_tracking");
|
||||
await client.execute("DELETE FROM share_tokens");
|
||||
await client.execute("DELETE FROM refresh_tokens");
|
||||
|
||||
Reference in New Issue
Block a user