@protobase/server 0.66.11 → 0.66.12

package/dist/changes/capture-plan.js

@@ -35,7 +35,8 @@ const capturePlan = (schema, models, state) => {
 	const drop = state.triggers.filter((found) => found.function === capture?.oid).filter((found) => !wanted.some(({ trigger, table }) => table === found.table && trigger.name === found.name));
 	return {
 		setup: captured.length > 0 && (!state.outbox || !current),
-		history: models.some((model) => model.history) && !state.history,
+		history: models.some((model) => model.history) && (!state.history || !state.historyIndexed),
+		historyMissing: models.some((model) => model.history) && !state.history,
 		notices: models.some((model) => model.live) && !state.notices,
 		create: create.map(({ model, trigger }) => ({
 			model,
@@ -65,7 +66,7 @@ const planSql = (schema, plan) => {
 /** The resources whose changes would not be captured or kept as the config declares: what a server refuses to start with. */
 const uncaptured = (plan, models) => [...new Set([
 	...plan.setup ? models.filter(isCaptured) : plan.create.map(({ model }) => model),
-	...plan.history ? models.filter((model) => model.history) : [],
+	...plan.historyMissing ? models.filter((model) => model.history) : [],
 	...plan.notices ? models.filter((model) => model.live) : []
 ].map((model) => model.name))];
 //#endregion

package/dist/changes/capture-schema.js

@@ -25,9 +25,12 @@ const readCaptureState = async (db, schema, models) => {
       t.tgfoid::text as "function", t.tgtype::int as type, encode(t.tgargs, 'hex') as args
       from pg_trigger t join pg_class c on c.oid = t.tgrelid join pg_namespace ns on ns.oid = c.relnamespace
       where not t.tgisinternal and (t.tgfoid::text = ${capture?.oid ?? ""} or t.tgrelid::text = any(${oids}::text[]))`);
+	const outbox = await exists("outbox");
+	const history = await exists("history");
 	return {
-		outbox: await exists("outbox"),
-		history: await exists("history") && await hasIndexes(db, schema, "history", historyIndexes.map(([name]) => name)),
+		outbox,
+		history,
+		historyIndexed: 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

@@ -6,6 +6,9 @@ import { Db } from "@protobase/query";
  * 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. */
+/**
+ * Refuses to go on while a resource has `.comments()` and the database lacks their table; the project's migrations add
+ * it. An index added since only speeds reads up, so a table without it still serves and `protobase migration` adds it.
+ */
 export declare const checkComments: (db: Db, models: readonly ResourceModel[]) => Promise<void>;
 //#endregion

package/dist/comments/comments-sql.js

@@ -27,20 +27,23 @@ const commentsTableSql = () => `create table if not exists ${commentsTable} (
   "created_at" timestamptz not null default now()
 );
 ${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));
+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, 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;
+	if (await hasCommentsTable(db) && await hasIndexes(db, "comments", "comments", commentsIndexes.map(([name]) => name))) return void 0;
 	return `create schema if not exists "comments";\n\n${commentsTableSql()};`;
 };
-/** Refuses to go on while a resource has `.comments()` and the database lacks their table; the project's migrations add it. */
+/**
+* Refuses to go on while a resource has `.comments()` and the database lacks their table; the project's migrations add
+* it. An index added since only speeds reads up, so a table without it still serves and `protobase migration` adds it.
+*/
 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 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.`);
+	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.`);
 };
 //#endregion
 export { checkComments, commentsMigration, commentsTable, commentsTableSql };

package/dist/package.js

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

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

@@ -2,6 +2,11 @@ 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 2`;
+/** The version a function's comment names, `undefined` when it is not one Protobase wrote. */
+const commentVersion = (comment) => {
+	const match = comment?.match(/^Protobase webhooks (\d+)$/);
+	return match ? Number(match[1]) : void 0;
+};
 /** 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. */
@@ -137,4 +142,4 @@ 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, deliveryLogIndexesSql, deliveryLogSql, sendTestJob, subscriptionsIndexesSql, subscriptionsSql, webhooksComment };
+export { commandsSql, commentVersion, deliveriesSql, deliveryJobs, deliveryLogIndexesSql, deliveryLogSql, sendTestJob, subscriptionsIndexesSql, subscriptionsSql, webhooksComment };

package/dist/webhooks/table/schema.d.ts

@@ -8,6 +8,9 @@ import { Db } from "@protobase/query";
  * deliveries view reads. Tables are never dropped.
  */
 export declare const webhooksMigration: (db: Db, options?: WebhooksOptions, events?: EventsOptions) => Promise<string | undefined>;
-/** Refuses to go on while the `webhooks` schema lacks what `webhooks` needs; the project's migrations add it. */
+/**
+ * Refuses to go on while the `webhooks` schema lacks what `webhooks` needs; the project's migrations add it. A schema
+ * written by an earlier version this one still serves on starts, and `protobase migration` brings it current.
+ */
 export declare const checkWebhooksSchema: (db: Db, options?: WebhooksOptions) => Promise<void>;
 //#endregion

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, deliveryLogIndexesSql, deliveryLogSql, subscriptionsIndexesSql, subscriptionsSql, webhooksComment } from "./schema-sql.js";
+import { commandsSql, commentVersion, deliveriesSql, deliveryLogIndexesSql, deliveryLogSql, subscriptionsIndexesSql, subscriptionsSql } from "./schema-sql.js";
 import { sql } from "kysely";
 //#region src/webhooks/table/schema.ts
 const functionNames = ["subscription_commands", "deliveries_resend"];
@@ -10,9 +10,12 @@ const readWebhooksSchema = async (db, schema) => {
 	const exists = async (table) => (await sql`select to_regclass(${`${quoteIdent(schema)}.${quoteIdent(table)}`}) is not null as found`.execute(db)).rows[0].found;
 	const { rows } = await sql`select p.proname as name, obj_description(p.oid, 'pg_proc') as comment
     from pg_proc p join pg_namespace n on n.oid = p.pronamespace where n.nspname = ${schema} and p.proname = any(${functionNames}::text[]) order by p.proname`.execute(db);
+	const versions = functionNames.map((name) => commentVersion(rows.find((row) => row.name === name)?.comment ?? null));
+	const version = await exists("deliveries") && versions.every((found) => found !== void 0) ? Math.min(...versions) : void 0;
 	return {
 		subscriptions: await exists("subscriptions"),
-		current: functionNames.every((name) => rows.some((row) => row.name === name && row.comment === webhooksComment)) && await exists("deliveries"),
+		current: version === 2,
+		served: version !== void 0 && version >= 1,
 		deliveryLog: await exists("delivery_log")
 	};
 };
@@ -39,11 +42,14 @@ const webhooksMigration = async (db, options = {}, events) => {
 		...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. */
+/**
+* Refuses to go on while the `webhooks` schema lacks what `webhooks` needs; the project's migrations add it. A schema
+* written by an earlier version this one still serves on starts, and `protobase migration` brings it current.
+*/
 const checkWebhooksSchema = async (db, options = {}) => {
 	const schema = webhooksSchema(options);
 	const found = await readWebhooksSchema(db, schema);
-	if (found.subscriptions && found.current && (!options.deliveryLog || found.deliveryLog)) return;
+	if (found.subscriptions && found.served && (!options.deliveryLog || found.deliveryLog)) return;
 	throw new Error(`The ${schema} schema is missing or behind this version of Protobase. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.66.11",
+  "version": "0.66.12",
   "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.11",
-    "@protobase/query": "0.66.11",
-    "@protobase/schema": "0.66.11",
+    "@protobase/layout": "0.66.12",
+    "@protobase/query": "0.66.12",
+    "@protobase/schema": "0.66.12",
     "@react-email/render": "^2.1.0",
     "@react-pdf/primitives": "^4.4.0",
     "@react-pdf/renderer": "^4.9.0",