foldkit-cms-drizzle 0.1.0

package/dist/index.mjs

@@ -0,0 +1,714 @@
+import { and, eq, inArray, isNotNull, isNull, lte, ne, sql } from "drizzle-orm";
+import { Effect, Exit, Schema, Semaphore } from "effect";
+import { Cms } from "foldkit-cms";
+import { DrizzleDatabase, bind, query, returning, source } from "foldkit-remote-drizzle";
+import { RemoteServer, RemoteServerError } from "foldkit-remote-server";
+import { integer, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+import { integer as integer$1, sqliteTable, text as text$1 } from "drizzle-orm/sqlite-core";
+//#region src/tables.ts
+/**
+* The three tables the CMS keeps beside the application's own. Drizzle tables
+* are made per dialect, so there is one definition for each; they have the same
+* columns. An application adds them to its schema and its migrations as it does
+* any table, and may define its own instead, so long as the columns are these.
+*/
+/**
+* - `cms_entries`: a piece of content from first keystroke to archive. It exists
+*   before its content row does.
+* - `cms_drafts`: an entry's one working copy; its id is the entry's.
+* - `cms_revisions`: published values, append-only.
+*/
+const sqliteTables = () => ({
+	entries: sqliteTable("cms_entries", {
+		id: text$1("id").primaryKey(),
+		type: text$1("type").notNull(),
+		targetId: text$1("target_id"),
+		label: text$1("label").notNull(),
+		createdBy: text$1("created_by"),
+		createdAt: text$1("created_at").notNull(),
+		archivedAt: text$1("archived_at"),
+		revision: integer$1("revision")
+	}),
+	drafts: sqliteTable("cms_drafts", {
+		id: text$1("id").primaryKey(),
+		values: text$1("values", { mode: "json" }),
+		model: text$1("model", { mode: "json" }),
+		form: text$1("form").notNull(),
+		updatedAt: text$1("updated_at").notNull(),
+		updatedBy: text$1("updated_by"),
+		baseRevision: integer$1("base_revision"),
+		scheduledFor: text$1("scheduled_for"),
+		scheduledBy: text$1("scheduled_by"),
+		scheduleError: text$1("schedule_error")
+	}),
+	revisions: sqliteTable("cms_revisions", {
+		id: text$1("id").primaryKey(),
+		entryId: text$1("entry_id").notNull(),
+		n: integer$1("n").notNull(),
+		values: text$1("values", { mode: "json" }),
+		publishedAt: text$1("published_at").notNull(),
+		publishedBy: text$1("published_by")
+	})
+});
+const pgTables = () => ({
+	entries: pgTable("cms_entries", {
+		id: text("id").primaryKey(),
+		type: text("type").notNull(),
+		targetId: text("target_id"),
+		label: text("label").notNull(),
+		createdBy: text("created_by"),
+		createdAt: text("created_at").notNull(),
+		archivedAt: text("archived_at"),
+		revision: integer("revision")
+	}),
+	drafts: pgTable("cms_drafts", {
+		id: text("id").primaryKey(),
+		values: jsonb("values"),
+		model: jsonb("model"),
+		form: text("form").notNull(),
+		updatedAt: text("updated_at").notNull(),
+		updatedBy: text("updated_by"),
+		baseRevision: integer("base_revision"),
+		scheduledFor: text("scheduled_for"),
+		scheduledBy: text("scheduled_by"),
+		scheduleError: text("schedule_error")
+	}),
+	revisions: pgTable("cms_revisions", {
+		id: text("id").primaryKey(),
+		entryId: text("entry_id").notNull(),
+		n: integer("n").notNull(),
+		values: jsonb("values"),
+		publishedAt: text("published_at").notNull(),
+		publishedBy: text("published_by")
+	})
+});
+/** The `create table` statements for SQLite, for a test or a first migration. */
+const sqliteSchema = `
+create table if not exists cms_entries (
+  id text primary key, type text not null, target_id text, label text not null,
+  created_by text, created_at text not null, archived_at text, revision integer
+);
+create table if not exists cms_drafts (
+  id text primary key, "values" text, model text, form text not null,
+  updated_at text not null, updated_by text, base_revision integer,
+  scheduled_for text, scheduled_by text, schedule_error text
+);
+create table if not exists cms_revisions (
+  id text primary key, entry_id text not null, n integer not null, "values" text,
+  published_at text not null, published_by text
+);
+`;
+//#endregion
+//#region src/index.ts
+/**
+* `foldkit-cms-drizzle` — the server half of `foldkit-cms`.
+*
+* It keeps an author's unpublished work in three tables beside the
+* application's own, and it is where the audience boundary is enforced: a
+* principal that is not an author is refused entries, drafts and revisions
+* outright, and sees of the content only the rows its `published` role shows.
+* Both are a binding's `visible`, so they hold on every path a table is read by.
+*
+* Publishing runs the application's own mutation with the draft's value, inside
+* a transaction that also appends the revision and removes the draft, so a
+* publish happened entirely or did not happen.
+*/
+const statement = (database, text) => Effect.promise(() => {
+	const runs = database;
+	return Promise.resolve(runs.run !== void 0 ? runs.run(sql.raw(text)) : runs.execute(sql.raw(text)));
+});
+const turns = /* @__PURE__ */ new WeakMap();
+const turnOf = (database) => {
+	const held = turns.get(database);
+	if (held !== void 0) return held;
+	const made = Semaphore.makeUnsafe(1);
+	turns.set(database, made);
+	return made;
+};
+const Transaction = {
+	/**
+	* `begin`, the work, then `commit` or `rollback`, as statements. For a database
+	* that is one connection, such as a SQLite file, which it takes turns at: the
+	* operations of this package wait for one another. A write of your own on the
+	* same connection does not, so make it inside `Transaction.statements` too.
+	* Over a pool each statement may take a different connection: use `drizzle` there.
+	*/
+	statements: ((work) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		return yield* turnOf(database).withPermit(statement(database, "begin").pipe(Effect.andThen(work), Effect.onExit((exit) => statement(database, Exit.isSuccess(exit) ? "commit" : "rollback"))));
+	})),
+	/**
+	* Drizzle's `database.transaction`, with the work given the transaction as its
+	* database. For a driver whose transactions are asynchronous: Postgres, libSQL.
+	*/
+	drizzle: ((work) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		const failed = Symbol("failed");
+		let exit;
+		yield* Effect.promise(() => database.transaction(async (inner) => {
+			exit = await Effect.runPromiseExit(work.pipe(Effect.provideService(DrizzleDatabase, inner)));
+			if (!Exit.isSuccess(exit)) throw failed;
+		}).catch((error) => {
+			if (error !== failed) throw error;
+		}));
+		return yield* exit;
+	}))
+};
+const refuse = (message) => new RemoteServerError({ message });
+/**
+* Whether a unique index on this column refused a write. Drivers say so in their
+* own words, and Drizzle wraps what they say, so every message down the chain of
+* causes is read. SQLite names the column; Postgres names the constraint, which
+* by default is made of the column's name.
+*/
+const refusedAsDuplicate = (defect, column) => {
+	const said = [];
+	for (let at = defect, depth = 0; at != null && depth < 5; depth++) {
+		const { message, constraint, cause } = at;
+		if (!String(message).startsWith("Failed query")) said.push(String(message ?? at), String(constraint ?? ""));
+		at = cause;
+	}
+	const text = said.join(" ");
+	const named = new RegExp(`(^|[^a-zA-Z0-9])${column.replace(/[^\w]/g, ".")}([^a-zA-Z0-9]|$)`);
+	return /unique|duplicate/i.test(text) && named.test(text);
+};
+/**
+* For a content table's binding: a visitor sees the rows whose `published`
+* column is set, and an author sees every row. Give it as the storage's
+* `visible` when the table is bound; `CmsServer.make` refuses a content type
+* that can be unpublished and whose binding shows every row to everyone.
+*/
+const published = (column, isAuthor) => (principal) => isAuthor(principal) ? void 0 : isNotNull(column);
+const CmsServer = { make: (config) => {
+	const { tables, isAuthor } = config;
+	const now = config.now ?? (() => /* @__PURE__ */ new Date());
+	const nameOf = config.nameOf ?? (() => null);
+	const maxDraftSize = config.maxDraftSize ?? 1e6;
+	const byType = new Map(config.content.map((served) => [served.type.name, served]));
+	for (const { type, binding, create, update } of config.content) {
+		for (const [handler, declared] of [[create, type.publish.create], [update, type.publish.update]]) if (handler.mutation !== declared.name) throw new Error(`foldkit-cms-drizzle: content "${type.name}" publishes through "${declared.name}", but was given the handler of "${handler.mutation}"`);
+		if (type.roles.published === void 0) continue;
+		if (binding.visible === void 0) throw new Error(`foldkit-cms-drizzle: content "${type.name}" can be unpublished, but its binding shows every row to everyone; bind its table with \`visible: published(column, isAuthor)\``);
+	}
+	const authorsOnly = (principal) => isAuthor(principal) ? void 0 : sql`0 = 1`;
+	const Db = bind(Cms.Entities, {
+		Entry: {
+			table: tables.entries,
+			visible: authorsOnly,
+			relations: {
+				draft: { foreignKey: tables.drafts.id },
+				revisions: {
+					foreignKey: tables.revisions.entryId,
+					orderBy: [{
+						column: tables.revisions.n,
+						direction: "desc"
+					}]
+				}
+			},
+			derived: { state: { supplied: true } }
+		},
+		Draft: {
+			table: tables.drafts,
+			visible: authorsOnly
+		},
+		Revision: {
+			table: tables.revisions,
+			visible: authorsOnly
+		}
+	});
+	/** What is known of some entries, for their state: their drafts, and whether a visitor sees their rows. */
+	const factsOf = (entries) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		const ids = entries.map((entry) => entry.id);
+		const drafts = ids.length === 0 ? [] : yield* Effect.promise(() => Promise.resolve(database.select({
+			id: tables.drafts.id,
+			scheduledFor: tables.drafts.scheduledFor,
+			scheduleError: tables.drafts.scheduleError
+		}).from(tables.drafts).where(inArray(tables.drafts.id, ids))));
+		const draftOf = new Map(drafts.map((draft) => [String(draft.id), draft]));
+		const rows = /* @__PURE__ */ new Map();
+		for (const [name, { type, binding }] of byType) {
+			const targets = entries.flatMap((entry) => entry.type === name && entry.targetId !== null ? [entry.targetId] : []);
+			if (targets.length === 0) continue;
+			const id = binding.columns.id;
+			const publishedColumn = type.roles.published === void 0 ? void 0 : binding.columns[type.roles.published.key];
+			const found = yield* Effect.promise(() => Promise.resolve(database.select({
+				id,
+				...publishedColumn === void 0 ? {} : { shown: publishedColumn }
+			}).from(binding.table).where(inArray(id, targets))));
+			for (const row of found) rows.set(`${name}:${String(row.id)}`, publishedColumn === void 0 || row.shown !== null ? "visible" : "hidden");
+		}
+		return new Map(entries.map((entry) => {
+			const draft = draftOf.get(entry.id);
+			return [entry.id, {
+				archivedAt: entry.archivedAt,
+				row: entry.targetId === null ? "none" : rows.get(`${entry.type}:${entry.targetId}`) ?? "none",
+				draft: draft === void 0 ? null : {
+					scheduledFor: draft.scheduledFor ?? null,
+					scheduleError: draft.scheduleError ?? null
+				}
+			}];
+		}));
+	});
+	const entryColumns = {
+		id: tables.entries.id,
+		type: tables.entries.type,
+		targetId: tables.entries.targetId,
+		label: tables.entries.label,
+		archivedAt: tables.entries.archivedAt,
+		revision: tables.entries.revision
+	};
+	const findEntry = (id) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		const [row] = yield* Effect.promise(() => Promise.resolve(database.select(entryColumns).from(tables.entries).where(eq(tables.entries.id, id)).limit(1)));
+		return row;
+	});
+	const generated = source(Db.Entry);
+	const entries = {
+		...generated,
+		read: (context) => Effect.gen(function* () {
+			const wantsState = context.fields.includes("state");
+			const fields = context.fields.filter((field) => field !== "state");
+			const records = yield* generated.read({
+				...context,
+				fields: wantsState ? [.../* @__PURE__ */ new Set([
+					...fields,
+					"type",
+					"targetId",
+					"archivedAt"
+				])] : fields
+			});
+			if (!wantsState) return records;
+			const facts = yield* factsOf(records.map((record) => ({
+				id: record.id,
+				type: String(record.values.type),
+				targetId: record.values.targetId ?? null,
+				label: "",
+				archivedAt: record.values.archivedAt ?? null,
+				revision: null
+			})));
+			const at = now();
+			return records.map((record) => ({
+				id: record.id,
+				values: {
+					...Object.fromEntries(Object.entries(record.values).filter(([field]) => field === "id" || context.fields.includes(field))),
+					state: Cms.state(facts.get(record.id), at)
+				}
+			}));
+		})
+	};
+	const worklist = query(Cms.Entries, { entity: Db.Entry });
+	/** A mutation of this server: its principal and its database are fixed, its input is the descriptor's. */
+	const operation = (descriptor, run) => RemoteServer.mutation(descriptor, (context) => isAuthor(context.principal) ? config.transaction(run(context)) : Effect.fail(refuse("Only an author may change unpublished work")));
+	/**
+	* A scheduled draft is published, when its time comes, as whoever scheduled it.
+	* So changing it, replacing it or removing it is for someone who could have
+	* scheduled it: otherwise an author who may not publish would publish through
+	* someone who may.
+	*/
+	const promised = (principal, entry) => Effect.gen(function* () {
+		const [draft] = yield* readRows(Db.Draft, { scheduledFor: tables.drafts.scheduledFor }, entry.id);
+		if (draft?.scheduledFor == null) return;
+		if (config.allow?.(principal, "schedule", entry) === false) return yield* refuse("This draft is scheduled, and only someone who may schedule it may change it");
+	});
+	/** Whether the application lets this author do this, once the entry is known. */
+	const asking = (principal, transition, entry) => entry !== void 0 && config.allow?.(principal, transition, entry) === false ? Effect.fail(refuse(`This author may not ${transition} this entry`)) : Effect.void;
+	const draftPatch = returning(Db.Draft, [
+		"values",
+		"model",
+		"form",
+		"updatedAt",
+		"updatedBy",
+		"baseRevision"
+	]);
+	const entryPatch = returning(Db.Entry, [
+		"type",
+		"targetId",
+		"label",
+		"createdAt",
+		"archivedAt",
+		"revision"
+	]);
+	/**
+	* The entry as the client should now hold it, its state with it: an operation
+	* changes the state, and a patch without it would leave the old one on screen.
+	*/
+	const entryPatches = (id) => Effect.gen(function* () {
+		const patches = entryPatch.patches(yield* readRows(Db.Entry, entryPatch.columns, id));
+		const entry = yield* findEntry(id);
+		if (entry === void 0) return patches;
+		const facts = (yield* factsOf([entry])).get(id);
+		return patches.map((patch) => ({
+			...patch,
+			values: {
+				...patch.values,
+				state: Cms.state(facts, now())
+			}
+		}));
+	});
+	const readRows = (binding, columns, id) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		return yield* Effect.promise(() => Promise.resolve(database.select(columns).from(binding.table).where(eq(binding.columns.id, id))));
+	});
+	const SaveDraft = operation(Cms.Operations.SaveDraft, ({ input, principal }) => Effect.gen(function* () {
+		if (!byType.has(input.type)) return yield* refuse(`"${input.type}" is not a type of content this server knows`);
+		const size = JSON.stringify([input.values, input.model]).length;
+		if (size > maxDraftSize) return yield* refuse(`This draft is too large to save: ${size} characters, and ${maxDraftSize} is the most`);
+		const existing = yield* findEntry(input.entry);
+		if (existing !== void 0 && existing.type !== input.type) return yield* refuse(`This entry is of "${existing.type}", not "${input.type}"`);
+		if (existing?.archivedAt != null) return yield* refuse("An archived entry takes no draft");
+		yield* asking(principal, "save", existing);
+		if (existing !== void 0) yield* promised(principal, existing);
+		const database = yield* DrizzleDatabase;
+		const who = nameOf(principal);
+		const id = existing?.id ?? input.entry;
+		const [held] = yield* readRows(Db.Draft, { updatedAt: tables.drafts.updatedAt }, id);
+		const previous = held === void 0 ? null : String(held.updatedAt);
+		const at = now().toISOString();
+		const updatedAt = previous !== null && at <= previous ? new Date(new Date(previous).getTime() + 1).toISOString() : at;
+		const written = {
+			values: input.values,
+			model: input.model,
+			form: input.form,
+			updatedAt,
+			updatedBy: who,
+			scheduleError: null
+		};
+		if (previous === null && input.basedOn !== null) return yield* refuse("CmsConflict: this draft was discarded");
+		if (existing === void 0) yield* Effect.promise(() => Promise.resolve(database.insert(tables.entries).values({
+			id,
+			type: input.type,
+			targetId: null,
+			label: input.label,
+			createdBy: who,
+			createdAt: at,
+			archivedAt: null,
+			revision: null
+		})));
+		if (previous === null) yield* Effect.promise(() => Promise.resolve(database.insert(tables.drafts).values({
+			id,
+			...written,
+			baseRevision: null
+		})));
+		else if ((yield* Effect.promise(() => Promise.resolve(database.update(tables.drafts).set(written).where(and(eq(tables.drafts.id, id), eq(tables.drafts.updatedAt, input.basedOn ?? ""))).returning({ id: tables.drafts.id })))).length === 0) return yield* refuse("CmsConflict: this draft was saved by someone else since");
+		if (existing !== void 0 && existing.label !== input.label) yield* Effect.promise(() => Promise.resolve(database.update(tables.entries).set({ label: input.label }).where(eq(tables.entries.id, id)).returning({ id: tables.entries.id })));
+		const entities = [...yield* entryPatches(id), ...draftPatch.patches(yield* readRows(Db.Draft, draftPatch.columns, id))];
+		return {
+			output: {
+				entry: id,
+				updatedAt
+			},
+			entities
+		};
+	}));
+	const DiscardDraft = operation(Cms.Operations.DiscardDraft, ({ input, principal }) => Effect.gen(function* () {
+		const entry = yield* findEntry(input.entry);
+		if (entry === void 0) return yield* refuse("There is no such entry");
+		yield* asking(principal, "discard", entry);
+		yield* promised(principal, entry);
+		const database = yield* DrizzleDatabase;
+		yield* Effect.promise(() => Promise.resolve(database.delete(tables.drafts).where(eq(tables.drafts.id, entry.id))));
+		const gone = [{
+			entity: "CmsDraft",
+			id: entry.id
+		}];
+		if (entry.targetId !== null) return {
+			output: {},
+			deleted: gone,
+			entities: yield* entryPatches(entry.id)
+		};
+		yield* Effect.promise(() => Promise.resolve(database.delete(tables.entries).where(eq(tables.entries.id, entry.id))));
+		return {
+			output: {},
+			deleted: [...gone, {
+				entity: "CmsEntry",
+				id: entry.id
+			}]
+		};
+	}));
+	const done = {
+		publish: "published",
+		unpublish: "unpublished",
+		schedule: "scheduled",
+		unschedule: "unscheduled",
+		archive: "archived",
+		unarchive: "unarchived",
+		restore: "restored"
+	};
+	/** The entry, if its state offers this transition now. */
+	const offering = (id, transition) => Effect.gen(function* () {
+		const entry = yield* findEntry(id);
+		if (entry === void 0) return yield* refuse("There is no such entry");
+		const served = byType.get(entry.type);
+		if (served === void 0) return yield* refuse(`"${entry.type}" is not a type of content this server knows`);
+		const facts = (yield* factsOf([entry])).get(entry.id);
+		if (!Cms.offers(facts, now(), served.type).includes(transition)) return yield* refuse(`This entry cannot be ${done[transition]} as it stands`);
+		return {
+			entry,
+			served,
+			facts
+		};
+	});
+	/** What the `published` role's column holds for "now". */
+	const stamp = (column, at) => {
+		const kind = column.dataType.split(" ")[0];
+		return kind === "string" ? at.toISOString() : kind === "number" ? at.getTime() : at;
+	};
+	const scheduledPatch = returning(Db.Draft, ["scheduledFor", "scheduleError"]);
+	const revisionPatch = returning(Db.Revision, [
+		"n",
+		"values",
+		"publishedAt",
+		"publishedBy"
+	]);
+	/** The draft as the publish mutation would take it, or why it would not. */
+	const readied = ({ entry, served, facts }) => Effect.gen(function* () {
+		const [draft] = yield* readRows(Db.Draft, { values: tables.drafts.values }, entry.id);
+		const creating = facts.row === "none";
+		const handler = creating ? served.create : served.update;
+		const value = creating || typeof draft?.values !== "object" || draft.values === null ? draft?.values : {
+			...draft.values,
+			id: entry.targetId
+		};
+		return {
+			draft,
+			creating,
+			handler,
+			decoded: yield* Schema.decodeUnknownEffect(handler.Input)(value).pipe(Effect.mapError((error) => refuse(`This draft is not ready to publish: ${String(error)}`)))
+		};
+	});
+	/** A publish, for the operation that asks for one and for the schedule that comes due. */
+	const publishing = (found, principal, basedOn) => Effect.gen(function* () {
+		const { entry, served } = found;
+		const database = yield* DrizzleDatabase;
+		const held = entry.revision;
+		const conflict = refuse("CmsConflict: this entry was published by someone else since");
+		if (held !== basedOn) return yield* conflict;
+		const { draft, creating, handler, decoded } = yield* readied(found);
+		const address = served.type.roles.slug;
+		const slug = address === void 0 ? void 0 : decoded?.[address.key];
+		const taken = (key) => refuse(Cms.slugTaken.message(key, String(slug)));
+		if (address !== void 0 && typeof slug === "string") {
+			const column = served.binding.columns[address.key];
+			const id = served.binding.columns.id;
+			if ((yield* Effect.promise(() => Promise.resolve(database.select({ id }).from(served.binding.table).where(and(eq(column, slug), creating ? void 0 : ne(id, entry.targetId))).limit(1)))).length > 0) return yield* taken(address.key);
+		}
+		return yield* Effect.gen(function* () {
+			const writes = yield* DrizzleDatabase;
+			const n = (held ?? 0) + 1;
+			if ((yield* Effect.promise(() => Promise.resolve(writes.update(tables.entries).set({ revision: n }).where(and(eq(tables.entries.id, entry.id), held === null ? isNull(tables.entries.revision) : eq(tables.entries.revision, held))).returning({ id: tables.entries.id })))).length === 0) return yield* conflict;
+			const ran = yield* handler.run({
+				input: decoded,
+				principal
+			});
+			const targetId = creating ? String(ran.output.id) : entry.targetId;
+			const at = now();
+			const shown = served.type.roles.published;
+			if (shown !== void 0) {
+				const column = served.binding.columns[shown.key];
+				yield* Effect.promise(() => Promise.resolve(writes.update(served.binding.table).set({ [shown.key]: stamp(column, at) }).where(and(eq(served.binding.columns.id, targetId), isNull(column))).returning({ id: served.binding.columns.id })));
+			}
+			const revisionId = `${entry.id}:${n}`;
+			yield* Effect.promise(() => Promise.resolve(writes.insert(tables.revisions).values({
+				id: revisionId,
+				entryId: entry.id,
+				n,
+				values: draft?.values,
+				publishedAt: at.toISOString(),
+				publishedBy: nameOf(principal)
+			})));
+			yield* Effect.promise(() => Promise.resolve(writes.delete(tables.drafts).where(eq(tables.drafts.id, entry.id))));
+			yield* Effect.promise(() => Promise.resolve(writes.update(tables.entries).set({ targetId }).where(eq(tables.entries.id, entry.id)).returning({ id: tables.entries.id })));
+			const content = returning(served.binding, shown === void 0 ? [] : [shown.key]);
+			return {
+				output: {
+					entry: entry.id,
+					targetId,
+					revision: n
+				},
+				entities: [
+					...ran.entities,
+					...content.patches(yield* readRows(served.binding, content.columns, targetId)),
+					...yield* entryPatches(entry.id),
+					...revisionPatch.patches(yield* readRows(Db.Revision, revisionPatch.columns, revisionId))
+				],
+				connections: ran.connections,
+				deleted: [...ran.deleted, {
+					entity: "CmsDraft",
+					id: entry.id
+				}]
+			};
+		}).pipe(Effect.catchDefect((defect) => address !== void 0 && refusedAsDuplicate(defect, served.binding.columns[address.key].name) ? Effect.fail(taken(address.key)) : Effect.die(defect)));
+	});
+	const Publish = operation(Cms.Operations.Publish, ({ input, principal }) => Effect.gen(function* () {
+		const found = yield* offering(input.entry, "publish");
+		yield* asking(principal, "publish", found.entry);
+		return yield* publishing(found, principal, input.basedOn);
+	}));
+	/** Writes to an entry's draft, and answers with both as the client should now hold them. */
+	const drafted = (id, values) => Effect.gen(function* () {
+		const writes = yield* DrizzleDatabase;
+		yield* Effect.promise(() => Promise.resolve(writes.update(tables.drafts).set(values).where(eq(tables.drafts.id, id)).returning({ id: tables.drafts.id })));
+		return {
+			output: {},
+			entities: [...yield* entryPatches(id), ...scheduledPatch.patches(yield* readRows(Db.Draft, scheduledPatch.columns, id))]
+		};
+	});
+	const Schedule = operation(Cms.Operations.Schedule, ({ input, principal }) => Effect.gen(function* () {
+		const found = yield* offering(input.entry, "schedule");
+		yield* asking(principal, "schedule", found.entry);
+		if (Number.isNaN(new Date(input.at).getTime())) return yield* refuse(`"${input.at}" is not a time`);
+		yield* readied(found);
+		return yield* drafted(found.entry.id, {
+			scheduledFor: new Date(input.at).toISOString(),
+			scheduledBy: nameOf(principal),
+			scheduleError: null
+		});
+	}));
+	const Unschedule = operation(Cms.Operations.Unschedule, ({ input, principal }) => Effect.gen(function* () {
+		const found = yield* offering(input.entry, "unschedule");
+		yield* asking(principal, "unschedule", found.entry);
+		return yield* drafted(found.entry.id, {
+			scheduledFor: null,
+			scheduledBy: null,
+			scheduleError: null
+		});
+	}));
+	/** Archiving and its undoing: a fact about the entry, and for what can be hidden, the row. */
+	const archiving = (transition) => operation(transition === "archive" ? Cms.Operations.Archive : Cms.Operations.Unarchive, ({ input, principal }) => Effect.gen(function* () {
+		const { entry, served } = yield* offering(input.entry, transition);
+		yield* asking(principal, transition, entry);
+		const writes = yield* DrizzleDatabase;
+		yield* Effect.promise(() => Promise.resolve(writes.update(tables.entries).set({ archivedAt: transition === "archive" ? now().toISOString() : null }).where(eq(tables.entries.id, entry.id)).returning({ id: tables.entries.id })));
+		const shown = served.type.roles.published;
+		if (transition === "unarchive" || shown === void 0 || entry.targetId === null) return {
+			output: {},
+			entities: yield* entryPatches(entry.id)
+		};
+		yield* Effect.promise(() => Promise.resolve(writes.update(served.binding.table).set({ [shown.key]: null }).where(eq(served.binding.columns.id, entry.targetId)).returning({ id: served.binding.columns.id })));
+		const content = returning(served.binding, [shown.key]);
+		return {
+			output: {},
+			entities: [...content.patches(yield* readRows(served.binding, content.columns, entry.targetId)), ...yield* entryPatches(entry.id)]
+		};
+	}));
+	/**
+	* A revision's value becomes the working copy, and nothing is published. It
+	* replaces what the draft held, and takes back a promise made of that: what
+	* was scheduled is not what is there now. The saved Model goes too, so an
+	* editor fills its form from the values, key by key.
+	*/
+	const Restore = operation(Cms.Operations.Restore, ({ input, principal }) => Effect.gen(function* () {
+		const { entry } = yield* offering(input.entry, "restore");
+		yield* asking(principal, "restore", entry);
+		yield* promised(principal, entry);
+		const database = yield* DrizzleDatabase;
+		const [revision] = yield* Effect.promise(() => Promise.resolve(database.select({ values: tables.revisions.values }).from(tables.revisions).where(and(eq(tables.revisions.entryId, entry.id), eq(tables.revisions.n, input.revision))).limit(1)));
+		if (revision === void 0) return yield* refuse(`This entry has no revision ${input.revision}`);
+		const writes = database;
+		const [held] = yield* readRows(Db.Draft, { updatedAt: tables.drafts.updatedAt }, entry.id);
+		const at = now().toISOString();
+		const updatedAt = held !== void 0 && at <= String(held.updatedAt) ? new Date(new Date(String(held.updatedAt)).getTime() + 1).toISOString() : at;
+		const restored = {
+			values: revision.values,
+			model: null,
+			form: `restored@${input.revision}`,
+			updatedAt,
+			updatedBy: nameOf(principal),
+			baseRevision: entry.revision,
+			scheduledFor: null,
+			scheduledBy: null,
+			scheduleError: null
+		};
+		yield* Effect.promise(() => Promise.resolve(held === void 0 ? writes.insert(tables.drafts).values({
+			id: entry.id,
+			...restored
+		}) : writes.update(tables.drafts).set(restored).where(eq(tables.drafts.id, entry.id)).returning({ id: tables.drafts.id })));
+		return {
+			output: { updatedAt },
+			entities: [
+				...yield* entryPatches(entry.id),
+				...draftPatch.patches(yield* readRows(Db.Draft, draftPatch.columns, entry.id)),
+				...scheduledPatch.patches(yield* readRows(Db.Draft, scheduledPatch.columns, entry.id))
+			]
+		};
+	}));
+	/**
+	* Publishes every draft whose time has come, each in its own transaction, as
+	* whoever scheduled it: `as` says who a stored name is. One that fails stays
+	* scheduled with the reason, and is left alone until its draft changes, so a
+	* fault the author must fix is not tried again every minute. The package owns
+	* no timer: a cron trigger, an interval or a queue calls this.
+	*/
+	const due = (at, options) => Effect.gen(function* () {
+		const database = yield* DrizzleDatabase;
+		const waiting = yield* Effect.promise(() => Promise.resolve(database.select({
+			id: tables.drafts.id,
+			scheduledBy: tables.drafts.scheduledBy
+		}).from(tables.drafts).where(and(isNotNull(tables.drafts.scheduledFor), lte(tables.drafts.scheduledFor, at.toISOString()), isNull(tables.drafts.scheduleError), sql`${tables.drafts.id} in (select ${tables.entries.id} from ${tables.entries} where ${tables.entries.archivedAt} is null)`))));
+		const outcomes = [];
+		for (const draft of waiting) {
+			const id = String(draft.id);
+			const principal = options.as(draft.scheduledBy ?? null);
+			const error = yield* config.transaction(Effect.gen(function* () {
+				if (!isAuthor(principal)) return yield* refuse("Whoever scheduled this is no longer an author");
+				const found = yield* offering(id, "publish");
+				yield* asking(principal, "publish", found.entry);
+				yield* publishing(found, principal, found.entry.revision);
+				return null;
+			})).pipe(Effect.catch((failure) => Effect.succeed(failure.message)), Effect.catchDefect((defect) => Effect.succeed(String(defect))));
+			if (error !== null) yield* config.transaction(drafted(id, { scheduleError: error }));
+			outcomes.push({
+				entry: id,
+				error
+			});
+		}
+		return outcomes;
+	});
+	const Unpublish = operation(Cms.Operations.Unpublish, ({ input, principal }) => Effect.gen(function* () {
+		const { entry, served } = yield* offering(input.entry, "unpublish");
+		yield* asking(principal, "unpublish", entry);
+		const shown = served.type.roles.published;
+		const writes = yield* DrizzleDatabase;
+		yield* Effect.promise(() => Promise.resolve(writes.update(served.binding.table).set({ [shown.key]: null }).where(eq(served.binding.columns.id, entry.targetId)).returning({ id: served.binding.columns.id })));
+		const content = returning(served.binding, [shown.key]);
+		return {
+			output: {},
+			entities: [...content.patches(yield* readRows(served.binding, content.columns, entry.targetId)), ...yield* entryPatches(entry.id)]
+		};
+	}));
+	const sources = [
+		entries,
+		source(Db.Draft),
+		source(Db.Revision),
+		...config.content.map((served) => source(served.binding))
+	];
+	const mutations = [
+		SaveDraft,
+		DiscardDraft,
+		Publish,
+		Unpublish,
+		Schedule,
+		Unschedule,
+		archiving("archive"),
+		archiving("unarchive"),
+		Restore
+	];
+	return {
+		/**
+		* The sources of the content types and of the CMS's own Entities, each behind
+		* the audience boundary. Register these and not `source(binding)` of a content
+		* table: that is how the boundary cannot be forgotten.
+		*/
+		sources,
+		queries: [worklist, ...config.content.flatMap(({ type, binding }) => type.roles.slug === void 0 ? [] : [query(Cms.bySlug(type), { entity: binding })])],
+		mutations,
+		due,
+		/** The bindings of `Entry`, `Draft` and `Revision`, for a handler that returns patches of them. */
+		bindings: Db
+	};
+} };
+//#endregion
+export { CmsServer, Transaction, pgTables, published, sqliteSchema, sqliteTables };
+
+//# sourceMappingURL=index.mjs.map