dineway 0.1.4 → 0.1.5

package/dist/{registry-DSd1GWB8.mjs → registry-C0zjeB9P.mjs}

@@ -1,36 +1,11 @@
 import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
-import { a as isSqlite, c as tableExists, n as currentTimestamp, s as listTablesLike } from "./dialect-helpers-B9uSp2GJ.mjs";
-import { t as validateIdentifier } from "./validate-CqRJb_xU.mjs";
-import { i as RESERVED_FIELD_SLUGS, n as FIELD_TYPE_TO_COLUMN, r as RESERVED_COLLECTION_SLUGS } from "./types-DuNbGKjF.mjs";
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { a as isSqlite, c as tableExists, n as currentTimestamp, s as listTablesLike } from "./dialect-helpers-DhTzaUxP.mjs";
+import { t as withTransaction } from "./transaction-Cn2rjY78.mjs";
+import { i as RESERVED_FIELD_SLUGS, n as FIELD_TYPE_TO_COLUMN, r as RESERVED_COLLECTION_SLUGS } from "./types-COeOq9nK.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
-//#region src/database/transaction.ts
-/**
-* Run a callback inside a transaction if supported, or directly if not.
-*
-* Probes the database once on first call to determine if transactions work.
-* The result is cached for the lifetime of the process/worker.
-*/
-let transactionsSupported = null;
-const TRANSACTIONS_NOT_SUPPORTED_RE = /transactions are not supported/i;
-async function withTransaction(db, fn) {
-	if (transactionsSupported === true) return db.transaction().execute(fn);
-	if (transactionsSupported === false) return fn(db);
-	try {
-		const result = await db.transaction().execute(fn);
-		transactionsSupported = true;
-		return result;
-	} catch (error) {
-		if (error instanceof Error && TRANSACTIONS_NOT_SUPPORTED_RE.test(error.message)) {
-			transactionsSupported = false;
-			return fn(db);
-		}
-		throw error;
-	}
-}
-
-//#endregion
 //#region src/search/fts-manager.ts
 /**
 * FTS5 Manager
@@ -55,12 +30,14 @@ var FTSManager = class {
 	* Uses _dineway_ prefix to clearly mark as internal/system table
 	*/
 	getFtsTableName(collectionSlug) {
+		validateIdentifier(collectionSlug, "collection slug");
 		return `_dineway_fts_${collectionSlug}`;
 	}
 	/**
 	* Get the content table name for a collection
 	*/
 	getContentTableName(collectionSlug) {
+		validateIdentifier(collectionSlug, "collection slug");
 		return `ec_${collectionSlug}`;
 	}
 	/**
@@ -99,9 +76,14 @@ var FTSManager = class {
 		await this.createTriggers(collectionSlug, searchableFields);
 	}
 	/**
-	* Create triggers to keep FTS table in sync with content table
+	* Create triggers to keep FTS table in sync with content table.
+	*
+	* Insert and update triggers only add rows to the FTS index when
+	* `deleted_at IS NULL`. This keeps soft-deleted content out of the
+	* index and keeps repair counts aligned with searchable content.
 	*/
 	async createTriggers(collectionSlug, searchableFields) {
+		this.validateInputs(collectionSlug, searchableFields);
 		const ftsTable = this.getFtsTableName(collectionSlug);
 		const contentTable = this.getContentTableName(collectionSlug);
 		const fieldList = searchableFields.join(", ");
@@ -109,6 +91,7 @@ var FTSManager = class {
 		await sql.raw(`
 			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert" 
 			AFTER INSERT ON "${contentTable}" 
+			WHEN NEW.deleted_at IS NULL
 			BEGIN
 				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
 				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
@@ -120,7 +103,8 @@ var FTSManager = class {
 			BEGIN
 				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
 				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
+				SELECT NEW.rowid, NEW.id, NEW.locale, ${newFieldList}
+				WHERE NEW.deleted_at IS NULL;
 			END
 		`).execute(this.db);
 		await sql.raw(`
@@ -135,6 +119,7 @@ var FTSManager = class {
 	* Drop triggers for a collection
 	*/
 	async dropTriggers(collectionSlug) {
+		this.validateInputs(collectionSlug);
 		const ftsTable = this.getFtsTableName(collectionSlug);
 		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(this.db);
 		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(this.db);
@@ -211,16 +196,16 @@ var FTSManager = class {
 		return (await this.db.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collection.id).where("searchable", "=", 1).execute()).map((f) => f.slug);
 	}
 	/**
-	* Enable search for a collection
+	* Enable search for a collection.
 	*
-	* Creates the FTS table and triggers, and populates from existing content.
+	* Rebuilds from scratch to ensure stale tables or triggers do not survive
+	* repeated enablement.
 	*/
 	async enableSearch(collectionSlug, options) {
 		if (!isSqlite(this.db)) throw new Error("Full-text search is only available with SQLite databases");
 		const searchableFields = await this.getSearchableFields(collectionSlug);
 		if (searchableFields.length === 0) throw new Error(`No searchable fields defined for collection "${collectionSlug}". Mark at least one field as searchable before enabling search.`);
-		await this.createFtsTable(collectionSlug, searchableFields, options?.weights);
-		await this.populateFromContent(collectionSlug, searchableFields);
+		await this.rebuildIndex(collectionSlug, searchableFields, options?.weights);
 		await this.setSearchConfig(collectionSlug, {
 			enabled: true,
 			weights: options?.weights
@@ -233,8 +218,12 @@ var FTSManager = class {
 	*/
 	async disableSearch(collectionSlug) {
 		if (!isSqlite(this.db)) return;
+		const existing = await this.getSearchConfig(collectionSlug);
 		await this.dropFtsTable(collectionSlug);
-		await this.setSearchConfig(collectionSlug, { enabled: false });
+		await this.setSearchConfig(collectionSlug, {
+			enabled: false,
+			weights: existing?.weights
+		});
 	}
 	/**
 	* Get index statistics for a collection
@@ -242,10 +231,10 @@ var FTSManager = class {
 	async getIndexStats(collectionSlug) {
 		if (!isSqlite(this.db)) return null;
 		this.validateInputs(collectionSlug);
-		const ftsTable = this.getFtsTableName(collectionSlug);
+		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
 		if (!await this.ftsTableExists(collectionSlug)) return null;
 		return { indexed: (await sql`
-			SELECT COUNT(*) as count FROM "${sql.raw(ftsTable)}"
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
 		`.execute(this.db)).rows[0]?.count ?? 0 };
 	}
 	/**
@@ -258,22 +247,27 @@ var FTSManager = class {
 	async verifyAndRepairIndex(collectionSlug) {
 		if (!isSqlite(this.db)) return false;
 		this.validateInputs(collectionSlug);
-		const ftsTable = this.getFtsTableName(collectionSlug);
+		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
 		const contentTable = this.getContentTableName(collectionSlug);
-		if (!await this.ftsTableExists(collectionSlug)) return false;
+		const fields = await this.getSearchableFields(collectionSlug);
+		const config = await this.getSearchConfig(collectionSlug);
+		if (!await this.ftsTableExists(collectionSlug)) {
+			if (!config?.enabled || fields.length === 0) return false;
+			console.warn(`FTS index for "${collectionSlug}" is missing. Rebuilding.`);
+			await this.rebuildIndex(collectionSlug, fields, config.weights);
+			return true;
+		}
 		const contentCount = await sql`
 			SELECT COUNT(*) as count FROM ${sql.ref(contentTable)}
 			WHERE deleted_at IS NULL
 		`.execute(this.db);
 		const ftsCount = await sql`
-			SELECT COUNT(*) as count FROM "${sql.raw(ftsTable)}"
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
 		`.execute(this.db);
 		const contentRows = contentCount.rows[0]?.count ?? 0;
 		const ftsRows = ftsCount.rows[0]?.count ?? 0;
 		if (contentRows !== ftsRows) {
 			console.warn(`FTS index for "${collectionSlug}" has ${ftsRows} rows but content table has ${contentRows}. Rebuilding.`);
-			const fields = await this.getSearchableFields(collectionSlug);
-			const config = await this.getSearchConfig(collectionSlug);
 			if (fields.length > 0) await this.rebuildIndex(collectionSlug, fields, config?.weights);
 			return true;
 		}
@@ -334,6 +328,16 @@ function isFieldType(value) {
 function isColumnType(value) {
 	return COLUMN_TYPES.has(value);
 }
+function parseSupports(value) {
+	if (!value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.filter((item) => typeof item === "string");
+	} catch {
+		return [];
+	}
+}
 /**
 * Error thrown when a schema operation fails
 */
@@ -387,6 +391,9 @@ var SchemaRegistry = class {
 		this.validateSlug(input.slug, "collection");
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		if (await this.getCollection(input.slug)) throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		await this.validateUrlPattern(input.urlPattern);
+		await this.checkLabelUniqueness(input.label, input.labelSingular);
+		await this.checkUrlPatternUniqueness(input.urlPattern);
 		const id = ulid();
 		const hasSeo = input.hasSeo ?? input.supports?.includes("seo") ?? false;
 		await withTransaction(this.db, async (trx) => {
@@ -415,26 +422,67 @@ var SchemaRegistry = class {
 	async updateCollection(slug, input) {
 		const existing = await this.getCollection(slug);
 		if (!existing) throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
+		const labelChanged = input.label !== void 0 && input.label !== existing.label;
+		const labelSingularChanged = input.labelSingular !== void 0 && input.labelSingular !== (existing.labelSingular ?? void 0);
+		if (labelChanged || labelSingularChanged) await this.checkLabelUniqueness(labelChanged ? input.label : void 0, labelSingularChanged ? input.labelSingular : void 0, slug);
+		if (input.urlPattern !== void 0 && input.urlPattern !== (existing.urlPattern ?? null)) {
+			await this.validateUrlPattern(input.urlPattern);
+			await this.checkUrlPatternUniqueness(input.urlPattern, slug);
+		}
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const supportsArray = input.supports ?? existing.supports;
 		const hasSeo = input.hasSeo !== void 0 ? input.hasSeo : input.supports !== void 0 ? supportsArray.includes("seo") : existing.hasSeo;
-		await this.db.updateTable("_dineway_collections").set({
-			label: input.label ?? existing.label,
-			label_singular: input.labelSingular ?? existing.labelSingular ?? null,
-			description: input.description ?? existing.description ?? null,
-			icon: input.icon ?? existing.icon ?? null,
-			supports: input.supports ? JSON.stringify(input.supports) : JSON.stringify(existing.supports),
-			url_pattern: input.urlPattern !== void 0 ? input.urlPattern ?? null : existing.urlPattern ?? null,
-			has_seo: hasSeo ? 1 : 0,
-			comments_enabled: input.commentsEnabled !== void 0 ? input.commentsEnabled ? 1 : 0 : existing.commentsEnabled ? 1 : 0,
-			comments_moderation: input.commentsModeration ?? existing.commentsModeration,
-			comments_closed_after_days: input.commentsClosedAfterDays !== void 0 ? input.commentsClosedAfterDays : existing.commentsClosedAfterDays,
-			comments_auto_approve_users: input.commentsAutoApproveUsers !== void 0 ? input.commentsAutoApproveUsers ? 1 : 0 : existing.commentsAutoApproveUsers ? 1 : 0,
-			updated_at: now
-		}).where("slug", "=", slug).execute();
-		const updated = await this.getCollection(slug);
-		if (!updated) throw new SchemaError("Failed to update collection", "UPDATE_FAILED");
-		return updated;
+		return withTransaction(this.db, async (trx) => {
+			await trx.updateTable("_dineway_collections").set({
+				label: input.label ?? existing.label,
+				label_singular: input.labelSingular ?? existing.labelSingular ?? null,
+				description: input.description ?? existing.description ?? null,
+				icon: input.icon ?? existing.icon ?? null,
+				supports: input.supports ? JSON.stringify(input.supports) : JSON.stringify(existing.supports),
+				url_pattern: input.urlPattern !== void 0 ? input.urlPattern ?? null : existing.urlPattern ?? null,
+				has_seo: hasSeo ? 1 : 0,
+				comments_enabled: input.commentsEnabled !== void 0 ? input.commentsEnabled ? 1 : 0 : existing.commentsEnabled ? 1 : 0,
+				comments_moderation: input.commentsModeration ?? existing.commentsModeration,
+				comments_closed_after_days: input.commentsClosedAfterDays !== void 0 ? input.commentsClosedAfterDays : existing.commentsClosedAfterDays,
+				comments_auto_approve_users: input.commentsAutoApproveUsers !== void 0 ? input.commentsAutoApproveUsers ? 1 : 0 : existing.commentsAutoApproveUsers ? 1 : 0,
+				updated_at: now
+			}).where("slug", "=", slug).execute();
+			const row = await trx.selectFrom("_dineway_collections").where("slug", "=", slug).selectAll().executeTakeFirst();
+			if (!row) throw new SchemaError("Failed to update collection", "UPDATE_FAILED");
+			if (input.supports !== void 0) {
+				if (existing.supports.includes("search") !== parseSupports(row.supports).includes("search")) await this.syncSearchState(slug, trx);
+			}
+			return this.mapCollectionRow(row);
+		});
+	}
+	async validateUrlPattern(urlPattern) {
+		if (!urlPattern) return;
+		if (!urlPattern.includes("{slug}")) throw new SchemaError("URL pattern must include a {slug} placeholder", "INVALID_URL_PATTERN");
+	}
+	async checkLabelUniqueness(label, labelSingular, excludeSlug) {
+		if (!label && !labelSingular) return;
+		let query = this.db.selectFrom("_dineway_collections").select([
+			"slug",
+			"label",
+			"label_singular"
+		]);
+		if (excludeSlug) query = query.where("slug", "!=", excludeSlug);
+		const others = await query.execute();
+		for (const other of others) {
+			if (label && other.label === label) throw new SchemaError(`A content type with the label "${label}" already exists`, "LABEL_EXISTS");
+			if (labelSingular && other.label_singular === labelSingular) throw new SchemaError(`A content type with the singular label "${labelSingular}" already exists`, "LABEL_EXISTS");
+		}
+	}
+	async checkUrlPatternUniqueness(urlPattern, excludeSlug) {
+		if (!urlPattern) return;
+		let query = this.db.selectFrom("_dineway_collections").select([
+			"slug",
+			"label",
+			"url_pattern"
+		]);
+		if (excludeSlug) query = query.where("slug", "!=", excludeSlug);
+		const others = await query.execute();
+		for (const other of others) if (other.url_pattern === urlPattern) throw new SchemaError(`The URL pattern "${urlPattern}" is already used by "${other.label}"`, "URL_PATTERN_EXISTS");
 	}
 	/**
 	* Delete a collection
@@ -445,8 +493,11 @@ var SchemaRegistry = class {
 		if (!options?.force) {
 			if (await this.collectionHasContent(slug)) throw new SchemaError(`Collection "${slug}" has content. Use force: true to delete.`, "COLLECTION_HAS_CONTENT");
 		}
-		await this.dropContentTable(slug);
-		await this.db.deleteFrom("_dineway_collections").where("id", "=", existing.id).execute();
+		await withTransaction(this.db, async (trx) => {
+			await new FTSManager(trx).dropFtsTable(slug);
+			await this.dropContentTable(slug, trx);
+			await trx.deleteFrom("_dineway_collections").where("id", "=", existing.id).execute();
+		});
 	}
 	/**
 	* List fields for a collection
@@ -476,30 +527,34 @@ var SchemaRegistry = class {
 		const columnType = FIELD_TYPE_TO_COLUMN[input.type];
 		const maxSort = await this.db.selectFrom("_dineway_fields").where("collection_id", "=", collection.id).select((eb) => eb.fn.max("sort_order").as("max")).executeTakeFirst();
 		const sortOrder = input.sortOrder ?? (maxSort?.max ?? -1) + 1;
-		await this.db.insertInto("_dineway_fields").values({
-			id,
-			collection_id: collection.id,
-			slug: input.slug,
-			label: input.label,
-			type: input.type,
-			column_type: columnType,
-			required: input.required ? 1 : 0,
-			unique: input.unique ? 1 : 0,
-			default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : null,
-			validation: input.validation ? JSON.stringify(input.validation) : null,
-			widget: input.widget ?? null,
-			options: input.options ? JSON.stringify(input.options) : null,
-			sort_order: sortOrder,
-			searchable: input.searchable ? 1 : 0,
-			translatable: input.translatable === false ? 0 : 1
-		}).execute();
-		await this.addColumn(collectionSlug, input.slug, input.type, {
-			required: input.required,
-			defaultValue: input.defaultValue
+		return withTransaction(this.db, async (trx) => {
+			await trx.insertInto("_dineway_fields").values({
+				id,
+				collection_id: collection.id,
+				slug: input.slug,
+				label: input.label,
+				type: input.type,
+				column_type: columnType,
+				required: input.required ? 1 : 0,
+				unique: input.unique ? 1 : 0,
+				default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : null,
+				validation: input.validation ? JSON.stringify(input.validation) : null,
+				widget: input.widget ?? null,
+				options: input.options ? JSON.stringify(input.options) : null,
+				sort_order: sortOrder,
+				searchable: input.searchable ? 1 : 0,
+				translatable: input.translatable === false ? 0 : 1
+			}).execute();
+			await this.addColumn(collectionSlug, input.slug, input.type, {
+				required: input.required,
+				defaultValue: input.defaultValue
+			}, trx);
+			const fieldRow = await trx.selectFrom("_dineway_fields").where("collection_id", "=", collection.id).where("slug", "=", input.slug).selectAll().executeTakeFirst();
+			if (!fieldRow) throw new SchemaError("Failed to create field", "CREATE_FAILED");
+			const field = this.mapFieldRow(fieldRow);
+			if (input.searchable) await this.syncSearchState(collectionSlug, trx);
+			return field;
 		});
-		const field = await this.getField(collectionSlug, input.slug);
-		if (!field) throw new SchemaError("Failed to create field", "CREATE_FAILED");
-		return field;
 	}
 	/**
 	* Update a field
@@ -507,36 +562,43 @@ var SchemaRegistry = class {
 	async updateField(collectionSlug, fieldSlug, input) {
 		const field = await this.getField(collectionSlug, fieldSlug);
 		if (!field) throw new SchemaError(`Field "${fieldSlug}" not found in collection "${collectionSlug}"`, "FIELD_NOT_FOUND");
-		await this.db.updateTable("_dineway_fields").set({
-			label: input.label ?? field.label,
-			required: input.required !== void 0 ? input.required ? 1 : 0 : field.required ? 1 : 0,
-			unique: input.unique !== void 0 ? input.unique ? 1 : 0 : field.unique ? 1 : 0,
-			searchable: input.searchable !== void 0 ? input.searchable ? 1 : 0 : field.searchable ? 1 : 0,
-			translatable: input.translatable !== void 0 ? input.translatable ? 1 : 0 : field.translatable ? 1 : 0,
-			default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : field.defaultValue !== void 0 ? JSON.stringify(field.defaultValue) : null,
-			validation: input.validation ? JSON.stringify(input.validation) : field.validation ? JSON.stringify(field.validation) : null,
-			widget: input.widget ?? field.widget ?? null,
-			options: input.options ? JSON.stringify(input.options) : field.options ? JSON.stringify(field.options) : null,
-			sort_order: input.sortOrder ?? field.sortOrder
-		}).where("id", "=", field.id).execute();
-		const updated = await this.getField(collectionSlug, fieldSlug);
-		if (!updated) throw new SchemaError("Failed to update field", "UPDATE_FAILED");
-		if (input.searchable !== void 0 && input.searchable !== field.searchable) await this.rebuildSearchIndex(collectionSlug);
-		return updated;
-	}
-	/**
-	* Rebuild the search index for a collection
+		return withTransaction(this.db, async (trx) => {
+			await trx.updateTable("_dineway_fields").set({
+				label: input.label ?? field.label,
+				required: input.required !== void 0 ? input.required ? 1 : 0 : field.required ? 1 : 0,
+				unique: input.unique !== void 0 ? input.unique ? 1 : 0 : field.unique ? 1 : 0,
+				searchable: input.searchable !== void 0 ? input.searchable ? 1 : 0 : field.searchable ? 1 : 0,
+				translatable: input.translatable !== void 0 ? input.translatable ? 1 : 0 : field.translatable ? 1 : 0,
+				default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : field.defaultValue !== void 0 ? JSON.stringify(field.defaultValue) : null,
+				validation: input.validation ? JSON.stringify(input.validation) : field.validation ? JSON.stringify(field.validation) : null,
+				widget: input.widget ?? field.widget ?? null,
+				options: input.options ? JSON.stringify(input.options) : field.options ? JSON.stringify(field.options) : null,
+				sort_order: input.sortOrder ?? field.sortOrder
+			}).where("id", "=", field.id).execute();
+			const updatedRow = await trx.selectFrom("_dineway_fields").where("collection_id", "=", field.collectionId).where("slug", "=", fieldSlug).selectAll().executeTakeFirst();
+			if (!updatedRow) throw new SchemaError("Failed to update field", "UPDATE_FAILED");
+			const updated = this.mapFieldRow(updatedRow);
+			if (input.searchable !== void 0 && input.searchable !== field.searchable) await this.syncSearchState(collectionSlug, trx);
+			return updated;
+		});
+	}
+	/**
+	* Synchronize an existing FTS index with the collection's current state.
 	*
-	* Called when searchable fields change. If search is enabled for the collection,
-	* this will rebuild the FTS table with the updated field list.
+	* Schema writes must not first-time enable FTS. Initial enablement stays in
+	* explicit seed/import/admin flows where FTS failures can be handled deliberately.
 	*/
-	async rebuildSearchIndex(collectionSlug) {
-		const ftsManager = new FTSManager(this.db);
-		const config = await ftsManager.getSearchConfig(collectionSlug);
-		if (!config?.enabled) return;
+	async syncSearchState(collectionSlug, db) {
+		const conn = db ?? this.db;
+		const ftsManager = new FTSManager(conn);
+		const row = await conn.selectFrom("_dineway_collections").where("slug", "=", collectionSlug).select("supports").executeTakeFirst();
+		if (!row) return;
+		const wantsSearch = parseSupports(row.supports).includes("search");
 		const searchableFields = await ftsManager.getSearchableFields(collectionSlug);
-		if (searchableFields.length === 0) await ftsManager.disableSearch(collectionSlug);
-		else await ftsManager.rebuildIndex(collectionSlug, searchableFields, config.weights);
+		const config = await ftsManager.getSearchConfig(collectionSlug);
+		const ftsActive = config?.enabled === true;
+		if (wantsSearch && searchableFields.length > 0 && ftsActive) await ftsManager.rebuildIndex(collectionSlug, searchableFields, config?.weights);
+		else if (ftsActive && (!wantsSearch || searchableFields.length === 0)) await ftsManager.disableSearch(collectionSlug);
 	}
 	/**
 	* Delete a field
@@ -544,8 +606,11 @@ var SchemaRegistry = class {
 	async deleteField(collectionSlug, fieldSlug) {
 		const field = await this.getField(collectionSlug, fieldSlug);
 		if (!field) throw new SchemaError(`Field "${fieldSlug}" not found in collection "${collectionSlug}"`, "FIELD_NOT_FOUND");
-		await this.dropColumn(collectionSlug, fieldSlug);
-		await this.db.deleteFrom("_dineway_fields").where("id", "=", field.id).execute();
+		await withTransaction(this.db, async (trx) => {
+			await trx.deleteFrom("_dineway_fields").where("id", "=", field.id).execute();
+			if (field.searchable) await this.syncSearchState(collectionSlug, trx);
+			await this.dropColumn(collectionSlug, fieldSlug, trx);
+		});
 	}
 	/**
 	* Reorder fields
@@ -615,14 +680,15 @@ var SchemaRegistry = class {
 	/**
 	* Drop a content table
 	*/
-	async dropContentTable(slug) {
+	async dropContentTable(slug, db) {
 		const tableName = this.getTableName(slug);
-		await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(this.db);
+		await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(db ?? this.db);
 	}
 	/**
 	* Add a column to a content table
 	*/
-	async addColumn(collectionSlug, fieldSlug, fieldType, options) {
+	async addColumn(collectionSlug, fieldSlug, fieldType, options, db) {
+		const conn = db ?? this.db;
 		const tableName = this.getTableName(collectionSlug);
 		const columnType = FIELD_TYPE_TO_COLUMN[fieldType];
 		const columnName = this.getColumnName(fieldSlug);
@@ -631,28 +697,28 @@ var SchemaRegistry = class {
 			await sql`
 				ALTER TABLE ${sql.ref(tableName)} 
 				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)} NOT NULL DEFAULT ${sql.raw(defaultVal)}
-			`.execute(this.db);
+			`.execute(conn);
 		} else if (options?.required) {
 			const defaultVal = this.getEmptyDefault(fieldType);
 			await sql`
 				ALTER TABLE ${sql.ref(tableName)} 
 				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)} NOT NULL DEFAULT ${sql.raw(defaultVal)}
-			`.execute(this.db);
+			`.execute(conn);
 		} else await sql`
 				ALTER TABLE ${sql.ref(tableName)} 
 				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)}
-			`.execute(this.db);
+			`.execute(conn);
 	}
 	/**
 	* Drop a column from a content table
 	*/
-	async dropColumn(collectionSlug, fieldSlug) {
+	async dropColumn(collectionSlug, fieldSlug, db) {
 		const tableName = this.getTableName(collectionSlug);
 		const columnName = this.getColumnName(fieldSlug);
 		await sql`
 			ALTER TABLE ${sql.ref(tableName)} 
 			DROP COLUMN ${sql.ref(columnName)}
-		`.execute(this.db);
+		`.execute(db ?? this.db);
 	}
 	/**
 	* Check if a collection has any content
@@ -672,12 +738,14 @@ var SchemaRegistry = class {
 	* Get table name for a collection
 	*/
 	getTableName(slug) {
+		validateIdentifier(slug, "collection slug");
 		return `ec_${slug}`;
 	}
 	/**
 	* Get column name for a field
 	*/
 	getColumnName(slug) {
+		validateIdentifier(slug, "field slug");
 		return slug;
 	}
 	/**
@@ -848,4 +916,4 @@ var SchemaRegistry = class {
 };
 
 //#endregion
-export { withTransaction as a, FTSManager as i, SchemaRegistry as n, registry_exports as r, SchemaError as t };
+export { FTSManager as i, SchemaRegistry as n, registry_exports as r, SchemaError as t };

package/dist/request-cache-Dk5qPSOx.mjs

@@ -0,0 +1,66 @@
+import { getRequestContext } from "./request-context.mjs";
+
+//#region src/request-cache.ts
+const STORE_KEY = Symbol.for("dineway:request-cache");
+function getStore() {
+	const existing = Reflect.get(globalThis, STORE_KEY);
+	if (existing instanceof WeakMap) return existing;
+	const weakMap = /* @__PURE__ */ new WeakMap();
+	Reflect.set(globalThis, STORE_KEY, weakMap);
+	return weakMap;
+}
+function asTypedPromise(promise) {
+	return promise;
+}
+const store = getStore();
+/**
+* Return a cached promise for `key` in the current request scope.
+*
+* Rejected promises are evicted so later retries can re-run the query.
+*/
+function requestCached(key, fn) {
+	const ctx = getRequestContext();
+	if (!ctx) return fn();
+	let cache = store.get(ctx);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		store.set(ctx, cache);
+	}
+	const existing = cache.get(key);
+	if (existing) return asTypedPromise(existing);
+	const promise = Promise.resolve().then(fn).catch((error) => {
+		cache.delete(key);
+		throw error;
+	});
+	cache.set(key, promise);
+	return promise;
+}
+/**
+* Peek at a cached promise without inserting a new one.
+*/
+function peekRequestCache(key) {
+	const ctx = getRequestContext();
+	if (!ctx) return void 0;
+	const existing = store.get(ctx)?.get(key);
+	return existing ? asTypedPromise(existing) : void 0;
+}
+/**
+* Pre-populate the request cache with a resolved value.
+*
+* Used by hydration paths that already loaded the data in bulk and want
+* narrower downstream helper calls to short-circuit without re-querying.
+*/
+function setRequestCacheEntry(key, value) {
+	const ctx = getRequestContext();
+	if (!ctx) return;
+	let cache = store.get(ctx);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		store.set(ctx, cache);
+	}
+	if (cache.has(key)) return;
+	cache.set(key, Promise.resolve(value));
+}
+
+//#endregion
+export { requestCached as n, setRequestCacheEntry as r, peekRequestCache as t };

package/dist/request-context.d.mts

@@ -1,20 +1,6 @@
+import { QueryRecorder } from "./database/instrumentation.mjs";
+
 //#region src/request-context.d.ts
-/**
- * Dineway Request Context
- *
- * Uses AsyncLocalStorage to provide request-scoped state to query functions
- * without requiring explicit parameter passing. The middleware wraps next()
- * in als.run(), making the context available to all code during rendering.
- *
- * For logged-out users with no CMS signals (no edit cookie, no preview param),
- * the middleware skips ALS entirely — zero overhead for normal traffic.
- *
- * The AsyncLocalStorage instance is stored on globalThis with a Symbol key
- * to guarantee a singleton even when bundlers duplicate this module across
- * code-split chunks. Without this, Rollup/Vite may inline the module into
- * multiple chunks (e.g. middleware and page components), each with its own
- * ALS instance — breaking request-scoped state propagation.
- */
 interface DinewayRequestContext {
   /** Whether the current request is in visual editing mode */
   editMode: boolean;
@@ -34,6 +20,8 @@ interface DinewayRequestContext {
    * playground sidecar flows.
    */
   db?: unknown;
+  /** Optional query recorder for per-request instrumentation. */
+  queryRecorder?: QueryRecorder;
 }
 /**
  * Run a function within a Dineway request context.

package/dist/{runner-B5l1JfOj.d.mts → runner-CFI6B6J2.d.mts}

@@ -1,4 +1,4 @@
-import { t as Database } from "./types-DkvMXalq.mjs";
+import { t as Database } from "./types-DOrVigru.mjs";
 import { Kysely } from "kysely";
 
 //#region src/database/migrations/runner.d.ts