@protobase/server 0.66.6 → 0.66.8

package/dist/changes/capture-schema.js

@@ -1,6 +1,8 @@
 import { isCaptured, quoteIdent, tableSql } from "./capture-sql.js";
+import { historyIndexes } from "../history/history-sql.js";
 import { capturePlan, planSql, uncaptured } from "./capture-plan.js";
 import { changesSchema } from "./events-options.js";
+import { hasIndexes } from "../has-indexes.js";
 import { sql } from "kysely";
 //#region src/changes/capture-schema.ts
 /** The command that writes what the config needs as a migration file of the project. */
@@ -25,7 +27,7 @@ const readCaptureState = async (db, schema, models) => {
       where not t.tgisinternal and (t.tgfoid::text = ${capture?.oid ?? ""} or t.tgrelid::text = any(${oids}::text[]))`);
 	return {
 		outbox: await exists("outbox"),
-		history: await exists("history"),
+		history: await exists("history") && await hasIndexes(db, schema, "history", historyIndexes.map(([name]) => name)),
 		notices: await exists("notices"),
 		...capture && { capture },
 		triggers: triggers.map((trigger) => ({

package/dist/comments/comments-sql.d.ts

@@ -1,7 +1,10 @@
 import { ResourceModel } from "@protobase/schema";
 import { Db } from "@protobase/query";
 //#region src/comments/comments-sql.d.ts
-/** The SQL that adds the `comments` schema and its table, `undefined` when it is there. The table is never dropped. */
+/**
+ * The SQL that adds the `comments` schema and its table, or the indexes it lacks, `undefined` when it has them all. The
+ * table is never dropped.
+ */
 export declare const commentsMigration: (db: Db) => Promise<string | undefined>;
 /** Refuses to go on while a resource has `.comments()` and the database lacks their table; the project's migrations add it. */
 export declare const checkComments: (db: Db, models: readonly ResourceModel[]) => Promise<void>;

package/dist/comments/comments-sql.js

@@ -1,8 +1,17 @@
+import { hasIndexes } from "../has-indexes.js";
 import { migrationCommand } from "../changes/capture-schema.js";
 import { sql } from "kysely";
 //#region src/comments/comments-sql.ts
 /** The table the comments of every resource with `.comments()` are kept in, in a schema of its own. */
 const commentsTable = "\"comments\".\"comments\"";
+/** An index for each read of the comments: the record pages', the admin list's filters, by name. */
+const commentsIndexes = [
+	["comments_record", "\"resource\", \"record_key\", \"id\""],
+	["comments_tenant", "\"tenant_id\", \"id\""],
+	["comments_author", "\"author_id\", \"id\""],
+	["comments_created_at", "\"created_at\""],
+	["comments_record_key", "\"record_key\""]
+];
 /**
 * A row per comment: the record it is on by resource and encoded key, its tenant, its author and the user ids it
 * mentions (`[]` for none). Every column the admin list filters on has an index.
@@ -17,12 +26,12 @@ const commentsTableSql = () => `create table if not exists ${commentsTable} (
   "mentions" jsonb not null,
   "created_at" timestamptz not null default now()
 );
-create index if not exists "comments_record" on ${commentsTable} ("resource", "record_key", "id");
-create index if not exists "comments_tenant" on ${commentsTable} ("tenant_id", "id");
-create index if not exists "comments_author" on ${commentsTable} ("author_id", "id");
-create index if not exists "comments_created_at" on ${commentsTable} ("created_at")`;
-const hasCommentsTable = async (db) => (await sql`select to_regclass('comments.comments') is not null as found`.execute(db)).rows[0].found;
-/** The SQL that adds the `comments` schema and its table, `undefined` when it is there. The table is never dropped. */
+${commentsIndexes.map(([name, columns]) => `create index if not exists "${name}" on ${commentsTable} (${columns})`).join(";\n")}`;
+const hasCommentsTable = async (db) => (await sql`select to_regclass('comments.comments') is not null as found`.execute(db)).rows[0].found && await hasIndexes(db, "comments", "comments", commentsIndexes.map(([name]) => name));
+/**
+* The SQL that adds the `comments` schema and its table, or the indexes it lacks, `undefined` when it has them all. The
+* table is never dropped.
+*/
 const commentsMigration = async (db) => {
 	if (await hasCommentsTable(db)) return void 0;
 	return `create schema if not exists "comments";\n\n${commentsTableSql()};`;
@@ -31,7 +40,7 @@ const commentsMigration = async (db) => {
 const checkComments = async (db, models) => {
 	if (!models.some((model) => model.comments)) return;
 	if (await hasCommentsTable(db)) return;
-	throw new Error(`The comments schema is missing, and resources with .comments() keep their comments in comments.comments. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+	throw new Error(`The comments schema is missing or behind this version of Protobase, and resources with .comments() keep their comments in comments.comments. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
 };
 //#endregion
 export { checkComments, commentsMigration, commentsTable, commentsTableSql };

package/dist/comments/record-comments.js

@@ -15,7 +15,7 @@ const commentsResource = ({ tenant }) => {
 		author_id: f.text().readOnly().filterable(),
 		body: f.text().readOnly(),
 		mentions: f.json().readOnly(),
-		created_at: f.timestamp().readOnly().filterable()
+		created_at: f.timestamp().readOnly().dbDefault().filterable()
 	}).primaryKey((r) => r.id).access({
 		list: admins,
 		read: admins,

package/dist/config-exports.d.ts

@@ -1,2 +1,4 @@
 import { configExports } from "./resource-source.js";
-export { configExports };
+import { builtInResources } from "./built-in-resources.js";
+import { webhooksModule } from "./webhooks/table/webhooks-module.js";
+export { builtInResources, configExports, webhooksModule };

package/dist/config-exports.js

@@ -1,2 +1,4 @@
+import { builtInResources } from "./built-in-resources.js";
 import { configExports } from "./resource-source.js";
-export { configExports };
+import { webhooksModule } from "./webhooks/table/webhooks-module.js";
+export { builtInResources, configExports, webhooksModule };

package/dist/create-admin.js

@@ -50,8 +50,6 @@ import { appOrigin } from "./comments/app-origin.js";
 import { betterAuthActorNames } from "./history/actor-names.js";
 import { betterAuthCommentUsers } from "./comments/comment-users.js";
 import { mentionJob } from "./comments/mention-job.js";
-import { commentsResource, commentsView } from "./comments/record-comments.js";
-import { activityResource, activityView } from "./history/activity.js";
 import { historyDays } from "./history/options.js";
 import { pruneHistoryJob } from "./history/prune-history.js";
 import { callerRecords } from "./functions/records.js";
@@ -113,7 +111,7 @@ import { mcpIcons } from "./web-app/mcp-icons.js";
 import { recordRoutes } from "./routes/record.js";
 import { firstAdminUrl } from "./better-auth/first-admin-url.js";
 import { createScanGuard } from "./scan-guard.js";
-import { failedJobs, failedJobsView } from "./jobs/failed-jobs.js";
+import { builtInResources } from "./built-in-resources.js";
 import { Hono } from "hono";
 import { accountPage, accountPageName, checkPages, settingsResources, withSettingsFields } from "@protobase/layout";
 import { guestCallsPath, ringsPath, statusPath } from "@protobase/schema/internal";
@@ -129,22 +127,17 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	const appModels = appResources.map((resource) => resource.toModel());
 	const withComments = appModels.some((model) => model.comments);
 	const withAiFields = hasAiFields(appModels);
-	const withJobs = jobs.length > 0 || appModels.some(isCaptured) || withComments || withAiFields || notifications !== void 0;
 	const withHistory = appModels.some((model) => model.history);
 	const changes = changesSchema(events);
 	const days = historyDays(historyOptions);
-	const resources = [
-		...appResources,
-		...withJobs ? [failedJobs] : [],
-		...withHistory ? [activityResource(changes, { tenant: appModels.some((model) => model.history && model.tenant) })] : [],
-		...withComments ? [commentsResource({ tenant: appModels.some((model) => model.comments && model.tenant) })] : []
-	];
-	const views = [
-		...appViews,
-		...withJobs ? [failedJobsView] : [],
-		...withHistory ? [activityView] : [],
-		...withComments ? [commentsView] : []
-	];
+	const builtIn = builtInResources({
+		models: appModels,
+		jobs: jobs.length > 0,
+		notifications: notifications !== void 0,
+		...events && { events }
+	});
+	const resources = [...appResources, ...builtIn.resources];
+	const views = [...appViews, ...builtIn.views];
 	const commentUsers = withComments ? givenCommentUsers ?? (auth && betterAuthCommentUsers(auth)) : void 0;
 	const mentions = withComments ? mentionJob(commentUsers, shownAppName(auth, globalThis.process?.env ?? {})) : void 0;
 	const registry = buildRegistry(resources);

package/dist/gotrue/user-routes.js

@@ -24,9 +24,10 @@ const logoutScopes = [
 /**
 * The signed-in user's own endpoints, with their access token: `GET /user`, `PUT /user` for a new password or metadata,
 * and `POST /logout`. A token whose session has ended, by signing out or a ban, is GoTrue's `session_not_found`.
-* With MCP on, signing out everywhere or the other sessions, and setting a password, disconnect the user's MCP clients,
-* as the same steps do through Better Auth: GoTrue has no way to tell a password reset from a change, so every new
-* password does.
+* With MCP on, signing out everywhere or the other sessions disconnects the user's MCP clients, as the same steps do
+* through Better Auth. A new password signs out the other sessions, with the MCP clients, and mails the owner, as a
+* change through Better Auth does: GoTrue has no way to tell a password reset or a first password from a change, so
+* every new password does.
 */
 const userRoutes = ({ auth, context }) => {
 	const claimsOf = accessClaimsOf(goTrueTokens({ auth }));
@@ -85,7 +86,8 @@ const userRoutes = ({ auth, context }) => {
 				accountId: user.id,
 				password: hash
 			});
-			if (auth.mcp) await revokeMcpGrants(ctx.adapter, user.id);
+			await signOut(found.claims, "others");
+			await auth.api.passwordChanged({ body: { email: user.email } });
 		}
 		const merged = data && Object.fromEntries(Object.entries({
 			...userMetadata(user.metadata),

package/dist/has-indexes.js

@@ -0,0 +1,9 @@
+import { sql } from "kysely";
+//#region src/has-indexes.ts
+/** Whether the table `schema`.`table` has an index of each name in `names`. Only reads the catalogue. */
+const hasIndexes = async (db, schema, table, names) => {
+	const { rows } = await sql`select indexname as name from pg_indexes where schemaname = ${schema} and tablename = ${table}`.execute(db);
+	return names.every((name) => rows.some((row) => row.name === name));
+};
+//#endregion
+export { hasIndexes };

package/dist/history/history-sql.js

@@ -6,6 +6,17 @@ import { quoteIdent } from "../changes/capture-sql.js";
 * ones included. `actor_id` and `actor_roles` are the API's caller, `null` for a write from elsewhere; `database_role`
 * is the role that wrote, `null` for a change captured before Protobase kept it.
 */
+/** An index for each read the record pages and the Activity list take, by name, so a migration can add the ones a table lacks. */
+const historyIndexes = [
+	["history_record", "\"resource\", \"record_key\", \"id\""],
+	["history_tenant", "\"tenant_id\", \"id\""],
+	["history_at", "\"at\""],
+	["history_record_key", "\"record_key\""],
+	["history_operation", "\"operation\""],
+	["history_actor", "\"actor_id\""],
+	["history_database_role", "\"database_role\""],
+	["history_transaction", "\"transaction\""]
+];
 const historyTableSql = (schema) => {
 	const table = `${quoteIdent(schema)}."history"`;
 	return `create table if not exists ${table} (
@@ -23,9 +34,7 @@ const historyTableSql = (schema) => {
   "transaction" bigint not null,
   "at" timestamptz not null
 );
-create index if not exists "history_record" on ${table} ("resource", "record_key", "id");
-create index if not exists "history_tenant" on ${table} ("tenant_id", "id");
-create index if not exists "history_at" on ${table} ("at")`;
+${historyIndexes.map(([name, columns]) => `create index if not exists "${name}" on ${table} (${columns})`).join(";\n")}`;
 };
 //#endregion
-export { historyTableSql };
+export { historyIndexes, historyTableSql };

package/dist/internal.js

@@ -8,8 +8,8 @@ import { appPool, longQueryPool } from "./app-pool.js";
 import { betterAuthAuthenticator } from "./better-auth/authenticator.js";
 import { fileProviderOf } from "./files/provider-settings.js";
 import { declaredJob } from "./jobs/declared-job.js";
+import { webhooksModule } from "./webhooks/table/webhooks-module.js";
 import { appAuthOptions, buildAppAuth } from "./better-auth/auth-settings.js";
 import { buildAuthenticator } from "./better-auth/authenticate-settings.js";
-import { webhooksModule } from "./webhooks/table/webhooks-module.js";
 import { checkCallsOptions } from "./calls/calls-options.js";
 export { appAuthOptions, appPool, betterAuthAuthenticator, buildAppAuth, buildAuth, buildAuthenticator, checkCallsOptions, checkNotificationsOptions, checkStatusOptions, createAuth, declaredJob, fileProviderOf, isSubscription, loadAuthPlugins, localFiles, longQueryPool, s3Files, webhooksModule };

package/dist/mcp/mcp-input-schemas.js

@@ -0,0 +1,24 @@
+import { fromJsonSchema } from "@modelcontextprotocol/server";
+//#region src/mcp/mcp-input-schemas.ts
+/**
+* Turns a tool's parameters object into its MCP input schema, keeping the last `limit` it turned, least recently used
+* dropped first. The SDK compiles each schema object it is given into a cache that never lets go, so a server built per
+* request from the same tools gets the same input schema and adds nothing to it.
+*/
+const inputSchemaMemo = (limit) => {
+	const schemas = /* @__PURE__ */ new Map();
+	return (parameters) => {
+		const known = schemas.get(parameters);
+		if (known) {
+			schemas.delete(parameters);
+			schemas.set(parameters, known);
+			return known;
+		}
+		const schema = fromJsonSchema(parameters);
+		schemas.set(parameters, schema);
+		if (schemas.size > limit) schemas.delete(schemas.keys().next().value);
+		return schema;
+	};
+};
+//#endregion
+export { inputSchemaMemo };

package/dist/mcp/mcp-server.js

@@ -3,18 +3,12 @@ import { checkedTools } from "../assistant/checked-tools.js";
 import { refusalOf } from "../assistant/record-tool-args.js";
 import { ApprovalNeeded, approvalAsked, approvedUnasked, mcpApproval, writesUnasked } from "./mcp-approval.js";
 import { callHash, callScope, scopeHash } from "./mcp-call-hash.js";
+import { inputSchemaMemo } from "./mcp-input-schemas.js";
 import { mcpInstructions } from "./mcp-instructions.js";
-import { CLIENT_CAPABILITIES_META_KEY, McpServer, fromJsonSchema } from "@modelcontextprotocol/server";
+import { CLIENT_CAPABILITIES_META_KEY, McpServer } from "@modelcontextprotocol/server";
 //#region src/mcp/mcp-server.ts
 const capabilitiesOf = (envelope) => envelope?.[CLIENT_CAPABILITIES_META_KEY];
-const inputSchemas = /* @__PURE__ */ new WeakMap();
-const inputSchemaOf = (parameters) => {
-	const known = inputSchemas.get(parameters);
-	if (known) return known;
-	const schema = fromJsonSchema(parameters);
-	inputSchemas.set(parameters, schema);
-	return schema;
-};
+const inputSchemaOf = inputSchemaMemo(1e3);
 const failed = {
 	content: [{
 		type: "text",

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.66.6";
+var version = "0.66.8";
 //#endregion
 export { version };

package/dist/reveal-service.js

@@ -17,7 +17,7 @@ const revealedValue = (deps, model, field, record) => {
 	});
 };
 /** The refusal of a reveal that needs a strong sign-in more recent than the caller's, which the app answers by asking them to confirm it's them. */
-const strongSignInRequired = (minutes) => new HttpProblem(403, "strong-sign-in-required", "Forbidden", `Confirm it's you with a passkey or a second step: this needs one in the last ${minutes} minutes.`, { minutes });
+const strongSignInRequired = (minutes) => new HttpProblem(403, "strong-sign-in-required", "Forbidden", `Confirm it's you with a passkey, a second step or an emailed code: this needs one in the last ${minutes} minutes.`, { minutes });
 const requireStrongSignIn = async (session, minutes, now = /* @__PURE__ */ new Date()) => {
 	const at = session.signIn && !session.signIn.staff && !session.client ? await session.signIn.strongAt?.() : void 0;
 	if (at && now.getTime() - at.getTime() <= minutes * 6e4) return;

package/dist/webhooks/table/schema-sql.js

@@ -1,7 +1,7 @@
 import { jobsSchema } from "../../jobs/schema.js";
 import { quoteIdent } from "../../changes/capture-sql.js";
 /** The comment the schema's functions carry, which the startup check reads. */
-const webhooksComment = `Protobase webhooks 1`;
+const webhooksComment = `Protobase webhooks 2`;
 /** The delivery jobs, whose waiting and failed ones the deliveries view lists. */
 const deliveryJobs = ["webhooks.deliver", "webhooks.deliver-ordered"];
 /** The job that sends a subscription a test event. */
@@ -34,8 +34,23 @@ const subscriptionsSql = (schema, changesSchema) => `create table if not exists
   "rotate_secret" boolean not null default false,
   "send_test" boolean not null default false,
   "resend_failed" boolean not null default false
-);
-create index if not exists "subscriptions_tenant" on ${quoteIdent(schema)}."subscriptions" ("tenant_id")`;
+)`;
+/**
+* An index for each read of the subscriptions the API takes: the tenant and owner every caller's rows keep to, the
+* sorts and filter the list offers, and pg_trgm ones for its search over the name and URL.
+*/
+const subscriptionsIndexesSql = (schema) => {
+	const table = `${quoteIdent(schema)}."subscriptions"`;
+	return `create extension if not exists pg_trgm;
+create index if not exists "subscriptions_tenant" on ${table} ("tenant_id");
+create index if not exists "subscriptions_owner" on ${table} ("owner_id");
+create index if not exists "subscriptions_created_at" on ${table} ("created_at");
+create index if not exists "subscriptions_name" on ${table} ("name");
+create index if not exists "subscriptions_enabled" on ${table} ("enabled");
+create index if not exists "subscriptions_last_success_at" on ${table} ("last_success_at");
+create index if not exists "subscriptions_name_search" on ${table} using gin ("name" gin_trgm_ops);
+create index if not exists "subscriptions_url_search" on ${table} using gin ("url" gin_trgm_ops)`;
+};
 const retryJobs = (where) => `update ${jobsSchema}.job
     set state = 'retry', retry_limit = retry_limit + 1, completed_on = null,
       start_after = greatest(start_after, ${jobsSchema}.job_now()), keep_until = greatest(keep_until, ${jobsSchema}.job_now() + interval '14 days')
@@ -110,7 +125,16 @@ const deliveryLogSql = (schema) => `create table if not exists ${quoteIdent(sche
   "response" text,
   "duration_ms" integer not null,
   "at" timestamptz not null default now()
-);
-create index if not exists "delivery_log_subscription" on ${quoteIdent(schema)}."delivery_log" ("subscription_id", "at")`;
+)`;
+/** An index for each filter and sort of the delivery log the API takes. */
+const deliveryLogIndexesSql = (schema) => {
+	const table = `${quoteIdent(schema)}."delivery_log"`;
+	return `create index if not exists "delivery_log_subscription" on ${table} ("subscription_id", "at");
+create index if not exists "delivery_log_at" on ${table} ("at");
+create index if not exists "delivery_log_event_id" on ${table} ("event_id");
+create index if not exists "delivery_log_event_type" on ${table} ("event_type");
+create index if not exists "delivery_log_status" on ${table} ("status");
+create index if not exists "delivery_log_status_code" on ${table} ("status_code")`;
+};
 //#endregion
-export { commandsSql, deliveriesSql, deliveryJobs, deliveryLogSql, sendTestJob, subscriptionsSql, webhooksComment };
+export { commandsSql, deliveriesSql, deliveryJobs, deliveryLogIndexesSql, deliveryLogSql, sendTestJob, subscriptionsIndexesSql, subscriptionsSql, webhooksComment };

package/dist/webhooks/table/schema.js

@@ -2,7 +2,7 @@ import { quoteIdent } from "../../changes/capture-sql.js";
 import { changesSchema } from "../../changes/events-options.js";
 import { migrationCommand } from "../../changes/capture-schema.js";
 import { webhooksSchema } from "./options.js";
-import { commandsSql, deliveriesSql, deliveryLogSql, subscriptionsSql, webhooksComment } from "./schema-sql.js";
+import { commandsSql, deliveriesSql, deliveryLogIndexesSql, deliveryLogSql, subscriptionsIndexesSql, subscriptionsSql, webhooksComment } from "./schema-sql.js";
 import { sql } from "kysely";
 //#region src/webhooks/table/schema.ts
 const functionNames = ["subscription_commands", "deliveries_resend"];
@@ -25,12 +25,18 @@ const webhooksMigration = async (db, options = {}, events) => {
 	const schema = webhooksSchema(options);
 	const found = await readWebhooksSchema(db, schema);
 	const needsLog = Boolean(options.deliveryLog) && !found.deliveryLog;
-	if (found.subscriptions && found.current && !needsLog) return void 0;
+	const current = found.subscriptions && found.current;
+	if (current && !needsLog) return void 0;
 	return `${[
 		`create schema if not exists ${quoteIdent(schema)}`,
 		...found.subscriptions ? [] : [subscriptionsSql(schema, changesSchema(events))],
-		...found.current && found.subscriptions ? [] : [commandsSql(schema), deliveriesSql(schema)],
-		...needsLog ? [deliveryLogSql(schema)] : []
+		...current ? [] : [
+			subscriptionsIndexesSql(schema),
+			commandsSql(schema),
+			deliveriesSql(schema)
+		],
+		...needsLog ? [deliveryLogSql(schema)] : [],
+		...needsLog || !current && found.deliveryLog ? [deliveryLogIndexesSql(schema)] : []
 	].join(";\n\n")};`;
 };
 /** Refuses to go on while the `webhooks` schema lacks what `webhooks` needs; the project's migrations add it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.66.6",
+  "version": "0.66.8",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -43,9 +43,9 @@
     "@better-auth/sso": "^1.7.12",
     "@livekit/protocol": "1.53.1",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.66.6",
-    "@protobase/query": "0.66.6",
-    "@protobase/schema": "0.66.6",
+    "@protobase/layout": "0.66.8",
+    "@protobase/query": "0.66.8",
+    "@protobase/schema": "0.66.8",
     "@react-email/render": "^2.1.0",
     "@react-pdf/primitives": "^4.4.0",
     "@react-pdf/renderer": "^4.9.0",