@protobase/server 0.22.0 → 0.22.2

package/dist/better-auth/users/user-endpoints.js

@@ -0,0 +1,79 @@
+import { invitationLink, invitationToken } from "../invitations/invitation-token.js";
+import { sendAuthEmail } from "../auth-mail/send-auth-email.js";
+import { adminOnly } from "../admin-only.js";
+import { createAppInvitation, deleteAppInvitation, listAppInvitations } from "./app-invitation-store.js";
+import { roleLabels } from "../roles/role-labels.js";
+import * as z$1 from "zod";
+import { APIError, createAuthEndpoint } from "better-auth/api";
+//#region src/better-auth/users/user-endpoints.ts
+const admins = adminOnly("Only an admin manages users.");
+const answerOf = ({ id, email, roles, expiresAt }) => ({
+	id,
+	email,
+	roles,
+	expiresAt: expiresAt.toISOString()
+});
+/**
+* What an admin manages people with besides Better Auth's admin endpoints, which list, create, set roles and block:
+* invitations to the app by email, which work with or without organizations, and the roles with their labels.
+*/
+const userEndpoints = ({ definitions, mail, invitationUrl, invitationSeconds }) => ({
+	/**
+	* `POST /users/invite` with `{ email, roles }`: invites an address without an account to make one, with `roles`, from
+	* the link it is mailed. Inviting it again replaces the earlier invitation, so its link stops working.
+	*/
+	inviteUser: createAuthEndpoint("/users/invite", {
+		method: "POST",
+		use: [admins],
+		body: z$1.object({
+			email: z$1.email(),
+			roles: z$1.array(z$1.string()).min(1)
+		})
+	}, async (ctx) => {
+		const unknown = ctx.body.roles.find((role) => !definitions.names.includes(role));
+		if (unknown !== void 0) throw new APIError("BAD_REQUEST", {
+			code: "UNKNOWN_ROLE",
+			message: `Unknown role "${unknown}"; use ${definitions.names.join(", ")}`
+		});
+		if (await ctx.context.internalAdapter.findUserByEmail(ctx.body.email.toLowerCase())) throw new APIError("BAD_REQUEST", {
+			code: "ACCOUNT_EXISTS",
+			message: "This address has an account already."
+		});
+		const inviter = ctx.context.session.user;
+		const invitation = await createAppInvitation(ctx.context, {
+			email: ctx.body.email,
+			roles: [...new Set(ctx.body.roles)],
+			inviterId: inviter.id
+		}, invitationSeconds);
+		if (mail) {
+			const url = invitationLink(invitationUrl, await invitationToken(ctx.context.secret, invitation));
+			await sendAuthEmail(mail, "invitationEmail", invitation.email, {
+				inviter: inviter.name || inviter.email,
+				url,
+				expiresAt: invitation.expiresAt
+			}, url);
+		}
+		return ctx.json(answerOf(invitation));
+	}),
+	/** `GET /users/invitations`: the pending invitations to the app, oldest first. */
+	listUserInvitations: createAuthEndpoint("/users/invitations", {
+		method: "GET",
+		use: [admins]
+	}, async (ctx) => ctx.json({ invitations: (await listAppInvitations(ctx.context)).map(answerOf) })),
+	/** `POST /users/invitations/cancel` with `{ id }`: revokes an invitation to the app, so its link stops working. */
+	cancelUserInvitation: createAuthEndpoint("/users/invitations/cancel", {
+		method: "POST",
+		use: [admins],
+		body: z$1.object({ id: z$1.string().min(1) })
+	}, async (ctx) => {
+		await deleteAppInvitation(ctx.context, ctx.body.id);
+		return ctx.json({ id: ctx.body.id });
+	}),
+	/** `GET /users/roles`: every role with its label, to choose from when inviting, creating or changing a user. */
+	userRoles: createAuthEndpoint("/users/roles", {
+		method: "GET",
+		use: [admins]
+	}, async (ctx) => ctx.json(roleLabels(definitions)))
+});
+//#endregion
+export { userEndpoints };

package/dist/better-auth/users/users-plugin.js

@@ -0,0 +1,22 @@
+import { invitationLinkHook } from "../invitations/invitation-link-hook.js";
+import { invitationEndpoints } from "../invitations/invitation-endpoints.js";
+import { userEndpoints } from "./user-endpoints.js";
+//#region src/better-auth/users/users-plugin.ts
+/**
+* Managing people without the command line: invitations to the app and the roles to give, for admins, and the endpoints
+* every invitation link opens, to the app or, with `organizations`, to one of them. Without a mailer, whoever invites
+* gets the link in the answer.
+*/
+const usersPlugin = (options) => ({
+	id: "protobase-users",
+	endpoints: {
+		...userEndpoints(options),
+		...invitationEndpoints({
+			mail: Boolean(options.mail),
+			...options.organizations && { organizations: options.organizations }
+		})
+	},
+	hooks: { after: options.mail ? [] : [invitationLinkHook(["/users/invite"], options.invitationUrl)] }
+});
+//#endregion
+export { usersPlugin };

package/dist/better-auth/users.js

@@ -1,4 +1,5 @@
 import { parseRoles } from "./parse-roles.js";
+import { isActiveAdmin } from "./last-admin.js";
 import { ownOrganizationsWithoutMembers } from "./organizations/host.js";
 //#region src/better-auth/users.ts
 /** The roles this auth instance allows, `admin` first. */
@@ -61,8 +62,6 @@ const allUsers = async (auth) => {
 	});
 };
 const rolesOf = (user) => parseRoles(user.role);
-const isAdmin = (user) => rolesOf(user).includes("admin");
-const isActiveAdmin = (user) => isAdmin(user) && !user.banned;
 const findUser = async (auth, email) => {
 	const user = (await allUsers(auth)).find((candidate) => candidate.email.toLowerCase() === email.toLowerCase());
 	if (!user) throw new Error(`No user with email ${email}`);

package/dist/check-views.js

@@ -7,7 +7,7 @@ import { mapDisplayErrors, mapErrors } from "./view-map.js";
 import { relatedColumnErrors } from "./view-related-column.js";
 import { editableErrors } from "./view-editable.js";
 import { conditionProblems } from "@protobase/layout";
-import { actionInputErrors, addressErrors, addressPlaceholders, boardErrors, calendarErrors, chartFields, displayFields, fieldRefsIn, hrefField, hrefPlaceholders, layoutItems, linkActionError, promptError, promptFields } from "@protobase/schema/internal";
+import { actionInputErrors, addressErrors, addressPlaceholders, boardErrors, calendarErrors, chartFields, displayFields, fieldRefsIn, hrefField, hrefPlaceholders, layoutItems, linkActionError, promptError, promptFields, updateSetErrors } from "@protobase/schema/internal";
 import { isRecordCondition } from "@protobase/schema";
 //#region src/check-views.ts
 const linkFields = (run) => run?.kind !== "link" ? [] : "to" in run ? addressPlaceholders(run.to) : hrefPlaceholders(run.href);
@@ -85,9 +85,11 @@ const aiActionErrors = (view, model) => view.actions.flatMap(({ name, run }) =>
 	].map((error) => `action "${name}": ${error}`);
 });
 const inputErrors = (view, models) => view.actions.flatMap(({ name, run, inputs }) => {
-	if (!inputs) return [];
+	const update = run?.kind === "update" ? updateSetErrors(run.values, inputs) : [];
+	if (!inputs) return update.map((error) => `action "${name}": ${error}`);
 	return [
-		...run ? [`inputs need a handler, and a${run.kind === "update" || run.kind === "ai" ? "n" : ""} ${run.kind} action has none`] : [],
+		...update,
+		...run && run.kind !== "update" ? [`inputs need a handler, and a${run.kind === "ai" ? "n" : ""} ${run.kind} action has none`] : [],
 		...actionInputErrors(inputs),
 		...inputs.flatMap((input) => input.resource !== void 0 && !models[input.resource] ? [`input "${input.name}" picks from resource "${input.resource}", which the app does not have`] : [])
 	].map((error) => `action "${name}": ${error}`);

package/dist/index.js

@@ -19,8 +19,8 @@ import { consoleAuditQueue } from "./audit/console-queue.js";
 import { webauthnPath } from "./better-auth/origins.js";
 import { readOperatorSettings } from "./better-auth/operator-provider.js";
 import { parseRoles } from "./better-auth/parse-roles.js";
-import { defaultSignInPolicy, signInPolicyMethods } from "./better-auth/sign-in-policy.js";
 import { readPlatformSignIn } from "./better-auth/platform-sign-in.js";
+import { defaultSignInPolicy, signInPolicyMethods } from "./better-auth/sign-in-policy.js";
 import { createAuth, normalizeRoles } from "./better-auth/create-auth.js";
 import { addAppRoleToOwners, addMember, createOrganization, listOrganizations, removeMember, setMemberRoles } from "./better-auth/organizations/host.js";
 import { createUser, deleteUser, hasUsers, listUsers, roleChoices, setUserBanned, setUserRole } from "./better-auth/users.js";

package/dist/view-related.js

@@ -46,6 +46,16 @@ const openErrors = (item, models) => {
 	if (!far) return [`open: unknown resource "${field.relation.resource}"`];
 	return far.primaryKey.length === 1 ? [] : [`open: ${far.name} has a composite key, so its records cannot be opened from "${item.open}"`];
 };
+/** What is wrong with matching `field` of the listed records against the `from` field of the owner's record. */
+const fromErrors = (item, from, owner, target) => {
+	if (item.through) return ["from and through cannot be combined"];
+	const source = Object.hasOwn(owner.fields, from) ? owner.fields[from] : void 0;
+	if (!source) return [`from: unknown field "${from}" on ${owner.name}`];
+	if (source.sensitive) return [`from: "${from}" on ${owner.name} is sensitive`];
+	const match = Object.hasOwn(target.fields, item.field) ? target.fields[item.field] : void 0;
+	if (!match) return [];
+	return source.type === match.type && source.relation?.resource === match.relation?.resource ? [] : [`from: "${from}" on ${owner.name} and "${item.field}" on ${target.name} do not hold the same kind of value`];
+};
 /**
 * What is wrong with a related section on the record page of `resource`, against these models; empty when it can be
 * shown. Against the full models it checks the config; against a caller's models, whether that caller can use it.
@@ -56,7 +66,7 @@ const relatedErrors = (item, resource, models) => {
 	if (!owner || !target) return [`unknown resource "${owner ? item.resource : resource}"`];
 	if (owner.primaryKey.length !== 1) return [`${resource} has a composite key, so a related section cannot match it`];
 	return [
-		...item.through ? [...throughErrors(item.through, resource, models), ...matchErrors(target, item.field)] : matchErrors(target, item.field, resource),
+		...item.from !== void 0 ? [...matchErrors(target, item.field), ...fromErrors(item, item.from, owner, target)] : item.through ? [...throughErrors(item.through, resource, models), ...matchErrors(target, item.field)] : matchErrors(target, item.field, resource),
 		...filterErrors(target, item.filter).map((error) => `filter: ${error}`),
 		...sortErrors(target, item.sort).map((error) => `sort: ${error}`),
 		...(item.columns ?? []).flatMap((column) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -31,9 +31,9 @@
   "dependencies": {
     "@better-auth/passkey": "^1.7.7",
     "@better-auth/sso": "^1.7.7",
-    "@protobase/layout": "0.22.0",
-    "@protobase/query": "0.22.0",
-    "@protobase/schema": "0.22.0",
+    "@protobase/layout": "0.22.2",
+    "@protobase/query": "0.22.2",
+    "@protobase/schema": "0.22.2",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",