pgkiln 0.82.0 → 0.83.0

package/src/builder/datapump.ts

@@ -12,6 +12,7 @@ import { icon } from '../icons.ts';
 import { clientIp, logActivity, type Session } from '../session.ts';
 import { isAdmin } from './locks.ts';
 import { back, BASE, csrf, developer, flash, region, send, shell, workshopTabs, type Body, type Req } from './ui.ts';
+import { tr, type BuilderKey, type BuilderTranslate } from './i18n.ts';
 
 // (sprint 103, Database Actions DA-16: Data Pump) SQL Workshop › Schema Export / Import, for administrators: pg_dump of a
 // schema (custom or plain, definitions and/or data, tables in or out) and pg_restore of an archive into a new or
@@ -19,68 +20,70 @@ import { back, BASE, csrf, developer, flash, region, send, shell, workshopTabs,
 // The work: src/datapump.ts (jobs, pg_dump, pg_restore) and src/dumpscript.ts (the import's script runner).
 
 const URL_BASE = `${BASE}/sql/data-pump`;
-const TITLE = 'Schema Export / Import';
 const jobUrl = (id: number) => `${URL_BASE}/job/${id}`;
-const crumbs = (...more: [string, string?][]): [string, string?][] => [['SQL Workshop', `${BASE}/sql`], [TITLE, more.length ? URL_BASE : undefined], ...more];
+const crumbs = (tx: BuilderTranslate, ...more: [string, string?][]): [string, string?][] => [[tx('rail.sql_workshop'), `${BASE}/sql`], [tx('sql.tool.datapump'), more.length ? URL_BASE : undefined], ...more];
 const many = (v: unknown) => ([] as string[]).concat((v as string | string[] | undefined) ?? []);
-const CONTENT: [Content, string][] = [['all', 'Definitions and data'], ['definitions', 'Definitions only'], ['data', 'Data only']];
+const CONTENT: [Content, BuilderKey][] = [['all', 'dp.content.all'], ['definitions', 'dp.content.definitions'], ['data', 'dp.content.data']];
+const contentLabel = (tx: BuilderTranslate, c: unknown) => { const x = CONTENT.find(([k]) => k === c); return x ? tx(x[1]) : ''; };
 
 /** An administrator's session; others get a 403 page. */
 async function admin(req: Req, reply: FastifyReply) {
   const s = await developer(req, reply);
   if (!s) return null;
   if (await isAdmin(s.username)) return s;
-  const main = html`<h1 class="u-mb1">${TITLE}</h1><div class="alert alert-error" role="alert">Only administrators export and import schemas: an export holds every row of a schema, an import runs its SQL as pgkiln's owner role.</div>`;
-  await send(reply.code(403), s, shell(s, TITLE, crumbs(), main, 'sql'));
+  const tx = tr(s);
+  const main = html`<h1 class="u-mb1">${tx('sql.tool.datapump')}</h1><div class="alert alert-error" role="alert">${tx('dp.admins_only')}</div>`;
+  await send(reply.code(403), s, shell(s, tx('sql.tool.datapump'), crumbs(tx), main, 'sql'));
   return null;
 }
 
 const page = (reply: FastifyReply, s: Session, title: string, trail: [string, string?][], body: Raw, code = 200) =>
-  send(reply.code(code), s, shell(s, title, crumbs(...trail), html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('datapump', s)}${body}`, 'sql'));
+  send(reply.code(code), s, shell(s, title, crumbs(tr(s), ...trail), html`<h1 class="u-mb1">${tr(s)('rail.sql_workshop')}</h1>${workshopTabs('datapump', s)}${body}`, 'sql'));
 
 export const size = (n: number | null) =>
   n === null ? '' : n < 1024 ? `${n} B` : n < 1024 ** 2 ? `${(n / 1024).toFixed(1)} KB` : n < 1024 ** 3 ? `${(n / 1024 ** 2).toFixed(1)} MB` : `${(n / 1024 ** 3).toFixed(2)} GB`;
 
-const STATUS: Record<Job['status'], [string, string]> = {
-  uploaded: ['tag-info', 'uploaded'], running: ['tag-warning', 'running'], succeeded: ['tag-ok', 'succeeded'], failed: ['tag-error', 'failed'], cancelled: ['', 'cancelled'],
-};
-const status = (j: Job) => html`<span class="tag ${STATUS[j.status][0]}">${STATUS[j.status][1]}</span>`;
-const what = (j: Job) =>
+const STATUS: Record<Job['status'], string> = { uploaded: 'tag-info', running: 'tag-warning', succeeded: 'tag-ok', failed: 'tag-error', cancelled: '' };
+const status = (tx: BuilderTranslate, j: Job) => html`<span class="tag ${STATUS[j.status]}">${tx.dyn(`dp.status.${j.status}`, j.status)}</span>`;
+const what = (tx: BuilderTranslate, j: Job) =>
   j.kind === 'export'
-    ? html`Export of <strong>${j.schema_name ?? ''}</strong>${(j.options.format as string) === 'plain' ? ' (plain SQL)' : ''}`
+    ? html`${tx.rich('dp.what.export', { schema: html`<strong>${j.schema_name ?? ''}</strong>` })}${(j.options.format as string) === 'plain' ? ` ${tx('dp.plain_sql')}` : ''}`
     : j.status === 'uploaded'
-      ? html`Upload <strong class="u-break">${j.original_name ?? ''}</strong>`
-      : html`Import of <strong>${j.schema_name ?? ''}</strong> into <strong>${j.target_schema ?? ''}</strong>`;
+      ? tx.rich('dp.what.upload', { file: html`<strong class="u-break">${j.original_name ?? ''}</strong>` })
+      : tx.rich('dp.what.import', { schema: html`<strong>${j.schema_name ?? ''}</strong>`, target: html`<strong>${j.target_schema ?? ''}</strong>` });
 
 /** Can this job's file be imported? (an export in custom format, or an upload; while its file is kept) */
 const importable = (j: Job) =>
   j.file_live && ((j.kind === 'export' && j.status === 'succeeded' && j.options.format !== 'plain') || (j.kind === 'import' && !j.source_job && j.status !== 'running'));
 
-const toolNote = (t: ToolState) =>
+const toolNote = (tx: BuilderTranslate, t: ToolState) =>
   t.ok
-    ? html`<p class="muted small">${t.tools.version} and pg_restore for a PostgreSQL ${String(t.server)} server. Files are kept ${String(KEEP_DAYS)} day${KEEP_DAYS === 1 ? '' : 's'} in the dump directory.</p>`
-    : html`<div class="alert alert-warning" role="alert"><strong>Export and import need pg_dump and pg_restore.</strong> ${t.reason}${t.found.length ? html` Found: ${t.found.join('; ')}.` : ''}</div>`;
+    ? html`<p class="muted small">${tx(KEEP_DAYS === 1 ? 'dp.tools_one' : 'dp.tools', { version: t.tools.version, server: String(t.server), n: KEEP_DAYS })}</p>`
+    : html`<div class="alert alert-warning" role="alert"><strong>${tx('dp.need_tools')}</strong> ${t.reason}${t.found.length ? html` ${tx('dp.found', { list: t.found.join('; ') })}` : ''}</div>`;
 
 async function listPage(reply: FastifyReply, s: Session) {
   const [jobs, tools] = await Promise.all([listJobs(), findTools()]);
-  const body = html`<div class="ide-head-title u-mb1"><div><h2 class="u-m0">${TITLE}</h2><span class="muted small">A schema to a file with pg_dump, and a file into a schema with pg_restore (Data Pump), as background jobs.</span></div>
-      <div class="buttons ide-head-actions"><a class="btn btn-hot" href="${URL_BASE}/export">${icon('download')} Export a schema</a> <a class="btn" href="${URL_BASE}/import">${icon('upload')} Import</a></div></div>
-    ${toolNote(tools)}
-    ${region('Jobs', html`<div class="table-wrap"><table class="report report-reflow dp-jobs"><thead><tr><th>Job</th><th>What</th><th>Status</th><th class="num">Size</th><th>Started</th><th class="num">Seconds</th><th>By</th></tr></thead>
+  const tx = tr(s);
+  const L = { job: tx('dp.col.job'), what: tx('dp.col.what'), status: tx('sm.col.state'), size: tx('scr.col.size'), started: tx('scr.col.started'), seconds: tx('dp.col.seconds'), by: tx('scr.col.by') };
+  const body = html`<div class="ide-head-title u-mb1"><div><h2 class="u-m0">${tx('sql.tool.datapump')}</h2><span class="muted small">${tx('dp.intro')}</span></div>
+      <div class="buttons ide-head-actions"><a class="btn btn-hot" href="${URL_BASE}/export">${icon('download')} ${tx('dp.export_schema')}</a> <a class="btn" href="${URL_BASE}/import">${icon('upload')} ${tx('dp.import')}</a></div></div>
+    ${toolNote(tx, tools)}
+    ${region(tx('dp.jobs'), html`<div class="table-wrap"><table class="report report-reflow dp-jobs"><thead><tr><th>${L.job}</th><th>${L.what}</th><th>${L.status}</th><th class="num">${L.size}</th><th>${L.started}</th><th class="num">${L.seconds}</th><th>${L.by}</th></tr></thead>
       <tbody>${jobs.length ? jobs.map((j) => html`<tr>
-        <td data-label="Job"><a href="${jobUrl(j.id)}">#${String(j.id)}</a></td>
-        <td data-label="What" class="u-break">${what(j)}</td>
-        <td data-label="Status">${status(j)}</td>
-        <td data-label="Size" class="num">${size(j.bytes)}${j.file_name && !j.file_live ? '' : j.bytes !== null && !j.file_name ? html` <span class="muted small">(removed)</span>` : ''}</td>
-        <td data-label="Started">${j.started_at ?? j.created_at}</td>
-        <td data-label="Seconds" class="num">${j.seconds === null ? '' : String(j.seconds)}</td>
-        <td data-label="By" class="u-break">${j.username}</td></tr>`)
-        : html`<tr><td colspan="7" class="empty">No exports or imports yet.</td></tr>`}</tbody></table></div>`)}`;
-  return page(reply, s, TITLE, [], body);
+        <td data-label="${L.job}"><a href="${jobUrl(j.id)}">#${String(j.id)}</a></td>
+        <td data-label="${L.what}" class="u-break">${what(tx, j)}</td>
+        <td data-label="${L.status}">${status(tx, j)}</td>
+        <td data-label="${L.size}" class="num">${size(j.bytes)}${j.file_name && !j.file_live ? '' : j.bytes !== null && !j.file_name ? html` <span class="muted small">(${tx('dp.removed')})</span>` : ''}</td>
+        <td data-label="${L.started}">${j.started_at ?? j.created_at}</td>
+        <td data-label="${L.seconds}" class="num">${j.seconds === null ? '' : String(j.seconds)}</td>
+        <td data-label="${L.by}" class="u-break">${j.username}</td></tr>`)
+        : html`<tr><td colspan="7" class="empty">${tx('dp.no_jobs')}</td></tr>`}</tbody></table></div>`)}`;
+  return page(reply, s, tx('sql.tool.datapump'), [], body);
 }
 
 async function exportPage(reply: FastifyReply, s: Session, q: Record<string, string | string[] | undefined>, errors: string[] = []) {
   const schemas = await exportableSchemas();
+  const tx = tr(s);
   const schema = schemas.includes(String(q.schema ?? '')) ? String(q.schema) : '';
   const tables = schema ? await schemaTables(schema) : [];
   const mode = ['all', 'only', 'except'].includes(String(q.mode)) ? String(q.mode) : 'all';
@@ -88,45 +91,48 @@ async function exportPage(reply: FastifyReply, s: Session, q: Record<string, str
   const format = q.format === 'plain' ? 'plain' : 'custom';
   const content = CONTENT.some(([c]) => c === q.content) ? String(q.content) : 'all';
   const privileges = q.schema === undefined || q.privileges === '1';
-  const body = html`${toolNote(await findTools())}
+  const body = html`${toolNote(tx, await findTools())}
     ${errors.length ? html`<div class="alert alert-error" role="alert">${errors.map((e) => html`<div>${e}</div>`)}</div>` : ''}
-    <form method="get" action="${URL_BASE}/export" class="u-mb1"><div class="form-grid"><div class="field"><label class="label" for="dp-schema">Schema</label>
-      <select id="dp-schema" name="schema" required><option value="">- choose a schema -</option>${schemas.map((x) => html`<option value="${x}"${x === schema ? raw(' selected') : ''}>${x}</option>`)}</select></div></div>
-      <div class="buttons"><button class="btn">${icon('table')} Choose</button></div></form>
-    ${schema ? region(`Export ${schema}`, html`<form method="post" action="${URL_BASE}/export">${csrf(s)}<input type="hidden" name="schema" value="${schema}">
-      <fieldset class="prop-group"><legend>Format</legend><div class="form-grid">
-        <label class="check"><input type="radio" name="format" value="custom"${format === 'custom' ? raw(' checked') : ''}> Custom (compressed; imports here with pg_restore)</label>
-        <label class="check"><input type="radio" name="format" value="plain"${format === 'plain' ? raw(' checked') : ''}> Plain SQL (for psql; not imported here)</label></div></fieldset>
-      <fieldset class="prop-group"><legend>Content</legend><div class="form-grid">
-        ${CONTENT.map(([c, label]) => html`<label class="check"><input type="radio" name="content" value="${c}"${content === c ? raw(' checked') : ''}> ${label}</label>`)}
-        <label class="check"><input type="checkbox" name="privileges" value="1"${privileges ? raw(' checked') : ''}> Grants</label></div></fieldset>
-      <fieldset class="prop-group"><legend>Tables, views and sequences</legend>
-        <div class="form-grid">${[['all', 'The whole schema'], ['only', 'Only the checked ones'], ['except', 'All but the checked ones']].map(([m, label]) =>
-          html`<label class="check"><input type="radio" name="mode" value="${m}"${mode === m ? raw(' checked') : ''}> ${label}</label>`)}</div>
+    <form method="get" action="${URL_BASE}/export" class="u-mb1"><div class="form-grid"><div class="field"><label class="label" for="dp-schema">${tx('sm.schema')}</label>
+      <select id="dp-schema" name="schema" required><option value="">${tx('ddl.choose_schema')}</option>${schemas.map((x) => html`<option value="${x}"${x === schema ? raw(' selected') : ''}>${x}</option>`)}</select></div></div>
+      <div class="buttons"><button class="btn">${icon('table')} ${tx('ul.choose')}</button></div></form>
+    ${schema ? region(tx('dp.export_of', { schema }), html`<form method="post" action="${URL_BASE}/export">${csrf(s)}<input type="hidden" name="schema" value="${schema}">
+      <fieldset class="prop-group"><legend>${tx('cl.format')}</legend><div class="form-grid">
+        <label class="check"><input type="radio" name="format" value="custom"${format === 'custom' ? raw(' checked') : ''}> ${tx('dp.fmt.custom')}</label>
+        <label class="check"><input type="radio" name="format" value="plain"${format === 'plain' ? raw(' checked') : ''}> ${tx('dp.fmt.plain')}</label></div></fieldset>
+      <fieldset class="prop-group"><legend>${tx('dp.content')}</legend><div class="form-grid">
+        ${CONTENT.map(([c, label]) => html`<label class="check"><input type="radio" name="content" value="${c}"${content === c ? raw(' checked') : ''}> ${tx(label)}</label>`)}
+        <label class="check"><input type="checkbox" name="privileges" value="1"${privileges ? raw(' checked') : ''}> ${tx('ddl.grants')}</label></div></fieldset>
+      <fieldset class="prop-group"><legend>${tx('dp.tables')}</legend>
+        <div class="form-grid">${([['all', 'dp.mode.all'], ['only', 'dp.mode.only'], ['except', 'dp.mode.except']] as [string, BuilderKey][]).map(([m, label]) =>
+          html`<label class="check"><input type="radio" name="mode" value="${m}"${mode === m ? raw(' checked') : ''}> ${tx(label)}</label>`)}</div>
         ${tables.length ? html`<div class="dp-tables">${tables.map((t) => html`<label class="check u-break"><input type="checkbox" name="t" value="${t}"${picked.has(t) ? raw(' checked') : ''}> ${t}</label>`)}</div>`
-          : html`<p class="muted">The schema has no tables, views or sequences.</p>`}
-        <p class="muted small">Only some tables: the file has no CREATE SCHEMA, and functions, types and the other objects of the schema stay out.</p></fieldset>
-      <div class="buttons"><button class="btn btn-hot">${icon('download')} Start the export</button></div></form>`) : ''}`;
-  return page(reply, s, 'Export a schema', [['Export']], body, errors.length ? 422 : 200);
+          : html`<p class="muted">${tx('dp.no_tables')}</p>`}
+        <p class="muted small">${tx('dp.some_tables_note')}</p></fieldset>
+      <div class="buttons"><button class="btn btn-hot">${icon('download')} ${tx('dp.start_export')}</button></div></form>`) : ''}`;
+  return page(reply, s, tx('dp.export_schema'), [[tx('dp.export')]], body, errors.length ? 422 : 200);
 }
 
 async function importPage(reply: FastifyReply, s: Session) {
   const files = (await listJobs()).filter(importable);
-  const body = html`${toolNote(await findTools())}
-    ${region('Upload a dump', html`<form method="post" action="${URL_BASE}/upload" enctype="multipart/form-data">${csrf(s)}
-      <div class="form-grid"><div class="field"><label class="label" for="dp-file">A custom or tar archive of one schema (pg_dump -Fc or -Ft), up to ${String(uploadMaxMb())} MB</label>
+  const tx = tr(s);
+  const L = { job: tx('dp.col.job'), file: tx('dp.col.file'), size: tx('scr.col.size'), made: tx('dp.col.made') };
+  const body = html`${toolNote(tx, await findTools())}
+    ${region(tx('dp.upload_title'), html`<form method="post" action="${URL_BASE}/upload" enctype="multipart/form-data">${csrf(s)}
+      <div class="form-grid"><div class="field"><label class="label" for="dp-file">${tx('dp.upload_label', { mb: String(uploadMaxMb()) })}</label>
         <input type="file" id="dp-file" name="file" required></div></div>
-      <div class="buttons"><button class="btn btn-hot">${icon('upload')} Upload</button></div></form>
-      <p class="muted small">The next page shows what the archive holds before anything runs. A dump is code: its functions and triggers run as pgkiln's owner role, so import only dumps you trust.</p>`)}
-    ${region('Or an export of this server', html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Job</th><th>File</th><th class="num">Size</th><th>Made</th><th></th></tr></thead>
-      <tbody>${files.length ? files.map((j) => html`<tr><td data-label="Job"><a href="${jobUrl(j.id)}">#${String(j.id)}</a></td><td data-label="File" class="u-break">${what(j)}</td>
-        <td data-label="Size" class="num">${size(j.bytes)}</td><td data-label="Made">${j.finished_at ?? j.created_at}</td>
-        <td><a class="btn btn-sm" href="${jobUrl(j.id)}/import">${icon('upload')} Import…</a></td></tr>`)
-        : html`<tr><td colspan="5" class="empty">No exports in custom format are kept.</td></tr>`}</tbody></table></div>`)}`;
-  return page(reply, s, 'Import', [['Import']], body);
+      <div class="buttons"><button class="btn btn-hot">${icon('upload')} ${tx('scr.upload')}</button></div></form>
+      <p class="muted small">${tx('dp.upload_note')}</p>`)}
+    ${region(tx('dp.or_export'), html`<div class="table-wrap"><table class="report report-reflow"><thead><tr><th>${L.job}</th><th>${L.file}</th><th class="num">${L.size}</th><th>${L.made}</th><th></th></tr></thead>
+      <tbody>${files.length ? files.map((j) => html`<tr><td data-label="${L.job}"><a href="${jobUrl(j.id)}">#${String(j.id)}</a></td><td data-label="${L.file}" class="u-break">${what(tx, j)}</td>
+        <td data-label="${L.size}" class="num">${size(j.bytes)}</td><td data-label="${L.made}">${j.finished_at ?? j.created_at}</td>
+        <td><a class="btn btn-sm" href="${jobUrl(j.id)}/import">${icon('upload')} ${tx('dp.import_dots')}</a></td></tr>`)
+        : html`<tr><td colspan="5" class="empty">${tx('dp.no_exports')}</td></tr>`}</tbody></table></div>`)}`;
+  return page(reply, s, tx('dp.import'), [[tx('dp.import')]], body);
 }
 
 async function importForm(reply: FastifyReply, s: Session, j: Job, body: Body = {}, errors: string[] = []) {
+  const tx = tr(s);
   let preview: Raw;
   let schema = '';
   try {
@@ -141,9 +147,9 @@ async function importForm(reply: FastifyReply, s: Session, j: Job, body: Body =
     const rows = toc.entries.filter((e) => e.desc === 'TABLE DATA').length;
     preview = html`${problem ? html`<div class="alert alert-error" role="alert">${problem}</div>` : ''}
       <dl class="dp-facts">${toc.header.filter(([k]) => /^(Archive created at|dbname|Format|Dumped from database version|Dumped by pg_dump version)$/.test(k)).map(([k, v]) => html`<dt>${k}</dt><dd class="u-break">${v}</dd>`)}
-        <dt>Schema</dt><dd>${toc.schemas.join(', ') || '-'}${toc.schemaEntry ? '' : html` <span class="muted small">(some tables: no CREATE SCHEMA)</span>`}</dd>
-        <dt>Tables</dt><dd class="u-break">${tables.length ? tables.join(', ') : html`<span class="muted">none</span>`}${rows ? html` <span class="muted small">(data of ${String(rows)})</span>` : ''}</dd></dl>
-      <div class="table-wrap"><table class="report"><thead><tr><th>Object type</th><th class="num">Entries</th></tr></thead>
+        <dt>${tx('sm.schema')}</dt><dd>${toc.schemas.join(', ') || '-'}${toc.schemaEntry ? '' : html` <span class="muted small">${tx('dp.no_create_schema')}</span>`}</dd>
+        <dt>${tx('su.tables')}</dt><dd class="u-break">${tables.length ? tables.join(', ') : html`<span class="muted">${tx('dp.none')}</span>`}${rows ? html` <span class="muted small">${tx('dp.data_of', { n: String(rows) })}</span>` : ''}</dd></dl>
+      <div class="table-wrap"><table class="report"><thead><tr><th>${tx('dp.object_type')}</th><th class="num">${tx('dp.entries')}</th></tr></thead>
         <tbody>${toc.counts.map(([d, n]) => html`<tr><td>${d.toLowerCase()}</td><td class="num">${String(n)}</td></tr>`)}</tbody></table></div>`;
     if (problem) schema = '';
   } catch (e) {
@@ -151,43 +157,48 @@ async function importForm(reply: FastifyReply, s: Session, j: Job, body: Body =
   }
   const target = body.target ?? schema;
   const content = CONTENT.some(([c]) => c === body.content) ? body.content! : 'all';
-  const form = schema ? region('Import into', html`<form method="post" action="${jobUrl(j.id)}/import">${csrf(s)}
-      <div class="form-grid"><div class="field"><label class="label" for="dp-target">Schema</label>
+  const form = schema ? region(tx('dp.import_into'), html`<form method="post" action="${jobUrl(j.id)}/import">${csrf(s)}
+      <div class="form-grid"><div class="field"><label class="label" for="dp-target">${tx('sm.schema')}</label>
         <input id="dp-target" name="target" value="${target}" required maxlength="63" pattern="[A-Za-z_][A-Za-z0-9_$]{0,62}" autocomplete="off" spellcheck="false">
-        <span class="help muted small">A new schema is created; into an existing one, the dump's objects are added (or replaced, below). A name other than ${schema} renames the dump's schema in the same transaction.</span></div></div>
-      <fieldset class="prop-group"><legend>Content</legend><div class="form-grid">
-        ${CONTENT.map(([c, label]) => html`<label class="check"><input type="radio" name="content" value="${c}"${content === c ? raw(' checked') : ''}> ${label}</label>`)}
-        <label class="check"><input type="checkbox" name="clean" value="1"${body.clean === '1' ? raw(' checked') : ''}> Drop the dump's objects in the schema first</label>
-        <label class="check"><input type="checkbox" name="privileges" value="1"${body.target === undefined || body.privileges === '1' ? raw(' checked') : ''}> Grants</label></div></fieldset>
-      <p class="muted small">Everything runs in one transaction: an error rolls it all back. Objects are owned by pgkiln's owner role. Names inside PL/pgSQL bodies are text: after a rename they still say ${schema}.</p>
-      <div class="buttons"><button class="btn btn-hot">${icon('upload')} Start the import</button></div></form>`) : '';
+        <span class="help muted small">${tx('dp.target_help', { schema })}</span></div></div>
+      <fieldset class="prop-group"><legend>${tx('dp.content')}</legend><div class="form-grid">
+        ${CONTENT.map(([c, label]) => html`<label class="check"><input type="radio" name="content" value="${c}"${content === c ? raw(' checked') : ''}> ${tx(label)}</label>`)}
+        <label class="check"><input type="checkbox" name="clean" value="1"${body.clean === '1' ? raw(' checked') : ''}> ${tx('dp.clean')}</label>
+        <label class="check"><input type="checkbox" name="privileges" value="1"${body.target === undefined || body.privileges === '1' ? raw(' checked') : ''}> ${tx('ddl.grants')}</label></div></fieldset>
+      <p class="muted small">${tx('dp.one_tx_note', { schema })}</p>
+      <div class="buttons"><button class="btn btn-hot">${icon('upload')} ${tx('dp.start_import')}</button></div></form>`) : '';
   const main = html`${errors.length ? html`<div class="alert alert-error" role="alert">${errors.map((e) => html`<div>${e}</div>`)}</div>` : ''}
-    ${region(`What ${j.original_name ?? j.file_name ?? ''} holds`, preview)}${form}`;
-  return page(reply, s, 'Import', [[`Job #${j.id}`, jobUrl(j.id)], ['Import']], main, errors.length ? 422 : 200);
+    ${region(tx('dp.holds', { file: j.original_name ?? j.file_name ?? '' }), preview)}${form}`;
+  return page(reply, s, tx('dp.import'), [[tx('dp.job', { id: j.id }), jobUrl(j.id)], [tx('dp.import')]], main, errors.length ? 422 : 200);
 }
 
 async function jobPage(reply: FastifyReply, s: Session, j: Job) {
   const o = j.options;
+  const tx = tr(s);
+  const exportOpts = () => [
+    tx('dp.opt.format', { format: String(o.format) }), contentLabel(tx, o.content), ...(o.privileges ? [tx('ddl.grants')] : []),
+  ].join(', ') + ((o.tables as string[])?.length ? `; ${tx('dp.opt.only', { list: (o.tables as string[]).join(', ') })}` : '') + ((o.exclude as string[])?.length ? `; ${tx('dp.opt.without', { list: (o.exclude as string[]).join(', ') })}` : '');
+  const importOpts = () => [contentLabel(tx, o.content), ...(o.clean ? [tx('dp.opt.cleaned')] : []), ...(o.privileges ? [tx('ddl.grants')] : [])].join(', ');
   const facts: [string, Raw | string][] = [
-    ['Status', html`${status(j)}${j.error ? html` <span class="u-break">${j.error}</span>` : ''}`],
-    ['By', j.username],
-    ['Created', j.created_at],
-    ...(j.started_at ? [['Started', j.started_at] as [string, string]] : []),
-    ...(j.finished_at ? [['Finished', `${j.finished_at} (${j.seconds} s)`] as [string, string]] : []),
-    ...(j.kind === 'export' ? [['Options', `${o.format} format, ${CONTENT.find(([c]) => c === o.content)?.[1].toLowerCase() ?? ''}${o.privileges ? ', grants' : ''}${(o.tables as string[])?.length ? `; only ${(o.tables as string[]).join(', ')}` : ''}${(o.exclude as string[])?.length ? `; without ${(o.exclude as string[]).join(', ')}` : ''}`] as [string, string]] : []),
-    ...(j.kind === 'import' && j.target_schema ? [['Options', `${CONTENT.find(([c]) => c === o.content)?.[1].toLowerCase() ?? ''}${o.clean ? ', existing objects dropped first' : ''}${o.privileges ? ', grants' : ''}`] as [string, string]] : []),
-    ...(j.source_job ? [['From', html`<a href="${jobUrl(j.source_job)}">job #${String(j.source_job)}</a>`] as [string, Raw]] : []),
-    ['File', j.file_live ? html`${j.original_name ?? j.file_name ?? ''} · ${size(j.bytes)} · kept until ${j.expires_at ?? ''}` : j.file_name || j.bytes === null ? html`<span class="muted">none</span>` : html`<span class="muted">removed (${size(j.bytes)})</span>`],
+    [tx('sm.col.state'), html`${status(tx, j)}${j.error ? html` <span class="u-break">${j.error}</span>` : ''}`],
+    [tx('scr.col.by'), j.username],
+    [tx('dp.created'), j.created_at],
+    ...(j.started_at ? [[tx('scr.col.started'), j.started_at] as [string, string]] : []),
+    ...(j.finished_at ? [[tx('dp.finished'), `${j.finished_at} (${j.seconds} s)`] as [string, string]] : []),
+    ...(j.kind === 'export' ? [[tx('dp.options'), exportOpts()] as [string, string]] : []),
+    ...(j.kind === 'import' && j.target_schema ? [[tx('dp.options'), importOpts()] as [string, string]] : []),
+    ...(j.source_job ? [[tx('cl.col.from'), html`<a href="${jobUrl(j.source_job)}">${tx('dp.job_lower', { id: String(j.source_job) })}</a>`] as [string, Raw]] : []),
+    [tx('dp.col.file'), j.file_live ? html`${j.original_name ?? j.file_name ?? ''} · ${size(j.bytes)} · ${tx('dp.kept_until', { time: j.expires_at ?? '' })}` : j.file_name || j.bytes === null ? html`<span class="muted">${tx('dp.none')}</span>` : html`<span class="muted">${tx('dp.removed')} (${size(j.bytes)})</span>`],
   ];
   const actions = html`<div class="buttons">
-    ${j.status === 'running' ? html`<a class="btn" href="${jobUrl(j.id)}">${icon('refresh')} Refresh</a>
-      <form method="post" action="${jobUrl(j.id)}/cancel" class="inline">${csrf(s)}<button class="btn">${icon('close')} Cancel</button></form>` : ''}
-    ${j.file_live && j.kind === 'export' && j.status === 'succeeded' ? html`<a class="btn btn-hot" href="${jobUrl(j.id)}/download">${icon('download')} Download</a>` : ''}
-    ${importable(j) ? html`<a class="btn" href="${jobUrl(j.id)}/import">${icon('upload')} Import…</a>` : ''}
-    ${j.status !== 'running' ? html`<form method="post" action="${jobUrl(j.id)}/delete" class="inline">${csrf(s)}<button class="btn btn-danger">${icon('trash')} Delete${j.file_live ? ' with its file' : ''}</button></form>` : ''}</div>`;
-  const body = html`${region(`Job #${j.id}: ${j.kind}`, html`<p>${what(j)}</p><dl class="dp-facts">${facts.map(([k, v]) => html`<dt>${k}</dt><dd>${v}</dd>`)}</dl>${actions}`)}
-    ${region('Log', j.log ? html`<pre class="ddl wrap-pre dp-log">${j.log}</pre>` : html`<p class="muted">Nothing logged${j.status === 'running' ? ' yet' : ''}.</p>`)}`;
-  return page(reply, s, `Job #${j.id}`, [[`Job #${j.id}`]], body);
+    ${j.status === 'running' ? html`<a class="btn" href="${jobUrl(j.id)}">${icon('refresh')} ${tx('sm.refresh')}</a>
+      <form method="post" action="${jobUrl(j.id)}/cancel" class="inline">${csrf(s)}<button class="btn">${icon('close')} ${tx('sm.cancel')}</button></form>` : ''}
+    ${j.file_live && j.kind === 'export' && j.status === 'succeeded' ? html`<a class="btn btn-hot" href="${jobUrl(j.id)}/download">${icon('download')} ${tx('scr.download')}</a>` : ''}
+    ${importable(j) ? html`<a class="btn" href="${jobUrl(j.id)}/import">${icon('upload')} ${tx('dp.import_dots')}</a>` : ''}
+    ${j.status !== 'running' ? html`<form method="post" action="${jobUrl(j.id)}/delete" class="inline">${csrf(s)}<button class="btn btn-danger">${icon('trash')} ${j.file_live ? tx('dp.delete_with_file') : tx('scr.delete')}</button></form>` : ''}</div>`;
+  const body = html`${region(tx('dp.job_kind', { id: j.id, kind: tx.dyn(`dp.kind.${j.kind}`, j.kind) }), html`<p>${what(tx, j)}</p><dl class="dp-facts">${facts.map(([k, v]) => html`<dt>${k}</dt><dd>${v}</dd>`)}</dl>${actions}`)}
+    ${region(tx('dp.log'), j.log ? html`<pre class="ddl wrap-pre dp-log">${j.log}</pre>` : html`<p class="muted">${j.status === 'running' ? tx('dp.nothing_logged_yet') : tx('dp.nothing_logged')}</p>`)}`;
+  return page(reply, s, tx('dp.job', { id: j.id }), [[tx('dp.job', { id: j.id })]], body);
 }
 
 const exportOptions = (b: Body) => {
@@ -217,7 +228,7 @@ export async function dataPumpRoutes(app: FastifyInstance) {
     if (!s) return;
     const b = req.body ?? {};
     const o = exportOptions(b);
-    if (b.mode === 'only' && !o.tables.length) return exportPage(reply, s, { ...b, t: [] } as never, ['Check the tables to export.']);
+    if (b.mode === 'only' && !o.tables.length) return exportPage(reply, s, { ...b, t: [] } as never, [tr(s)('dp.err.check_tables')]);
     try {
       const id = await startExport(s.username!, String(b.schema ?? ''), o);
       await logActivity({ username: s.username, event: 'schema_export', ip: clientIp(req), detail: `${b.schema}: job ${id}` });
@@ -270,12 +281,12 @@ export async function dataPumpRoutes(app: FastifyInstance) {
     }
     const session = s as Session;
     if (!saved) {
-      flash(session, 'Choose a file.', 'error');
+      flash(session, tr(session)('dp.err.choose_file'), 'error');
       return back(reply, session, `${URL_BASE}/import`);
     }
     if (saved.truncated || !saved.bytes) {
       await rm(filePath(saved.name), { force: true });
-      flash(session, saved.truncated ? `The file is larger than ${uploadMaxMb()} MB (PGKILN_DUMP_MAX_MB).` : 'The file is empty.', 'error');
+      flash(session, saved.truncated ? tr(session)('dp.err.too_large', { mb: uploadMaxMb() }) : tr(session)('dp.err.empty'), 'error');
       return back(reply, session, `${URL_BASE}/import`);
     }
     const id = await uploadJob(session.username!, saved.name, saved.original, saved.bytes);
@@ -310,9 +321,9 @@ export async function dataPumpRoutes(app: FastifyInstance) {
     const x = await withJob(req, reply);
     if (!x) return;
     const b = req.body ?? {};
-    if (!importable(x.j)) return importForm(reply, x.s, x.j, b, ['This file can\'t be imported (any more).']);
+    if (!importable(x.j)) return importForm(reply, x.s, x.j, b, [tr(x.s)('dp.err.not_importable')]);
     const target = String(b.target ?? '').trim();
-    if (!SCHEMA_NAME.test(target)) return importForm(reply, x.s, x.j, b, ['The schema: letters, digits, _ and $, up to 63, not starting with a digit.']);
+    if (!SCHEMA_NAME.test(target)) return importForm(reply, x.s, x.j, b, [tr(x.s)('dp.err.schema_name')]);
     try {
       const id = await startImport(x.s.username!, x.j, {
         target, content: (CONTENT.some(([c]) => c === b.content) ? b.content : 'all') as Content, clean: b.clean === '1', privileges: b.privileges === '1',
@@ -344,7 +355,7 @@ export async function dataPumpRoutes(app: FastifyInstance) {
   app.post(`${URL_BASE}/job/:id/cancel`, async (req: Req, reply) => {
     const x = await withJob(req, reply);
     if (!x) return;
-    flash(x.s, cancelJob(x.j.id) ? 'Cancelling the job.' : 'The job doesn\'t run on this server (any more).', 'ok');
+    flash(x.s, cancelJob(x.j.id) ? tr(x.s)('dp.cancelling') : tr(x.s)('dp.not_running'), 'ok');
     return back(reply, x.s, jobUrl(x.j.id));
   });
 
@@ -358,7 +369,7 @@ export async function dataPumpRoutes(app: FastifyInstance) {
       flash(x.s, e.message, 'error');
       return back(reply, x.s, jobUrl(x.j.id));
     }
-    flash(x.s, `Job #${x.j.id} deleted.`);
+    flash(x.s, tr(x.s)('dp.deleted', { id: x.j.id }));
     return back(reply, x.s, URL_BASE);
   });
 }

package/src/builder/ddl-tools.ts

@@ -8,22 +8,24 @@ import { clientIp, logActivity } from '../session.ts';
 import { BASE, csrf, developer, region, send, shell, workshopTabs, type Req } from './ui.ts';
 import type { Session } from '../session.ts';
 import { workshopDb } from './workspaces.ts';
+import { tr, type BuilderKey, type BuilderTranslate } from './i18n.ts';
 
 // SQL Workshop → Generate DDL and Schema Comparison (APEX: SQL Workshop →
 // Utilities). Both only read the catalog (src/ddl.ts); the scripts they
 // write are shown and downloaded. (sprint 106) Compare's Apply and record
 // runs the change script and records it (changelog.ts).
 
-const TYPE_LABELS: Record<(typeof OBJECT_TYPES)[number], string> = {
-  types: 'Types and domains', sequences: 'Sequences', tables: 'Tables (constraints, indexes)', views: 'Views and materialized views',
-  functions: 'Functions and procedures', triggers: 'Triggers', policies: 'Row level security and policies',
+const TYPE_LABELS: Record<(typeof OBJECT_TYPES)[number], BuilderKey> = {
+  types: 'ddl.type.types', sequences: 'ddl.type.sequences', tables: 'ddl.type.tables', views: 'ddl.type.views',
+  functions: 'ddl.type.functions', triggers: 'ddl.type.triggers', policies: 'ddl.type.policies',
 };
-const STATE_LABELS: Record<Difference['state'], string> = { source: 'Only in the source', target: 'Only in the target', different: 'Different' };
+const STATE_LABELS: Record<Difference['state'], BuilderKey> = { source: 'cmp.only_source', target: 'cmp.only_target', different: 'cmp.different' };
+const STATE_COUNTS: Record<Difference['state'], BuilderKey> = { source: 'cmp.n_only_source', target: 'cmp.n_only_target', different: 'cmp.n_different' };
 
 const many = (v: unknown) => ([] as string[]).concat((v as string | string[] | undefined) ?? []);
-const schemaSelect = (name: string, label: string, schemas: string[], current: string) =>
+const schemaSelect = (tx: BuilderTranslate, name: string, label: string, schemas: string[], current: string) =>
   html`<div class="field"><label class="label" for="f_${name}">${label}</label>
-    <select id="f_${name}" name="${name}" required><option value="">- choose a schema -</option>${schemas.map((x) => html`<option value="${x}"${x === current ? raw(' selected') : ''}>${x}</option>`)}</select></div>`;
+    <select id="f_${name}" name="${name}" required><option value="">${tx('ddl.choose_schema')}</option>${schemas.map((x) => html`<option value="${x}"${x === current ? raw(' selected') : ''}>${x}</option>`)}</select></div>`;
 
 /** A unified diff with added and removed lines marked. */
 const diffBlock = (d: Difference, source: string, target: string) => {
@@ -32,10 +34,10 @@ const diffBlock = (d: Difference, source: string, target: string) => {
 };
 
 /** (sprint 106, DA-17) Apply the change script in one transaction and record it in the change log (changelog.ts). */
-const applyForm = (s: Session, source: string, target: string) =>
+const applyForm = (s: Session, source: string, target: string, tx = tr(s)) =>
   html`<form method="post" action="${BASE}/sql/compare/apply" class="u-mt1">${csrf(s)}<input type="hidden" name="source" value="${source}"><input type="hidden" name="target" value="${target}">
-    <button class="btn btn-hot" data-confirm="Run the change script on ${target} in one transaction?">${icon('play')} Apply and record</button>
-    <span class="muted small">Runs the script on ${target} (commented-out drops stay out) and records it in the <a href="${BASE}/sql/changes?schema=${encodeURIComponent(target)}">change log</a>.</span></form>`;
+    <button class="btn btn-hot" data-confirm="${tx('cmp.apply_confirm', { target })}">${icon('play')} ${tx('cmp.apply')}</button>
+    <span class="muted small">${tx.rich('cmp.apply_note', { target, log: html`<a href="${BASE}/sql/changes?schema=${encodeURIComponent(target)}">${tx('cmp.change_log')}</a>` })}</span></form>`;
 
 export async function ddlToolRoutes(app: FastifyInstance) {
   app.get(`${BASE}/sql/ddl`, async (req: Req, reply) => {
@@ -43,6 +45,7 @@ export async function ddlToolRoutes(app: FastifyInstance) {
     if (!s) return;
     const db = await workshopDb(s);
     const schemas = await userSchemas(db, { usable: db !== owner });
+    const tx = tr(s);
     const q = req.query ?? {};
     const schema = schemas.includes(q.schema ?? '') ? q.schema! : '';
     // the first visit: every type, comments and grants
@@ -58,26 +61,26 @@ export async function ddlToolRoutes(app: FastifyInstance) {
         if (q.download === '1')
           return reply.header('content-disposition', `attachment; filename="${schema}.sql"`).type('application/sql; charset=utf-8').send(script);
         const qs = new URLSearchParams([['schema', schema], ...[...types].map((x) => ['t', x]), ...(opts.comments ? [['comments', '1']] : []), ...(opts.grants ? [['grants', '1']] : []), ['download', '1']]);
-        result = region(`DDL of ${schema}`, html`<p class="muted">${objects.length} object(s). Review the script before you run it (SQL Workshop → SQL Scripts).</p>
-          <textarea class="code" rows="24" spellcheck="false" readonly aria-label="DDL of ${schema}" data-code="plpgsql">${script}</textarea>`,
-          html`<a class="btn" href="${BASE}/sql/ddl?${qs.toString()}">${icon('download')} Download ${schema}.sql</a>`);
+        result = region(tx('ddl.of', { schema }), html`<p class="muted">${tx('ddl.objects_review', { n: objects.length })}</p>
+          <textarea class="code" rows="24" spellcheck="false" readonly aria-label="${tx('ddl.of', { schema })}" data-code="plpgsql">${script}</textarea>`,
+          html`<a class="btn" href="${BASE}/sql/ddl?${qs.toString()}">${icon('download')} ${tx('ddl.download', { file: `${schema}.sql` })}</a>`);
       } catch (e) {
         result = html`<div class="alert alert-error" role="alert">${(e as Error).message}</div>`;
       }
     }
-    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('ddl', s)}
-      <p class="muted">The DDL of a schema's objects, from the database catalog, in an order that runs: types, sequences, tables, functions, views, constraints, indexes, triggers, row level security, comments and grants (APEX: Generate DDL). Objects of extensions are left out.</p>
+    const main = html`<h1 class="u-mb1">${tx('rail.sql_workshop')}</h1>${workshopTabs('ddl', s)}
+      <p class="muted">${tx('ddl.intro')}</p>
       <form method="get" class="u-mb1">
-        <div class="form-grid">${schemaSelect('schema', 'Schema', schemas, schema)}</div>
-        <fieldset class="prop-group"><legend>Objects</legend><div class="form-grid">
-          ${OBJECT_TYPES.map((x) => html`<label class="check"><input type="checkbox" name="t" value="${x}"${types.has(x) ? raw(' checked') : ''}> ${TYPE_LABELS[x]}</label>`)}
-          <label class="check"><input type="checkbox" name="comments" value="1"${opts.comments ? raw(' checked') : ''}> Comments</label>
-          <label class="check"><input type="checkbox" name="grants" value="1"${opts.grants ? raw(' checked') : ''}> Grants</label>
+        <div class="form-grid">${schemaSelect(tx, 'schema', tx('sm.schema'), schemas, schema)}</div>
+        <fieldset class="prop-group"><legend>${tx('ddl.objects')}</legend><div class="form-grid">
+          ${OBJECT_TYPES.map((x) => html`<label class="check"><input type="checkbox" name="t" value="${x}"${types.has(x) ? raw(' checked') : ''}> ${tx(TYPE_LABELS[x])}</label>`)}
+          <label class="check"><input type="checkbox" name="comments" value="1"${opts.comments ? raw(' checked') : ''}> ${tx('ddl.comments')}</label>
+          <label class="check"><input type="checkbox" name="grants" value="1"${opts.grants ? raw(' checked') : ''}> ${tx('ddl.grants')}</label>
         </div></fieldset>
-        <div class="buttons"><button class="btn btn-hot">${icon('code')} Generate</button></div>
+        <div class="buttons"><button class="btn btn-hot">${icon('code')} ${tx('ddl.generate')}</button></div>
       </form>
       ${result}`;
-    return send(reply, s, shell(s, 'Generate DDL', [['SQL Workshop', `${BASE}/sql`], ['Generate DDL']], main, 'sql'));
+    return send(reply, s, shell(s, tx('sql.tool.ddl'), [[tx('rail.sql_workshop'), `${BASE}/sql`], [tx('sql.tool.ddl')]], main, 'sql'));
   });
 
   app.get(`${BASE}/sql/compare`, async (req: Req, reply) => {
@@ -88,8 +91,9 @@ export async function ddlToolRoutes(app: FastifyInstance) {
     const q = req.query ?? {};
     const source = schemas.includes(q.source ?? '') ? q.source! : '';
     const target = schemas.includes(q.target ?? '') ? q.target! : '';
+    const tx = tr(s);
     let result: Raw | '' = '';
-    if (source && target && source === target) result = html`<div class="alert alert-error" role="alert">Choose two different schemas.</div>`;
+    if (source && target && source === target) result = html`<div class="alert alert-error" role="alert">${tx('cmp.two_different')}</div>`;
     else if (source && target) {
       try {
         const [a, b] = await Promise.all([readSchema(db.pool, source), readSchema(db.pool, target)]);
@@ -99,28 +103,28 @@ export async function ddlToolRoutes(app: FastifyInstance) {
         if (q.download === '1')
           return reply.header('content-disposition', `attachment; filename="${target}-like-${source}.sql"`).type('application/sql; charset=utf-8').send(script);
         const groups = (['source', 'target', 'different'] as const).map((st) => [st, differences.filter((d) => d.state === st)] as const).filter(([, list]) => list.length);
-        result = html`${region('Summary', html`<p>${differences.length
-            ? `${differences.length} difference(s): ${groups.map(([st, list]) => `${list.length} ${STATE_LABELS[st].toLowerCase()}`).join(', ')}; ${same} object(s) the same.`
-            : `The schemas are the same (${same} objects).`}</p>`)}
-          ${groups.map(([st, list]) => html`<div class="u-spacer"></div>${region(`${STATE_LABELS[st]} (${st === 'source' ? source : st === 'target' ? target : `${source} and ${target}`})`,
+        result = html`${region(tx('cmp.summary'), html`<p>${differences.length
+            ? tx('cmp.differences', { n: differences.length, parts: groups.map(([st, list]) => tx(STATE_COUNTS[st], { n: list.length })).join(', '), same })
+            : tx('cmp.same', { n: same })}</p>`)}
+          ${groups.map(([st, list]) => html`<div class="u-spacer"></div>${region(`${tx(STATE_LABELS[st])} (${st === 'source' ? source : st === 'target' ? target : tx('cmp.both', { source, target })})`,
             html`<ul class="compare-list">${list.map((d) => html`<li><details><summary><span class="tag">${d.kind}</span> ${d.name}</summary>
               ${st === 'different' ? diffBlock(d, source, target) : html`<pre class="diff">${d.source ?? d.target}</pre>`}</details></li>`)}</ul>`)}`)}
           <div class="u-spacer"></div>
-          ${region(`Change script: make ${target} like ${source}`, html`<p class="muted">Creates what only ${source} has, changes what differs, and lists what only ${target} has as commented-out drops; columns that change identity or generation, and types, domains and sequences that differ, are left for review. Nothing runs until you choose Apply and record.</p>
-            <textarea class="code" rows="20" spellcheck="false" readonly aria-label="Change script" data-code="plpgsql">${script}</textarea>`,
-            html`<a class="btn" href="${BASE}/sql/compare?${new URLSearchParams({ source, target, download: '1' }).toString()}">${icon('download')} Download</a>`)}
+          ${region(tx('cmp.script_title', { source, target }), html`<p class="muted">${tx('cmp.script_intro', { source, target })}</p>
+            <textarea class="code" rows="20" spellcheck="false" readonly aria-label="${tx('cmp.change_script')}" data-code="plpgsql">${script}</textarea>`,
+            html`<a class="btn" href="${BASE}/sql/compare?${new URLSearchParams({ source, target, download: '1' }).toString()}">${icon('download')} ${tx('scr.download')}</a>`)}
           ${differences.length ? applyForm(s, source, target) : ''}`;
       } catch (e) {
         result = html`<div class="alert alert-error" role="alert">${(e as Error).message}</div>`;
       }
     }
-    const main = html`<h1 class="u-mb1">SQL Workshop</h1>${workshopTabs('compare', s)}
-      <p class="muted">Compares the objects of two schemas of this database by their DDL (APEX: Schema Comparison), e.g. a development copy with the schema it came from, and writes a script that makes the target like the source. The order of a table's columns is not compared.</p>
+    const main = html`<h1 class="u-mb1">${tx('rail.sql_workshop')}</h1>${workshopTabs('compare', s)}
+      <p class="muted">${tx('cmp.intro')}</p>
       <form method="get" class="u-mb1">
-        <div class="form-grid">${schemaSelect('source', 'Source', schemas, source)}${schemaSelect('target', 'Target (to make like the source)', schemas, target)}</div>
-        <div class="buttons"><button class="btn btn-hot">${icon('layers')} Compare</button></div>
+        <div class="form-grid">${schemaSelect(tx, 'source', tx('cmp.source'), schemas, source)}${schemaSelect(tx, 'target', tx('cmp.target'), schemas, target)}</div>
+        <div class="buttons"><button class="btn btn-hot">${icon('layers')} ${tx('cmp.compare')}</button></div>
       </form>
       ${result}`;
-    return send(reply, s, shell(s, 'Schema Comparison', [['SQL Workshop', `${BASE}/sql`], ['Schema Comparison']], main, 'sql'));
+    return send(reply, s, shell(s, tx('sql.tool.compare'), [[tx('rail.sql_workshop'), `${BASE}/sql`], [tx('sql.tool.compare')]], main, 'sql'));
   });
 }