@btst/stack 2.8.1 → 2.9.0

package/src/plugins/media/__tests__/getters.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { defineDb } from "@btst/db";
+import type { DBAdapter as Adapter } from "@btst/db";
+import { mediaSchema } from "../db";
+import {
+	listAssets,
+	getAssetById,
+	listFolders,
+	getFolderById,
+} from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(mediaSchema);
+	return createMemoryAdapter(db)({});
+};
+
+const makeAsset = (
+	overrides: Partial<{
+		filename: string;
+		originalName: string;
+		mimeType: string;
+		size: number;
+		url: string;
+		folderId: string | undefined;
+		alt: string | undefined;
+	}> = {},
+) => ({
+	filename: "image.jpg",
+	originalName: "My Image.jpg",
+	mimeType: "image/jpeg",
+	size: 1024,
+	url: "https://example.com/image.jpg",
+	folderId: undefined,
+	alt: undefined,
+	createdAt: new Date(),
+	...overrides,
+});
+
+const makeFolder = (
+	overrides: Partial<{
+		name: string;
+		parentId: string | undefined;
+	}> = {},
+) => ({
+	name: "My Folder",
+	parentId: undefined,
+	createdAt: new Date(),
+	...overrides,
+});
+
+describe("media getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	// ── listAssets ────────────────────────────────────────────────────────────
+
+	describe("listAssets", () => {
+		it("returns empty result when no assets exist", async () => {
+			const result = await listAssets(adapter);
+			expect(result.items).toEqual([]);
+			expect(result.total).toBe(0);
+		});
+
+		it("returns all assets with correct fields", async () => {
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({
+					filename: "photo.jpg",
+					url: "https://example.com/photo.jpg",
+				}),
+			});
+
+			const result = await listAssets(adapter);
+			expect(result.items).toHaveLength(1);
+			expect(result.total).toBe(1);
+			expect(result.items[0]!.filename).toBe("photo.jpg");
+			expect(result.items[0]!.mimeType).toBe("image/jpeg");
+		});
+
+		it("filters assets by folderId", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Photos" }),
+			});
+			const folder = await adapter.findOne<{ id: string }>({
+				model: "mediaFolder",
+				where: [{ field: "name", value: "Photos", operator: "eq" }],
+			});
+
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({ filename: "in-folder.jpg", folderId: folder!.id }),
+			});
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({ filename: "no-folder.jpg" }),
+			});
+
+			const result = await listAssets(adapter, { folderId: folder!.id });
+			expect(result.items).toHaveLength(1);
+			expect(result.items[0]!.filename).toBe("in-folder.jpg");
+		});
+
+		it("filters assets by mimeType", async () => {
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({ filename: "image.jpg", mimeType: "image/jpeg" }),
+			});
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({ filename: "doc.pdf", mimeType: "application/pdf" }),
+			});
+
+			const images = await listAssets(adapter, { mimeType: "image/jpeg" });
+			expect(images.items).toHaveLength(1);
+			expect(images.items[0]!.filename).toBe("image.jpg");
+
+			const pdfs = await listAssets(adapter, { mimeType: "application/pdf" });
+			expect(pdfs.items).toHaveLength(1);
+			expect(pdfs.items[0]!.filename).toBe("doc.pdf");
+		});
+
+		it("searches assets by query string across filename, originalName, and alt", async () => {
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({
+					filename: "holiday-photo.jpg",
+					originalName: "Holiday Photo.jpg",
+					alt: "Beach sunset",
+				}),
+			});
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({
+					filename: "logo.png",
+					originalName: "Company Logo.png",
+					alt: "Brand logo",
+				}),
+			});
+
+			const holidayResult = await listAssets(adapter, { query: "holiday" });
+			expect(holidayResult.items).toHaveLength(1);
+			expect(holidayResult.items[0]!.filename).toBe("holiday-photo.jpg");
+
+			// "beach" matches only the alt text of the first asset
+			const beachResult = await listAssets(adapter, { query: "beach" });
+			expect(beachResult.items).toHaveLength(1);
+			expect(beachResult.items[0]!.alt).toBe("Beach sunset");
+
+			// "logo" matches only the second asset (filename, originalName, alt)
+			const logoResult = await listAssets(adapter, { query: "logo" });
+			expect(logoResult.items).toHaveLength(1);
+			expect(logoResult.items[0]!.filename).toBe("logo.png");
+
+			// "photo" matches only the first asset via filename and originalName
+			const photoResult = await listAssets(adapter, { query: "photo" });
+			expect(photoResult.items).toHaveLength(1);
+			expect(photoResult.items[0]!.filename).toBe("holiday-photo.jpg");
+		});
+
+		it("paginates results with limit and offset", async () => {
+			for (let i = 0; i < 5; i++) {
+				await adapter.create({
+					model: "mediaAsset",
+					data: makeAsset({
+						filename: `asset-${i}.jpg`,
+						url: `https://example.com/${i}.jpg`,
+					}),
+				});
+			}
+
+			const page1 = await listAssets(adapter, { limit: 2, offset: 0 });
+			expect(page1.items).toHaveLength(2);
+			expect(page1.total).toBe(5);
+
+			const page2 = await listAssets(adapter, { limit: 2, offset: 2 });
+			expect(page2.items).toHaveLength(2);
+			expect(page2.total).toBe(5);
+
+			const page3 = await listAssets(adapter, { limit: 2, offset: 4 });
+			expect(page3.items).toHaveLength(1);
+			expect(page3.total).toBe(5);
+		});
+	});
+
+	// ── getAssetById ─────────────────────────────────────────────────────────
+
+	describe("getAssetById", () => {
+		it("returns null when asset does not exist", async () => {
+			const result = await getAssetById(adapter, "nonexistent-id");
+			expect(result).toBeNull();
+		});
+
+		it("returns the asset by ID", async () => {
+			const created = await adapter.create<{ id: string }>({
+				model: "mediaAsset",
+				data: makeAsset({ filename: "found.jpg" }),
+			});
+
+			const result = await getAssetById(adapter, created.id);
+			expect(result).not.toBeNull();
+			expect(result!.filename).toBe("found.jpg");
+		});
+	});
+
+	// ── listFolders ───────────────────────────────────────────────────────────
+
+	describe("listFolders", () => {
+		it("returns empty array when no folders exist", async () => {
+			const result = await listFolders(adapter);
+			expect(result).toEqual([]);
+		});
+
+		it("returns all folders sorted by name", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Zeta" }),
+			});
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Alpha" }),
+			});
+
+			const result = await listFolders(adapter);
+			expect(result).toHaveLength(2);
+			expect(result[0]!.name).toBe("Alpha");
+			expect(result[1]!.name).toBe("Zeta");
+		});
+
+		it("filters folders by parentId", async () => {
+			const root = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Root" }),
+			});
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Child", parentId: root.id }),
+			});
+
+			// No params — returns ALL folders
+			const allFolders = await listFolders(adapter);
+			expect(allFolders).toHaveLength(2);
+
+			// Filter children of root
+			const childFolders = await listFolders(adapter, { parentId: root.id });
+			expect(childFolders).toHaveLength(1);
+			expect(childFolders[0]!.name).toBe("Child");
+		});
+	});
+
+	// ── getFolderById ─────────────────────────────────────────────────────────
+
+	describe("getFolderById", () => {
+		it("returns null when folder does not exist", async () => {
+			const result = await getFolderById(adapter, "nonexistent-id");
+			expect(result).toBeNull();
+		});
+
+		it("returns the folder by ID", async () => {
+			const created = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Test Folder" }),
+			});
+
+			const result = await getFolderById(adapter, created.id);
+			expect(result).not.toBeNull();
+			expect(result!.name).toBe("Test Folder");
+		});
+	});
+});

package/src/plugins/media/__tests__/mutations.test.ts

@@ -0,0 +1,299 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { defineDb } from "@btst/db";
+import type { DBAdapter as Adapter } from "@btst/db";
+import { mediaSchema } from "../db";
+import type { Asset, Folder } from "../types";
+import {
+	createAsset,
+	updateAsset,
+	deleteAsset,
+	createFolder,
+	deleteFolder,
+} from "../api/mutations";
+import { getAssetById, getFolderById } from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(mediaSchema);
+	return createMemoryAdapter(db)({});
+};
+
+const assetInput = {
+	filename: "photo.jpg",
+	originalName: "My Photo.jpg",
+	mimeType: "image/jpeg",
+	size: 2048,
+	url: "https://example.com/photo.jpg",
+};
+
+describe("media mutations", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	// ── createAsset ───────────────────────────────────────────────────────────
+
+	describe("createAsset", () => {
+		it("creates an asset with required fields", async () => {
+			const asset = await createAsset(adapter, assetInput);
+
+			expect(asset.id).toBeDefined();
+			expect(asset.filename).toBe("photo.jpg");
+			expect(asset.originalName).toBe("My Photo.jpg");
+			expect(asset.mimeType).toBe("image/jpeg");
+			expect(asset.size).toBe(2048);
+			expect(asset.url).toBe("https://example.com/photo.jpg");
+			expect(asset.createdAt).toBeInstanceOf(Date);
+		});
+
+		it("creates an asset with optional fields", async () => {
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				folderId: "folder-123",
+				alt: "A beautiful photo",
+			});
+
+			expect(asset.folderId).toBe("folder-123");
+			expect(asset.alt).toBe("A beautiful photo");
+		});
+
+		it("creates multiple independent assets", async () => {
+			await createAsset(adapter, {
+				...assetInput,
+				filename: "a.jpg",
+				url: "https://example.com/a.jpg",
+			});
+			await createAsset(adapter, {
+				...assetInput,
+				filename: "b.jpg",
+				url: "https://example.com/b.jpg",
+			});
+
+			const all = await adapter.findMany<Asset>({ model: "mediaAsset" });
+			expect(all).toHaveLength(2);
+		});
+	});
+
+	// ── updateAsset ───────────────────────────────────────────────────────────
+
+	describe("updateAsset", () => {
+		it("updates the alt text of an asset", async () => {
+			const asset = await createAsset(adapter, assetInput);
+			const updated = await updateAsset(adapter, asset.id, {
+				alt: "Updated alt text",
+			});
+
+			expect(updated).not.toBeNull();
+			expect(updated!.alt).toBe("Updated alt text");
+		});
+
+		it("updates the folderId of an asset", async () => {
+			const asset = await createAsset(adapter, assetInput);
+			const updated = await updateAsset(adapter, asset.id, {
+				folderId: "folder-abc",
+			});
+
+			expect(updated!.folderId).toBe("folder-abc");
+		});
+
+		it("returns the updated asset when only folderId is changed", async () => {
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				folderId: "folder-old",
+			});
+			const updated = await updateAsset(adapter, asset.id, {
+				folderId: "folder-new",
+			});
+
+			expect(updated).not.toBeNull();
+			expect(updated!.folderId).toBe("folder-new");
+		});
+
+		it("clears the folder association when folderId is null", async () => {
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				folderId: "folder-to-clear",
+			});
+			expect(asset.folderId).toBe("folder-to-clear");
+
+			const updated = await updateAsset(adapter, asset.id, { folderId: null });
+			expect(updated).not.toBeNull();
+			expect(updated!.folderId == null).toBe(true);
+		});
+
+		it("does not change folderId when folderId is not in the input", async () => {
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				folderId: "folder-keep",
+			});
+
+			const updated = await updateAsset(adapter, asset.id, {
+				alt: "new alt text",
+			});
+			expect(updated).not.toBeNull();
+			expect(updated!.folderId).toBe("folder-keep");
+			expect(updated!.alt).toBe("new alt text");
+		});
+
+		it("returns null for nonexistent asset", async () => {
+			const result = await updateAsset(adapter, "nonexistent-id", {
+				alt: "test",
+			});
+			expect(result).toBeNull();
+		});
+	});
+
+	// ── deleteAsset ───────────────────────────────────────────────────────────
+
+	describe("deleteAsset", () => {
+		it("removes the asset from the database", async () => {
+			const asset = await createAsset(adapter, assetInput);
+			await deleteAsset(adapter, asset.id);
+
+			const found = await getAssetById(adapter, asset.id);
+			expect(found).toBeNull();
+		});
+
+		it("does not throw when deleting a nonexistent asset", async () => {
+			await expect(
+				deleteAsset(adapter, "nonexistent-id"),
+			).resolves.not.toThrow();
+		});
+
+		it("only deletes the targeted asset", async () => {
+			const a = await createAsset(adapter, {
+				...assetInput,
+				filename: "a.jpg",
+				url: "https://example.com/a.jpg",
+			});
+			await createAsset(adapter, {
+				...assetInput,
+				filename: "b.jpg",
+				url: "https://example.com/b.jpg",
+			});
+
+			await deleteAsset(adapter, a.id);
+
+			const remaining = await adapter.findMany<Asset>({ model: "mediaAsset" });
+			expect(remaining).toHaveLength(1);
+			expect(remaining[0]!.filename).toBe("b.jpg");
+		});
+	});
+
+	// ── createFolder ──────────────────────────────────────────────────────────
+
+	describe("createFolder", () => {
+		it("creates a root folder", async () => {
+			const folder = await createFolder(adapter, { name: "Uploads" });
+
+			expect(folder.id).toBeDefined();
+			expect(folder.name).toBe("Uploads");
+			expect(folder.parentId).toBeUndefined();
+			expect(folder.createdAt).toBeInstanceOf(Date);
+		});
+
+		it("creates a nested folder with parentId", async () => {
+			const parent = await createFolder(adapter, { name: "Root" });
+			const child = await createFolder(adapter, {
+				name: "Photos",
+				parentId: parent.id,
+			});
+
+			expect(child.parentId).toBe(parent.id);
+		});
+	});
+
+	// ── deleteFolder ──────────────────────────────────────────────────────────
+
+	describe("deleteFolder", () => {
+		it("deletes an empty folder", async () => {
+			const folder = await createFolder(adapter, { name: "Empty" });
+			await deleteFolder(adapter, folder.id);
+
+			const found = await getFolderById(adapter, folder.id);
+			expect(found).toBeNull();
+		});
+
+		it("throws an error when the folder contains assets", async () => {
+			const folder = await createFolder(adapter, { name: "Full Folder" });
+			await createAsset(adapter, { ...assetInput, folderId: folder.id });
+
+			await expect(deleteFolder(adapter, folder.id)).rejects.toThrow(
+				"Cannot delete folder",
+			);
+
+			const stillExists = await getFolderById(adapter, folder.id);
+			expect(stillExists).not.toBeNull();
+		});
+
+		it("allows deletion after assets are removed", async () => {
+			const folder = await createFolder(adapter, { name: "Soon Empty" });
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				folderId: folder.id,
+			});
+
+			await deleteAsset(adapter, asset.id);
+			await expect(deleteFolder(adapter, folder.id)).resolves.not.toThrow();
+
+			const found = await getFolderById(adapter, folder.id);
+			expect(found).toBeNull();
+		});
+
+		it("does not throw when deleting a nonexistent folder", async () => {
+			await expect(
+				deleteFolder(adapter, "nonexistent-id"),
+			).resolves.not.toThrow();
+		});
+
+		it("only deletes the targeted folder and not siblings", async () => {
+			const a = await createFolder(adapter, { name: "Folder A" });
+			await createFolder(adapter, { name: "Folder B" });
+
+			await deleteFolder(adapter, a.id);
+
+			const remaining = await adapter.findMany<Folder>({
+				model: "mediaFolder",
+			});
+			expect(remaining).toHaveLength(1);
+			expect(remaining[0]!.name).toBe("Folder B");
+		});
+
+		it("cascade-deletes child folders when the subtree has no assets", async () => {
+			const parent = await createFolder(adapter, { name: "Parent" });
+			const child = await createFolder(adapter, {
+				name: "Child",
+				parentId: parent.id,
+			});
+			const grandchild = await createFolder(adapter, {
+				name: "Grandchild",
+				parentId: child.id,
+			});
+
+			await deleteFolder(adapter, parent.id);
+
+			expect(await getFolderById(adapter, parent.id)).toBeNull();
+			expect(await getFolderById(adapter, child.id)).toBeNull();
+			expect(await getFolderById(adapter, grandchild.id)).toBeNull();
+		});
+
+		it("throws when a child folder contains assets and leaves the whole subtree intact", async () => {
+			const parent = await createFolder(adapter, { name: "Parent" });
+			const child = await createFolder(adapter, {
+				name: "Child",
+				parentId: parent.id,
+			});
+			await createAsset(adapter, { ...assetInput, folderId: child.id });
+
+			await expect(deleteFolder(adapter, parent.id)).rejects.toThrow(
+				"Cannot delete folder",
+			);
+
+			// Both folders still exist — no partial deletion.
+			expect(await getFolderById(adapter, parent.id)).not.toBeNull();
+			expect(await getFolderById(adapter, child.id)).not.toBeNull();
+		});
+	});
+});