dineway 0.1.14 → 0.1.16

package/dist/taxonomies-z6Lz91BC.mjs

@@ -1,355 +0,0 @@
-import { t as TaxonomyRepository } from "./taxonomy-D5cbhc8u.mjs";
-import { c as invalidateTermCache } from "./taxonomies-D2aZGuns.mjs";
-import { ulid } from "ulidx";
-
-//#region src/api/handlers/taxonomies.ts
-/** Taxonomy name validation pattern: lowercase alphanumeric + underscores, starts with letter */
-const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
-/**
-* Build tree structure from flat terms
-*/
-function buildTree(flatTerms) {
-	const map = /* @__PURE__ */ new Map();
-	const roots = [];
-	for (const term of flatTerms) map.set(term.id, term);
-	for (const term of flatTerms) if (term.parentId && map.has(term.parentId)) map.get(term.parentId).children.push(term);
-	else roots.push(term);
-	return roots;
-}
-/**
-* Look up a taxonomy definition by name, returning a NOT_FOUND error if missing.
-*/
-async function requireTaxonomyDef(db, name) {
-	const def = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).executeTakeFirst();
-	if (!def) return {
-		success: false,
-		error: {
-			code: "NOT_FOUND",
-			message: `Taxonomy '${name}' not found`
-		}
-	};
-	return {
-		success: true,
-		def
-	};
-}
-/**
-* List all taxonomy definitions
-*/
-async function handleTaxonomyList(db) {
-	try {
-		return {
-			success: true,
-			data: { taxonomies: (await db.selectFrom("_dineway_taxonomy_defs").selectAll().execute()).map((row) => ({
-				id: row.id,
-				name: row.name,
-				label: row.label,
-				labelSingular: row.label_singular ?? void 0,
-				hierarchical: row.hierarchical === 1,
-				collections: row.collections ? JSON.parse(row.collections) : []
-			})) }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TAXONOMY_LIST_ERROR",
-				message: "Failed to list taxonomies"
-			}
-		};
-	}
-}
-/**
-* Create a new taxonomy definition
-*/
-async function handleTaxonomyCreate(db, input) {
-	try {
-		if (!NAME_PATTERN.test(input.name)) return {
-			success: false,
-			error: {
-				code: "VALIDATION_ERROR",
-				message: "Taxonomy name must start with a letter and contain only lowercase letters, numbers, and underscores"
-			}
-		};
-		const collections = [...new Set(input.collections ?? [])];
-		if (collections.length > 0) {
-			const existingCollections = await db.selectFrom("_dineway_collections").select("slug").where("slug", "in", collections).execute();
-			const existingSlugs = new Set(existingCollections.map((c) => c.slug));
-			const invalid = collections.filter((c) => !existingSlugs.has(c));
-			if (invalid.length > 0) return {
-				success: false,
-				error: {
-					code: "VALIDATION_ERROR",
-					message: `Unknown collection(s): ${invalid.join(", ")}`
-				}
-			};
-		}
-		if (await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", input.name).executeTakeFirst()) return {
-			success: false,
-			error: {
-				code: "CONFLICT",
-				message: `Taxonomy '${input.name}' already exists`
-			}
-		};
-		const id = ulid();
-		await db.insertInto("_dineway_taxonomy_defs").values({
-			id,
-			name: input.name,
-			label: input.label,
-			label_singular: null,
-			hierarchical: input.hierarchical ? 1 : 0,
-			collections: JSON.stringify(collections)
-		}).execute();
-		return {
-			success: true,
-			data: { taxonomy: {
-				id,
-				name: input.name,
-				label: input.label,
-				hierarchical: input.hierarchical ?? false,
-				collections
-			} }
-		};
-	} catch (error) {
-		if (error instanceof Error && error.message.includes("UNIQUE constraint failed")) return {
-			success: false,
-			error: {
-				code: "CONFLICT",
-				message: `Taxonomy '${input.name}' already exists`
-			}
-		};
-		return {
-			success: false,
-			error: {
-				code: "TAXONOMY_CREATE_ERROR",
-				message: "Failed to create taxonomy"
-			}
-		};
-	}
-}
-/**
-* List all terms for a taxonomy (returns tree for hierarchical taxonomies)
-*/
-async function handleTermList(db, taxonomyName) {
-	try {
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
-		if (!lookup.success) return lookup;
-		const repo = new TaxonomyRepository(db);
-		const terms = await repo.findByName(taxonomyName);
-		const counts = await repo.countEntriesForTerms(terms.map((term) => term.id));
-		const termData = terms.map((term) => ({
-			id: term.id,
-			name: term.name,
-			slug: term.slug,
-			label: term.label,
-			parentId: term.parentId,
-			description: typeof term.data?.description === "string" ? term.data.description : void 0,
-			children: [],
-			count: counts.get(term.id) ?? 0
-		}));
-		return {
-			success: true,
-			data: { terms: lookup.def.hierarchical === 1 ? buildTree(termData) : termData }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TERM_LIST_ERROR",
-				message: "Failed to list terms"
-			}
-		};
-	}
-}
-/**
-* Create a new term in a taxonomy
-*/
-async function handleTermCreate(db, taxonomyName, input) {
-	try {
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
-		if (!lookup.success) return lookup;
-		const repo = new TaxonomyRepository(db);
-		if (await repo.findBySlug(taxonomyName, input.slug)) return {
-			success: false,
-			error: {
-				code: "CONFLICT",
-				message: `Term with slug '${input.slug}' already exists in taxonomy '${taxonomyName}'`
-			}
-		};
-		const term = await repo.create({
-			name: taxonomyName,
-			slug: input.slug,
-			label: input.label,
-			parentId: input.parentId ?? void 0,
-			data: input.description ? { description: input.description } : void 0
-		});
-		/* @__PURE__ */ invalidateTermCache();
-		return {
-			success: true,
-			data: { term: {
-				id: term.id,
-				name: term.name,
-				slug: term.slug,
-				label: term.label,
-				parentId: term.parentId,
-				description: typeof term.data?.description === "string" ? term.data.description : void 0
-			} }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TERM_CREATE_ERROR",
-				message: "Failed to create term"
-			}
-		};
-	}
-}
-/**
-* Get a single term by slug
-*/
-async function handleTermGet(db, taxonomyName, termSlug) {
-	try {
-		const repo = new TaxonomyRepository(db);
-		const term = await repo.findBySlug(taxonomyName, termSlug);
-		if (!term) return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `Term '${termSlug}' not found in taxonomy '${taxonomyName}'`
-			}
-		};
-		const count = await repo.countEntriesWithTerm(term.id);
-		const children = await repo.findChildren(term.id);
-		return {
-			success: true,
-			data: { term: {
-				id: term.id,
-				name: term.name,
-				slug: term.slug,
-				label: term.label,
-				parentId: term.parentId,
-				description: typeof term.data?.description === "string" ? term.data.description : void 0,
-				count,
-				children: children.map((c) => ({
-					id: c.id,
-					slug: c.slug,
-					label: c.label
-				}))
-			} }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TERM_GET_ERROR",
-				message: "Failed to get term"
-			}
-		};
-	}
-}
-/**
-* Update a term
-*/
-async function handleTermUpdate(db, taxonomyName, termSlug, input) {
-	try {
-		const repo = new TaxonomyRepository(db);
-		const term = await repo.findBySlug(taxonomyName, termSlug);
-		if (!term) return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `Term '${termSlug}' not found in taxonomy '${taxonomyName}'`
-			}
-		};
-		if (input.slug && input.slug !== termSlug) {
-			const existing = await repo.findBySlug(taxonomyName, input.slug);
-			if (existing && existing.id !== term.id) return {
-				success: false,
-				error: {
-					code: "CONFLICT",
-					message: `Term with slug '${input.slug}' already exists in taxonomy '${taxonomyName}'`
-				}
-			};
-		}
-		const updated = await repo.update(term.id, {
-			slug: input.slug,
-			label: input.label,
-			parentId: input.parentId,
-			data: input.description !== void 0 ? { description: input.description } : void 0
-		});
-		/* @__PURE__ */ invalidateTermCache();
-		if (!updated) return {
-			success: false,
-			error: {
-				code: "TERM_UPDATE_ERROR",
-				message: "Failed to update term"
-			}
-		};
-		return {
-			success: true,
-			data: { term: {
-				id: updated.id,
-				name: updated.name,
-				slug: updated.slug,
-				label: updated.label,
-				parentId: updated.parentId,
-				description: typeof updated.data?.description === "string" ? updated.data.description : void 0
-			} }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TERM_UPDATE_ERROR",
-				message: "Failed to update term"
-			}
-		};
-	}
-}
-/**
-* Delete a term
-*/
-async function handleTermDelete(db, taxonomyName, termSlug) {
-	try {
-		const repo = new TaxonomyRepository(db);
-		const term = await repo.findBySlug(taxonomyName, termSlug);
-		if (!term) return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `Term '${termSlug}' not found in taxonomy '${taxonomyName}'`
-			}
-		};
-		if ((await repo.findChildren(term.id)).length > 0) return {
-			success: false,
-			error: {
-				code: "VALIDATION_ERROR",
-				message: "Cannot delete term with children. Delete children first."
-			}
-		};
-		if (!await repo.delete(term.id)) return {
-			success: false,
-			error: {
-				code: "TERM_DELETE_ERROR",
-				message: "Failed to delete term"
-			}
-		};
-		/* @__PURE__ */ invalidateTermCache();
-		return {
-			success: true,
-			data: { deleted: true }
-		};
-	} catch {
-		return {
-			success: false,
-			error: {
-				code: "TERM_DELETE_ERROR",
-				message: "Failed to delete term"
-			}
-		};
-	}
-}
-
-//#endregion
-export { handleTermGet as a, handleTermDelete as i, handleTaxonomyList as n, handleTermList as o, handleTermCreate as r, handleTermUpdate as s, handleTaxonomyCreate as t };

package/dist/taxonomy-D5cbhc8u.mjs

@@ -1,165 +0,0 @@
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-D_jVet6z.mjs";
-import { ulid } from "ulidx";
-
-//#region src/database/repositories/taxonomy.ts
-/**
-* Taxonomy repository for categories, tags, and other classification
-*
-* Taxonomies are hierarchical (via parentId) and can be attached to content entries.
-*/
-var TaxonomyRepository = class {
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Create a new taxonomy term
-	*/
-	async create(input) {
-		const id = ulid();
-		const row = {
-			id,
-			name: input.name,
-			slug: input.slug,
-			label: input.label,
-			parent_id: input.parentId ?? null,
-			data: input.data ? JSON.stringify(input.data) : null
-		};
-		await this.db.insertInto("taxonomies").values(row).execute();
-		const taxonomy = await this.findById(id);
-		if (!taxonomy) throw new Error("Failed to create taxonomy");
-		return taxonomy;
-	}
-	/**
-	* Find taxonomy by ID
-	*/
-	async findById(id) {
-		const row = await this.db.selectFrom("taxonomies").selectAll().where("id", "=", id).executeTakeFirst();
-		return row ? this.rowToTaxonomy(row) : null;
-	}
-	/**
-	* Find taxonomy by name and slug (unique constraint)
-	*/
-	async findBySlug(name, slug) {
-		const row = await this.db.selectFrom("taxonomies").selectAll().where("name", "=", name).where("slug", "=", slug).executeTakeFirst();
-		return row ? this.rowToTaxonomy(row) : null;
-	}
-	/**
-	* Get all terms for a taxonomy (e.g., all categories)
-	*/
-	async findByName(name, options = {}) {
-		let query = this.db.selectFrom("taxonomies").selectAll().where("name", "=", name).orderBy("label", "asc");
-		if (options.parentId !== void 0) if (options.parentId === null) query = query.where("parent_id", "is", null);
-		else query = query.where("parent_id", "=", options.parentId);
-		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Get children of a taxonomy term
-	*/
-	async findChildren(parentId) {
-		return (await this.db.selectFrom("taxonomies").selectAll().where("parent_id", "=", parentId).orderBy("label", "asc").execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Update a taxonomy term
-	*/
-	async update(id, input) {
-		if (!await this.findById(id)) return null;
-		const updates = {};
-		if (input.slug !== void 0) updates.slug = input.slug;
-		if (input.label !== void 0) updates.label = input.label;
-		if (input.parentId !== void 0) updates.parent_id = input.parentId;
-		if (input.data !== void 0) updates.data = JSON.stringify(input.data);
-		if (Object.keys(updates).length > 0) await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
-		return this.findById(id);
-	}
-	/**
-	* Delete a taxonomy term
-	*/
-	async delete(id) {
-		await this.db.deleteFrom("content_taxonomies").where("taxonomy_id", "=", id).execute();
-		return ((await this.db.deleteFrom("taxonomies").where("id", "=", id).executeTakeFirst()).numDeletedRows ?? 0) > 0;
-	}
-	/**
-	* Attach a taxonomy term to a content entry
-	*/
-	async attachToEntry(collection, entryId, taxonomyId) {
-		const row = {
-			collection,
-			entry_id: entryId,
-			taxonomy_id: taxonomyId
-		};
-		await this.db.insertInto("content_taxonomies").values(row).onConflict((oc) => oc.doNothing()).execute();
-	}
-	/**
-	* Detach a taxonomy term from a content entry
-	*/
-	async detachFromEntry(collection, entryId, taxonomyId) {
-		await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", taxonomyId).execute();
-	}
-	/**
-	* Get all taxonomy terms for a content entry
-	*/
-	async getTermsForEntry(collection, entryId, taxonomyName) {
-		let query = this.db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id").selectAll("taxonomies").where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "=", entryId);
-		if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
-		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Set all taxonomy terms for a content entry (replaces existing)
-	* Uses batch operations to avoid N+1 queries.
-	*/
-	async setTermsForEntry(collection, entryId, taxonomyName, taxonomyIds) {
-		const current = await this.getTermsForEntry(collection, entryId, taxonomyName);
-		const currentIds = new Set(current.map((t) => t.id));
-		const newIds = new Set(taxonomyIds);
-		const toRemove = current.filter((t) => !newIds.has(t.id)).map((t) => t.id);
-		if (toRemove.length > 0) await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", toRemove).execute();
-		const toAdd = taxonomyIds.filter((id) => !currentIds.has(id));
-		if (toAdd.length > 0) await this.db.insertInto("content_taxonomies").values(toAdd.map((taxonomy_id) => ({
-			collection,
-			entry_id: entryId,
-			taxonomy_id
-		}))).onConflict((oc) => oc.doNothing()).execute();
-	}
-	/**
-	* Remove all taxonomy associations for an entry (use when entry is deleted)
-	*/
-	async clearEntryTerms(collection, entryId) {
-		const result = await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0);
-	}
-	/**
-	* Count entries that have a specific taxonomy term
-	*/
-	async countEntriesWithTerm(taxonomyId) {
-		const result = await this.db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", taxonomyId).executeTakeFirst();
-		return Number(result?.count || 0);
-	}
-	/**
-	* Batch count entries for multiple taxonomy term IDs.
-	*/
-	async countEntriesForTerms(termIds) {
-		if (termIds.length === 0) return /* @__PURE__ */ new Map();
-		const counts = /* @__PURE__ */ new Map();
-		for (const chunk of chunks(termIds, SQL_BATCH_SIZE)) {
-			const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id", (eb) => eb.fn.count("entry_id").as("count")]).where("taxonomy_id", "in", chunk).groupBy("taxonomy_id").execute();
-			for (const row of rows) counts.set(row.taxonomy_id, Number(row.count || 0));
-		}
-		return counts;
-	}
-	/**
-	* Convert database row to Taxonomy object
-	*/
-	rowToTaxonomy(row) {
-		return {
-			id: row.id,
-			name: row.name,
-			slug: row.slug,
-			label: row.label,
-			parentId: row.parent_id,
-			data: row.data ? JSON.parse(row.data) : null
-		};
-	}
-};
-
-//#endregion
-export { TaxonomyRepository as t };

package/dist/version-B3z9Tv-J.mjs

@@ -1,6 +0,0 @@
-//#region src/version.ts
-const VERSION = "0.1.14";
-const COMMIT = "63a0d06c";
-
-//#endregion
-export { VERSION as n, COMMIT as t };