@protobase/server 0.23.4 → 0.23.6

package/dist/admin-options.d.ts

@@ -5,6 +5,7 @@ import { PluginOption } from "./plugins/plugin-settings.js";
 import { SourceOption } from "./sources/source-settings.js";
 import { CorsOrigins } from "./api-cors.js";
 import { AssistantOptions } from "./assistant/assistant-settings.js";
+import { LocaleOption } from "./locale/locale-option.js";
 import { RuntimeOptions } from "./runtime/runtime-settings.js";
 import { ResolveOptions, RoleLimit } from "@protobase/schema";
 //#region src/admin-options.d.ts
@@ -59,6 +60,11 @@ export type AdminOptions = {
    * with `false`, the app draws no maps.
    */
   maps?: MapOptions | false;
+  /**
+   * The language of the admin app's built-in screens and of its numbers and dates, for every user: `'en'` or `'nl'`.
+   * Unset, each user sees their browser's language when the screens come in it, and English otherwise.
+   */
+  locale?: LocaleOption;
   /**
    * The plugins the admin app loads (see `PluginOption`), before the ones the platform lists in `PROTOBASE_PLUGINS`
    * and, for those that load before sign-in, `PROTOBASE_PLUGINS_BEFORE_SIGN_IN`; `false` turns all of them off.

package/dist/changes/capture-sql.js

@@ -5,6 +5,7 @@ const quoteLiteral = (text) => `'${text.replaceAll("'", "''")}'`;
 const qualified = ({ schema, name }) => schema ? `${quoteIdent(schema)}.${quoteIdent(name)}` : quoteIdent(name);
 /** A Postgres array literal of text, every element quoted, so the same columns always give the same text. */
 const textArray = (items) => `{${items.map((item) => `"${item.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`).join(",")}}`;
+/** A name as Postgres keeps it: the whole characters within its first 63 bytes. */
 const identifier = (name) => {
 	const encoder = new TextEncoder();
 	let kept = "";
@@ -123,4 +124,4 @@ const createTriggerSql = (schema, trigger, table) => {
 	return `create trigger ${quoteIdent(trigger.name)} ${timing} on ${table} for each row${when} execute function ${quoteIdent(schema)}."capture"(${args})`;
 };
 //#endregion
-export { captureBody, captureFunctionSql, createTriggerSql, dispatchGroup, dispatchJobName, dropTriggerSql, isCaptured, outboxSql, quoteIdent, resourceTriggers, tableSql };
+export { captureBody, captureFunctionSql, createTriggerSql, dispatchGroup, dispatchJobName, dropTriggerSql, identifier, isCaptured, outboxSql, quoteIdent, resourceTriggers, tableSql };

package/dist/computed/column-sql.js

@@ -0,0 +1,10 @@
+//#region src/computed/column-sql.ts
+/** The column type of a rollup or formula field, as Postgres's `format_type` names it. */
+const columnType = (field) => {
+	if (field.type === "integer") return "integer";
+	if (field.type === "bigint") return "bigint";
+	if (field.type === "decimal" && field.decimal) return `numeric(${field.decimal.precision},${field.decimal.scale})`;
+	throw new Error(`Not implemented: a rollup or formula column of type ${field.type}`);
+};
+//#endregion
+export { columnType };

package/dist/computed/computed-plan.js

@@ -0,0 +1,81 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { columnType } from "./column-sql.js";
+import { addFormulaSql, formulaComment, isFormulaComment } from "./formula-sql.js";
+import { addRollupColumnSql, backfillSql, dropRollupFunctionSql, dropRollupTriggerSql, rollupBody, rollupFunctionName, rollupFunctionSql, rollupTriggerName, rollupTriggerSql, rollupsSchema } from "./rollup-sql.js";
+import { rollupTargets } from "./rollup-targets.js";
+//#region src/computed/computed-plan.ts
+/** Whether a resource has rollup or formula fields. */
+const hasComputed = (model) => Object.values(model.fields).some((field) => field.rollup || field.formula !== void 0);
+const fieldName = (model, field) => `${model.name}.${field.name}`;
+const formulaStatements = (model, field, table, found) => {
+	const name = `${table}.${quoteIdent(field.column)}`;
+	if (!found) return addFormulaSql(table, model, field);
+	if (!found.generated) throw new Error(`Column ${name} of formula field "${fieldName(model, field)}" is a plain column; drop or rename it in a migration, then write the formula's with \`protobase migration\``);
+	if (!isFormulaComment(found.comment)) throw new Error(`Column ${name} of formula field "${fieldName(model, field)}" is a generated column of the project's own; drop it in a migration, or remove .formula()`);
+	if (found.comment === formulaComment(model, field) && found.type === columnType(field)) return [];
+	return [`-- The formula of "${fieldName(model, field)}" changed: its column is generated again, and an index on it has to be created again\nalter table ${table} drop column ${quoteIdent(field.column)}`, ...addFormulaSql(table, model, field)];
+};
+const rollupColumnStatements = (target, found) => {
+	const name = `${target.table}.${quoteIdent(target.field.column)}`;
+	if (!found) return [addRollupColumnSql(target)];
+	if (found.generated) throw new Error(`Column ${name} of rollup field "${fieldName(target.model, target.field)}" is a generated column; drop it in a migration, then write the rollup's with \`protobase migration\``);
+	if (found.type !== columnType(target.field)) throw new Error(`Column ${name} of rollup field "${fieldName(target.model, target.field)}" is ${found.type}, not ${columnType(target.field)} as the field declares; change one of them`);
+	return [];
+};
+/**
+* Compares the database with the resources' rollup and formula fields. Fails on what it cannot change safely: a
+* missing table, a column of the project's own where one is declared, or a trigger of the same name that calls another
+* function. A changed formula's column is dropped and added again; a rollup's function, trigger and values are written
+* again when its column is new or its definition changed. Columns are never dropped otherwise.
+*/
+const computedPlan = (models, state) => {
+	const table = (model) => {
+		const found = state.tables[model.name];
+		if (!found) throw new Error(`The table of resource "${model.name}" does not exist`);
+		return found;
+	};
+	const column = (model, field) => state.columns.find((found) => found.table === table(model).oid && found.name === field.column);
+	const behind = [];
+	const formulas = [];
+	const regenerated = /* @__PURE__ */ new Set();
+	for (const model of models) for (const field of Object.values(model.fields).filter((candidate) => candidate.formula !== void 0)) {
+		const sql = formulaStatements(model, field, table(model).sql, column(model, field));
+		if (sql.length === 0) continue;
+		behind.push(fieldName(model, field));
+		if (column(model, field)) regenerated.add(fieldName(model, field));
+		formulas.push(...sql);
+	}
+	const readsRegenerated = ({ from, field }) => field.rollup.field !== void 0 && regenerated.has(`${from.name}.${field.rollup.field}`);
+	const targets = rollupTargets(models, (model) => table(model).sql);
+	const rollupColumns = [];
+	const droppedTriggers = [];
+	const rollups = [];
+	for (const target of targets) {
+		const columnSql = rollupColumnStatements(target, column(target.model, target.field));
+		const fn = state.functions.find((found) => found.name === rollupFunctionName(target));
+		const fromOid = table(target.from).oid;
+		const own = state.triggers.find((found) => found.table === fromOid && found.name === rollupTriggerName(target));
+		if (own && !state.functions.some((found) => found.oid === own.function)) throw new Error(`Table ${target.fromTable} has a trigger "${own.name}" of its own; rename it, since rollup field "${fieldName(target.model, target.field)}" needs that name`);
+		const stale = fn ? state.triggers.filter((found) => found.function === fn.oid && (found.table !== fromOid || found.name !== rollupTriggerName(target))) : [];
+		if (columnSql.length === 0 && fn !== void 0 && fn.definer && fn.source === rollupBody(target) && own?.function === fn.oid && stale.length === 0 && !readsRegenerated(target)) continue;
+		behind.push(fieldName(target.model, target.field));
+		rollupColumns.push(...columnSql);
+		droppedTriggers.push(...stale.map((found) => dropRollupTriggerSql(found.name, found.tableSql)), dropRollupTriggerSql(rollupTriggerName(target), target.fromTable));
+		rollups.push(rollupFunctionSql(target), rollupTriggerSql(target), backfillSql(target));
+	}
+	const wanted = targets.map(rollupFunctionName);
+	const dropped = state.functions.filter((found) => !wanted.includes(found.name)).map((found) => dropRollupFunctionSql(found.name));
+	return {
+		statements: [
+			...rollups.length > 0 ? [`create schema if not exists ${quoteIdent(rollupsSchema)}`] : [],
+			...dropped,
+			...droppedTriggers,
+			...rollupColumns,
+			...formulas,
+			...rollups
+		],
+		behind
+	};
+};
+//#endregion
+export { computedPlan, hasComputed };

package/dist/computed/computed-schema.d.ts

@@ -0,0 +1,15 @@
+import { ResourceModel } from "@protobase/schema";
+import { Db } from "@protobase/query";
+//#region src/computed/computed-schema.d.ts
+/**
+ * The SQL that brings the database to the resources' rollup and formula fields: their columns, and for each rollup
+ * the function and trigger that keep it, with its values set once; `undefined` when the database is current.
+ */
+export declare const computedMigration: (db: Db, models: readonly ResourceModel[]) => Promise<string | undefined>;
+/**
+ * Refuses to go on while a rollup or formula field's column, function or trigger is missing or out of date. The server
+ * never changes the schema itself: the project's migrations do, before the new version serves. Reads nothing without
+ * such fields.
+ */
+export declare const checkComputed: (db: Db, models: readonly ResourceModel[]) => Promise<void>;
+//#endregion

package/dist/computed/computed-schema.js

@@ -0,0 +1,54 @@
+import { tableSql } from "../changes/capture-sql.js";
+import { migrationCommand } from "../changes/capture-schema.js";
+import { rollupsSchema } from "./rollup-sql.js";
+import { computedPlan, hasComputed } from "./computed-plan.js";
+import { sql } from "kysely";
+//#region src/computed/computed-schema.ts
+const rowsOf = async (db, query) => (await query.execute(db)).rows;
+const involved = (models) => {
+	const computed = models.filter(hasComputed);
+	const read = new Set(computed.flatMap((model) => Object.values(model.fields).flatMap((field) => field.rollup ? [field.rollup.from] : [])));
+	return models.filter((model) => hasComputed(model) || read.has(model.name));
+};
+const readComputedState = async (db, models) => {
+	const tables = {};
+	for (const model of involved(models)) {
+		const [found] = await rowsOf(db, sql`select c.oid::text as oid, format('%I.%I', n.nspname, c.relname) as sql from pg_class c join pg_namespace n on n.oid = c.relnamespace where c.oid = to_regclass(${tableSql(model)})`);
+		tables[model.name] = found ?? null;
+	}
+	const wanted = models.filter(hasComputed).flatMap((model) => Object.values(model.fields).filter((field) => field.rollup || field.formula !== void 0).flatMap((field) => tables[model.name] ? [`${tables[model.name].oid}:${field.column}`] : []));
+	const columns = await rowsOf(db, sql`select a.attrelid::text as "table", a.attname as name, format_type(a.atttypid, a.atttypmod) as type, a.attgenerated <> '' as generated, col_description(a.attrelid, a.attnum) as comment
+      from pg_attribute a where a.attnum > 0 and not a.attisdropped and a.attrelid::text || ':' || a.attname = any(${wanted}::text[])`);
+	const functions = await rowsOf(db, sql`select p.oid::text as oid, p.proname as name, p.prosrc as source, p.prosecdef as definer from pg_proc p join pg_namespace n on n.oid = p.pronamespace where n.nspname = ${rollupsSchema}`);
+	const oids = Object.values(tables).flatMap((found) => found ? [found.oid] : []);
+	return {
+		tables,
+		columns,
+		functions,
+		triggers: await rowsOf(db, sql`select t.tgrelid::text as "table", format('%I.%I', ns.nspname, c.relname) as "tableSql", t.tgname as name, t.tgfoid::text as "function"
+      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 = any(${functions.map((found) => found.oid)}::text[]) or t.tgrelid::text = any(${oids}::text[]))`)
+	};
+};
+const plan = async (db, models) => computedPlan(models, await readComputedState(db, models));
+/**
+* The SQL that brings the database to the resources' rollup and formula fields: their columns, and for each rollup
+* the function and trigger that keep it, with its values set once; `undefined` when the database is current.
+*/
+const computedMigration = async (db, models) => {
+	const { statements } = await plan(db, models);
+	return statements.length === 0 ? void 0 : `${statements.join(";\n\n")};`;
+};
+/**
+* Refuses to go on while a rollup or formula field's column, function or trigger is missing or out of date. The server
+* never changes the schema itself: the project's migrations do, before the new version serves. Reads nothing without
+* such fields.
+*/
+const checkComputed = async (db, models) => {
+	if (!models.some(hasComputed)) return;
+	const { behind } = await plan(db, models);
+	if (behind.length === 0) return;
+	throw new Error(`The rollup and formula fields ${behind.join(", ")} are not kept by the database as declared: their columns, functions or triggers are missing or out of date. Write the change as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+};
+//#endregion
+export { checkComputed, computedMigration };

package/dist/computed/formula-sql.js

@@ -0,0 +1,22 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { columnType } from "./column-sql.js";
+import { parseFormula } from "@protobase/schema/internal";
+//#region src/computed/formula-sql.ts
+const expressionSql = (node, model) => {
+	if (node.kind === "number") return `${node.value}::numeric`;
+	if (node.kind === "field") return `${quoteIdent(model.fields[node.name].column)}::numeric`;
+	if (node.kind === "negate") return `(- ${expressionSql(node.operand, model)})`;
+	if (node.kind === "binary") return `(${expressionSql(node.left, model)} ${node.op} ${expressionSql(node.right, model)})`;
+	if (node.kind === "coalesce") return `coalesce(${node.args.map((arg) => expressionSql(arg, model)).join(", ")})`;
+	return `round(${expressionSql(node.value, model)}${node.digits === void 0 ? "" : `, ${node.digits}`})`;
+};
+/** A formula field's generation expression, cast to its column's type. */
+const formulaSql = (model, field) => `(${expressionSql(parseFormula(field.formula), model)})::${columnType(field)}`;
+/** The comment that marks a formula's column as Protobase's, with the expression it was generated from. */
+const formulaComment = (model, field) => `protobase formula: ${formulaSql(model, field)}`;
+/** Whether a column's comment marks it as a formula's column. */
+const isFormulaComment = (comment) => comment?.startsWith("protobase formula: ") ?? false;
+/** The statements that add a formula's generated column to `table` and mark it. */
+const addFormulaSql = (table, model, field) => [`alter table ${table} add column ${quoteIdent(field.column)} ${columnType(field)} generated always as (${formulaSql(model, field)}) stored`, `comment on column ${table}.${quoteIdent(field.column)} is '${formulaComment(model, field).replaceAll("'", "''")}'`];
+//#endregion
+export { addFormulaSql, formulaComment, formulaSql, isFormulaComment };

package/dist/computed/rollup-sql.js

@@ -0,0 +1,64 @@
+import { identifier, quoteIdent } from "../changes/capture-sql.js";
+import { columnType } from "./column-sql.js";
+//#region src/computed/rollup-sql.ts
+/** The schema of the functions that keep rollups. */
+const rollupsSchema = "rollups";
+/** The function that keeps one rollup, named for its resource's table and column. */
+const rollupFunctionName = ({ model, field }) => identifier([
+	model.table.schema,
+	model.table.name,
+	field.column
+].filter(Boolean).join("_"));
+/** The trigger on `from`'s table that calls it. */
+const rollupTriggerName = (target) => identifier(`${rollupFunctionName(target)}_rollup`);
+const functionSql = (target) => `${quoteIdent(rollupsSchema)}.${quoteIdent(rollupFunctionName(target))}`;
+const viaColumn = ({ from, field }) => quoteIdent(from.fields[field.rollup.via].column);
+const keyColumn = ({ model }) => quoteIdent(model.fields[model.primaryKey[0]].column);
+const aggregateSql = ({ from, field }) => {
+	const { fn, field: name } = field.rollup;
+	const value = name === void 0 ? "*" : `c.${quoteIdent(from.fields[name].column)}`;
+	if (fn === "count") return `count(${value})`;
+	if (fn === "sum") return `coalesce(sum(${value}), 0)`;
+	return `${fn}(${value})`;
+};
+const liveRecords = ({ from }) => from.softDelete ? ` and c.${quoteIdent(from.fields[from.softDelete].column)} is null` : "";
+const refreshSql = (target, where) => `update ${target.table} as p set ${quoteIdent(target.field.column)} = (select ${aggregateSql(target)} from ${target.fromTable} as c where c.${viaColumn(target)} = p.${keyColumn(target)}${liveRecords(target)}) where ${where}`;
+/**
+* The body of a rollup's function: after a record of `from` is written, it sets the rollup of the record it points at,
+* and of the one it pointed at before when the write moved it.
+*/
+const rollupBody = (target) => {
+	const via = viaColumn(target);
+	const key = keyColumn(target);
+	return `
+begin
+  if TG_OP <> 'INSERT' then
+    ${refreshSql(target, `p.${key} = OLD.${via}`)};
+  end if;
+  if TG_OP = 'INSERT' or (TG_OP = 'UPDATE' and NEW.${via} is distinct from OLD.${via}) then
+    ${refreshSql(target, `p.${key} = NEW.${via}`)};
+  end if;
+  return null;
+end
+`;
+};
+/**
+* The function runs as its owner, with a fixed search path and the tables qualified: a writer of `from` needs no rights
+* on the rollup's table.
+*/
+const rollupFunctionSql = (target) => `create or replace function ${functionSql(target)}() returns trigger language plpgsql security definer set search_path = pg_catalog, pg_temp as $rollup$${rollupBody(target)}$rollup$`;
+const readColumns = ({ from, field }) => [
+	field.rollup.via,
+	field.rollup.field,
+	from.softDelete
+].filter((name) => name !== void 0).map((name) => quoteIdent(from.fields[name].column));
+/** A rollup's trigger: after inserts, deletes and updates of the columns it reads, for each row. */
+const rollupTriggerSql = (target) => `create trigger ${quoteIdent(rollupTriggerName(target))} after insert or delete or update of ${readColumns(target).join(", ")} on ${target.fromTable} for each row execute function ${functionSql(target)}()`;
+const dropRollupTriggerSql = (name, table) => `drop trigger if exists ${quoteIdent(name)} on ${table}`;
+const dropRollupFunctionSql = (name) => `drop function if exists ${quoteIdent(rollupsSchema)}.${quoteIdent(name)}() cascade`;
+/** Sets every record's rollup from what `from` has now. */
+const backfillSql = (target) => refreshSql(target, "true");
+/** The statement that adds the rollup's column, empty until the backfill sets it. */
+const addRollupColumnSql = ({ table, field }) => `alter table ${table} add column ${quoteIdent(field.column)} ${columnType(field)}`;
+//#endregion
+export { addRollupColumnSql, backfillSql, dropRollupFunctionSql, dropRollupTriggerSql, rollupBody, rollupFunctionName, rollupFunctionSql, rollupTriggerName, rollupTriggerSql, rollupsSchema };

package/dist/computed/rollup-targets.js

@@ -0,0 +1,43 @@
+//#region src/computed/rollup-targets.ts
+const numberTypes = [
+	"integer",
+	"bigint",
+	"decimal"
+];
+const targetProblems = (model, field, from) => {
+	const { from: name, via, field: read } = field.rollup;
+	if (!from) return [`rolls up "${name}", which is not a resource`];
+	if (from.table.name === model.table.name && from.table.schema === model.table.schema) return [`rolls up "${name}", whose table is its own (not implemented)`];
+	const relation = Object.hasOwn(from.fields, via) ? from.fields[via] : void 0;
+	const value = read !== void 0 && Object.hasOwn(from.fields, read) ? from.fields[read] : void 0;
+	return [
+		...model.primaryKey.length === 1 ? [] : ["is on a resource with a key of several columns (not implemented)"],
+		...!relation ? [`is via "${via}", which is not a field of "${name}"`] : [],
+		...relation && relation.relation?.resource !== model.name ? [`is via "${via}", which is no relation of "${name}" to "${model.name}"`] : [],
+		...relation?.relation && relation.relation.columns.length !== 1 ? [`is via "${via}", a relation of several columns (not implemented)`] : [],
+		...read !== void 0 && !value ? [`reads "${read}", which is not a field of "${name}"`] : [],
+		...value?.sensitive ? [`reads "${read}", which is sensitive`] : [],
+		...value && field.rollup.fn !== "count" && !numberTypes.includes(value.type) ? [`reads "${read}", which is ${value.type}, not a number`] : []
+	];
+};
+/**
+* Every rollup of the resources with its tables, as `tableSql` names a resource's; fails on a rollup whose resource,
+* relation or field is not there.
+*/
+const rollupTargets = (models, tableSql) => {
+	const byName = new Map(models.map((model) => [model.name, model]));
+	return models.flatMap((model) => Object.values(model.fields).filter((field) => field.rollup).map((field) => {
+		const from = byName.get(field.rollup.from);
+		const problems = targetProblems(model, field, from);
+		if (problems.length > 0) throw new Error(`Resource "${model.name}": ${problems.map((problem) => `rollup field "${field.name}" ${problem}`).join("; ")}`);
+		return {
+			model,
+			field,
+			from,
+			table: tableSql(model),
+			fromTable: tableSql(from)
+		};
+	}));
+};
+//#endregion
+export { rollupTargets };

package/dist/create-admin.js

@@ -42,6 +42,7 @@ import { fileRoutes } from "./files/routes.js";
 import { formRoutes } from "./forms/routes.js";
 import { createFormsRuntime } from "./forms/runtime.js";
 import { functionRoutes } from "./functions/routes.js";
+import { localeSetting } from "./locale/locale-option.js";
 import { mapSettings } from "./maps/map-settings.js";
 import { pluginOptions, pluginsBeforeSignIn } from "./plugins/plugin-settings.js";
 import { runtimeUrl } from "./runtime/runtime-settings.js";
@@ -114,6 +115,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	const runtime = runtimeUrl(options.runtime, globalThis.process?.env ?? {});
 	const errorReporting = errorReportingSettings(options.errorReporting, globalThis.process?.env ?? {});
 	const maps = mapSettings(options.maps, globalThis.process?.env ?? {});
+	const locale = localeSetting(options.locale);
 	const plugins = pluginOptions(options.plugins, globalThis.process?.env ?? {}, bundlePlugins);
 	const sources = sourceOptions(options.sources, globalThis.process?.env ?? {});
 	checkSourceNames(sources, {
@@ -156,6 +158,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		...runtime && { runtime },
 		...errorReporting && { errorReporting },
 		...maps && { maps },
+		...locale && { locale },
 		plugins,
 		sources,
 		...files && { files },

package/dist/deps.d.ts

@@ -6,5 +6,6 @@ import "./plugins/plugin-settings.js";
 import "./registry.js";
 import "./scan-guard.js";
 import { PageModel } from "@protobase/layout";
+import { Locale } from "@protobase/schema/internal";
 import { ResolveOptions, ViewModel } from "@protobase/schema";
 import { Db } from "@protobase/query";

package/dist/index.d.ts

@@ -55,6 +55,7 @@ import { IssueTokenOptions, issueToken, maxTokenTtlSeconds } from "./better-auth
 import { webauthnPath } from "./better-auth/origins.js";
 import { authSchemaMigration, checkAuthSchema } from "./better-auth/auth-schema.js";
 import { changesMigration, checkChanges, migrationCommand } from "./changes/capture-schema.js";
+import { checkComputed, computedMigration } from "./computed/computed-schema.js";
 import { isCaptured } from "./changes/capture-sql.js";
 import { CapturedRow, CoalescedChange, coalesce } from "./changes/coalesce.js";
 import { ResourceChange, recordOf, resourceChange } from "./changes/resource-change.js";
@@ -92,4 +93,4 @@ import { FatalJobError } from "./jobs/run-job.js";
 import { DrainResult, JobsRuntime, StartJobsOptions, startJobs } from "./jobs/runtime.js";
 import { jobsDrainApp } from "./jobs/drain-route.js";
 import { checkJobsSchema, jobsSchema, jobsSchemaMigration } from "./jobs/schema.js";
-export { type Admin, type AdminAuth, type AdminOptions, type ApiFunction, type ApprovalAnswer, type ApprovalRequest, type AssistantBackend, type AssistantOptions, type AssistantSettings, type AssistantTool, type AuditEvent, type AuditQueue, type Authenticator, type BetterAuthAuthenticatorOptions, type CapturedRow, type ChatMessage, type ChatTextPart, type CheckAiInput, type CleanupEntry, type CleanupReport, type CleanupSchedule, type CoalescedChange, type CommentItem, type CommentUsers, type Completion, type CompletionOptions, type Conversation, type ConversationRecord, type ConversationStore, type ConversationsOptions, type CorsOptions, type CorsOrigins, type CreateAdminInput, type CreateAuthOptions, type DrainResult, type EmailComponent, type EmailOptions, type EmailTemplate, type EnqueueOptions, type ErrorReporter, type ErrorReportingOptions, type ErrorReportingSettings, type EventData, type EventsOptions, FatalJobError, type FileCleanupInput, type FileLimits, type FileObject, type FileProvider, type FileRef, type FileStore, type FileVariantObject, type FilesOptions, type FunctionApp, type FunctionCaller, type FunctionContext, type FunctionEnv, type FunctionHandler, type FunctionOptions, type FunctionRecords, type FunctionSource, type HistoryOptions, HttpProblem, type IssueTokenOptions, type JobContext, type JobDefinition, type JobOptions, type JobsRuntime, type JwtOptions, type LinkedAccount, type ListParams, type LocalFilesOptions, type MailMessage, type Mailer, type MapLayer, type MapOptions, type MapSettings, type MemberInput, MissingCredentials, ModelError, type ModelSettings, type NewOrganization, type NewUser, type OperatorProvider, type OrganizationRole, type OrganizationsOptions, type PipelineHook, type PlatformSignIn, type PluginOption, type PluginRef, type ProjectConfig, type ProtectedFunctionOptions, type PublicFunctionContext, type PublicFunctionEnv, type PublicFunctionHandler, type PublicFunctionOptions, type QueryOptions, type QueryResult, type ReasoningDetail, type ReasoningEffort, type RecordKeyInput, type RecordPage, type RenderedEmail, type ResourceChange, type ResourceSource, type RoleDefinition, type RolesInput, type RunContext, type RuntimeOptions, type S3Bucket, type S3FilesOptions, type S3ListPage, type S3Object, type ScanGuardMode, type ScheduledDelete, type Session, type SessionOrganization, type Sharp, type SignInPolicy, type SignInRule, type SignatureOptions, type SourceOption, type SourceRef, type StaffAccessRule, type StaffSignIn, type StandardSchema, type StandardWebhookOptions, type StartJobsOptions, type StoreFileInput, type StoredMember, type StoredObject, type StoredOrganization, type StoredUser, type SubscriptionDefinition, type SubscriptionEvent, type SubscriptionOptions, type TenantValue, type ToolCall, type ToolContext, type ToolRecord, type ToolRecords, type ToolSpec, type TrustedApp, type TurnOptions, type User, type UserCreatedHook, type ViewSource, type WebhooksOptions, type WidgetOptions, type WriteEvent, type WriteOperation, addAppRoleToOwners, addMember, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaMigration, badRequest, beforeSignInPluginsVariable, betterAuthAuthenticator, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkJobsSchema, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentsMigration, configExports, consoleAuditQueue, conversationKey, createAdmin, createAuth, createConversations, createFileCleanup, createOrganization, createUser, defaultSignInPolicy, defineConfig, defineEmail, defineFunction, defineJob, defineTool, deleteUser, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, handleDroppedConnections, hasUsers, imageSize, isBackgroundWork, isCaptured, isJobDefinition, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, limitedFileStore, listOrganizations, listUsers, localFileStore, localFiles, mapSettings, mapStyleUrl, mapStyleVariable, maxTokenTtlSeconds, maxWidgetPropsBytes, mergeConfig, migrationCommand, newWebhookSecret, normalizeRoles, notFound, parseColumns, parseRoles, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, processor, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readWriteQueryTool, recordOf, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, s3Files, seesAssistant, seesRuntime, setMemberRoles, setUserBanned, setUserRole, signInPolicyMethods, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storeFile, streamChatCompletion, subscription, thumbHash, unauthorized, variantPath, verifySignature, verifyStandardWebhook, webauthnPath, webhooks, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps };
+export { type Admin, type AdminAuth, type AdminOptions, type ApiFunction, type ApprovalAnswer, type ApprovalRequest, type AssistantBackend, type AssistantOptions, type AssistantSettings, type AssistantTool, type AuditEvent, type AuditQueue, type Authenticator, type BetterAuthAuthenticatorOptions, type CapturedRow, type ChatMessage, type ChatTextPart, type CheckAiInput, type CleanupEntry, type CleanupReport, type CleanupSchedule, type CoalescedChange, type CommentItem, type CommentUsers, type Completion, type CompletionOptions, type Conversation, type ConversationRecord, type ConversationStore, type ConversationsOptions, type CorsOptions, type CorsOrigins, type CreateAdminInput, type CreateAuthOptions, type DrainResult, type EmailComponent, type EmailOptions, type EmailTemplate, type EnqueueOptions, type ErrorReporter, type ErrorReportingOptions, type ErrorReportingSettings, type EventData, type EventsOptions, FatalJobError, type FileCleanupInput, type FileLimits, type FileObject, type FileProvider, type FileRef, type FileStore, type FileVariantObject, type FilesOptions, type FunctionApp, type FunctionCaller, type FunctionContext, type FunctionEnv, type FunctionHandler, type FunctionOptions, type FunctionRecords, type FunctionSource, type HistoryOptions, HttpProblem, type IssueTokenOptions, type JobContext, type JobDefinition, type JobOptions, type JobsRuntime, type JwtOptions, type LinkedAccount, type ListParams, type LocalFilesOptions, type MailMessage, type Mailer, type MapLayer, type MapOptions, type MapSettings, type MemberInput, MissingCredentials, ModelError, type ModelSettings, type NewOrganization, type NewUser, type OperatorProvider, type OrganizationRole, type OrganizationsOptions, type PipelineHook, type PlatformSignIn, type PluginOption, type PluginRef, type ProjectConfig, type ProtectedFunctionOptions, type PublicFunctionContext, type PublicFunctionEnv, type PublicFunctionHandler, type PublicFunctionOptions, type QueryOptions, type QueryResult, type ReasoningDetail, type ReasoningEffort, type RecordKeyInput, type RecordPage, type RenderedEmail, type ResourceChange, type ResourceSource, type RoleDefinition, type RolesInput, type RunContext, type RuntimeOptions, type S3Bucket, type S3FilesOptions, type S3ListPage, type S3Object, type ScanGuardMode, type ScheduledDelete, type Session, type SessionOrganization, type Sharp, type SignInPolicy, type SignInRule, type SignatureOptions, type SourceOption, type SourceRef, type StaffAccessRule, type StaffSignIn, type StandardSchema, type StandardWebhookOptions, type StartJobsOptions, type StoreFileInput, type StoredMember, type StoredObject, type StoredOrganization, type StoredUser, type SubscriptionDefinition, type SubscriptionEvent, type SubscriptionOptions, type TenantValue, type ToolCall, type ToolContext, type ToolRecord, type ToolRecords, type ToolSpec, type TrustedApp, type TurnOptions, type User, type UserCreatedHook, type ViewSource, type WebhooksOptions, type WidgetOptions, type WriteEvent, type WriteOperation, addAppRoleToOwners, addMember, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaMigration, badRequest, beforeSignInPluginsVariable, betterAuthAuthenticator, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkComputed, checkJobsSchema, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentsMigration, computedMigration, configExports, consoleAuditQueue, conversationKey, createAdmin, createAuth, createConversations, createFileCleanup, createOrganization, createUser, defaultSignInPolicy, defineConfig, defineEmail, defineFunction, defineJob, defineTool, deleteUser, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, handleDroppedConnections, hasUsers, imageSize, isBackgroundWork, isCaptured, isJobDefinition, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, limitedFileStore, listOrganizations, listUsers, localFileStore, localFiles, mapSettings, mapStyleUrl, mapStyleVariable, maxTokenTtlSeconds, maxWidgetPropsBytes, mergeConfig, migrationCommand, newWebhookSecret, normalizeRoles, notFound, parseColumns, parseRoles, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, processor, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readWriteQueryTool, recordOf, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, s3Files, seesAssistant, seesRuntime, setMemberRoles, setUserBanned, setUserRole, signInPolicyMethods, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storeFile, streamChatCompletion, subscription, thumbHash, unauthorized, variantPath, verifySignature, verifyStandardWebhook, webauthnPath, webhooks, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps };

package/dist/index.js

@@ -54,6 +54,7 @@ import { withTrustedApps } from "./better-auth/app-tokens.js";
 import { betterAuthAuthenticator } from "./better-auth/authenticator.js";
 import { issueToken, maxTokenTtlSeconds } from "./better-auth/tokens.js";
 import { authSchemaMigration, checkAuthSchema } from "./better-auth/auth-schema.js";
+import { checkComputed, computedMigration } from "./computed/computed-schema.js";
 import { webhooks } from "./webhooks/table/plugin.js";
 import { checkWebhooksSchema, webhooksMigration } from "./webhooks/table/schema.js";
 import { checkAi } from "./ai/check-ai.js";
@@ -69,4 +70,4 @@ import { aspectRatio, fileSize, fileType, imageSize, processor } from "./files/p
 import { defineEmail } from "./mail/define-email.js";
 import { startJobs } from "./jobs/runtime.js";
 import { jobsDrainApp } from "./jobs/drain-route.js";
-export { FatalJobError, HttpProblem, MissingCredentials, ModelError, addAppRoleToOwners, addMember, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaMigration, badRequest, beforeSignInPluginsVariable, betterAuthAuthenticator, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkJobsSchema, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentsMigration, configExports, consoleAuditQueue, conversationKey, createAdmin, createAuth, createConversations, createFileCleanup, createOrganization, createUser, defaultSignInPolicy, defineConfig, defineEmail, defineFunction, defineJob, defineTool, deleteUser, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, handleDroppedConnections, hasUsers, imageSize, isBackgroundWork, isCaptured, isJobDefinition, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, limitedFileStore, listOrganizations, listUsers, localFileStore, localFiles, mapSettings, mapStyleUrl, mapStyleVariable, maxTokenTtlSeconds, maxWidgetPropsBytes, mergeConfig, migrationCommand, newWebhookSecret, normalizeRoles, notFound, parseColumns, parseRoles, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, processor, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readWriteQueryTool, recordOf, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, s3Files, seesAssistant, seesRuntime, setMemberRoles, setUserBanned, setUserRole, signInPolicyMethods, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storeFile, streamChatCompletion, subscription, thumbHash, unauthorized, variantPath, verifySignature, verifyStandardWebhook, webauthnPath, webhooks, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps };
+export { FatalJobError, HttpProblem, MissingCredentials, ModelError, addAppRoleToOwners, addMember, aspectRatio, assistantProtocolRoutes, assistantRoles, assistantSettings, assistantVariables, authSchemaMigration, badRequest, beforeSignInPluginsVariable, betterAuthAuthenticator, changesMigration, checkAi, checkAuthSchema, checkChanges, checkComments, checkComputed, checkJobsSchema, checkSourceNames, checkViewQueries, checkWebhooksSchema, coalesce, commentsMigration, computedMigration, configExports, consoleAuditQueue, conversationKey, createAdmin, createAuth, createConversations, createFileCleanup, createOrganization, createUser, defaultSignInPolicy, defineConfig, defineEmail, defineFunction, defineJob, defineTool, deleteUser, errorReportingSettings, errorReportingVariable, eventMatcher, fileConversationStore, fileSize, fileType, forbidden, formatUri, functionApp, handleDroppedConnections, hasUsers, imageSize, isBackgroundWork, isCaptured, isJobDefinition, issueToken, jobDefinitions, jobsDrainApp, jobsSchema, jobsSchemaMigration, jwtAuthenticator, limitedFileStore, listOrganizations, listUsers, localFileStore, localFiles, mapSettings, mapStyleUrl, mapStyleVariable, maxTokenTtlSeconds, maxWidgetPropsBytes, mergeConfig, migrationCommand, newWebhookSecret, normalizeRoles, notFound, parseColumns, parseRoles, pluginOptions, pluginsBeforeSignIn, pluginsFor, pluginsVariable, processor, readJson, readOnlyQueryTool, readOperatorSettings, readOutbox, readPlatformSignIn, readWriteQueryTool, recordOf, removeMember, renderVariant, requestApproval, requireEnv, resourceChange, roleChoices, runInBackground, runReadOnlyQuery, runReadWriteQuery, runTurn, runtimeUrl, runtimeVariable, s3FileStore, s3Files, seesAssistant, seesRuntime, setMemberRoles, setUserBanned, setUserRole, signInPolicyMethods, sourceOptions, sourcesFor, sourcesVariable, startErrorReporting, startJobs, storageCleanupSchedule, storeFile, streamChatCompletion, subscription, thumbHash, unauthorized, variantPath, verifySignature, verifyStandardWebhook, webauthnPath, webhooks, webhooksMigration, widget, withCacheBreakpoints, withTrustedApps };

package/dist/locale/locale-option.d.ts

@@ -0,0 +1,5 @@
+import { Locale } from "@protobase/schema/internal";
+//#region src/locale/locale-option.d.ts
+/** The language of the admin app's built-in screens, for every user; unset, each sees their browser's language. */
+export type LocaleOption = Locale;
+//#endregion

package/dist/locale/locale-option.js

@@ -0,0 +1,10 @@
+import { isLocale, locales } from "@protobase/schema/internal";
+//#region src/locale/locale-option.ts
+/** The option, checked: a language the screens do not come in stops startup. */
+const localeSetting = (option) => {
+	if (option === void 0) return void 0;
+	if (isLocale(option)) return option;
+	throw new Error(`options.locale is ${JSON.stringify(option)}: use one of ${locales.map((locale) => `'${locale}'`).join(", ")}`);
+};
+//#endregion
+export { localeSetting };

package/dist/meta.js

@@ -86,6 +86,7 @@ const createMeta = (deps, appName) => {
 			...deps.runtime && seesRuntime(session.user.roles) && { runtime: { url: deps.runtime } },
 			...deps.errorReporting && { errorReporting: deps.errorReporting },
 			...deps.maps && { maps: deps.maps },
+			...deps.locale && { locale: deps.locale },
 			...deps.files && deps.files.trustedHosts.length > 0 && { files: { trustedHosts: deps.files.trustedHosts } },
 			...plugins.length > 0 && { plugins },
 			...sources.length > 0 && { sources }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.23.4",
+  "version": "0.23.6",
   "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.23.4",
-    "@protobase/query": "0.23.4",
-    "@protobase/schema": "0.23.4",
+    "@protobase/layout": "0.23.6",
+    "@protobase/query": "0.23.6",
+    "@protobase/schema": "0.23.6",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",