@hollware/server 0.3.0 → 0.5.0

package/dist/{store-Sq0pwUQv.mjs → store-DiS8UFI2.mjs}

@@ -135,6 +135,11 @@ const tokens = sqliteTable("tokens", {
 	userId: text("user_id").notNull(),
 	label: text("label").notNull(),
 	hash: text("hash").notNull(),
+	/**
+	* `personal` (`hw_pat_`) or `read` (`hw_read_`), which reads the published content of the
+	* site over the read API and nothing else. Its CHECK is the column's own (migration 0007).
+	*/
+	kind: text("kind", { enum: ["personal", "read"] }).notNull().default("personal"),
 	/** A JSON array of scopes. */
 	scopes: text("scopes").notNull(),
 	expiresAt: text("expires_at"),
@@ -413,10 +418,12 @@ const deliveries = sqliteTable("deliveries", {
 	}),
 	check("deliveries_attempts", sql`${t.attempts} >= 0`)
 ]);
-/** The passkeys of a person (ADR-026): WebAuthn credentials, by their id, with their public key. */
+/**
+* The passkeys of a person (ADR-026): WebAuthn credentials, by their id, with their public key. A
+* person is one across the sites of a deployment (v0.4), and so are their passkeys and sessions.
+*/
 const passkeys = sqliteTable("passkeys", {
 	id: id("pky"),
-	siteId: siteId(),
 	userId: text("user_id").notNull(),
 	/** The credential id, base64url, as the authenticator gives it. */
 	credentialId: text("credential_id").notNull(),
@@ -430,14 +437,8 @@ const passkeys = sqliteTable("passkeys", {
 	lastUsedAt: text("last_used_at"),
 	...timestamps()
 }, (t) => [
-	unique("passkeys_id_site").on(t.id, t.siteId),
 	unique("passkeys_credential").on(t.credentialId),
 	index("passkeys_user").on(t.userId),
-	foreignKey({
-		name: "passkeys_site",
-		columns: [t.siteId],
-		foreignColumns: [sites.id]
-	}),
 	foreignKey({
 		name: "passkeys_user_fk",
 		columns: [t.userId],
@@ -479,7 +480,6 @@ const invitations = sqliteTable("invitations", {
 /** WebAuthn challenges, each used once and briefly (ADR-026). */
 const authChallenges = sqliteTable("auth_challenges", {
 	id: id("chl"),
-	siteId: siteId(),
 	challenge: text("challenge").notNull(),
 	/** `register` or `authenticate`. */
 	purpose: text("purpose").notNull(),
@@ -489,37 +489,19 @@ const authChallenges = sqliteTable("auth_challenges", {
 	userId: text("user_id"),
 	expiresAt: text("expires_at").notNull(),
 	...timestamps()
-}, (t) => [
-	unique("auth_challenges_id_site").on(t.id, t.siteId),
-	foreignKey({
-		name: "auth_challenges_site",
-		columns: [t.siteId],
-		foreignColumns: [sites.id]
-	}),
-	check("auth_challenges_purpose", sql`${t.purpose} IN ('register', 'authenticate')`)
-]);
+}, (t) => [check("auth_challenges_purpose", sql`${t.purpose} IN ('register', 'authenticate')`)]);
 /** Signed-in people (ADR-026): the session cookie that `/authorize` reads, by its hash. */
 const sessions = sqliteTable("sessions", {
 	id: id("ses"),
-	siteId: siteId(),
 	userId: text("user_id").notNull(),
 	hash: text("hash").notNull(),
 	expiresAt: text("expires_at").notNull(),
 	...timestamps()
-}, (t) => [
-	unique("sessions_id_site").on(t.id, t.siteId),
-	unique("sessions_hash").on(t.hash),
-	foreignKey({
-		name: "sessions_site",
-		columns: [t.siteId],
-		foreignColumns: [sites.id]
-	}),
-	foreignKey({
-		name: "sessions_user",
-		columns: [t.userId],
-		foreignColumns: [users.id]
-	})
-]);
+}, (t) => [unique("sessions_hash").on(t.hash), foreignKey({
+	name: "sessions_user",
+	columns: [t.userId],
+	foreignColumns: [users.id]
+})]);
 /**
 * Reviews (v0.3): a person who may write but not publish asks for a revision to be published, and
 * a person who may publish approves it, which publishes it, or asks for changes with a note. An
@@ -576,6 +558,47 @@ const reviews = sqliteTable("reviews", {
 	check("reviews_decided", sql`(${t.status} IN ('pending', 'cancelled')) OR (${t.decidedBy} IS NOT NULL AND ${t.decidedAt} IS NOT NULL)`),
 	check("reviews_json", sql`json_valid(${t.acknowledged}) AND json_type(${t.acknowledged}) = 'array' AND (${t.requestedMeta} IS NULL OR json_valid(${t.requestedMeta}))`)
 ]);
+/**
+* The vectors of an entry, as derived data (v0.5): the published revision they were made from,
+* with which model and which version of the chunker, and how many pieces there are. The vectors
+* live in Vectorize under `<entry id>:<piece>`; this row says which exist and whether they are
+* current. One row per entry: a new publication replaces it.
+*/
+const entryEmbeddings = sqliteTable("entry_embeddings", {
+	id: id("emb"),
+	siteId: siteId(),
+	entryId: text("entry_id").notNull(),
+	revisionId: text("revision_id").notNull(),
+	model: text("model").notNull(),
+	chunkerVersion: text("chunker_version").notNull(),
+	/** How many pieces, so how many vectors: `<entry id>:0` to `<entry id>:<pieces - 1>`. */
+	pieces: integer("pieces").notNull(),
+	/**
+	* The entries closest to this one by their summaries, in its collection and locale, closest
+	* first, as JSON: `[{ "id": "ent_…", "score": 0.91 }]`. Found when its vectors were made.
+	*/
+	related: text("related").notNull().default("[]"),
+	...timestamps()
+}, (t) => [
+	unique("entry_embeddings_id_site").on(t.id, t.siteId),
+	unique("entry_embeddings_entry").on(t.siteId, t.entryId),
+	foreignKey({
+		name: "entry_embeddings_site",
+		columns: [t.siteId],
+		foreignColumns: [sites.id]
+	}),
+	foreignKey({
+		name: "entry_embeddings_entry_fk",
+		columns: [t.entryId, t.siteId],
+		foreignColumns: [entries.id, entries.siteId]
+	}).onDelete("cascade"),
+	foreignKey({
+		name: "entry_embeddings_revision_fk",
+		columns: [t.revisionId, t.siteId],
+		foreignColumns: [revisions.id, revisions.siteId]
+	}),
+	check("entry_embeddings_pieces", sql`${t.pieces} >= 1`)
+]);
 //#endregion
 //#region src/identity/secrets.ts
 /**
@@ -607,7 +630,7 @@ function userHandle(userId) {
 //#region src/identity/store.ts
 function roleOf(value) {
 	if (value === "owner" || value === "editor" || value === "author") return value;
-	throw new Error(`An invitation has the role ${value}, which the schema does not allow`);
+	throw new Error(`A role of ${value} is no role the schema allows`);
 }
 /** Creates a link that lets one person in, and gives its secret, which is never stored. */
 async function createInvitation(db, input) {
@@ -633,24 +656,25 @@ async function createInvitation(db, input) {
 	};
 }
 /** The invitation of a secret, while it is unused and has not expired. */
-async function findInvitation(db, site, secret, now) {
+async function findInvitation(db, secret, now) {
 	const [row] = await db.select({
 		id: invitations.id,
+		site: invitations.siteId,
 		role: invitations.role,
 		userId: invitations.userId
-	}).from(invitations).where(and(eq(invitations.siteId, site), eq(invitations.hash, await hashSecret(secret)), isNull(invitations.usedAt), gt(invitations.expiresAt, now.toISOString()))).limit(1);
+	}).from(invitations).where(and(eq(invitations.hash, await hashSecret(secret)), isNull(invitations.usedAt), gt(invitations.expiresAt, now.toISOString()))).limit(1);
 	return row === void 0 ? null : {
 		...row,
 		role: roleOf(row.role)
 	};
 }
 /** Uses an invitation, once: `false` when it was used already or has expired. */
-async function redeemInvitation(db, site, id, now) {
+async function redeemInvitation(db, id, now) {
 	const at = now.toISOString();
 	return (await db.update(invitations).set({
 		usedAt: at,
 		updatedAt: at
-	}).where(and(eq(invitations.siteId, site), eq(invitations.id, id), isNull(invitations.usedAt), gt(invitations.expiresAt, at))).returning({ id: invitations.id })).length === 1;
+	}).where(and(eq(invitations.id, id), isNull(invitations.usedAt), gt(invitations.expiresAt, at))).returning({ id: invitations.id })).length === 1;
 }
 /** Keeps a WebAuthn challenge for five minutes. */
 async function saveChallenge(db, input) {
@@ -658,7 +682,6 @@ async function saveChallenge(db, input) {
 	const now = input.now.toISOString();
 	await db.insert(authChallenges).values({
 		id,
-		siteId: input.site,
 		challenge: input.challenge,
 		purpose: input.purpose,
 		invitationId: input.invitationId,
@@ -671,16 +694,16 @@ async function saveChallenge(db, input) {
 }
 /** Takes a challenge, once, if it has the purpose asked and has not expired. */
 async function takeChallenge(db, input) {
-	const [row] = await db.delete(authChallenges).where(and(eq(authChallenges.siteId, input.site), eq(authChallenges.id, input.id))).returning();
+	const [row] = await db.delete(authChallenges).where(eq(authChallenges.id, input.id)).returning();
 	if (row === void 0 || row.purpose !== input.purpose) return null;
 	if (row.expiresAt <= input.now.toISOString()) return null;
 	return row;
 }
-async function passkeysOf(db, site, userId) {
-	return db.select().from(passkeys).where(and(eq(passkeys.siteId, site), eq(passkeys.userId, userId)));
+async function passkeysOf(db, userId) {
+	return db.select().from(passkeys).where(eq(passkeys.userId, userId));
 }
-async function findPasskey(db, site, credentialId) {
-	const [row] = await db.select().from(passkeys).where(and(eq(passkeys.siteId, site), eq(passkeys.credentialId, credentialId))).limit(1);
+async function findPasskey(db, credentialId) {
+	const [row] = await db.select().from(passkeys).where(eq(passkeys.credentialId, credentialId)).limit(1);
 	return row ?? null;
 }
 /** Records a sign-in with a passkey: its new counter, and when. */
@@ -714,7 +737,6 @@ async function addPasskey(db, input) {
 	const at = input.now.toISOString();
 	await db.insert(passkeys).values({
 		id: newId("pky"),
-		siteId: input.site,
 		userId: input.userId,
 		credentialId: input.credentialId,
 		publicKey: input.publicKey,
@@ -733,7 +755,6 @@ async function createSession(db, input) {
 	const expiresAt = new Date(input.now.getTime() + input.hours * 36e5).toISOString();
 	await db.insert(sessions).values({
 		id: newId("ses"),
-		siteId: input.site,
 		userId: input.userId,
 		hash: await hashSecret(secret),
 		expiresAt,
@@ -745,26 +766,36 @@ async function createSession(db, input) {
 		expiresAt
 	};
 }
-/** The person of a session cookie, while it lasts, with their role in its site now. */
-async function findSession(db, site, secret, now) {
+/** The person of a session cookie, while it lasts. */
+async function findSession(db, secret, now) {
 	const [row] = await db.select({
 		userId: sessions.userId,
-		name: users.name,
-		role: members.role
-	}).from(sessions).innerJoin(users, eq(users.id, sessions.userId)).innerJoin(members, and(eq(members.userId, sessions.userId), eq(members.siteId, sessions.siteId))).where(and(eq(sessions.siteId, site), eq(sessions.hash, await hashSecret(secret)), gt(sessions.expiresAt, now.toISOString()))).limit(1);
+		name: users.name
+	}).from(sessions).innerJoin(users, eq(users.id, sessions.userId)).where(and(eq(sessions.hash, await hashSecret(secret)), gt(sessions.expiresAt, now.toISOString()))).limit(1);
 	return row ?? null;
 }
+/** The sites a person is a member of, with their role in each, in the order they joined. */
+async function membershipsOf(db, userId) {
+	return (await db.select({
+		site: members.siteId,
+		role: members.role
+	}).from(members).where(eq(members.userId, userId)).orderBy(members.createdAt, members.siteId)).map((row) => ({
+		site: row.site,
+		role: roleOf(row.role)
+	}));
+}
 /** An invitation by its id, used or not: what a registration redeems. */
-async function invitationById(db, site, id) {
+async function invitationById(db, id) {
 	const [row] = await db.select({
 		id: invitations.id,
+		site: invitations.siteId,
 		role: invitations.role,
 		userId: invitations.userId
-	}).from(invitations).where(and(eq(invitations.siteId, site), eq(invitations.id, id))).limit(1);
+	}).from(invitations).where(eq(invitations.id, id)).limit(1);
 	return row === void 0 ? null : {
 		...row,
 		role: roleOf(row.role)
 	};
 }
 //#endregion
-export { isRole as A, revisions as C, users as D, tokens as E, ROLE_SCOPES as O, revisionTags as S, sites as T, invitations as _, findInvitation as a, publications as b, invitationById as c, saveChallenge as d, takeChallenge as f, entries as g, deliveries as h, createUser as i, effectiveScopes as k, passkeysOf as l, userHandle as m, createInvitation as n, findPasskey as o, touchPasskey as p, createSession as r, findSession as s, addPasskey as t, redeemInvitation as u, members as v, schedules as w, reviews as x, outbox as y };
+export { ROLE_SCOPES as A, reviews as C, sites as D, schedules as E, isRole as M, tokens as O, publications as S, revisions as T, entries as _, findInvitation as a, members as b, invitationById as c, redeemInvitation as d, saveChallenge as f, deliveries as g, userHandle as h, createUser as i, effectiveScopes as j, users as k, membershipsOf as l, touchPasskey as m, createInvitation as n, findPasskey as o, takeChallenge as p, createSession as r, findSession as s, addPasskey as t, passkeysOf as u, entryEmbeddings as v, revisionTags as w, outbox as x, invitations as y };

package/migrations/0006_people_across_sites.sql

@@ -0,0 +1,54 @@
+-- Edited by hand (ADR-023): a person is one across the sites of a deployment (v0.4), so passkeys,
+-- sessions and sign-in challenges lose site_id. Each table is rebuilt, which D1 allows here since
+-- no other table points at them; the PRAGMA foreign_keys lines drizzle-kit writes are gone, as D1
+-- ignores them, and the CHECKs name their columns without the temporary table's name.
+CREATE TABLE `__new_auth_challenges` (
+	`id` text PRIMARY KEY NOT NULL,
+	`challenge` text NOT NULL,
+	`purpose` text NOT NULL,
+	`invitation_id` text,
+	`user_id` text,
+	`expires_at` text NOT NULL,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL,
+	CONSTRAINT "auth_challenges_purpose" CHECK("purpose" IN ('register', 'authenticate'))
+);
+--> statement-breakpoint
+INSERT INTO `__new_auth_challenges`("id", "challenge", "purpose", "invitation_id", "user_id", "expires_at", "created_at", "updated_at") SELECT "id", "challenge", "purpose", "invitation_id", "user_id", "expires_at", "created_at", "updated_at" FROM `auth_challenges`;--> statement-breakpoint
+DROP TABLE `auth_challenges`;--> statement-breakpoint
+ALTER TABLE `__new_auth_challenges` RENAME TO `auth_challenges`;--> statement-breakpoint
+CREATE TABLE `__new_passkeys` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`credential_id` text NOT NULL,
+	`public_key` text NOT NULL,
+	`counter` integer NOT NULL,
+	`transports` text NOT NULL,
+	`label` text NOT NULL,
+	`last_used_at` text,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL,
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "passkeys_counter" CHECK("counter" >= 0),
+	CONSTRAINT "passkeys_json" CHECK(json_valid("transports") AND json_type("transports") = 'array')
+);
+--> statement-breakpoint
+INSERT INTO `__new_passkeys`("id", "user_id", "credential_id", "public_key", "counter", "transports", "label", "last_used_at", "created_at", "updated_at") SELECT "id", "user_id", "credential_id", "public_key", "counter", "transports", "label", "last_used_at", "created_at", "updated_at" FROM `passkeys`;--> statement-breakpoint
+DROP TABLE `passkeys`;--> statement-breakpoint
+ALTER TABLE `__new_passkeys` RENAME TO `passkeys`;--> statement-breakpoint
+CREATE INDEX `passkeys_user` ON `passkeys` (`user_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `passkeys_credential` ON `passkeys` (`credential_id`);--> statement-breakpoint
+CREATE TABLE `__new_sessions` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`hash` text NOT NULL,
+	`expires_at` text NOT NULL,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL,
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+INSERT INTO `__new_sessions`("id", "user_id", "hash", "expires_at", "created_at", "updated_at") SELECT "id", "user_id", "hash", "expires_at", "created_at", "updated_at" FROM `sessions`;--> statement-breakpoint
+DROP TABLE `sessions`;--> statement-breakpoint
+ALTER TABLE `__new_sessions` RENAME TO `sessions`;--> statement-breakpoint
+CREATE UNIQUE INDEX `sessions_hash` ON `sessions` (`hash`);

package/migrations/0007_read_tokens.sql

@@ -0,0 +1,4 @@
+-- Edited by hand (ADR-023). Read tokens (v0.4): a token is personal (hw_pat_) or a read token (hw_read_), which reads the
+-- published content of its site over the read API and nothing else. Every token so far is
+-- personal. The CHECK is the column's own, so the table is not rebuilt.
+ALTER TABLE `tokens` ADD `kind` text DEFAULT 'personal' NOT NULL CHECK (`kind` IN ('personal', 'read'));

package/migrations/0008_search.sql

@@ -0,0 +1,47 @@
+-- Written by hand (ADR-023), as drizzle-kit has no virtual tables. Full-text search (v0.5): an
+-- FTS5 index of the published revision of each entry, its title, its tags and its text. The text
+-- is taken from the stored Comark document, the strings at the text positions of its nodes, so
+-- the Markdown's own marks are never indexed. `unicode61 remove_diacritics 2` matches
+-- "migracion" with "migración".
+--
+-- The triggers keep it in the step that changes what is published, whichever write does it:
+-- publish, a group, a schedule that comes due, unpublish. Only published content is in it.
+CREATE VIRTUAL TABLE `entries_fts` USING fts5(
+	`title`,
+	`tags`,
+	`body`,
+	`entry_id` UNINDEXED,
+	`site_id` UNINDEXED,
+	`collection` UNINDEXED,
+	`locale` UNINDEXED,
+	tokenize = 'unicode61 remove_diacritics 2'
+);
+--> statement-breakpoint
+CREATE TRIGGER `entries_fts_publication` AFTER UPDATE OF `published_rev` ON `entries`
+BEGIN
+	DELETE FROM `entries_fts` WHERE `entry_id` = OLD.`id`;
+	INSERT INTO `entries_fts` (`title`, `tags`, `body`, `entry_id`, `site_id`, `collection`, `locale`)
+	SELECT
+		coalesce(json_extract(r.`frontmatter`, '$.title'), ''),
+		coalesce((SELECT group_concat(t.`tag`, ' ') FROM `revision_tags` t WHERE t.`revision_id` = r.`id`), ''),
+		coalesce((SELECT group_concat(n.`value`, ' ') FROM json_tree(r.`document`, '$.nodes') n
+			WHERE n.`type` = 'text' AND typeof(n.`key`) = 'integer' AND n.`key` >= 2), ''),
+		NEW.`id`, NEW.`site_id`, NEW.`collection`, NEW.`locale`
+	FROM `revisions` r
+	WHERE NEW.`published_rev` IS NOT NULL AND r.`id` = NEW.`published_rev`;
+END;
+--> statement-breakpoint
+CREATE TRIGGER `entries_fts_removal` AFTER DELETE ON `entries`
+BEGIN
+	DELETE FROM `entries_fts` WHERE `entry_id` = OLD.`id`;
+END;
+--> statement-breakpoint
+-- What is published already.
+INSERT INTO `entries_fts` (`title`, `tags`, `body`, `entry_id`, `site_id`, `collection`, `locale`)
+SELECT
+	coalesce(json_extract(r.`frontmatter`, '$.title'), ''),
+	coalesce((SELECT group_concat(t.`tag`, ' ') FROM `revision_tags` t WHERE t.`revision_id` = r.`id`), ''),
+	coalesce((SELECT group_concat(n.`value`, ' ') FROM json_tree(r.`document`, '$.nodes') n
+		WHERE n.`type` = 'text' AND typeof(n.`key`) = 'integer' AND n.`key` >= 2), ''),
+	e.`id`, e.`site_id`, e.`collection`, e.`locale`
+FROM `entries` e JOIN `revisions` r ON r.`id` = e.`published_rev`;

package/migrations/0009_embeddings.sql

@@ -0,0 +1,19 @@
+CREATE TABLE `entry_embeddings` (
+	`id` text PRIMARY KEY NOT NULL,
+	`site_id` text NOT NULL,
+	`entry_id` text NOT NULL,
+	`revision_id` text NOT NULL,
+	`model` text NOT NULL,
+	`chunker_version` text NOT NULL,
+	`pieces` integer NOT NULL,
+	`related` text DEFAULT '[]' NOT NULL,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL,
+	FOREIGN KEY (`site_id`) REFERENCES `sites`(`id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`entry_id`,`site_id`) REFERENCES `entries`(`id`,`site_id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`revision_id`,`site_id`) REFERENCES `revisions`(`id`,`site_id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT "entry_embeddings_pieces" CHECK("entry_embeddings"."pieces" >= 1)
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `entry_embeddings_id_site` ON `entry_embeddings` (`id`,`site_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `entry_embeddings_entry` ON `entry_embeddings` (`site_id`,`entry_id`);