dineway 0.1.3

package/dist/content-zSgdNmnt.mjs

@@ -0,0 +1,836 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { n as decodeCursor, r as encodeCursor, t as DinewayValidationError } from "./types-BawVha09.mjs";
+import { sql } from "kysely";
+import { monotonicFactory, ulid } from "ulidx";
+
+//#region src/utils/slugify.ts
+const DIACRITICS_PATTERN = /[\u0300-\u036f]/g;
+const WHITESPACE_UNDERSCORE_PATTERN = /[\s_]+/g;
+const NON_ALPHANUMERIC_HYPHEN_PATTERN = /[^a-z0-9-]/g;
+const MULTIPLE_HYPHENS_PATTERN = /-+/g;
+const LEADING_TRAILING_HYPHEN_PATTERN = /^-|-$/g;
+const TRAILING_HYPHEN_PATTERN = /-$/;
+/**
+* Convert a string to a URL-friendly slug.
+*
+* Handles unicode by normalizing to NFD and stripping diacritics,
+* so "café" becomes "cafe", "naïve" becomes "naive", etc.
+*/
+function slugify(text, maxLength = 80) {
+	return text.toLowerCase().normalize("NFD").replace(DIACRITICS_PATTERN, "").replace(WHITESPACE_UNDERSCORE_PATTERN, "-").replace(NON_ALPHANUMERIC_HYPHEN_PATTERN, "").replace(MULTIPLE_HYPHENS_PATTERN, "-").replace(LEADING_TRAILING_HYPHEN_PATTERN, "").slice(0, maxLength).replace(TRAILING_HYPHEN_PATTERN, "");
+}
+
+//#endregion
+//#region src/database/repositories/revision.ts
+const monotonic = monotonicFactory();
+/**
+* Revision repository for version history
+*
+* Each revision stores a JSON snapshot of the content at a point in time.
+* Used when collection has `supports: ["revisions"]` enabled.
+*/
+var RevisionRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Create a new revision
+	*/
+	async create(input) {
+		const id = monotonic();
+		const row = {
+			id,
+			collection: input.collection,
+			entry_id: input.entryId,
+			data: JSON.stringify(input.data),
+			author_id: input.authorId ?? null
+		};
+		await this.db.insertInto("revisions").values(row).execute();
+		const revision = await this.findById(id);
+		if (!revision) throw new Error("Failed to create revision");
+		return revision;
+	}
+	/**
+	* Find revision by ID
+	*/
+	async findById(id) {
+		const row = await this.db.selectFrom("revisions").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? this.rowToRevision(row) : null;
+	}
+	/**
+	* Get all revisions for an entry (newest first)
+	*
+	* Orders by monotonic ULID (descending). The monotonic factory
+	* guarantees strictly increasing IDs even within the same millisecond.
+	*/
+	async findByEntry(collection, entryId, options = {}) {
+		let query = this.db.selectFrom("revisions").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("id", "desc");
+		if (options.limit) query = query.limit(options.limit);
+		return (await query.execute()).map((row) => this.rowToRevision(row));
+	}
+	/**
+	* Get the most recent revision for an entry
+	*/
+	async findLatest(collection, entryId) {
+		const row = await this.db.selectFrom("revisions").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("id", "desc").limit(1).executeTakeFirst();
+		return row ? this.rowToRevision(row) : null;
+	}
+	/**
+	* Count revisions for an entry
+	*/
+	async countByEntry(collection, entryId) {
+		const result = await this.db.selectFrom("revisions").select((eb) => eb.fn.count("id").as("count")).where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
+		return Number(result?.count || 0);
+	}
+	/**
+	* Delete all revisions for an entry (use when entry is deleted)
+	*/
+	async deleteByEntry(collection, entryId) {
+		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	/**
+	* Delete old revisions, keeping the most recent N
+	*/
+	async pruneOldRevisions(collection, entryId, keepCount) {
+		const keepIds = (await this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount).execute()).map((r) => r.id);
+		if (keepIds.length === 0) return 0;
+		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).where("id", "not in", keepIds).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+	/**
+	* Update revision data in place
+	* Used for autosave to avoid creating many small revisions.
+	*/
+	async updateData(id, data) {
+		await this.db.updateTable("revisions").set({ data: JSON.stringify(data) }).where("id", "=", id).execute();
+	}
+	/**
+	* Convert database row to Revision object
+	*/
+	rowToRevision(row) {
+		return {
+			id: row.id,
+			collection: row.collection,
+			entryId: row.entry_id,
+			data: JSON.parse(row.data),
+			authorId: row.author_id,
+			createdAt: row.created_at
+		};
+	}
+};
+
+//#endregion
+//#region src/database/repositories/content.ts
+var content_exports = /* @__PURE__ */ __exportAll({ ContentRepository: () => ContentRepository });
+const ULID_PATTERN = /^[0-9A-Z]{26}$/;
+/**
+* System columns that exist in every ec_* table
+*/
+const SYSTEM_COLUMNS = new Set([
+	"id",
+	"slug",
+	"status",
+	"author_id",
+	"primary_byline_id",
+	"created_at",
+	"updated_at",
+	"published_at",
+	"scheduled_at",
+	"deleted_at",
+	"version",
+	"live_revision_id",
+	"draft_revision_id",
+	"locale",
+	"translation_group"
+]);
+/**
+* Get the table name for a collection type
+*/
+function getTableName(type) {
+	return `ec_${type}`;
+}
+/**
+* Serialize a value for database storage
+* Objects/arrays are JSON-stringified
+* Booleans are converted to 0/1 for SQLite
+*/
+function serializeValue(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "object") return JSON.stringify(value);
+	return value;
+}
+/**
+* Deserialize a value from database storage
+* Attempts to parse JSON strings that look like objects/arrays
+*/
+function deserializeValue(value) {
+	if (typeof value === "string") {
+		if (value.startsWith("{") || value.startsWith("[")) try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+	}
+	return value;
+}
+/** Pattern for escaping special regex characters */
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+/**
+* Escape special regex characters in a string for use in `new RegExp()`
+*/
+function escapeRegExp(s) {
+	return s.replace(REGEX_ESCAPE_PATTERN, "\\$&");
+}
+/**
+* Repository for content CRUD operations
+*
+* Content is stored in per-collection tables (ec_posts, ec_pages, etc.)
+* Each field becomes a real column in the table.
+*/
+var ContentRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Create a new content item
+	*/
+	async create(input) {
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const { type, slug, data, status = "draft", authorId, primaryBylineId, locale, translationOf, publishedAt, createdAt } = input;
+		if (!type) throw new DinewayValidationError("Content type is required");
+		const tableName = getTableName(type);
+		let translationGroup = id;
+		if (translationOf) {
+			const source = await this.findById(type, translationOf);
+			if (!source) throw new DinewayValidationError("Translation source content not found");
+			translationGroup = source.translationGroup || source.id;
+		}
+		const columns = [
+			"id",
+			"slug",
+			"status",
+			"author_id",
+			"primary_byline_id",
+			"created_at",
+			"updated_at",
+			"published_at",
+			"version",
+			"locale",
+			"translation_group"
+		];
+		const values = [
+			id,
+			slug || null,
+			status,
+			authorId || null,
+			primaryBylineId ?? null,
+			createdAt || now,
+			now,
+			publishedAt || null,
+			1,
+			locale || "en",
+			translationGroup
+		];
+		if (data && typeof data === "object") {
+			for (const [key, value] of Object.entries(data)) if (!SYSTEM_COLUMNS.has(key)) {
+				columns.push(key);
+				values.push(serializeValue(value));
+			}
+		}
+		const columnRefs = columns.map((c) => sql.ref(c));
+		const valuePlaceholders = values.map((v) => v === null ? sql`NULL` : sql`${v}`);
+		await sql`
+			INSERT INTO ${sql.ref(tableName)} (${sql.join(columnRefs, sql`, `)})
+			VALUES (${sql.join(valuePlaceholders, sql`, `)})
+		`.execute(this.db);
+		const item = await this.findById(type, id);
+		if (!item) throw new Error("Failed to create content");
+		return item;
+	}
+	/**
+	* Generate a unique slug for a content item within a collection.
+	*
+	* Checks the collection table for existing slugs that match `baseSlug`
+	* (optionally scoped to a locale) and appends a numeric suffix (`-1`,
+	* `-2`, etc.) on collision to guarantee uniqueness.
+	*
+	* Returns `null` if `baseSlug` is empty after slugification.
+	*/
+	async generateUniqueSlug(type, text, locale) {
+		const baseSlug = slugify(text);
+		if (!baseSlug) return null;
+		const tableName = getTableName(type);
+		if ((locale ? await sql`
+					SELECT slug FROM ${sql.ref(tableName)}
+					WHERE slug = ${baseSlug}
+					AND locale = ${locale}
+					LIMIT 1
+				`.execute(this.db) : await sql`
+					SELECT slug FROM ${sql.ref(tableName)}
+					WHERE slug = ${baseSlug}
+					LIMIT 1
+				`.execute(this.db)).rows.length === 0) return baseSlug;
+		const pattern = `${baseSlug}-%`;
+		const candidates = locale ? await sql`
+					SELECT slug FROM ${sql.ref(tableName)}
+					WHERE (slug = ${baseSlug} OR slug LIKE ${pattern})
+					AND locale = ${locale}
+				`.execute(this.db) : await sql`
+					SELECT slug FROM ${sql.ref(tableName)}
+					WHERE slug = ${baseSlug} OR slug LIKE ${pattern}
+				`.execute(this.db);
+		let maxSuffix = 0;
+		const suffixPattern = new RegExp(`^${escapeRegExp(baseSlug)}-(\\d+)$`);
+		for (const row of candidates.rows) {
+			const match = suffixPattern.exec(row.slug);
+			if (match) {
+				const n = parseInt(match[1], 10);
+				if (n > maxSuffix) maxSuffix = n;
+			}
+		}
+		return `${baseSlug}-${maxSuffix + 1}`;
+	}
+	/**
+	* Duplicate a content item
+	* Creates a new draft copy with "(Copy)" appended to the title.
+	* A slug is auto-generated from the new title by the handler layer.
+	*/
+	async duplicate(type, id, authorId) {
+		const original = await this.findById(type, id);
+		if (!original) throw new DinewayValidationError("Content item not found");
+		const newData = { ...original.data };
+		if (typeof newData.title === "string") newData.title = `${newData.title} (Copy)`;
+		else if (typeof newData.name === "string") newData.name = `${newData.name} (Copy)`;
+		const slugSource = typeof newData.title === "string" ? newData.title : typeof newData.name === "string" ? newData.name : null;
+		const slug = slugSource ? await this.generateUniqueSlug(type, slugSource, original.locale ?? void 0) : null;
+		return this.create({
+			type,
+			slug,
+			data: newData,
+			status: "draft",
+			authorId: authorId || original.authorId || void 0
+		});
+	}
+	/**
+	* Find content by ID
+	*/
+	async findById(type, id) {
+		const tableName = getTableName(type);
+		const row = (await sql`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db)).rows[0];
+		if (!row) return null;
+		return this.mapRow(type, row);
+	}
+	/**
+	* Find content by id, including trashed (soft-deleted) items.
+	* Used by restore endpoint for ownership checks.
+	*/
+	async findByIdIncludingTrashed(type, id) {
+		const tableName = getTableName(type);
+		const row = (await sql`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE id = ${id}
+		`.execute(this.db)).rows[0];
+		if (!row) return null;
+		return this.mapRow(type, row);
+	}
+	/**
+	* Find content by ID or slug. Tries ID first if it looks like a ULID,
+	* otherwise tries slug. Falls back to the other if the first lookup misses.
+	*/
+	async findByIdOrSlug(type, identifier, locale) {
+		return this._findByIdOrSlug(type, identifier, false, locale);
+	}
+	/**
+	* Find content by ID or slug, including trashed (soft-deleted) items.
+	* Used by restore/permanent-delete endpoints.
+	*/
+	async findByIdOrSlugIncludingTrashed(type, identifier, locale) {
+		return this._findByIdOrSlug(type, identifier, true, locale);
+	}
+	async _findByIdOrSlug(type, identifier, includeTrashed, locale) {
+		const looksLikeUlid = ULID_PATTERN.test(identifier);
+		const findById = includeTrashed ? (t, id) => this.findByIdIncludingTrashed(t, id) : (t, id) => this.findById(t, id);
+		const findBySlug = includeTrashed ? (t, s) => this.findBySlugIncludingTrashed(t, s, locale) : (t, s) => this.findBySlug(t, s, locale);
+		if (looksLikeUlid) {
+			const byId = await findById(type, identifier);
+			if (byId) return byId;
+			return findBySlug(type, identifier);
+		}
+		const bySlug = await findBySlug(type, identifier);
+		if (bySlug) return bySlug;
+		return findById(type, identifier);
+	}
+	/**
+	* Find content by slug
+	*/
+	async findBySlug(type, slug, locale) {
+		const tableName = getTableName(type);
+		const row = (locale ? await sql`
+					SELECT * FROM ${sql.ref(tableName)}
+					WHERE slug = ${slug}
+					AND locale = ${locale}
+					AND deleted_at IS NULL
+				`.execute(this.db) : await sql`
+					SELECT * FROM ${sql.ref(tableName)}
+					WHERE slug = ${slug}
+					AND deleted_at IS NULL
+					ORDER BY locale ASC
+					LIMIT 1
+				`.execute(this.db)).rows[0];
+		if (!row) return null;
+		return this.mapRow(type, row);
+	}
+	/**
+	* Find content by slug, including trashed (soft-deleted) items.
+	* Used by restore/permanent-delete endpoints.
+	*/
+	async findBySlugIncludingTrashed(type, slug, locale) {
+		const tableName = getTableName(type);
+		const row = (locale ? await sql`
+					SELECT * FROM ${sql.ref(tableName)}
+					WHERE slug = ${slug}
+					AND locale = ${locale}
+				`.execute(this.db) : await sql`
+					SELECT * FROM ${sql.ref(tableName)}
+					WHERE slug = ${slug}
+					ORDER BY locale ASC
+					LIMIT 1
+				`.execute(this.db)).rows[0];
+		if (!row) return null;
+		return this.mapRow(type, row);
+	}
+	/**
+	* Find many content items with filtering and pagination
+	*/
+	async findMany(type, options = {}) {
+		const tableName = getTableName(type);
+		const limit = Math.min(options.limit || 50, 100);
+		const orderField = options.orderBy?.field || "createdAt";
+		const orderDirection = options.orderBy?.direction || "desc";
+		const dbField = this.mapOrderField(orderField);
+		const safeOrderDirection = orderDirection.toLowerCase() === "asc" ? "ASC" : "DESC";
+		let query = this.db.selectFrom(tableName).selectAll().where("deleted_at", "is", null);
+		if (options.where?.status) query = query.where("status", "=", options.where.status);
+		if (options.where?.authorId) query = query.where("author_id", "=", options.where.authorId);
+		if (options.where?.locale) query = query.where("locale", "=", options.where.locale);
+		if (options.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			if (decoded) {
+				const { orderValue, id: cursorId } = decoded;
+				if (safeOrderDirection === "DESC") query = query.where((eb) => eb.or([eb(dbField, "<", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", "<", cursorId)])]));
+				else query = query.where((eb) => eb.or([eb(dbField, ">", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", ">", cursorId)])]));
+			}
+		}
+		query = query.orderBy(dbField, safeOrderDirection === "ASC" ? "asc" : "desc").orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
+		const rows = await query.execute();
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit);
+		const mappedResult = { items: items.map((row) => this.mapRow(type, row)) };
+		if (hasMore && items.length > 0) {
+			const lastRow = items.at(-1);
+			const lastOrderValue = lastRow[dbField];
+			mappedResult.nextCursor = encodeCursor(typeof lastOrderValue === "string" || typeof lastOrderValue === "number" ? String(lastOrderValue) : "", String(lastRow.id));
+		}
+		return mappedResult;
+	}
+	/**
+	* Update content
+	*/
+	async update(type, id, input) {
+		const tableName = getTableName(type);
+		const updates = {
+			updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+			version: sql`version + 1`
+		};
+		if (input.status !== void 0) updates.status = input.status;
+		if (input.slug !== void 0) updates.slug = input.slug;
+		if (input.publishedAt !== void 0) updates.published_at = input.publishedAt;
+		if (input.scheduledAt !== void 0) updates.scheduled_at = input.scheduledAt;
+		if (input.authorId !== void 0) updates.author_id = input.authorId;
+		if (input.primaryBylineId !== void 0) updates.primary_byline_id = input.primaryBylineId;
+		if (input.data !== void 0 && typeof input.data === "object") {
+			for (const [key, value] of Object.entries(input.data)) if (!SYSTEM_COLUMNS.has(key)) updates[key] = serializeValue(value);
+		}
+		await this.db.updateTable(tableName).set(updates).where("id", "=", id).where("deleted_at", "is", null).execute();
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Delete content (soft delete - moves to trash)
+	*/
+	async delete(type, id) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return ((await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET deleted_at = ${now}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+	}
+	/**
+	* Restore content from trash
+	*/
+	async restore(type, id) {
+		const tableName = getTableName(type);
+		return ((await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET deleted_at = NULL
+			WHERE id = ${id}
+			AND deleted_at IS NOT NULL
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+	}
+	/**
+	* Permanently delete content (cannot be undone)
+	*/
+	async permanentDelete(type, id) {
+		const tableName = getTableName(type);
+		return ((await sql`
+			DELETE FROM ${sql.ref(tableName)}
+			WHERE id = ${id}
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+	}
+	/**
+	* Find trashed content items
+	*/
+	async findTrashed(type, options = {}) {
+		const tableName = getTableName(type);
+		const limit = Math.min(options.limit || 50, 100);
+		const orderField = options.orderBy?.field || "deletedAt";
+		const orderDirection = options.orderBy?.direction || "desc";
+		const dbField = this.mapOrderField(orderField);
+		const safeOrderDirection = orderDirection.toLowerCase() === "asc" ? "ASC" : "DESC";
+		let query = this.db.selectFrom(tableName).selectAll().where("deleted_at", "is not", null);
+		if (options.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			if (decoded) {
+				const { orderValue, id: cursorId } = decoded;
+				if (safeOrderDirection === "DESC") query = query.where((eb) => eb.or([eb(dbField, "<", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", "<", cursorId)])]));
+				else query = query.where((eb) => eb.or([eb(dbField, ">", orderValue), eb.and([eb(dbField, "=", orderValue), eb("id", ">", cursorId)])]));
+			}
+		}
+		query = query.orderBy(dbField, safeOrderDirection === "ASC" ? "asc" : "desc").orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
+		const rows = await query.execute();
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit);
+		const mappedResult = { items: items.map((row) => {
+			const record = row;
+			return {
+				...this.mapRow(type, record),
+				deletedAt: typeof record.deleted_at === "string" ? record.deleted_at : ""
+			};
+		}) };
+		if (hasMore && items.length > 0) {
+			const lastRow = items.at(-1);
+			const lastOrderValue = lastRow[dbField];
+			mappedResult.nextCursor = encodeCursor(typeof lastOrderValue === "string" || typeof lastOrderValue === "number" ? String(lastOrderValue) : "", String(lastRow.id));
+		}
+		return mappedResult;
+	}
+	/**
+	* Count trashed content items
+	*/
+	async countTrashed(type) {
+		const tableName = getTableName(type);
+		const result = await this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count")).where("deleted_at", "is not", null).executeTakeFirst();
+		return Number(result?.count || 0);
+	}
+	/**
+	* Count content items
+	*/
+	async count(type, where) {
+		const tableName = getTableName(type);
+		let query = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count")).where("deleted_at", "is", null);
+		if (where?.status) query = query.where("status", "=", where.status);
+		if (where?.authorId) query = query.where("author_id", "=", where.authorId);
+		if (where?.locale) query = query.where("locale", "=", where.locale);
+		const result = await query.executeTakeFirst();
+		return Number(result?.count || 0);
+	}
+	async getStats(type) {
+		const tableName = getTableName(type);
+		const result = await this.db.selectFrom(tableName).select((eb) => [
+			eb.fn.count("id").as("total"),
+			eb.fn.sum(eb.case().when("status", "=", "published").then(1).else(0).end()).as("published"),
+			eb.fn.sum(eb.case().when("status", "=", "draft").then(1).else(0).end()).as("draft")
+		]).where("deleted_at", "is", null).executeTakeFirst();
+		return {
+			total: Number(result?.total || 0),
+			published: Number(result?.published || 0),
+			draft: Number(result?.draft || 0)
+		};
+	}
+	/**
+	* Schedule content for future publishing
+	*
+	* Sets status to 'scheduled' and stores the scheduled publish time.
+	* The content will be auto-published when the scheduled time is reached.
+	*/
+	async schedule(type, id, scheduledAt) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const scheduledDate = new Date(scheduledAt);
+		if (isNaN(scheduledDate.getTime())) throw new DinewayValidationError("Invalid scheduled date");
+		if (scheduledDate <= /* @__PURE__ */ new Date()) throw new DinewayValidationError("Scheduled date must be in the future");
+		const existing = await this.findById(type, id);
+		if (!existing) throw new DinewayValidationError("Content item not found");
+		const newStatus = existing.status === "published" ? "published" : "scheduled";
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET status = ${newStatus},
+				scheduled_at = ${scheduledAt},
+				updated_at = ${now}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Unschedule content
+	*
+	* Clears the scheduled time. Published posts stay published;
+	* draft/scheduled posts revert to 'draft'.
+	*/
+	async unschedule(type, id) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const existing = await this.findById(type, id);
+		if (!existing) throw new DinewayValidationError("Content item not found");
+		const newStatus = existing.status === "published" ? "published" : "draft";
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET status = ${newStatus},
+				scheduled_at = NULL,
+				updated_at = ${now}
+			WHERE id = ${id}
+			AND scheduled_at IS NOT NULL
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Find content that is ready to be published
+	*
+	* Returns all content where scheduled_at <= now, regardless of status.
+	* This covers both draft-scheduled posts (status='scheduled') and
+	* published posts with scheduled draft changes (status='published').
+	*/
+	async findReadyToPublish(type) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return (await sql`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE scheduled_at IS NOT NULL
+			AND scheduled_at <= ${now}
+			AND deleted_at IS NULL
+			ORDER BY scheduled_at ASC
+		`.execute(this.db)).rows.map((row) => this.mapRow(type, row));
+	}
+	/**
+	* Find all translations in a translation group
+	*/
+	async findTranslations(type, translationGroup) {
+		const tableName = getTableName(type);
+		return (await sql`
+			SELECT * FROM ${sql.ref(tableName)}
+			WHERE translation_group = ${translationGroup}
+			AND deleted_at IS NULL
+			ORDER BY locale ASC
+		`.execute(this.db)).rows.map((row) => this.mapRow(type, row));
+	}
+	/**
+	* Publish the current draft
+	*
+	* Promotes draft_revision_id to live_revision_id and clears draft pointer.
+	* Syncs the draft revision's data into the content table columns so the
+	* content table always reflects the published version.
+	* If no draft revision exists, creates one from current data and publishes it.
+	*/
+	async publish(type, id) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const existing = await this.findById(type, id);
+		if (!existing) throw new DinewayValidationError("Content item not found");
+		const revisionRepo = new RevisionRepository(this.db);
+		let revisionToPublish = existing.draftRevisionId || existing.liveRevisionId;
+		if (!revisionToPublish) revisionToPublish = (await revisionRepo.create({
+			collection: type,
+			entryId: id,
+			data: existing.data
+		})).id;
+		const revision = await revisionRepo.findById(revisionToPublish);
+		if (revision) {
+			await this.syncDataColumns(type, id, revision.data);
+			if (typeof revision.data._slug === "string") await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET slug = ${revision.data._slug}
+					WHERE id = ${id}
+				`.execute(this.db);
+		}
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET live_revision_id = ${revisionToPublish},
+				draft_revision_id = NULL,
+				status = 'published',
+				scheduled_at = NULL,
+				published_at = COALESCE(published_at, ${now}),
+				updated_at = ${now}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Unpublish content
+	*
+	* Removes live pointer but preserves draft. If no draft exists,
+	* creates one from the live version so the content isn't lost.
+	*/
+	async unpublish(type, id) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const existing = await this.findById(type, id);
+		if (!existing) throw new DinewayValidationError("Content item not found");
+		if (!existing.draftRevisionId && existing.liveRevisionId) {
+			const revisionRepo = new RevisionRepository(this.db);
+			const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
+			if (liveRevision) {
+				const draft = await revisionRepo.create({
+					collection: type,
+					entryId: id,
+					data: liveRevision.data
+				});
+				await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET draft_revision_id = ${draft.id}
+					WHERE id = ${id}
+				`.execute(this.db);
+			}
+		}
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET live_revision_id = NULL,
+				status = 'draft',
+				updated_at = ${now}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Discard pending draft changes
+	*
+	* Clears draft_revision_id. The content table columns already hold the
+	* published version, so no data sync is needed.
+	*/
+	async discardDraft(type, id) {
+		const tableName = getTableName(type);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const existing = await this.findById(type, id);
+		if (!existing) throw new DinewayValidationError("Content item not found");
+		if (!existing.draftRevisionId) return existing;
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET draft_revision_id = NULL,
+				updated_at = ${now}
+			WHERE id = ${id}
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		const updated = await this.findById(type, id);
+		if (!updated) throw new Error("Content not found");
+		return updated;
+	}
+	/**
+	* Sync data columns in the content table from a data object.
+	* Used to promote revision data into the content table on publish.
+	* Keys starting with _ are revision metadata (e.g. _slug) and are skipped.
+	*/
+	async syncDataColumns(type, id, data) {
+		const tableName = getTableName(type);
+		const updates = {};
+		for (const [key, value] of Object.entries(data)) {
+			if (SYSTEM_COLUMNS.has(key)) continue;
+			if (key.startsWith("_")) continue;
+			updates[key] = serializeValue(value);
+		}
+		if (Object.keys(updates).length === 0) return;
+		await this.db.updateTable(tableName).set(updates).where("id", "=", id).execute();
+	}
+	/**
+	* Count content items with a pending schedule.
+	* Includes both draft-scheduled (status='scheduled') and published
+	* posts with scheduled draft changes (status='published', scheduled_at set).
+	*/
+	async countScheduled(type) {
+		const tableName = getTableName(type);
+		const result = await sql`
+			SELECT COUNT(id) as count FROM ${sql.ref(tableName)}
+			WHERE scheduled_at IS NOT NULL
+			AND deleted_at IS NULL
+		`.execute(this.db);
+		return Number(result.rows[0]?.count || 0);
+	}
+	/**
+	* Map database row to ContentItem
+	* Extracts system columns and puts content fields in data
+	* Excludes null values from data to match input semantics
+	*/
+	mapRow(type, row) {
+		const data = {};
+		for (const [key, value] of Object.entries(row)) if (!SYSTEM_COLUMNS.has(key) && value !== null) data[key] = deserializeValue(value);
+		return {
+			id: row.id,
+			type,
+			slug: row.slug,
+			status: row.status,
+			data,
+			authorId: row.author_id,
+			primaryBylineId: row.primary_byline_id ?? null,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at,
+			publishedAt: row.published_at,
+			scheduledAt: row.scheduled_at,
+			liveRevisionId: row.live_revision_id ?? null,
+			draftRevisionId: row.draft_revision_id ?? null,
+			version: typeof row.version === "number" ? row.version : 1,
+			locale: row.locale ?? null,
+			translationGroup: row.translation_group ?? null
+		};
+	}
+	/**
+	* Map order field names to database columns.
+	* Only allows known fields to prevent column enumeration via crafted orderBy values.
+	*/
+	mapOrderField(field) {
+		const mapped = {
+			createdAt: "created_at",
+			updatedAt: "updated_at",
+			publishedAt: "published_at",
+			scheduledAt: "scheduled_at",
+			deletedAt: "deleted_at",
+			title: "title",
+			slug: "slug"
+		}[field];
+		if (!mapped) throw new DinewayValidationError(`Invalid order field: ${field}`);
+		return mapped;
+	}
+};
+
+//#endregion
+export { slugify as i, content_exports as n, RevisionRepository as r, ContentRepository as t };