dineway 0.2.32 → 0.2.34

package/dist/{store-c4qx3gVh.mjs → store-C1yDxxfv.mjs}

@@ -1,12 +1,14 @@
-import { i as encodeBase64url, n as decodeBase64url } from "./base64-F8-DUraK.mjs";
-import { i as parseEncryptionKeys, t as DinewaySecretsError } from "./secrets-AdCrGg1c.mjs";
+import { atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
+import { t as readRuntimeEnv } from "./runtime-env-CQVAWHzH.mjs";
+import { i as parseEncryptionKeys, t as DinewaySecretsError } from "./secrets-Cg0D2gQW.mjs";
 
 //#region src/database/repositories/integration-credentials.ts
 var IntegrationCredentialRepository = class {
 	constructor(db) {
 		this.db = db;
 	}
-	async put(input) {
+	preparePut(input) {
 		const now = input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
 		const row = {
 			provider: input.provider,
@@ -20,7 +22,7 @@ var IntegrationCredentialRepository = class {
 			created_at: now,
 			updated_at: now
 		};
-		await this.db.insertInto("_dineway_integration_credentials").values(row).onConflict((conflict) => conflict.column("provider").doUpdateSet({
+		return this.db.insertInto("_dineway_integration_credentials").values(row).onConflict((conflict) => conflict.column("provider").doUpdateSet({
 			credential_type: row.credential_type,
 			encryption_version: row.encryption_version,
 			key_id: row.key_id,
@@ -29,7 +31,25 @@ var IntegrationCredentialRepository = class {
 			fingerprint: row.fingerprint,
 			source: row.source,
 			updated_at: now
-		})).execute();
+		})).compile();
+	}
+	async put(input, expected) {
+		const checks = expected ? [rowUnchanged("_dineway_integration_credentials", {
+			provider: expected.provider,
+			credential_type: expected.credentialType,
+			encryption_version: expected.encryptionVersion,
+			key_id: expected.keyId,
+			nonce: expected.nonce,
+			ciphertext: expected.ciphertext,
+			fingerprint: expected.fingerprint,
+			source: expected.source,
+			created_at: expected.createdAt,
+			updated_at: expected.updatedAt
+		})] : [];
+		await atomicBatch(this.db, {
+			checks,
+			statements: [this.preparePut(input)]
+		});
 		const stored = await this.find(input.provider);
 		if (!stored) throw new Error("Integration credential write did not persist.");
 		return stored;
@@ -71,17 +91,18 @@ var IntegrationCredentialStore = class {
 	repository;
 	keysPromise;
 	constructor(db, options = {}) {
+		this.db = db;
 		this.repository = new IntegrationCredentialRepository(db);
 		this.keysPromise = options.keys ? Promise.resolve(options.keys) : parseEncryptionKeys(readEncryptionKey(options.env));
 	}
-	async set(provider, credential, source = "admin") {
+	async prepareSet(provider, credential, source = "admin") {
 		validateProvider(provider);
 		validateCredential(credential);
 		const primaryKey = (await this.requireKeys())[0];
 		if (!primaryKey) throw encryptionKeyRequired();
 		const serialized = serializeCredential(credential);
 		const encrypted = await encryptCredential(primaryKey, provider, credential.type, serialized);
-		return toStatus(await this.repository.put({
+		return this.repository.preparePut({
 			provider,
 			credentialType: credential.type,
 			encryptionVersion: ENCRYPTION_VERSION,
@@ -90,7 +111,13 @@ var IntegrationCredentialStore = class {
 			ciphertext: encrypted.ciphertext,
 			fingerprint: await fingerprintCredential(primaryKey, provider, serialized),
 			source
-		}));
+		});
+	}
+	async set(provider, credential, source = "admin") {
+		await atomicBatch(this.db, { statements: [await this.prepareSet(provider, credential, source)] });
+		const status = await this.status(provider);
+		if (!status) throw new Error("Integration credential write did not persist.");
+		return status;
 	}
 	async status(provider) {
 		validateProvider(provider);
@@ -131,7 +158,7 @@ var IntegrationCredentialStore = class {
 				ciphertext: encrypted.ciphertext,
 				fingerprint: await fingerprintCredential(primaryKey, provider, serialized),
 				source: stored.source
-			});
+			}, stored);
 		}
 		return credential;
 	}
@@ -234,9 +261,7 @@ function encryptionKeyRequired() {
 }
 function readEncryptionKey(env) {
 	if (env) return env.DINEWAY_ENCRYPTION_KEY;
-	const meta = import.meta.env ?? {};
-	const proc = typeof process !== "undefined" && process.env ? process.env : {};
-	return meta.DINEWAY_ENCRYPTION_KEY ?? proc.DINEWAY_ENCRYPTION_KEY;
+	return readRuntimeEnv("DINEWAY_ENCRYPTION_KEY");
 }
 function toStatus(stored) {
 	return {

package/dist/submission-BsHNfHc7.mjs

@@ -0,0 +1,155 @@
+import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { t as ContentRepository } from "./content-NobcQti0.mjs";
+import { t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
+import { i as isSupersededReview, r as ReviewRequestRepository, t as REVIEW_SUPERSESSION_ACTOR } from "./review-requests-BF2eEKr8.mjs";
+import { i as encodeRev, t as ReviewPayloadBuilder } from "./review-payload-DEylbssM.mjs";
+import { i as reviewDraft } from "./evidence-xJf8hQgH.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/review-automation/submission.ts
+var ReviewSubmissionError = class extends Error {
+	constructor(message, code = "REVIEW_SUBMISSION_INVALID") {
+		super(message);
+		this.code = code;
+	}
+};
+async function submitAutomatedReview(db, handlers, input) {
+	const contentRepo = new ContentRepository(db);
+	const entry = await contentRepo.findByIdOrSlug(input.collection, input.id);
+	const snapshot = entry ? await contentRepo.snapshot(input.collection, entry.id) : null;
+	if (!snapshot) throw new ReviewSubmissionError("The submitted content could not be read.");
+	const revisionIds = [snapshot.item.liveRevisionId, snapshot.item.draftRevisionId].filter((id) => id !== null);
+	const revisions = revisionIds.length ? await db.selectFrom("revisions").selectAll().where("id", "in", revisionIds).execute() : [];
+	const built = await new ReviewPayloadBuilder(handlers).buildContentReviewPayload(input);
+	if (input.expectedRev !== void 0 && input.expectedRev !== built.reviewedRev) throw new ReviewSubmissionError("Reload the latest draft before submitting it.", "REVIEW_REVISION_CHANGED");
+	const contentHash = await buildStableHash(reviewDraft(built));
+	const targetKey = await buildStableHash({
+		collection: built.collection,
+		id: built.entryId,
+		actionHash: built.actionHash
+	});
+	if (built.reviewedRev !== encodeRev(snapshot.item) || built.draftRevisionId !== snapshot.item.draftRevisionId || built.liveRevisionId !== snapshot.item.liveRevisionId) throw new ReviewSubmissionError("The submitted content changed. Review the latest draft.");
+	const scheduledAt = snapshot.item.scheduledAt;
+	const checks = [snapshot.check, ...revisions.map((revision) => rowUnchanged("revisions", revision))];
+	const reviews = new ReviewRequestRepository(db);
+	const prepareSupersession = async () => {
+		const statements = [];
+		if (!input.supersedePending) return {
+			checks: [],
+			statements
+		};
+		const query = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("requested_by_actor_type", "=", input.actor.actorType).where("requested_by_actor_id", "=", input.actor.actorId).where("status", "=", "pending").where("revoked_at", "is", null).where((eb) => eb.or([eb("reviewed_rev", "!=", built.reviewedRev), eb("action_hash", "!=", built.actionHash)]));
+		const previous = await query.select("id").execute();
+		const supersessionChecks = [sql`${query.select((eb) => eb.fn.countAll().as("count"))} = ${previous.length}`];
+		for (const prior of previous) {
+			const batch = await reviews.prepareResolve(prior.id, {
+				decision: "rejected",
+				resolvedByActorType: "system",
+				resolvedByActorId: REVIEW_SUPERSESSION_ACTOR,
+				reviewNote: "Superseded by a newer submission. This is not an editorial rejection."
+			});
+			if (!batch) throw new AtomicWriteConflict();
+			supersessionChecks.push(...batch.checks ?? []);
+			statements.push(...batch.statements);
+		}
+		return {
+			checks: supersessionChecks,
+			statements
+		};
+	};
+	const reuseReview = async (item) => {
+		const batch = await prepareSupersession();
+		if (batch.statements.length) await atomicBatch(db, {
+			checks: [
+				...checks,
+				rowUnchanged("_dineway_review_requests", {
+					id: item.id,
+					status: item.status,
+					revoked_at: item.revokedAt ?? null
+				}),
+				...batch.checks
+			],
+			statements: batch.statements
+		});
+		return {
+			item,
+			created: false
+		};
+	};
+	const findExisting = async () => {
+		const existing = await db.selectFrom("_dineway_review_jobs").select("review_id").where("target_key", "=", targetKey).executeTakeFirst();
+		if (existing) {
+			const item = await reviews.findById(existing.review_id);
+			if (!item || item.status === "rejected" || item.revokedAt) throw new ReviewSubmissionError("Edit the content before submitting a rejected or revoked target again.");
+			return item;
+		}
+		return null;
+	};
+	const existingReview = await findExisting();
+	if (existingReview) return reuseReview(existingReview);
+	const rejected = await db.selectFrom("_dineway_review_requests").select([
+		"id",
+		"status",
+		"review_payload",
+		"resolved_by_actor_type",
+		"resolved_by_actor_id"
+	]).where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("status", "=", "rejected").execute();
+	checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_review_jobs WHERE target_key = ${targetKey})`, sql`(SELECT COUNT(*) FROM _dineway_review_requests WHERE collection = ${built.collection} AND entry_id = ${built.entryId} AND status = 'rejected') = ${rejected.length}`, ...rejected.map((row) => rowUnchanged("_dineway_review_requests", row)));
+	for (const row of rejected) {
+		if (isSupersededReview(row)) continue;
+		if (await buildStableHash(z.object({ diff: z.object({ draft: z.unknown().optional() }).optional() }).parse(JSON.parse(row.review_payload)).diff?.draft) === contentHash) throw new ReviewSubmissionError("This content was rejected. Change it before submitting a new review.");
+	}
+	const approved = await reviews.findApprovedForTarget(built);
+	if (approved) return reuseReview(approved);
+	const pendingQuery = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("reviewed_rev", "=", built.reviewedRev).where("action_hash", "=", built.actionHash).where("status", "=", "pending").where("revoked_at", "is", null);
+	const pending = await pendingQuery.selectAll().orderBy("created_at").orderBy("id").executeTakeFirst();
+	checks.push(pending ? rowUnchanged("_dineway_review_requests", pending) : sql`NOT EXISTS ${pendingQuery.select("id")}`);
+	const prepared = pending ? null : reviews.prepareCreate({
+		...built,
+		riskReason: input.riskReason,
+		requestedByActorType: input.actor.actorType,
+		requestedByActorId: input.actor.actorId,
+		requestedAuthMetadata: input.actor.authMetadata
+	});
+	const reviewId = pending?.id ?? prepared.id;
+	const supersession = await prepareSupersession();
+	checks.push(...supersession.checks);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const job = db.insertInto("_dineway_review_jobs").values({
+		review_id: reviewId,
+		target_key: targetKey,
+		content_hash: contentHash,
+		state: "queued",
+		release_state: "none",
+		evidence_json: null,
+		reason: "Automated review in progress",
+		release_reason: null,
+		scheduled_at: scheduledAt,
+		created_at: now,
+		updated_at: now
+	}).compile();
+	try {
+		await atomicBatch(db, {
+			checks,
+			statements: [
+				...supersession.statements,
+				...prepared ? [prepared.statement] : [],
+				job
+			]
+		});
+	} catch (error) {
+		if (error instanceof AtomicWriteConflict) {
+			const existing = await findExisting();
+			if (existing) return reuseReview(existing);
+		}
+		throw error;
+	}
+	return {
+		item: await reviews.findById(reviewId),
+		created: !pending
+	};
+}
+
+//#endregion
+export { submitAutomatedReview as n, ReviewSubmissionError as t };

package/dist/{taxonomies-ALDiRQ84.mjs → taxonomies-4cnTcbD6.mjs}

@@ -1,6 +1,6 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { t as TaxonomyRepository } from "./taxonomy-BOBTJ_aE.mjs";
-import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-93DV-1QT.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-DWxxLpp5.mjs";
+import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-CllxqaH0.mjs";
 import { ulid } from "ulidx";
 
 //#region src/api/handlers/taxonomies.ts

package/dist/{taxonomies-93DV-1QT.mjs → taxonomies-CllxqaH0.mjs}

@@ -1,10 +1,10 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
 import { getRequestContext } from "./request-context.mjs";
-import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-BDje8ME2.mjs";
-import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-D51qOseS.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-CnuL55JE.mjs";
-import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-BruBnFAR.mjs";
-import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-pZ4NQM-X.mjs";
+import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-Cgsx23wU.mjs";
+import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-BGjIlY9s.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-BnG3LPMN.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-DPmV5nk4.mjs";
+import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-C80Pm2DW.mjs";
 
 //#region src/taxonomies/index.ts
 /**
@@ -393,7 +393,7 @@ function primeFoldedEntryTerms(collection, perEntry, options = {}) {
 * Get entries by term.
 */
 async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
-	const { getDinewayCollection } = await import("./query-CrW2yI6G.mjs").then((n) => n.o);
+	const { getDinewayCollection } = await import("./query-CEn9HXnf.mjs").then((n) => n.o);
 	const queryOptions = { where: { [taxonomyName]: termSlug } };
 	if (options.locale !== void 0) queryOptions.locale = options.locale;
 	const { entries } = await getDinewayCollection(collection, queryOptions);

package/dist/{taxonomy-BOBTJ_aE.mjs → taxonomy-DWxxLpp5.mjs}

@@ -1,5 +1,5 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { d as invalidateTaxonomyObjectCache } from "./object-cache-D51qOseS.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { d as invalidateTaxonomyObjectCache } from "./object-cache-BGjIlY9s.mjs";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/taxonomy.ts
@@ -226,7 +226,7 @@ var TaxonomyRepository = class {
 	*/
 	async countEntriesForTerms(translationGroups) {
 		if (translationGroups.length === 0) return /* @__PURE__ */ new Map();
-		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-CnuL55JE.mjs").then((n) => n.r);
+		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-BnG3LPMN.mjs").then((n) => n.r);
 		const counts = /* @__PURE__ */ new Map();
 		for (const chunk of chunks(translationGroups, 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();

package/dist/{tokens-c-qxNqzC.mjs → tokens-Bjuf1HID.mjs}

@@ -1,4 +1,4 @@
-import { i as encodeBase64url, n as decodeBase64url } from "./base64-F8-DUraK.mjs";
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
 
 //#region src/preview/tokens.ts
 /**

package/dist/{trusted-proxy-CdEl6g6B.mjs → trusted-proxy-CAW9o4Dw.mjs}

@@ -1,25 +1,17 @@
+import { t as readRuntimeEnv } from "./runtime-env-CQVAWHzH.mjs";
+
 //#region src/auth/trusted-proxy.ts
 /**
 * RFC 7230 token characters for HTTP header names.
 * Invalid names throw when passed to `Headers.get()`.
 */
 const HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9a-z]+$/;
-/** Cache for the env-derived value. `null` means "not yet parsed". */
-let envCache = null;
 function normalizeTrustedHeaders(names) {
 	return names.map((name) => name.trim().toLowerCase()).filter((name) => name.length > 0 && HEADER_NAME_PATTERN.test(name));
 }
 function getEnvTrustedHeaders() {
-	if (envCache !== null) return envCache;
-	let raw;
-	try {
-		const importMetaEnv = import.meta.env;
-		raw = (typeof process !== "undefined" ? process.env?.DINEWAY_TRUSTED_PROXY_HEADERS : void 0) || importMetaEnv?.DINEWAY_TRUSTED_PROXY_HEADERS;
-	} catch {
-		raw = void 0;
-	}
-	envCache = raw ? normalizeTrustedHeaders(raw.split(",")) : [];
-	return envCache;
+	const raw = readRuntimeEnv("DINEWAY_TRUSTED_PROXY_HEADERS");
+	return raw ? normalizeTrustedHeaders(raw.split(",")) : [];
 }
 function getTrustedProxyHeaders(config) {
 	if (config?.trustedProxyHeaders !== void 0) return normalizeTrustedHeaders(config.trustedProxyHeaders);

package/dist/{types-BRCUO8NR.d.mts → types-7Th6Mwz3.d.mts}

@@ -561,6 +561,7 @@ interface CronTaskTable {
   last_run_at: string | null;
   status: string;
   locked_at: string | null;
+  lease_token: string | null;
   enabled: number;
   created_at: Generated<string>;
 }

package/dist/{types-BpSTdH1H.mjs → types-BqxIv8Il.mjs}

@@ -1,5 +1,5 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { r as encodeBase64, t as decodeBase64 } from "./base64-F8-DUraK.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
 
 //#region src/database/repositories/types.ts
 var types_exports = /* @__PURE__ */ __exportAll({

package/dist/{types-6KmeXInJ.d.mts → types-CFgTpfPk.d.mts}

@@ -1,4 +1,4 @@
-import { c as CustomFieldValue } from "./types-CKIt_jmM.mjs";
+import { c as CustomFieldValue } from "./types-Bs-7Geuh.mjs";
 
 //#region src/database/repositories/types.d.ts
 interface CreateContentInput {