pgkiln 0.49.0 → 0.51.0

package/src/datasets.ts

@@ -0,0 +1,367 @@
+import pg from 'pg';
+import { heading } from './runtime/items.ts';
+import { OPERATORS } from './runtime/report.ts';
+
+// (sprint 110, migration 120) Data Reporter datasets: a reusable, trusted view of a workspace's data for business
+// users. A dataset is tables and views of one schema, joined (each table after the first joins to an earlier one on
+// column pairs; the builder proposes the pairs from foreign keys), the columns users may see with labels, format
+// masks and descriptions, and an optional row filter. Stored in meta.dataset per workspace; a Data Reporter region
+// offers one as a source ({"id", "dataset"} in config.sources).
+//
+// checkDataset() keeps only what is well formed (and, with a catalog, what exists); datasetSql() builds the
+// dataset's SELECT: identifiers come only from the checked definition and are always quoted, values are escaped
+// literals, operators come from the report filter whitelist. The runtime wraps it as a subquery and runs every
+// report on it as the application's database role.
+
+export interface DatasetJoin {
+  /** the alias of an earlier table */
+  to: string;
+  type: 'inner' | 'left';
+  /** column of this table = ref column of the earlier table */
+  on: { column: string; ref: string }[];
+}
+export interface DatasetTable {
+  alias: string;
+  table: string;
+  join?: DatasetJoin;
+}
+export interface DatasetColumn {
+  /** the name users and report definitions use (a static id) */
+  name: string;
+  /** the alias of its table */
+  table: string;
+  column: string;
+  label?: string;
+  format?: string;
+  description?: string;
+}
+export interface DatasetFilter {
+  table: string;
+  column: string;
+  op: string;
+  value: string;
+}
+export interface Dataset {
+  name: string;
+  label: string;
+  description?: string;
+  schema: string;
+  tables: DatasetTable[];
+  columns: DatasetColumn[];
+  filters: DatasetFilter[];
+}
+
+export const DATASET_NAME = /^[a-z][a-z0-9_]{0,39}$/;
+export const DATASET_LIMITS = { tables: 10, columns: 200, filters: 5, joinColumns: 4, label: 80, description: 500, columnDescription: 300, format: 40, value: 200 };
+const RESERVED = /^(pg_.*|information_schema|meta)$/i;
+const ALIAS = /^t[1-9][0-9]?$/;
+
+/** The columns of the schema's tables and views (name → column names), for checks against the catalog. */
+export type Catalog = Map<string, Set<string>>;
+
+const str = (v: unknown) => (typeof v === 'string' ? v : '');
+const clip = (v: unknown, max: number) => str(v).replace(/\0/g, '').trim().slice(0, max);
+const arr = (v: unknown): any[] => (Array.isArray(v) ? v : []);
+
+/**
+ * A dataset with only what is well formed: valid names, joins to earlier tables, columns and filters on its tables,
+ * whitelisted operators, bounded counts and lengths. With a catalog, tables and columns must also exist. Anything
+ * else is dropped and reported in errors (in words for the developer).
+ */
+export function checkDataset(loose: any, catalog?: Catalog): { dataset: Dataset; errors: string[] } {
+  const errors: string[] = [];
+  const name = str(loose?.name).trim().toLowerCase();
+  if (!DATASET_NAME.test(name)) errors.push(`"${name}" is not a valid dataset name: lower case letters, digits and _, starting with a letter (at most 40).`);
+  const label = clip(loose?.label, DATASET_LIMITS.label) || name;
+  const description = clip(loose?.description, DATASET_LIMITS.description) || undefined;
+  const schema = str(loose?.schema).trim();
+  if (!schema || schema.length > 63 || RESERVED.test(schema)) errors.push(`The schema "${schema}" can't be used for a dataset.`);
+
+  const tables: DatasetTable[] = [];
+  const has = (table: string, column: string) => !catalog || !!catalog.get(table)?.has(column);
+  for (const t of arr(loose?.tables)) {
+    const table = str(t?.table);
+    const alias = str(t?.alias);
+    if (!table || table.length > 63 || !ALIAS.test(alias) || tables.some((x) => x.alias === alias)) {
+      errors.push(`A table entry "${table || '?'}" is not valid.`);
+      continue;
+    }
+    if (catalog && !catalog.has(table)) {
+      errors.push(`The table or view ${schema}.${table} does not exist (any more).`);
+      continue;
+    }
+    if (tables.length >= DATASET_LIMITS.tables) {
+      errors.push(`A dataset has at most ${DATASET_LIMITS.tables} tables.`);
+      break;
+    }
+    if (!tables.length) {
+      tables.push({ alias, table });
+      continue;
+    }
+    const j = t?.join;
+    const to = tables.find((x) => x.alias === str(j?.to));
+    const on = arr(j?.on)
+      .map((p: any) => ({ column: str(p?.column), ref: str(p?.ref) }))
+      .filter((p) => p.column && p.ref && to && has(table, p.column) && has(to.table, p.ref))
+      .slice(0, DATASET_LIMITS.joinColumns);
+    if (!to || !on.length) {
+      errors.push(`The table ${table} needs a join to an earlier table on existing columns.`);
+      continue;
+    }
+    tables.push({ alias, table, join: { to: to.alias, type: j?.type === 'inner' ? 'inner' : 'left', on } });
+  }
+  if (!tables.length) errors.push('A dataset needs at least one table or view.');
+
+  const tableOf = (alias: string) => tables.find((x) => x.alias === alias);
+  const columns: DatasetColumn[] = [];
+  for (const c of arr(loose?.columns)) {
+    const t = tableOf(str(c?.table));
+    const column = str(c?.column);
+    const cname = str(c?.name).trim().toLowerCase();
+    if (!t || !column || !has(t.table, column)) continue;
+    if (!DATASET_NAME.test(cname)) {
+      errors.push(`"${cname}" is not a valid column name: lower case letters, digits and _, starting with a letter.`);
+      continue;
+    }
+    if (columns.some((x) => x.name === cname)) {
+      errors.push(`Two columns are named ${cname}.`);
+      continue;
+    }
+    if (columns.length >= DATASET_LIMITS.columns) break;
+    const lbl = clip(c?.label, DATASET_LIMITS.label);
+    const format = clip(c?.format, DATASET_LIMITS.format);
+    const desc = clip(c?.description, DATASET_LIMITS.columnDescription);
+    columns.push({ name: cname, table: t.alias, column, ...(lbl ? { label: lbl } : {}), ...(format ? { format } : {}), ...(desc ? { description: desc } : {}) });
+  }
+
+  const filters: DatasetFilter[] = [];
+  for (const f of arr(loose?.filters)) {
+    const t = tableOf(str(f?.table));
+    const column = str(f?.column);
+    const op = str(f?.op);
+    if (!t || !column || !has(t.table, column) || !Object.hasOwn(OPERATORS, op)) continue;
+    const value = OPERATORS[op].noValue ? '' : str(f?.value).replace(/\0/g, '').slice(0, DATASET_LIMITS.value);
+    if (!OPERATORS[op].noValue && value === '') continue;
+    if (filters.length >= DATASET_LIMITS.filters) break;
+    filters.push({ table: t.alias, column, op, value });
+  }
+  return { dataset: { name, label, ...(description ? { description } : {}), schema, tables, columns, filters }, errors };
+}
+
+const id = (s: string) => pg.escapeIdentifier(s);
+
+/** The dataset's SELECT: its columns under their names, from its joined tables, with its row filter. */
+export function datasetSql(d: Dataset): string {
+  const cols = d.columns.length ? d.columns : [];
+  const select = cols.map((c) => `${id(c.table)}.${id(c.column)} as ${id(c.name)}`);
+  const from = d.tables
+    .map((t, i) =>
+      i === 0 || !t.join
+        ? `${id(d.schema)}.${id(t.table)} ${id(t.alias)}`
+        : `${t.join.type === 'inner' ? 'join' : 'left join'} ${id(d.schema)}.${id(t.table)} ${id(t.alias)} on ${t.join.on.map((p) => `${id(t.alias)}.${id(p.column)} = ${id(t.join!.to)}.${id(p.ref)}`).join(' and ')}`,
+    )
+    .join(' ');
+  const where = d.filters.map((f) => OPERATORS[f.op].sql(`${id(f.table)}.${id(f.column)}`, f.value));
+  return `select ${select.length ? select.join(', ') : 'null as "__none"'} from ${from}${where.length ? ` where ${where.join(' and ')}` : ''}`;
+}
+
+/** A dataset row of meta.dataset as a definition. */
+export const datasetOf = (row: { name: string; label: string; description?: string | null; schema_name: string; tables: unknown; columns: unknown; filters: unknown }) =>
+  checkDataset({ name: row.name, label: row.label, description: row.description, schema: row.schema_name, tables: row.tables, columns: row.columns, filters: row.filters }).dataset;
+
+// ---------------------------------------------------------------- files
+
+export const DATASET_FORMAT = 'pgkiln-dataset/1';
+
+/** Datasets as a JSON file. */
+export function datasetFile(list: Dataset[]) {
+  return `${JSON.stringify({ format: DATASET_FORMAT, datasets: list }, null, 2)}\n`;
+}
+
+/** The datasets of a file (one dataset, or {format, datasets}); throws an Error with a message for the developer. */
+export function readDatasetFile(text: string): any[] {
+  let doc: any;
+  try {
+    doc = JSON.parse(text);
+  } catch {
+    throw new Error('The file is not valid JSON.');
+  }
+  if (doc && typeof doc === 'object' && doc.format !== undefined && doc.format !== DATASET_FORMAT) throw new Error(`Unknown format "${String(doc.format).slice(0, 40)}": expected ${DATASET_FORMAT}.`);
+  const list = Array.isArray(doc?.datasets) ? doc.datasets : doc && typeof doc === 'object' && doc.tables ? [doc] : null;
+  if (!list?.length) throw new Error('The file has no datasets.');
+  if (list.length > 50) throw new Error('A file has at most 50 datasets.');
+  return list;
+}
+
+/** A name for a column that the dataset doesn't use yet (from the column's name, or table_column). */
+export function freeColumnName(taken: Set<string>, table: string, column: string) {
+  const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^[^a-z]+/, '').slice(0, 40);
+  let base = norm(column) || 'col';
+  if (taken.has(base)) base = norm(`${table}_${column}`) || base;
+  let n = base;
+  for (let i = 2; taken.has(n); i++) n = `${base.slice(0, 36)}_${i}`;
+  return n;
+}
+
+// ---------------------------------------------------------------- the catalog
+
+/** A table or view of a schema with its columns (name and type, in table order). */
+export interface CatalogObject {
+  name: string;
+  kind: 'table' | 'view';
+  columns: { name: string; type: string; numeric: boolean }[];
+}
+/** A foreign key between two tables of the schema: table(columns) references ref(refColumns). */
+export interface CatalogFk {
+  table: string;
+  columns: string[];
+  ref: string;
+  refColumns: string[];
+}
+
+type Queryable = { query: <T extends pg.QueryResultRow = any>(sql: string, params?: unknown[]) => Promise<pg.QueryResult<T>> };
+
+/** The tables and views of a schema with their columns, and the foreign keys inside it (read as the given connection). */
+export async function readSchemaCatalog(db: Queryable, schema: string): Promise<{ objects: CatalogObject[]; fks: CatalogFk[] }> {
+  if (RESERVED.test(schema)) return { objects: [], fks: [] };
+  const objects = (
+    await db.query<CatalogObject>(
+      `select c.relname as name, case when c.relkind in ('v', 'm') then 'view' else 'table' end as kind,
+              coalesce(json_agg(json_build_object('name', a.attname, 'type', format_type(a.atttypid, a.atttypmod),
+                                                  'numeric', t.typcategory = 'N') order by a.attnum)
+                       filter (where a.attnum > 0), '[]') as columns
+         from pg_class c join pg_namespace n on n.oid = c.relnamespace
+         left join pg_attribute a on a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+         left join pg_type t on t.oid = a.atttypid
+        where n.nspname = $1 and c.relkind in ('r', 'p', 'v', 'm') and has_schema_privilege(n.oid, 'USAGE')
+        group by c.relname, c.relkind order by c.relname`,
+      [schema],
+    )
+  ).rows;
+  const fks = (
+    await db.query<CatalogFk>(
+      `select c.relname as table, f.relname as ref,
+              array(select a.attname::text from unnest(k.conkey) with ordinality u(n, i) join pg_attribute a on a.attrelid = k.conrelid and a.attnum = u.n order by u.i) as columns,
+              array(select a.attname::text from unnest(k.confkey) with ordinality u(n, i) join pg_attribute a on a.attrelid = k.confrelid and a.attnum = u.n order by u.i) as "refColumns"
+         from pg_constraint k join pg_class c on c.oid = k.conrelid join pg_class f on f.oid = k.confrelid
+        where k.contype = 'f' and c.relnamespace = $1::regnamespace and f.relnamespace = $1::regnamespace
+        order by c.relname, k.conname`,
+      [schema],
+    )
+  ).rows;
+  return { objects, fks };
+}
+
+/** The catalog as checkDataset() wants it. */
+export const catalogOf = (objects: CatalogObject[]): Catalog => new Map(objects.map((o) => [o.name, new Set(o.columns.map((c) => c.name))]));
+
+/**
+ * The join of a table to one of the earlier tables, proposed from foreign keys (either direction; the first match).
+ * null: no foreign key links it to them.
+ */
+export function proposeJoin(table: string, earlier: DatasetTable[], fks: CatalogFk[]): DatasetJoin | null {
+  for (const t of earlier) {
+    // this table references the earlier one (a child joined to its parent)
+    const out = fks.find((f) => f.table === table && f.ref === t.table);
+    if (out) return { to: t.alias, type: 'left', on: out.columns.map((c, i) => ({ column: c, ref: out.refColumns[i] })).slice(0, DATASET_LIMITS.joinColumns) };
+    // the earlier one references this table (a parent joined to the child before it)
+    const back = fks.find((f) => f.table === t.table && f.ref === table);
+    if (back) return { to: t.alias, type: 'left', on: back.refColumns.map((c, i) => ({ column: c, ref: back.columns[i] })).slice(0, DATASET_LIMITS.joinColumns) };
+  }
+  return null;
+}
+
+/**
+ * A new dataset on tables and views of a schema: joins proposed from foreign keys (a table without one joins to
+ * nothing and is reported), every column except binary ones, labelled from its name; numeric columns get a number mask.
+ */
+export function proposeDataset(name: string, label: string, schema: string, tableNames: string[], cat: { objects: CatalogObject[]; fks: CatalogFk[] }): { dataset: Dataset; errors: string[] } {
+  const errors: string[] = [];
+  const tables: DatasetTable[] = [];
+  // the tables in the order chosen, but a table that joins to none of the earlier ones waits for the others
+  const pending = tableNames.filter((t, i) => tableNames.indexOf(t) === i && cat.objects.some((o) => o.name === t)).slice(0, DATASET_LIMITS.tables);
+  let progress = true;
+  while (pending.length && progress) {
+    progress = false;
+    for (let i = 0; i < pending.length; i++) {
+      const table = pending[i];
+      const alias = `t${tables.length + 1}`;
+      if (!tables.length) tables.push({ alias, table });
+      else {
+        const join = proposeJoin(table, tables, cat.fks);
+        if (!join) continue;
+        tables.push({ alias, table, join });
+      }
+      pending.splice(i, 1);
+      i--;
+      progress = true;
+    }
+  }
+  for (const t of pending) errors.push(`No foreign key links ${t} to the other tables: add it on the dataset's page with a join of your own.`);
+  const taken = new Set<string>();
+  const columns: DatasetColumn[] = [];
+  for (const t of tables) {
+    const obj = cat.objects.find((o) => o.name === t.table)!;
+    // a join column of a later table repeats the earlier one's: offered once
+    const joined = new Set(t.join?.on.map((p) => p.column) ?? []);
+    for (const c of obj.columns) {
+      if (c.type === 'bytea' || joined.has(c.name) || columns.length >= DATASET_LIMITS.columns) continue;
+      const n = freeColumnName(taken, t.table, c.name);
+      taken.add(n);
+      columns.push({ name: n, table: t.alias, column: c.name, label: heading(c.name), ...(c.numeric && /^(numeric|real|double|money)/.test(c.type) ? { format: '999G999G990D00' } : {}) });
+    }
+  }
+  return { dataset: { name, label: label || name, schema, tables, columns, filters: [] }, errors };
+}
+
+// ---------------------------------------------------------------- storage
+
+export interface DatasetRow {
+  id: number;
+  workspace_id: number;
+  name: string;
+  label: string;
+  description: string | null;
+  schema_name: string;
+  tables: DatasetTable[];
+  columns: DatasetColumn[];
+  filters: DatasetFilter[];
+  updated_at: string;
+  updated_by: string | null;
+}
+
+/** The datasets of a workspace (name order). */
+export async function workspaceDatasets(db: Queryable, workspaceId: number): Promise<DatasetRow[]> {
+  return (await db.query<DatasetRow>('select * from meta.dataset where workspace_id = $1 order by name', [workspaceId])).rows;
+}
+
+/** Insert or replace a checked dataset of a workspace (by name); returns its id. */
+export async function storeDataset(db: Queryable, workspaceId: number, d: Dataset, by: string | null, opts: { replace?: boolean } = {}): Promise<number> {
+  const vals = [workspaceId, d.name, d.label, d.description ?? null, d.schema, JSON.stringify(d.tables), JSON.stringify(d.columns), JSON.stringify(d.filters), by];
+  const res = await db.query<{ id: number }>(
+    `insert into meta.dataset (workspace_id, name, label, description, schema_name, tables, columns, filters, created_by, updated_by)
+     values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $9)
+     on conflict (workspace_id, name) do ${opts.replace === false ? 'nothing' : `update
+       set label = excluded.label, description = excluded.description, schema_name = excluded.schema_name, tables = excluded.tables,
+           columns = excluded.columns, filters = excluded.filters, updated_by = excluded.updated_by, updated_at = now()`}
+     returning id`,
+    vals,
+  );
+  return res.rows[0]?.id ?? 0;
+}
+
+/**
+ * The datasets an application offers, by name, as definitions (read through the runtime's own login: row level
+ * security shows an isolated workspace's login its own workspace's datasets only).
+ */
+export async function appDatasets(db: Queryable, appId: number, names: string[]): Promise<Map<string, Dataset>> {
+  if (!names.length) return new Map();
+  const rows = (
+    await db.query(
+      `select name, label, description, schema_name, tables, columns, filters from meta.dataset
+        where workspace_id = meta.dataset_workspace($1) and name = any($2::text[])`,
+      [appId, names],
+    )
+  ).rows;
+  return new Map(rows.map((r) => [r.name as string, datasetOf(r)]));
+}

package/src/i18n/ar.ts

@@ -686,6 +686,22 @@ export const ar: Record<MessageKey, string> = {
   'reporter.welcome_text': "اختر البيانات لبدء تقرير: حدد الأعمدة، صفِّ، جمّع مع المجاميع، أضف مخططًا، ثم احفظه أو شاركه.",
   'reporter.columns_count': "{n} أعمدة",
   'reporter.search': "البحث في التقارير",
+  'reporter.published_reports': "التقارير المنشورة",
+  'reporter.published_tag': "منشور",
+  'reporter.publish': "نشر",
+  'reporter.unpublish': "إلغاء النشر",
+  'reporter.publish_on_save': "نشر لجميع مستخدمي التطبيق",
+  'reporter.published': "تم نشر التقرير \"{name}\".",
+  'reporter.unpublished': "تم إلغاء نشر التقرير \"{name}\".",
+  'reporter.pin': "تثبيت",
+  'reporter.unpin': "إلغاء التثبيت",
+  'reporter.pinned': "المثبتة",
+  'reporter.pinned_msg': "تم تثبيت التقرير \"{name}\".",
+  'reporter.unpinned_msg': "تم إلغاء تثبيت التقرير \"{name}\".",
+  'reporter.link': "رابط هذا التقرير",
+  'reporter.open_link': "فتح",
+  'reporter.no_published': "لا توجد تقارير منشورة بعد.",
+  'reporter.welcome_viewer': "افتح تقريرًا منشورًا: بياناته محدثة دائمًا.",
   'reporter.changed': "عُدِّل في {date}",
   'reporter.no_match': "لا توجد تقارير مطابقة للبحث.",
   'reporter.chart_tag': "مخطط",

package/src/i18n/cs.ts

@@ -686,6 +686,22 @@ export const cs: Record<MessageKey, string> = {
   'reporter.welcome_text': "Vyberte data pro novou sestavu: sloupce, filtry, seskupení se součty a graf, potom ji uložte nebo sdílejte.",
   'reporter.columns_count': "{n} sloupců",
   'reporter.search': "Hledat sestavy",
+  'reporter.published_reports': "Publikované sestavy",
+  'reporter.published_tag': "publikováno",
+  'reporter.publish': "Publikovat",
+  'reporter.unpublish': "Zrušit publikování",
+  'reporter.publish_on_save': "Publikovat pro všechny uživatele aplikace",
+  'reporter.published': "Sestava „{name}“ publikována.",
+  'reporter.unpublished': "Publikování sestavy „{name}“ zrušeno.",
+  'reporter.pin': "Připnout",
+  'reporter.unpin': "Odepnout",
+  'reporter.pinned': "Připnuté",
+  'reporter.pinned_msg': "Sestava „{name}“ připnuta.",
+  'reporter.unpinned_msg': "Sestava „{name}“ odepnuta.",
+  'reporter.link': "Odkaz na tuto sestavu",
+  'reporter.open_link': "Otevřít",
+  'reporter.no_published': "Zatím nejsou publikovány žádné sestavy.",
+  'reporter.welcome_viewer': "Otevřete publikovanou sestavu: její data jsou vždy aktuální.",
   'reporter.changed': "změněno {date}",
   'reporter.no_match': "Hledání neodpovídá žádná sestava.",
   'reporter.chart_tag': "graf",

package/src/i18n/da.ts

@@ -686,6 +686,22 @@ export const da: Record<MessageKey, string> = {
   'reporter.welcome_text': "Vælg data for at starte en rapport: vælg kolonner, filtrér, gruppér med totaler, tilføj et diagram, og gem eller del den.",
   'reporter.columns_count': "{n} kolonner",
   'reporter.search': "Søg i rapporter",
+  'reporter.published_reports': "Publicerede rapporter",
+  'reporter.published_tag': "publiceret",
+  'reporter.publish': "Publicer",
+  'reporter.unpublish': "Fjern publicering",
+  'reporter.publish_on_save': "Publicer for alle brugere af applikationen",
+  'reporter.published': "Rapporten \"{name}\" publiceret.",
+  'reporter.unpublished': "Publiceringen af rapporten \"{name}\" er fjernet.",
+  'reporter.pin': "Fastgør",
+  'reporter.unpin': "Frigør",
+  'reporter.pinned': "Fastgjorte",
+  'reporter.pinned_msg': "Rapporten \"{name}\" fastgjort.",
+  'reporter.unpinned_msg': "Rapporten \"{name}\" frigjort.",
+  'reporter.link': "Link til denne rapport",
+  'reporter.open_link': "Åbn",
+  'reporter.no_published': "Ingen rapporter er publiceret endnu.",
+  'reporter.welcome_viewer': "Åbn en publiceret rapport: dens data er altid opdaterede.",
   'reporter.changed': "ændret {date}",
   'reporter.no_match': "Ingen rapporter matcher søgningen.",
   'reporter.chart_tag': "diagram",

package/src/i18n/de.ts

@@ -686,6 +686,22 @@ export const de: Record<MessageKey, string> = {
   'reporter.welcome_text': "Wählen Sie die Daten für einen neuen Bericht: Spalten auswählen, filtern, mit Summen gruppieren, ein Diagramm hinzufügen und den Bericht speichern oder teilen.",
   'reporter.columns_count': "{n} Spalten",
   'reporter.search': "Berichte suchen",
+  'reporter.published_reports': "Veröffentlichte Berichte",
+  'reporter.published_tag': "veröffentlicht",
+  'reporter.publish': "Veröffentlichen",
+  'reporter.unpublish': "Veröffentlichung zurückziehen",
+  'reporter.publish_on_save': "Für alle Benutzer der Anwendung veröffentlichen",
+  'reporter.published': "Bericht \"{name}\" veröffentlicht.",
+  'reporter.unpublished': "Veröffentlichung von Bericht \"{name}\" zurückgezogen.",
+  'reporter.pin': "Anheften",
+  'reporter.unpin': "Lösen",
+  'reporter.pinned': "Angeheftet",
+  'reporter.pinned_msg': "Bericht \"{name}\" angeheftet.",
+  'reporter.unpinned_msg': "Bericht \"{name}\" gelöst.",
+  'reporter.link': "Link zu diesem Bericht",
+  'reporter.open_link': "Öffnen",
+  'reporter.no_published': "Es sind noch keine Berichte veröffentlicht.",
+  'reporter.welcome_viewer': "Öffnen Sie einen veröffentlichten Bericht: seine Daten sind immer aktuell.",
   'reporter.changed': "geändert {date}",
   'reporter.no_match': "Keine Berichte gefunden.",
   'reporter.chart_tag': "Diagramm",

package/src/i18n/el.ts

@@ -686,6 +686,22 @@ export const el: Record<MessageKey, string> = {
   'reporter.welcome_text': "Επιλέξτε τα δεδομένα για μια νέα αναφορά: στήλες, φίλτρα, ομαδοποίηση με σύνολα, ένα γράφημα, και αποθηκεύστε ή μοιραστείτε την.",
   'reporter.columns_count': "{n} στήλες",
   'reporter.search': "Αναζήτηση αναφορών",
+  'reporter.published_reports': "Δημοσιευμένες αναφορές",
+  'reporter.published_tag': "δημοσιευμένη",
+  'reporter.publish': "Δημοσίευση",
+  'reporter.unpublish': "Κατάργηση δημοσίευσης",
+  'reporter.publish_on_save': "Δημοσίευση για όλους τους χρήστες της εφαρμογής",
+  'reporter.published': "Η αναφορά «{name}» δημοσιεύτηκε.",
+  'reporter.unpublished': "Η δημοσίευση της αναφοράς «{name}» καταργήθηκε.",
+  'reporter.pin': "Καρφίτσωμα",
+  'reporter.unpin': "Ξεκαρφίτσωμα",
+  'reporter.pinned': "Καρφιτσωμένες",
+  'reporter.pinned_msg': "Η αναφορά «{name}» καρφιτσώθηκε.",
+  'reporter.unpinned_msg': "Η αναφορά «{name}» ξεκαρφιτσώθηκε.",
+  'reporter.link': "Σύνδεσμος προς αυτή την αναφορά",
+  'reporter.open_link': "Άνοιγμα",
+  'reporter.no_published': "Δεν υπάρχουν ακόμη δημοσιευμένες αναφορές.",
+  'reporter.welcome_viewer': "Ανοίξτε μια δημοσιευμένη αναφορά: τα δεδομένα της είναι πάντα ενημερωμένα.",
   'reporter.changed': "άλλαξε {date}",
   'reporter.no_match': "Καμία αναφορά δεν ταιριάζει με την αναζήτηση.",
   'reporter.chart_tag': "γράφημα",

package/src/i18n/es.ts

@@ -686,6 +686,22 @@ export const es: Record<MessageKey, string> = {
   'reporter.welcome_text': "Elija los datos para empezar un informe: columnas, filtros, agrupaciones con totales y un gráfico; después guárdelo o compártalo.",
   'reporter.columns_count': "{n} columnas",
   'reporter.search': "Buscar informes",
+  'reporter.published_reports': "Informes publicados",
+  'reporter.published_tag': "publicado",
+  'reporter.publish': "Publicar",
+  'reporter.unpublish': "Retirar publicación",
+  'reporter.publish_on_save': "Publicar para todos los usuarios de la aplicación",
+  'reporter.published': "Informe \"{name}\" publicado.",
+  'reporter.unpublished': "Publicación del informe \"{name}\" retirada.",
+  'reporter.pin': "Fijar",
+  'reporter.unpin': "Desfijar",
+  'reporter.pinned': "Fijados",
+  'reporter.pinned_msg': "Informe \"{name}\" fijado.",
+  'reporter.unpinned_msg': "Informe \"{name}\" desfijado.",
+  'reporter.link': "Enlace a este informe",
+  'reporter.open_link': "Abrir",
+  'reporter.no_published': "Aún no hay informes publicados.",
+  'reporter.welcome_viewer': "Abra un informe publicado: sus datos están siempre al día.",
   'reporter.changed': "modificado el {date}",
   'reporter.no_match': "Ningún informe coincide con la búsqueda.",
   'reporter.chart_tag': "gráfico",

package/src/i18n/fi.ts

@@ -686,6 +686,22 @@ export const fi: Record<MessageKey, string> = {
   'reporter.welcome_text': "Valitse tiedot uutta raporttia varten: sarakkeet, suodattimet, ryhmittely summineen ja kaavio, ja tallenna tai jaa raportti.",
   'reporter.columns_count': "{n} saraketta",
   'reporter.search': "Hae raportteja",
+  'reporter.published_reports': "Julkaistut raportit",
+  'reporter.published_tag': "julkaistu",
+  'reporter.publish': "Julkaise",
+  'reporter.unpublish': "Peru julkaisu",
+  'reporter.publish_on_save': "Julkaise kaikille sovelluksen käyttäjille",
+  'reporter.published': "Raportti \"{name}\" julkaistu.",
+  'reporter.unpublished': "Raportin \"{name}\" julkaisu peruttu.",
+  'reporter.pin': "Kiinnitä",
+  'reporter.unpin': "Irrota",
+  'reporter.pinned': "Kiinnitetyt",
+  'reporter.pinned_msg': "Raportti \"{name}\" kiinnitetty.",
+  'reporter.unpinned_msg': "Raportti \"{name}\" irrotettu.",
+  'reporter.link': "Linkki tähän raporttiin",
+  'reporter.open_link': "Avaa",
+  'reporter.no_published': "Raportteja ei ole vielä julkaistu.",
+  'reporter.welcome_viewer': "Avaa julkaistu raportti: sen tiedot ovat aina ajan tasalla.",
   'reporter.changed': "muutettu {date}",
   'reporter.no_match': "Haulla ei löytynyt raportteja.",
   'reporter.chart_tag': "kaavio",

package/src/i18n/fr.ts

@@ -686,6 +686,22 @@ export const fr: Record<MessageKey, string> = {
   'reporter.welcome_text': "Choisissez les données d'un nouveau rapport : colonnes, filtres, regroupements avec totaux, un graphique, puis enregistrez-le ou partagez-le.",
   'reporter.columns_count': "{n} colonnes",
   'reporter.search': "Rechercher des rapports",
+  'reporter.published_reports': "Rapports publiés",
+  'reporter.published_tag': "publié",
+  'reporter.publish': "Publier",
+  'reporter.unpublish': "Dépublier",
+  'reporter.publish_on_save': "Publier pour tous les utilisateurs de l'application",
+  'reporter.published': "Rapport « {name} » publié.",
+  'reporter.unpublished': "Rapport « {name} » dépublié.",
+  'reporter.pin': "Épingler",
+  'reporter.unpin': "Désépingler",
+  'reporter.pinned': "Épinglés",
+  'reporter.pinned_msg': "Rapport « {name} » épinglé.",
+  'reporter.unpinned_msg': "Rapport « {name} » désépinglé.",
+  'reporter.link': "Lien vers ce rapport",
+  'reporter.open_link': "Ouvrir",
+  'reporter.no_published': "Aucun rapport n'est encore publié.",
+  'reporter.welcome_viewer': "Ouvrez un rapport publié : ses données sont toujours à jour.",
   'reporter.changed': "modifié le {date}",
   'reporter.no_match': "Aucun rapport ne correspond à la recherche.",
   'reporter.chart_tag': "graphique",

package/src/i18n/he.ts

@@ -686,6 +686,22 @@ export const he: Record<MessageKey, string> = {
   'reporter.welcome_text': "בחרו את הנתונים כדי להתחיל דוח: עמודות, סינון, קיבוץ עם סיכומים ותרשים, ואז שמרו או שתפו אותו.",
   'reporter.columns_count': "{n} עמודות",
   'reporter.search': "חיפוש דוחות",
+  'reporter.published_reports': "דוחות שפורסמו",
+  'reporter.published_tag': "פורסם",
+  'reporter.publish': "פרסום",
+  'reporter.unpublish': "ביטול פרסום",
+  'reporter.publish_on_save': "פרסום לכל משתמשי היישום",
+  'reporter.published': "הדוח \"{name}\" פורסם.",
+  'reporter.unpublished': "פרסום הדוח \"{name}\" בוטל.",
+  'reporter.pin': "הצמדה",
+  'reporter.unpin': "ביטול הצמדה",
+  'reporter.pinned': "מוצמדים",
+  'reporter.pinned_msg': "הדוח \"{name}\" הוצמד.",
+  'reporter.unpinned_msg': "הצמדת הדוח \"{name}\" בוטלה.",
+  'reporter.link': "קישור לדוח זה",
+  'reporter.open_link': "פתיחה",
+  'reporter.no_published': "עדיין לא פורסמו דוחות.",
+  'reporter.welcome_viewer': "פתחו דוח שפורסם: הנתונים שלו תמיד עדכניים.",
   'reporter.changed': "שונה ב-{date}",
   'reporter.no_match': "אין דוחות התואמים לחיפוש.",
   'reporter.chart_tag': "תרשים",

package/src/i18n/it.ts

@@ -686,6 +686,22 @@ export const it: Record<MessageKey, string> = {
   'reporter.welcome_text': "Scegli i dati per iniziare un report: colonne, filtri, raggruppamenti con totali e un grafico, poi salvalo o condividilo.",
   'reporter.columns_count': "{n} colonne",
   'reporter.search': "Cerca report",
+  'reporter.published_reports': "Report pubblicati",
+  'reporter.published_tag': "pubblicato",
+  'reporter.publish': "Pubblica",
+  'reporter.unpublish': "Annulla pubblicazione",
+  'reporter.publish_on_save': "Pubblica per tutti gli utenti dell'applicazione",
+  'reporter.published': "Report \"{name}\" pubblicato.",
+  'reporter.unpublished': "Pubblicazione del report \"{name}\" annullata.",
+  'reporter.pin': "Fissa",
+  'reporter.unpin': "Sblocca",
+  'reporter.pinned': "Fissati",
+  'reporter.pinned_msg': "Report \"{name}\" fissato.",
+  'reporter.unpinned_msg': "Report \"{name}\" sbloccato.",
+  'reporter.link': "Link a questo report",
+  'reporter.open_link': "Apri",
+  'reporter.no_published': "Non ci sono ancora report pubblicati.",
+  'reporter.welcome_viewer': "Apri un report pubblicato: i suoi dati sono sempre aggiornati.",
   'reporter.changed': "modificato il {date}",
   'reporter.no_match': "Nessun report corrisponde alla ricerca.",
   'reporter.chart_tag': "grafico",

package/src/i18n/ja.ts

@@ -686,6 +686,22 @@ export const ja: Record<MessageKey, string> = {
   'reporter.welcome_text': "データを選んでレポートを始めます。列の選択、フィルター、合計付きのグループ化、グラフの追加を行い、保存または共有できます。",
   'reporter.columns_count': "{n} 列",
   'reporter.search': "レポートを検索",
+  'reporter.published_reports': "公開済みレポート",
+  'reporter.published_tag': "公開済み",
+  'reporter.publish': "公開",
+  'reporter.unpublish': "公開を取り消す",
+  'reporter.publish_on_save': "アプリケーションのすべてのユーザーに公開",
+  'reporter.published': "レポート「{name}」を公開しました。",
+  'reporter.unpublished': "レポート「{name}」の公開を取り消しました。",
+  'reporter.pin': "ピン留め",
+  'reporter.unpin': "ピン留めを外す",
+  'reporter.pinned': "ピン留め済み",
+  'reporter.pinned_msg': "レポート「{name}」をピン留めしました。",
+  'reporter.unpinned_msg': "レポート「{name}」のピン留めを外しました。",
+  'reporter.link': "このレポートへのリンク",
+  'reporter.open_link': "開く",
+  'reporter.no_published': "公開済みのレポートはまだありません。",
+  'reporter.welcome_viewer': "公開済みレポートを開きます。データは常に最新です。",
   'reporter.changed': "{date} に変更",
   'reporter.no_match': "検索に一致するレポートはありません。",
   'reporter.chart_tag': "グラフ",