pgkiln 0.38.0 → 0.40.0

package/src/builder/home.ts

@@ -296,13 +296,14 @@ export async function homeRoutes(app: FastifyInstance) {
         ${card(`${BASE}/users/directories`, icon('org'), 'LDAP directories', 'Sign in with directory accounts.')}
         ${card(`${BASE}/users#account-settings`, icon('shield'), 'Password policy', 'Length, complexity and lifetime of passwords.')}
         ${card(`${BASE}/developers`, icon('users'), 'Developers', 'Who may use this builder.')}
-        ${card(`${BASE}/sql`, icon('database'), 'SQL Workshop', 'Run SQL, browse objects and load data.')}
+        ${s.workspace?.sql_workshop === false ? '' : card(`${BASE}/sql`, icon('database'), 'SQL Workshop', 'Run SQL, browse objects and load data.')}
+        ${card(`${BASE}/backups`, icon('archive'), 'Manage backups', 'The backups of every application of this workspace; back them all up at once.')}
         ${card(`${BASE}/dashboard`, icon('activity'), 'Dashboard', 'Usage and problems across the workspace.')}
         ${(await isAdmin(s.username)) ? card(`${BASE}/instance`, icon('settings'), 'Instance settings', 'Session length, sign-in throttling and the server\'s configuration (administrators).') : ''}
         ${(await isAdmin(s.username))
           ? card(`${BASE}/workspaces`, icon('layers'), 'Workspaces', 'Groups of applications and their developers (administrators).')
           : s.workspace && (await workspaceAdmin(s.username, s.workspace.id))
-            ? card(`${BASE}/workspaces/${s.workspace.id}`, icon('layers'), `Workspace ${s.workspace.name}`, 'Its name and developers (workspace administrators).')
+            ? card(`${BASE}/workspaces/${s.workspace.id}`, icon('layers'), `Workspace ${s.workspace.name}`, 'Its name, developers, preferences and extension links (workspace administrators).')
             : ''}
         ${(await isAdmin(s.username)) ? card(`${BASE}/ai`, icon('bolt'), 'AI services', 'Claude and OpenAI for the applications: models, keys, limits and usage (administrators).') : ''}
         ${(await isAdmin(s.username)) ? card(`${BASE}/mail`, icon('send'), 'Mail services', 'SMTP, Microsoft 365, Amazon SES, Resend, Postmark, SendGrid or Mailgun for the applications\' e-mail (administrators).') : ''}

package/src/builder/region-settings.ts

@@ -55,6 +55,9 @@ const CHART_LABELS: Record<string, string> = {
   gantt: 'Gantt (task, start and end columns)',
   pyramid: 'Pyramid (one series; two series back to back)',
   polar: 'Polar area (one sector per row)',
+  range: 'Range (low and high columns: floating columns)',
+  boxplot: 'Box plot (one value per row, or min, Q1, median, Q3 and max)',
+  stock: 'Stock (open, high, low and close columns: candlesticks)',
 };
 const GAUGE_KEYS = ['min', 'max', 'warning', 'critical'] as const;
 const CARD_COLUMNS = ['title', 'subtitle', 'body', 'badge', 'icon'];
@@ -283,10 +286,10 @@ export const rangesText = (ranges: unknown) =>
     .map((r: any) => `${r?.from ?? ''}..${r?.to ?? ''}${r?.label ? ` = ${r.label}` : ''}`)
     .join('; ');
 
-const FACET_FORM_KEYS = ['label', 'limit', 'type', 'ranges', 'custom', 'exclude'];
+const FACET_FORM_KEYS = ['label', 'limit', 'type', 'ranges', 'custom', 'exclude', 'chart'];
 
 /** The facets table of a faceted search or smart filters form (and the report it filters). */
-function mergeFacetList(out: Config, config: Config, b: Body, a: Allowed) {
+function mergeFacetList(out: Config, config: Config, b: Body, a: Allowed, charts = true) {
   const set = setter(out);
   const report = Number(b.report);
   const columns = a.reports.get(report);
@@ -303,6 +306,7 @@ function mergeFacetList(out: Config, config: Config, b: Body, a: Allowed) {
     ranges: parseRanges(b[`ranges_${i}`]),
     custom: b[`custom_${i}`] === 'true',
     exclude: b[`exclude_${i}`] === 'true',
+    chart: charts && (b[`chart_${i}`] === 'bar' || b[`chart_${i}`] === 'pie') ? b[`chart_${i}`] : null,
     seq: Number(b[`seq_${i}`]) || (i + 1) * 10,
   }))
     .filter((f) => f.on && columns.includes(f.column))
@@ -320,6 +324,8 @@ function mergeFacetList(out: Config, config: Config, b: Body, a: Allowed) {
         ...(f.type === 'range' && f.ranges.length ? { ranges: f.ranges } : {}),
         // a range facet without ranges has from/to fields unless switched off; with ranges, only when switched on
         ...(f.type === 'range' && f.custom !== !f.ranges.length ? { custom: f.custom } : {}),
+        // (sprint 65) a chart of the counts (faceted search only)
+        ...(f.chart ? { chart: f.chart } : {}),
       };
     });
   set('facets', facets.length ? facets : undefined);
@@ -335,7 +341,8 @@ export function mergeFacetsSettings(config: Config, b: Body, a: Allowed): Config
 
 export function mergeSmartFiltersSettings(config: Config, b: Body, a: Allowed): Config {
   const out = { ...config };
-  if (!mergeFacetList(out, config, b, a)) return out;
+  // (sprint 65) facet charts belong to faceted search
+  if (!mergeFacetList(out, config, b, a, false)) return out;
   const set = setter(out);
   const n = Number(b.suggestions);
   set('suggestions', b.suggestions !== undefined && b.suggestions !== '' && Number.isInteger(n) && n >= 0 && n <= 10 && n !== 3 ? n : undefined);
@@ -618,6 +625,7 @@ async function facetsFields(r: RegionRow, pageId: number, appId: number, id: (n:
       <td data-label="Exclude"><input type="checkbox" name="exclude_${i}" value="true"${f?.exclude === true ? raw(' checked') : ''} aria-label="Users may exclude values of ${n}"></td>
       <td data-label="Ranges"><input name="ranges_${i}" value="${rangesText(f?.ranges)}" placeholder="..1000; 1000..3000 = Middle; 3000.." aria-label="Ranges of ${n}"></td>
       <td data-label="From/to"><input type="checkbox" name="custom_${i}" value="true"${custom ? raw(' checked') : ''} aria-label="Users may type a range for ${n}"></td>
+      ${smart ? '' : html`<td data-label="Chart"><select name="chart_${i}" aria-label="Chart of the facet on ${n}">${opt('', 'None', f?.chart)}${opt('bar', 'Bar', f?.chart)}${opt('pie', 'Pie', f?.chart)}</select></td>`}
       <td data-label="Order"><input name="seq_${i}" type="number" value="${(i + 1) * 10}" aria-label="Order of ${n}" class="u-mw6"></td>
     </tr>`;
   });
@@ -637,8 +645,8 @@ async function facetsFields(r: RegionRow, pageId: number, appId: number, id: (n:
     ${target
       ? html`<fieldset class="prop-group"><legend>Facets</legend>
           ${all.length
-            ? html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Column</th><th>Facet</th><th>Label</th><th>Type</th><th>Values shown</th><th>Exclude</th><th>Ranges</th><th>From/to</th><th>Order</th></tr></thead><tbody>${rows}</tbody></table></div>
-              <small class="help">Checkboxes list the most frequent values (Exclude lets users filter them out instead). Ranges and From/to need a number or date column: ranges are <code>from..to = label</code> separated by <code>;</code>, an open end left empty (<code>..1000</code>, <code>2020-01-01..</code>); a range includes its start, not its end. A star rating offers "4 stars and up" and so on (up to 5; <code>"max"</code> in the JSON changes it).</small>`
+            ? html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Column</th><th>Facet</th><th>Label</th><th>Type</th><th>Values shown</th><th>Exclude</th><th>Ranges</th><th>From/to</th>${smart ? '' : html`<th>Chart</th>`}<th>Order</th></tr></thead><tbody>${rows}</tbody></table></div>
+              <small class="help">Checkboxes list the most frequent values (Exclude lets users filter them out instead). Ranges and From/to need a number or date column: ranges are <code>from..to = label</code> separated by <code>;</code>, an open end left empty (<code>..1000</code>, <code>2020-01-01..</code>); a range includes its start, not its end. A star rating offers "4 stars and up" and so on (up to 5; <code>"max"</code> in the JSON changes it).${smart ? '' : ' Chart: a bar or pie chart of the counts under the facet (collapsed); a bar or slice filters on its value.'}</small>`
             : html`<p class="muted">The report has no columns.</p>`}
         </fieldset>`
       : ''}`;

package/src/builder/sql-utilities.ts

@@ -0,0 +1,278 @@
+import type { FastifyInstance } from 'fastify';
+import { owner, type Db } from '../db.ts';
+import { html, raw } from '../html.ts';
+import { icon } from '../icons.ts';
+import { BASE, developer, region, send, shell, workshopTabs, type Req } from './ui.ts';
+import { isAdmin } from './locks.ts';
+import { workshopDb, workshopRunsAs } from './workspaces.ts';
+
+// SQL Workshop → Utilities (sprint 62; APEX: SQL Workshop → Utilities): one
+// page with the workshop's tools (Load and Unload Data, Sample Data, DDL,
+// Compare, Query Builder) and three of its own:
+//
+//   - Object Reports: fixed catalogue queries (tables without a primary key,
+//     foreign keys without an index, RLS without policies, …) over the schemas
+//     the SQL Workshop's connection may use (workshopDb: an isolated
+//     workspace's developers see only their own roles' schemas);
+//   - About Database: version, a few settings, extensions, sizes;
+//   - Database Monitor (administrators): sessions and blocked queries of this
+//     database (pg_stat_activity), read only.
+//
+// Every query runs read only with a statement timeout.
+
+/** Schemas of the report queries: usable by the connection, not pgkiln's or the system's (alias n). */
+const USABLE = `n.nspname !~ '^pg_' and n.nspname not in ('information_schema', 'meta') and has_schema_privilege(n.oid, 'USAGE')`;
+
+interface Report {
+  title: string;
+  about: string;
+  columns: [key: string, label: string, cls?: 'num'][];
+  sql: string;
+}
+
+/** Object Reports. Each query returns `object` (schema.name, linked to the Object Browser) first. */
+export const OBJECT_REPORTS: Record<string, Report> = {
+  'no-primary-key': {
+    title: 'Tables without a primary key',
+    about: 'Forms, interactive grids and REST write-back need a key to find a row again.',
+    columns: [['rows', 'Rows (estimate)', 'num']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object, greatest(c.reltuples, 0)::bigint as rows
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace
+           where c.relkind in ('r', 'p') and not c.relispartition and ${USABLE}
+             and not exists (select 1 from pg_constraint k where k.conrelid = c.oid and k.contype = 'p')
+           order by 1`,
+  },
+  'unindexed-foreign-keys': {
+    title: 'Foreign keys without an index',
+    about: 'Deleting or updating a parent row scans the child table, and joins from the parent are slower. An index on the foreign key columns (in this order) avoids it.',
+    columns: [['constraint', 'Foreign key'], ['columns', 'Columns'], ['parent', 'References'], ['suggestion', 'Index']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object, k.conname as constraint,
+                 (select string_agg(quote_ident(a.attname), ', ' order by u.i) from unnest(k.conkey) with ordinality u(attnum, i)
+                    join pg_attribute a on a.attrelid = k.conrelid and a.attnum = u.attnum) as columns,
+                 k.confrelid::regclass::text as parent,
+                 format('create index on %I.%I (%s)', n.nspname, c.relname,
+                   (select string_agg(quote_ident(a.attname), ', ' order by u.i) from unnest(k.conkey) with ordinality u(attnum, i)
+                      join pg_attribute a on a.attrelid = k.conrelid and a.attnum = u.attnum)) as suggestion
+            from pg_constraint k join pg_class c on c.oid = k.conrelid join pg_namespace n on n.oid = c.relnamespace
+           where k.contype = 'f' and ${USABLE}
+             and not exists (select 1 from pg_index i where i.indrelid = k.conrelid
+                               and (i.indkey::int2[])[0:cardinality(k.conkey) - 1] @> k.conkey
+                               and (i.indkey::int2[])[0:cardinality(k.conkey) - 1] <@ k.conkey)
+           order by 1, 2`,
+  },
+  'rls-without-policies': {
+    title: 'Row-level security without policies',
+    about: 'Row-level security is enabled but the table has no policy: every role except its owner (and roles that bypass RLS) sees no rows and can change none.',
+    columns: [['forced', 'Forced for the owner']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object, case when c.relforcerowsecurity then 'yes' else 'no' end as forced
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace
+           where c.relkind in ('r', 'p') and c.relrowsecurity and ${USABLE}
+             and not exists (select 1 from pg_policy p where p.polrelid = c.oid)
+           order by 1`,
+  },
+  'no-row-level-security': {
+    title: 'Tables without row-level security',
+    about: 'Every role with a grant on these tables sees and changes all their rows. Fine for lookup tables; enable row-level security where rows belong to users or tenants.',
+    columns: [['owner', 'Owner'], ['grants', 'Granted to']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object, c.relowner::regrole::text as owner,
+                 (select string_agg(distinct case when g.grantee = 0 then 'PUBLIC' else g.grantee::regrole::text end, ', ')
+                    from aclexplode(c.relacl) g where g.grantee <> c.relowner) as grants
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace
+           where c.relkind in ('r', 'p') and not c.relispartition and not c.relrowsecurity and ${USABLE}
+           order by 1`,
+  },
+  'public-grants': {
+    title: 'Privileges granted to PUBLIC',
+    about: 'Every database role, including ones made later, has these privileges.',
+    columns: [['kind', 'Kind'], ['privileges', 'Privileges']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object,
+                 case c.relkind when 'r' then 'table' when 'p' then 'table' when 'v' then 'view' when 'm' then 'materialized view' when 'S' then 'sequence' when 'f' then 'foreign table' else c.relkind::text end as kind,
+                 string_agg(g.privilege_type, ', ' order by g.privilege_type) as privileges
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace, aclexplode(c.relacl) g
+           where g.grantee = 0 and ${USABLE}
+           group by 1, 2 order by 1`,
+  },
+  'unused-indexes': {
+    title: 'Unused indexes',
+    about: 'Indexes not used by a query since the statistics were last reset (not primary keys or unique ones). They slow down writes and take space; check on every server (replicas count their own) before dropping one.',
+    columns: [['index', 'Index'], ['size', 'Size', 'num']],
+    sql: `select format('%I.%I', s.schemaname, s.relname) as object, s.indexrelname as index, pg_size_pretty(pg_relation_size(s.indexrelid)) as size
+            from pg_stat_user_indexes s join pg_index i on i.indexrelid = s.indexrelid join pg_namespace n on n.nspname = s.schemaname
+           where s.idx_scan = 0 and not i.indisunique and not i.indisprimary and ${USABLE}
+           order by pg_relation_size(s.indexrelid) desc, 1`,
+  },
+  'largest-tables': {
+    title: 'Largest tables',
+    about: 'The 100 largest tables with their indexes and TOAST data.',
+    columns: [['rows', 'Rows (estimate)', 'num'], ['table_size', 'Table', 'num'], ['index_size', 'Indexes', 'num'], ['total', 'Total', 'num']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object, greatest(c.reltuples, 0)::bigint as rows,
+                 pg_size_pretty(pg_table_size(c.oid)) as table_size, pg_size_pretty(pg_indexes_size(c.oid)) as index_size,
+                 pg_size_pretty(pg_total_relation_size(c.oid)) as total
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace
+           where c.relkind in ('r', 'p', 'm') and ${USABLE}
+           order by pg_total_relation_size(c.oid) desc limit 100`,
+  },
+  'no-comments': {
+    title: 'Tables without a comment',
+    about: 'Comments (COMMENT ON) document a data model; the App Builder and its AI read them. SQL Workshop → AI → Describe tables drafts them.',
+    columns: [['columns', 'Columns', 'num'], ['commented', 'With a comment', 'num']],
+    sql: `select format('%I.%I', n.nspname, c.relname) as object,
+                 (select count(*) from pg_attribute a where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped)::int as columns,
+                 (select count(*) from pg_attribute a where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped and col_description(c.oid, a.attnum) is not null)::int as commented
+            from pg_class c join pg_namespace n on n.oid = c.relnamespace
+           where c.relkind in ('r', 'p', 'v', 'm') and not c.relispartition and obj_description(c.oid, 'pg_class') is null and ${USABLE}
+           order by 1`,
+  },
+};
+
+/** Run read-only queries with a statement timeout. */
+async function readOnly<T>(db: Db, fn: (q: (sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>) => Promise<T>): Promise<T> {
+  return db.tx(async (c) => {
+    await c.query('set transaction read only');
+    await c.query(`set local statement_timeout = '15s'`);
+    return fn(async (sql, params) => (await c.query(sql, params)).rows);
+  });
+}
+
+const crumbs = (last: string): [string, string?][] => [['SQL Workshop', `${BASE}/sql`], ['Utilities', `${BASE}/sql/utilities`], [last]];
+
+export async function sqlUtilityRoutes(app: FastifyInstance) {
+  app.get(`${BASE}/sql/utilities`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const admin = await isAdmin(s.username);
+    const tile = (href: string, ic: string, title: string, text: string) =>
+      html`<a class="ab-tile sw-tile" href="${BASE}${href}"><span class="ab-tile-icon sw-tile-icon">${icon(ic)}</span><strong>${title}</strong><span>${text}</span></a>`;
+    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('utilities')}
+      <div class="ab-tiles ab-tiles-wrap">
+        ${tile('/sql/load', 'upload', 'Data Workshop: Load Data', 'Load CSV, Excel, JSON or XML into a new or existing table, with saved definitions.')}
+        ${tile('/sql/unload', 'download', 'Data Workshop: Unload Data', 'Download a table or a query as CSV, JSON, XML, Excel or SQL inserts.')}
+        ${tile('/sql/sample-data', 'layers', 'Sample Data', 'Generate realistic rows for your tables.')}
+        ${tile('/sql/query', 'filter', 'Query Builder', 'Build a query by drawing joins between tables.')}
+        ${tile('/sql/ddl', 'file', 'Generate DDL', 'The SQL that creates a schema\'s objects.')}
+        ${tile('/sql/compare', 'layers', 'Schema Comparison', 'The differences between two schemas, and the SQL to align them.')}
+        ${tile('/sql/utilities/reports', 'list', 'Object Reports', 'Tables without a primary key, foreign keys without an index, row-level security, grants, sizes.')}
+        ${tile('/sql/utilities/about', 'help', 'About Database', 'The PostgreSQL version, settings, extensions and sizes.')}
+        ${admin ? tile('/sql/utilities/monitor', 'activity', 'Database Monitor', 'Sessions, running and blocked queries of this database (administrators).') : ''}
+      </div>`;
+    return send(reply, s, shell(s, 'SQL Workshop utilities', [['SQL Workshop', `${BASE}/sql`], ['Utilities']], main, 'sql'));
+  });
+
+  app.get(`${BASE}/sql/utilities/reports`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const db = await workshopDb(s);
+    const key = String((req.query as Record<string, unknown>)?.r ?? 'no-primary-key');
+    const r = Object.hasOwn(OBJECT_REPORTS, key) ? OBJECT_REPORTS[key] : null;
+    if (!r) return reply.code(404).send('Not found');
+    let rows: Record<string, unknown>[] = [];
+    let error = '';
+    try {
+      rows = await readOnly(db, (q) => q(r.sql));
+    } catch (e) {
+      error = (e as Error).message;
+    }
+    const nav = html`<nav aria-label="Object reports"><ul class="ab-links ab-tasks">${Object.entries(OBJECT_REPORTS).map(([k, x]) =>
+      html`<li><a href="${BASE}/sql/utilities/reports?r=${k}"${k === key ? raw(' aria-current="page"') : ''}>${x.title}${icon('chevron')}</a></li>`)}</ul></nav>`;
+    const table = html`<div class="table-wrap"><table class="report report-reflow">
+      <thead><tr><th>Object</th>${r.columns.map(([, l, c]) => html`<th${c ? raw(` class="${c}"`) : ''}>${l}</th>`)}</tr></thead>
+      <tbody>${rows.length
+        ? rows.map((row) => html`<tr><td data-label="Object" class="u-break"><a href="${BASE}/sql/objects?o=${encodeURIComponent(String(row.object))}">${String(row.object)}</a></td>
+            ${r.columns.map(([k, l, c]) => html`<td data-label="${l}"${c ? raw(` class="${c}"`) : raw(' class="u-break"')}>${k === 'suggestion' ? html`<code>${String(row[k] ?? '')}</code>` : String(row[k] ?? '')}</td>`)}</tr>`)
+        : html`<tr><td colspan="${r.columns.length + 1}" class="empty">${error ? 'The report failed.' : 'Nothing found.'}</td></tr>`}</tbody></table></div>`;
+    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('utilities')}
+      <div class="ab-home"><div class="ab-main">
+        ${region(r.title, html`<p class="muted u-mt0">${r.about} Over the schemas ${workshopRunsAs(db)} may use.</p>
+          ${error ? html`<div class="alert alert-error" role="alert">${error}</div>` : ''}${table}`)}
+      </div><aside class="ab-side" aria-label="Object reports"><section><h2>Object Reports</h2>${nav}</section></aside></div>`;
+    return send(reply, s, shell(s, r.title, crumbs('Object Reports'), main, 'sql'));
+  });
+
+  app.get(`${BASE}/sql/utilities/about`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const db = await workshopDb(s);
+    const info = await readOnly(db, async (q) => ({
+      server: (await q(`select version() as version, current_database() as database, current_user as "user", session_user as login,
+                               pg_size_pretty(pg_database_size(current_database())) as size,
+                               (select setting from pg_settings where name = 'server_version') as server_version,
+                               pg_postmaster_start_time() as started`))[0],
+      settings: await q(`select name, setting, unit, short_desc from pg_settings
+                          where name in ('server_encoding', 'lc_collate', 'TimeZone', 'max_connections', 'shared_buffers', 'work_mem',
+                                         'maintenance_work_mem', 'effective_cache_size', 'statement_timeout', 'default_transaction_isolation',
+                                         'row_security', 'shared_preload_libraries', 'wal_level', 'max_wal_size')
+                          order by lower(name)`),
+      extensions: await q(`select e.extname as name, e.extversion as version, n.nspname as schema, a.comment
+                             from pg_extension e join pg_namespace n on n.oid = e.extnamespace
+                             left join pg_available_extensions a on a.name = e.extname order by 1`),
+      schemas: await q(`select n.nspname as schema, n.nspowner::regrole::text as owner,
+                               count(c.oid) filter (where c.relkind in ('r', 'p'))::int as tables,
+                               pg_size_pretty(coalesce(sum(pg_total_relation_size(c.oid)) filter (where c.relkind in ('r', 'p', 'm')), 0)::bigint) as size
+                          from pg_namespace n left join pg_class c on c.relnamespace = n.oid
+                         where ${USABLE} group by 1, 2 order by 1`),
+    }));
+    const sv = info.server as Record<string, string>;
+    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('utilities')}
+      <div class="stat-grid u-mb1">
+        ${[['PostgreSQL', sv.server_version], ['Database', sv.database], ['Size', sv.size], ['Running since', new Date(sv.started).toISOString().slice(0, 16).replace('T', ' ') + ' UTC']]
+          .map(([l, v]) => html`<div class="stat"><b class="u-break">${v}</b><span>${l}</span></div>`)}
+      </div>
+      <p class="muted">${sv.version}. The SQL Workshop runs as <code>${sv.user}</code> (signed in as <code>${sv.login}</code>).</p>
+      <div class="columns">
+        ${region('Settings', html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Setting</th><th>Value</th></tr></thead>
+          <tbody>${info.settings.map((x) => html`<tr><td data-label="Setting" title="${String(x.short_desc ?? '')}"><code>${String(x.name)}</code></td>
+            <td data-label="Value" class="u-break">${String(x.setting ?? '')}${x.unit ? ` ${x.unit}` : ''}</td></tr>`)}</tbody></table></div>`)}
+        ${region('Extensions', html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Extension</th><th>Version</th><th>Schema</th></tr></thead>
+          <tbody>${info.extensions.map((x) => html`<tr><td data-label="Extension" class="u-break"><strong>${String(x.name)}</strong>${x.comment ? html` <span class="muted">${String(x.comment)}</span>` : ''}</td>
+            <td data-label="Version">${String(x.version)}</td><td data-label="Schema">${String(x.schema)}</td></tr>`)}</tbody></table></div>`)}
+      </div>
+      <div class="u-spacer"></div>
+      ${region('Schemas', html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Schema</th><th>Owner</th><th class="num">Tables</th><th class="num">Size</th></tr></thead>
+        <tbody>${info.schemas.length ? info.schemas.map((x) => html`<tr><td data-label="Schema">${String(x.schema)}</td><td data-label="Owner"><code>${String(x.owner)}</code></td>
+          <td class="num" data-label="Tables">${String(x.tables)}</td><td class="num" data-label="Size">${String(x.size)}</td></tr>`)
+          : html`<tr><td colspan="4" class="empty">No schemas.</td></tr>`}</tbody></table></div>`)}`;
+    return send(reply, s, shell(s, 'About Database', crumbs('About Database'), main, 'sql'));
+  });
+
+  app.get(`${BASE}/sql/utilities/monitor`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    if (!(await isAdmin(s.username))) return reply.code(403).send('Administrators only.');
+    const data = await readOnly(owner, async (q) => ({
+      sessions: await q(`select a.pid, a.usename as "user", a.application_name as app, a.client_addr::text as client, a.state,
+                                a.wait_event_type || coalesce(': ' || a.wait_event, '') as wait,
+                                to_char(a.backend_start, 'YYYY-MM-DD HH24:MI') as since,
+                                case when a.state = 'active' then round(extract(epoch from now() - a.query_start)::numeric, 1) end as running_s,
+                                case when a.state like 'idle in transaction%' then round(extract(epoch from now() - a.state_change)::numeric, 1) end as idle_tx_s,
+                                pg_blocking_pids(a.pid) as blocked_by, left(a.query, 500) as query
+                           from pg_stat_activity a
+                          where a.datname = current_database() and a.backend_type = 'client backend' and a.pid <> pg_backend_pid()
+                          order by a.state = 'active' desc, a.query_start nulls last limit 200`),
+      totals: (await q(`select count(*)::int as sessions, count(*) filter (where state = 'active')::int as active,
+                               count(*) filter (where state like 'idle in transaction%')::int as idle_tx,
+                               count(*) filter (where cardinality(pg_blocking_pids(pid)) > 0)::int as blocked,
+                               (select setting::int from pg_settings where name = 'max_connections') as max
+                          from pg_stat_activity where datname = current_database() and backend_type = 'client backend'`))[0],
+    }));
+    const t = data.totals as Record<string, number>;
+    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('utilities')}
+      <div class="stat-grid u-mb1">
+        ${[['Sessions', `${t.sessions} / ${t.max}`], ['Active', t.active], ['Idle in a transaction', t.idle_tx], ['Blocked', t.blocked]]
+          .map(([l, v]) => html`<div class="stat"><b>${String(v)}</b><span>${l}</span></div>`)}
+      </div>
+      ${region('Sessions', html`<p class="muted u-mt0">The client sessions of this database (pg_stat_activity), active ones first. A query's text is shown only for roles whose statistics the owner may read (<code>pg_read_all_stats</code>). Reload the page to refresh it.</p>
+        <div class="table-wrap"><table class="report report-reflow">
+        <thead><tr><th class="num">PID</th><th>User</th><th>Application</th><th>State</th><th>Wait</th><th class="num">Running (s)</th><th>Blocked by</th><th>Query</th></tr></thead>
+        <tbody>${data.sessions.length ? data.sessions.map((x) => html`<tr>
+          <td class="num" data-label="PID">${String(x.pid)}</td>
+          <td data-label="User">${String(x.user ?? '')}</td>
+          <td data-label="Application" class="u-break">${String(x.app ?? '')}${x.client ? html` <span class="muted">${String(x.client)}</span>` : ''}</td>
+          <td data-label="State">${x.idle_tx_s != null ? html`<span class="tag">${String(x.state)} ${String(x.idle_tx_s)} s</span>` : String(x.state ?? '')}</td>
+          <td data-label="Wait">${String(x.wait ?? '')}</td>
+          <td class="num" data-label="Running">${x.running_s != null ? String(x.running_s) : ''}</td>
+          <td data-label="Blocked by">${(x.blocked_by as number[]).length ? html`<span class="tag">${(x.blocked_by as number[]).join(', ')}</span>` : ''}</td>
+          <td data-label="Query" class="u-break"><code>${String(x.query ?? '')}</code></td></tr>`)
+          : html`<tr><td colspan="8" class="empty">No other sessions.</td></tr>`}</tbody></table></div>`)}`;
+    return send(reply, s, shell(s, 'Database Monitor', crumbs('Database Monitor'), main, 'sql'));
+  });
+}

package/src/builder/sql.ts

@@ -11,6 +11,7 @@ import { quickSqlRoutes } from './quicksql.ts';
 import { queryBuilderRoutes } from './querybuilder.ts';
 import { unloadRoutes } from './unload.ts';
 import { ddlToolRoutes } from './ddl-tools.ts';
+import { sqlUtilityRoutes } from './sql-utilities.ts';
 import { currentWorkspace, sessionSchema, usableSchemas, workshopDb, workshopRunsAs } from './workspaces.ts';
 
 // SQL Workshop: SQL commands and the object browser (owner connection; an isolated
@@ -61,7 +62,7 @@ async function workshopHome(req: Req, reply: FastifyReply) {
         ${tile('/sql/objects', 'search', 'Object Browser', 'Browse tables, views and functions, their policies, grants and data.')}
         ${tile('/sql/commands', 'code', 'SQL Commands', 'Run SQL statements against your schemas.')}
         ${tile('/sql/scripts', 'file', 'SQL Scripts', 'Create, upload and run stored SQL scripts.')}
-        ${tile('/sql/load', 'upload', 'Utilities', 'Load and unload data, sample data, DDL and schema comparison.')}
+        ${tile('/sql/utilities', 'wrench', 'Utilities', 'Load and unload data, sample data, DDL, schema comparison, object reports and the database.')}
         ${tile('/sql/quick', 'bolt', 'Quick SQL', 'Write a data model in shorthand and get the DDL.')}
       </div>
       <div class="sw-recents">
@@ -99,6 +100,7 @@ export async function sqlRoutes(app: FastifyInstance) {
   await app.register(unloadRoutes);
   // Generate DDL and Schema Comparison (sprint 56)
   await app.register(ddlToolRoutes);
+  await app.register(sqlUtilityRoutes);
   // ---------------------------------------------------------------- SQL workshop
   const resultTable = (res: pg.QueryResult<any[]>, limit = 500) => {
     const rows = (res.rows ?? []).slice(0, limit);

package/src/builder/ui.ts

@@ -109,7 +109,7 @@ export function shell(s: Session, title: string, crumbs: [string, string?][], ma
       <a class="rail-logo" href="${BASE}" title="pgkiln Builder"><span aria-hidden="true">pg</span><span class="sr-only">pgkiln Builder home</span></a>
       <ul class="rail-list">
         ${rail('apps', BASE, 'builder', 'App Builder')}
-        ${rail('sql', `${BASE}/sql`, 'database', 'SQL Workshop')}
+        ${s.workspace?.sql_workshop === false ? '' : rail('sql', `${BASE}/sql`, 'database', 'SQL Workshop')}
         ${rail('gallery', `${BASE}/gallery`, 'package', 'App Gallery')}
         ${appId ? rail('search', `${BASE}/apps/${appId}/search`, 'search', 'Search this application') : ''}
       </ul>
@@ -124,6 +124,8 @@ export function shell(s: Session, title: string, crumbs: [string, string?][], ma
             ${s.workspace?.admin ? html`<div class="menu-section menu-links">
               <span class="small muted">Manage service: ${s.workspace.name}</span>
               <a href="${BASE}/workspaces/${s.workspace.id}#service">${icon('bell')} Workspace message and environment banner</a>
+              <a href="${BASE}/workspaces/${s.workspace.id}#preferences">${icon('sliders-horizontal')} Workspace preferences</a>
+              <a href="${BASE}/workspaces/${s.workspace.id}#links">${icon('external-link')} Extension links</a>
               <a href="${BASE}/workspaces/${s.workspace.id}/utilization">${icon('chart')} Workspace utilization</a>
               <a href="${BASE}/workspaces/${s.workspace.id}">${icon('layers')} Workspace and developers</a>
             </div>` : ''}
@@ -134,6 +136,11 @@ export function shell(s: Session, title: string, crumbs: [string, string?][], ma
               <a href="${BASE}/developers">${icon('key')} Change my password</a>
             </div>
           </div></details></li>
+        ${s.workspace?.links?.length ? html`<li><details class="menu rail-user rail-admin rail-extensions">
+          <summary class="rail-link" title="Extensions">${icon('puzzle')}<span class="rail-label">Extensions</span></summary>
+          <div class="menu-panel"><div class="menu-section menu-links"><strong>Extensions</strong>
+            ${s.workspace.links.map((l) => html`<a href="${l.url}" target="_blank" rel="noopener noreferrer"${l.description ? html` title="${l.description}"` : ''}>${icon('external-link')} ${l.label}</a>`)}
+          </div></div></details></li>` : ''}
         ${rail('help', 'https://github.com/pgkiln/pgkiln/blob/main/docs/guide/03-builder.md', 'help', 'Help', raw(' target="_blank" rel="noopener"'))}
         <li><details class="menu rail-user">
           <summary class="rail-avatar" title="${s.username}"><span aria-hidden="true">${initials(s.username ?? '')}</span><span class="sr-only">Account: ${s.username}</span></summary>
@@ -232,13 +239,13 @@ export const appHeader = (a: any, active: 'pages' | 'shared' | 'settings' | 'act
 };
 
 /** Tabs of the SQL Workshop. */
-export type WorkshopTab = 'home' | 'sql' | 'scripts' | 'quicksql' | 'query' | 'objects' | 'load' | 'unload' | 'sample' | 'ai' | 'ddl' | 'compare';
+export type WorkshopTab = 'home' | 'sql' | 'scripts' | 'quicksql' | 'query' | 'objects' | 'load' | 'unload' | 'sample' | 'ai' | 'ddl' | 'compare' | 'utilities';
 export const workshopTabs = (active: WorkshopTab) => {
   const tab = (key: WorkshopTab, href: string, ic: string, label: string) =>
     html`<a class="ide-tab" href="${BASE}${href}"${active === key ? raw(' aria-current="page"') : ''}>${icon(ic)}<span>${label}</span></a>`;
   return html`<nav class="ide-tabs u-mb1" aria-label="SQL Workshop">
     ${tab('home', '/sql', 'home', 'Home')}${tab('sql', '/sql/commands', 'code', 'SQL Commands')}${tab('scripts', '/sql/scripts', 'file', 'SQL Scripts')}${tab('quicksql', '/sql/quick', 'bolt', 'Quick SQL')}
-    ${tab('query', '/sql/query', 'filter', 'Query Builder')}${tab('objects', '/sql/objects', 'database', 'Object Browser')}${tab('load', '/sql/load', 'upload', 'Load Data')}${tab('unload', '/sql/unload', 'download', 'Unload Data')}${tab('sample', '/sql/sample-data', 'layers', 'Sample Data')}${tab('ddl', '/sql/ddl', 'file', 'DDL')}${tab('compare', '/sql/compare', 'layers', 'Compare')}${tab('ai', '/sql/ai', 'bolt', 'AI')}</nav>`;
+    ${tab('query', '/sql/query', 'filter', 'Query Builder')}${tab('objects', '/sql/objects', 'database', 'Object Browser')}${tab('load', '/sql/load', 'upload', 'Load Data')}${tab('unload', '/sql/unload', 'download', 'Unload Data')}${tab('sample', '/sql/sample-data', 'layers', 'Sample Data')}${tab('ddl', '/sql/ddl', 'file', 'DDL')}${tab('compare', '/sql/compare', 'layers', 'Compare')}${tab('ai', '/sql/ai', 'bolt', 'AI')}${tab('utilities', '/sql/utilities', 'wrench', 'Utilities')}</nav>`;
 };
 
 /** Number of app tile colours (.app-color-0 … -7 in app.css). */
@@ -278,6 +285,12 @@ export async function developer(req: Req, reply: FastifyReply) {
     reply.code(404).send('Not found');
     return null;
   }
+  // (093) a workspace preference may turn the SQL Workshop off
+  if (s.workspace?.sql_workshop === false && /^\/builder\/sql(?:[/?]|$)/.test(req.url)) {
+    await send(reply.code(403), s, shell(s, 'SQL Workshop', [['App Builder', BASE], ['SQL Workshop']],
+      html`<h1>SQL Workshop</h1><div class="alert alert-info" role="status">The SQL Workshop is turned off for the workspace ${s.workspace.name}. Its administrators can turn it on in the workspace preferences${s.workspaces && s.workspaces.length > 1 ? '; or switch to another workspace' : ''}.</div>`, 'sql'));
+    return null;
+  }
   // a page or application locked by another developer can't be changed (locks.ts)
   if (req.method === 'POST') {
     const hit = await blockingLock(s.username, req.url);

package/src/builder/workspace-backups.ts

@@ -0,0 +1,78 @@
+import type { FastifyInstance } from 'fastify';
+import { owner } from '../db.ts';
+import { html } from '../html.ts';
+import { icon } from '../icons.ts';
+import { clientIp, logActivity } from '../session.ts';
+import { back, BASE, csrf, developer, flash, input, region, send, shell, type Req } from './ui.ts';
+import { currentWorkspace } from './workspaces.ts';
+
+// Workspace utilities → Manage backups (APEX: Workspace Utilities → Manage
+// Backups): the backups (082) of every application of the current workspace on
+// one page, and a backup of all of them at once. Downloading, restoring and
+// deleting a backup stay on the application's own Backups page.
+
+const when = (d: string | Date | null) => (d ? new Date(d).toISOString().slice(0, 16).replace('T', ' ') : '');
+const size = (n: number) => (n < 1024 * 1024 ? `${Math.max(n ? 1 : 0, Math.round(n / 1024))} KB` : `${(n / 1024 / 1024).toFixed(1)} MB`);
+
+export async function workspaceBackupRoutes(app: FastifyInstance) {
+  app.get(`${BASE}/backups`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const rows = (await owner.query(
+      `select a.id, a.name, a.alias, a.backups_keep, a.updated_at,
+              count(b.id)::int as backups, coalesce(sum(b.size), 0)::bigint as bytes, max(b.created_at) as newest,
+              (max(b.created_at) is null or a.updated_at > max(b.created_at)) as changed
+         from meta.app a left join meta.app_backup b on b.app_id = a.id
+        where meta.app_workspace(a.id) = $1
+        group by a.id order by lower(a.name), a.id`, [currentWorkspace(s)])).rows;
+    const total = rows.reduce((t, r) => t + Number(r.bytes), 0);
+    const main = html`<div class="title-row"><h1>Manage backups</h1></div>
+      <p class="muted u-mt0">The backups of the applications of ${s.workspace?.name ?? 'this workspace'}: one before every import that replaces an application, a merge or a restore, one a day when it changed, and the ones made by hand. Open an application's backups to download, restore or delete one.</p>
+      <div class="stat-grid u-mb1">
+        ${[['Applications', rows.length], ['Backups', rows.reduce((t, r) => t + r.backups, 0)], ['Storage', size(total)], ['Changed since their newest backup', rows.filter((r) => r.changed && r.backups_keep > 0).length]]
+          .map(([l, v]) => html`<div class="stat"><b>${String(v)}</b><span>${l}</span></div>`)}
+      </div>
+      ${region('Applications', html`<div class="table-wrap"><table class="report report-reflow">
+        <thead><tr><th>Application</th><th class="num">Backups</th><th class="num">Kept</th><th>Newest (UTC)</th><th class="num">Size</th><th></th></tr></thead>
+        <tbody>${rows.length ? rows.map((a) => html`<tr>
+          <td data-label="Application"><a href="${BASE}/apps/${a.id}">${a.name}</a> <span class="muted">/a/${a.alias}</span></td>
+          <td class="num" data-label="Backups">${a.backups}</td>
+          <td class="num" data-label="Kept">${a.backups_keep === 0 ? html`<span class="tag">none</span>` : a.backups_keep}</td>
+          <td data-label="Newest">${a.newest ? when(a.newest) : html`<span class="muted">never</span>`}${a.changed && a.backups_keep > 0 && a.newest ? html` <span class="tag">changed since</span>` : ''}</td>
+          <td class="num" data-label="Size">${size(Number(a.bytes))}</td>
+          <td><a class="btn btn-sm" href="${BASE}/apps/${a.id}/backups">${icon('history')} Backups</a></td></tr>`)
+          : html`<tr><td colspan="6" class="empty">No applications.</td></tr>`}</tbody></table></div>`)}
+      ${rows.length ? region('Back up all applications', html`<form method="post" action="${BASE}/backups">${csrf(s)}
+        <p class="muted u-mt0">Makes a backup of every application of this workspace that keeps backups.</p>
+        <div class="form-grid">${input('note', 'Note', '', { placeholder: 'e.g. before the upgrade' })}
+          <div class="field"><label class="check"><input type="checkbox" name="changed" value="true" checked> Only applications changed since their newest backup</label></div></div>
+        <div class="buttons"><button class="btn btn-hot">${icon('save')} Back up now</button></div></form>`) : ''}`;
+    return send(reply, s, shell(s, 'Manage backups', [['App Builder', BASE], ['Workspace utilities', `${BASE}/utilities`], ['Manage backups']], main));
+  });
+
+  app.post(`${BASE}/backups`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const note = String(req.body?.note ?? '').trim().slice(0, 500) || null;
+    const onlyChanged = req.body?.changed === 'true';
+    const apps = (await owner.query<{ id: number }>(
+      `select a.id from meta.app a
+        where meta.app_workspace(a.id) = $1 and a.backups_keep > 0
+          and (not $2 or not exists (select 1 from meta.app_backup b where b.app_id = a.id and b.created_at >= a.updated_at))
+        order by a.id`, [currentWorkspace(s), onlyChanged])).rows;
+    let made = 0;
+    const failed: number[] = [];
+    for (const a of apps) {
+      try {
+        if ((await owner.one(`select meta.backup_app($1, 'manual', $2, $3) as id`, [a.id, s.username, note])).id) made++;
+      } catch (e) {
+        failed.push(a.id);
+        console.error(`backup of application ${a.id}:`, (e as Error).message);
+      }
+    }
+    await logActivity({ appId: null, username: s.username, event: 'backup', ip: clientIp(req), detail: `workspace ${currentWorkspace(s)}: ${made} backup(s)` });
+    if (failed.length) flash(s, `${made} backup(s) made; not backed up: application${failed.length > 1 ? 's' : ''} ${failed.join(', ')}.`, 'error');
+    else flash(s, made ? `${made} backup${made > 1 ? 's' : ''} made.` : 'Nothing to back up: every application is unchanged since its newest backup, or keeps none.');
+    return back(reply, s, `${BASE}/backups`);
+  });
+}