@protobase/server 0.66.5 → 0.66.7

package/dist/better-auth/password-reset.js

@@ -5,7 +5,8 @@ const resetLinkLifetimeSeconds = 3600;
 const resetLinkLifetime = "1 hour";
 /**
 * Better Auth's own password reset, sending the link with `mail`. Resetting ends the user's sessions, so a reset
-* after a leaked password also signs out whoever used it, and `onPasswordReset` disconnects the user's MCP clients.
+* after a leaked password also signs out whoever used it, and `onPasswordReset` disconnects the user's MCP clients
+* and tells them their password changed.
 */
 const passwordResetOptions = (mail, { onPasswordReset } = {}) => ({
 	resetPasswordTokenExpiresIn: resetLinkLifetimeSeconds,

package/dist/better-auth/sign-in-mail.js

@@ -1,6 +1,9 @@
 import { sendAuthEmail } from "./auth-mail/send-auth-email.js";
-const codeLifetimeMinutes = 10;
-const codeLifetime = "10 minutes";
+import { emailCodeMinutes } from "@protobase/schema/internal";
+//#region src/better-auth/sign-in-mail.ts
+/** How long an emailed code works: in seconds for the sign-in code, and in the email's words. */
+const codeLifetimeSeconds = emailCodeMinutes * 60;
+const codeLifetime = `${emailCodeMinutes} minutes`;
 /**
 * Better Auth's email OTP plugin for signing in and changing the address: never a sign-up, codes stored hashed, sent
 * with `mail`. A new address gets its own email, with the code that moves the account to it. The plugin's other uses
@@ -8,7 +11,7 @@ const codeLifetime = "10 minutes";
 */
 const emailCodeOptions = (mail) => ({
 	disableSignUp: true,
-	expiresIn: 600,
+	expiresIn: codeLifetimeSeconds,
 	storeOTP: "hashed",
 	changeEmail: { enabled: true },
 	sendVerificationOTP: ({ email, otp, type }, ctx) => sendAuthEmail(mail, type === "change-email" ? "changeEmailCodeEmail" : "signInCodeEmail", email, {
@@ -26,7 +29,7 @@ const unusedEmailCodePaths = [
 ];
 /** The two-factor plugin's emailed code, sent with `mail`; stored hashed. */
 const twoFactorCodeOptions = (mail) => ({
-	period: codeLifetimeMinutes,
+	period: emailCodeMinutes,
 	storeOTP: "hashed",
 	sendOTP: ({ user, otp }, ctx) => sendAuthEmail(mail, "twoFactorCodeEmail", user.email, {
 		code: otp,
@@ -34,4 +37,4 @@ const twoFactorCodeOptions = (mail) => ({
 	}, ctx?.context.baseURL)
 });
 //#endregion
-export { emailCodeOptions, twoFactorCodeOptions, unusedEmailCodePaths };
+export { codeLifetime, codeLifetimeSeconds, emailCodeOptions, twoFactorCodeOptions, unusedEmailCodePaths };

package/dist/better-auth/sign-up/sign-up-code.js

@@ -1,5 +1,6 @@
+import { codeLifetimeSeconds } from "../sign-in-mail.js";
 import { APIError } from "better-auth/api";
-const signUpCodeLifetime = "10 minutes";
+//#region src/better-auth/sign-up/sign-up-code.ts
 const allowedAttempts = 3;
 const identifierOf = (email) => `sign-up-otp-${email}`;
 /** The SHA-256 of `secret`, base64: what the store keeps of a code or a ticket. */
@@ -26,7 +27,7 @@ const issueSignUpCode = async (context, email) => {
 	await context.internalAdapter.createVerificationValue({
 		identifier,
 		value: `${await hashOf(code)}:0`,
-		expiresAt: new Date(Date.now() + 6e5)
+		expiresAt: new Date(Date.now() + codeLifetimeSeconds * 1e3)
 	});
 	return code;
 };
@@ -50,4 +51,4 @@ const consumeSignUpCode = async (context, email, code) => {
 	throw invalidCode();
 };
 //#endregion
-export { consumeSignUpCode, hashOf, issueSignUpCode, signUpCodeLifetime };
+export { consumeSignUpCode, hashOf, issueSignUpCode };

package/dist/better-auth/sign-up/sign-up-plugin.js

@@ -2,8 +2,9 @@ import { effectiveSignInPolicy } from "../sign-in-policy.js";
 import { readSignInPolicy } from "../policy-store.js";
 import { checkNewAccountPassword } from "../new-account-password.js";
 import { sendAuthEmail } from "../auth-mail/send-auth-email.js";
+import { codeLifetime } from "../sign-in-mail.js";
 import { createSignedUpAccount } from "./sign-up-account.js";
-import { consumeSignUpCode, issueSignUpCode, signUpCodeLifetime } from "./sign-up-code.js";
+import { consumeSignUpCode, issueSignUpCode } from "./sign-up-code.js";
 import { consumeSignUpTicket, issueSignUpTicket } from "./sign-up-ticket.js";
 import * as z$1 from "zod";
 import { APIError, createAuthEndpoint } from "better-auth/api";
@@ -40,7 +41,7 @@ const signUpPlugin = ({ role, mail, defaultPolicy }) => ({
 			if (await adapter.count({ model: "user" }) === 0) throw noAdminYet();
 			const sending = await internalAdapter.findUserByEmail(email) ? sendAuthEmail(mail, "accountExistsEmail", email, {}, ctx.context.baseURL) : sendAuthEmail(mail, "signUpCodeEmail", email, {
 				code: await issueSignUpCode(ctx.context, email),
-				lifetime: signUpCodeLifetime
+				lifetime: codeLifetime
 			}, ctx.context.baseURL);
 			await ctx.context.runInBackgroundOrAwait(sending);
 			return ctx.json({ sent: true });

package/dist/built-in-resources.d.ts

@@ -0,0 +1,89 @@
+import { EventsOptions } from "./changes/events-options.js";
+import { ResourceModel } from "@protobase/schema";
+//#region src/built-in-resources.d.ts
+export type BuiltInInput = {
+  models: ResourceModel[];
+  /** Whether the app declares jobs of its own. */
+  jobs: boolean;
+  /** Whether the app sends notifications. */
+  notifications: boolean;
+  events?: EventsOptions;
+};
+/**
+ * The resources and views the API adds beside the app's own, by what the app uses: Failed jobs once anything runs
+ * jobs (events, history, comments, AI fields, notifications or the app's jobs), Activity with history and Comments
+ * with comments.
+ */
+export declare const builtInResources: ({ models, jobs, notifications, events }: BuiltInInput) => {
+  resources: (import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly name: import("@protobase/schema").Field<string>;
+    readonly error: import("@protobase/schema").Field<string | null>;
+    readonly attempts: import("@protobase/schema").Field<number>;
+    readonly failed_at: import("@protobase/schema").Field<string>;
+    readonly created_at: import("@protobase/schema").Field<string>;
+    readonly key: import("@protobase/schema").Field<string | null>;
+    readonly payload: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly output: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly retry: import("@protobase/schema").Field<boolean>;
+  }, import("@protobase/schema").Ref<"id", string>> | import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly resource: import("@protobase/schema").Field<string>;
+    readonly record_key: import("@protobase/schema").Field<string>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly operation: import("@protobase/schema").Field<"create" | "update" | "delete" | "undelete">;
+    readonly before: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly after: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly changed: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly actor_id: import("@protobase/schema").Field<string | null>;
+    readonly actor_roles: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly database_role: import("@protobase/schema").Field<string | null>;
+    readonly transaction: import("@protobase/schema").Field<string>;
+    readonly at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>> | import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly resource: import("@protobase/schema").Field<string>;
+    readonly record_key: import("@protobase/schema").Field<string>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly author_id: import("@protobase/schema").Field<string>;
+    readonly body: import("@protobase/schema").Field<string>;
+    readonly mentions: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly created_at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>>)[];
+  views: (import("@protobase/schema").ViewBuilder<import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly name: import("@protobase/schema").Field<string>;
+    readonly error: import("@protobase/schema").Field<string | null>;
+    readonly attempts: import("@protobase/schema").Field<number>;
+    readonly failed_at: import("@protobase/schema").Field<string>;
+    readonly created_at: import("@protobase/schema").Field<string>;
+    readonly key: import("@protobase/schema").Field<string | null>;
+    readonly payload: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly output: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly retry: import("@protobase/schema").Field<boolean>;
+  }, import("@protobase/schema").Ref<"id", string>>> | import("@protobase/schema").ViewBuilder<import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly resource: import("@protobase/schema").Field<string>;
+    readonly record_key: import("@protobase/schema").Field<string>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly operation: import("@protobase/schema").Field<"create" | "update" | "delete" | "undelete">;
+    readonly before: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly after: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly changed: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly actor_id: import("@protobase/schema").Field<string | null>;
+    readonly actor_roles: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly database_role: import("@protobase/schema").Field<string | null>;
+    readonly transaction: import("@protobase/schema").Field<string>;
+    readonly at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>>> | import("@protobase/schema").ViewBuilder<import("@protobase/schema").ResourceBuilder<{
+    readonly id: import("@protobase/schema").Field<string>;
+    readonly resource: import("@protobase/schema").Field<string>;
+    readonly record_key: import("@protobase/schema").Field<string>;
+    readonly tenant_id: import("@protobase/schema").Field<string | null>;
+    readonly author_id: import("@protobase/schema").Field<string>;
+    readonly body: import("@protobase/schema").Field<string>;
+    readonly mentions: import("@protobase/schema").Field<import("zod").JSONType>;
+    readonly created_at: import("@protobase/schema").Field<string>;
+  }, import("@protobase/schema").Ref<"id", string>>>)[];
+};
+//#endregion

package/dist/built-in-resources.js

@@ -0,0 +1,31 @@
+import { hasAiFields } from "./ai/ai-fields.js";
+import { isCaptured } from "./changes/capture-sql.js";
+import { changesSchema } from "./changes/events-options.js";
+import { commentsResource, commentsView } from "./comments/record-comments.js";
+import { activityResource, activityView } from "./history/activity.js";
+import { failedJobs, failedJobsView } from "./jobs/failed-jobs.js";
+//#region src/built-in-resources.ts
+/**
+* The resources and views the API adds beside the app's own, by what the app uses: Failed jobs once anything runs
+* jobs (events, history, comments, AI fields, notifications or the app's jobs), Activity with history and Comments
+* with comments.
+*/
+const builtInResources = ({ models, jobs, notifications, events }) => {
+	const withComments = models.some((model) => model.comments);
+	const withJobs = jobs || models.some(isCaptured) || withComments || hasAiFields(models) || notifications;
+	const withHistory = models.some((model) => model.history);
+	return {
+		resources: [
+			...withJobs ? [failedJobs] : [],
+			...withHistory ? [activityResource(changesSchema(events), { tenant: models.some((model) => model.history && model.tenant) })] : [],
+			...withComments ? [commentsResource({ tenant: models.some((model) => model.comments && model.tenant) })] : []
+		],
+		views: [
+			...withJobs ? [failedJobsView] : [],
+			...withHistory ? [activityView] : [],
+			...withComments ? [commentsView] : []
+		]
+	};
+};
+//#endregion
+export { builtInResources };

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.5";
+var version = "0.66.7";
 //#endregion
 export { version };

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.5",
+  "version": "0.66.7",
   "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.5",
-    "@protobase/query": "0.66.5",
-    "@protobase/schema": "0.66.5",
+    "@protobase/layout": "0.66.7",
+    "@protobase/query": "0.66.7",
+    "@protobase/schema": "0.66.7",
     "@react-email/render": "^2.1.0",
     "@react-pdf/primitives": "^4.4.0",
     "@react-pdf/renderer": "^4.9.0",